Add world keyboard input with movement and nice tweening

Change map render to keep colour with map for nicer background colour

Author: SgtCoDFish

core/src/uk/org/ulcompsoc/tesseract/Move.java

@@ -0,0 +1,115 @@
+package uk.org.ulcompsoc.tesseract;
+
+import com.badlogic.ashley.core.Entity;
+import com.badlogic.gdx.math.Vector2;
+
+/**
+ * @author Ashley Davis (SgtCoDFish)
+ */
+public class Move {
+	public enum Type {
+		TILE, ABSOLUTE;
+	}
+
+	public final Entity		mover;
+
+	public final Vector2	start;
+
+	public final float		nx;
+	public final float		ny;
+	public final Type		type;
+
+	public final int		stepCount;
+	public final float		timePerStep;
+
+	public int				currentStep;
+
+	public float			durationRemaining;
+	public float			stepTime;
+
+	public final boolean	isSolid;
+
+	// alternates between x and y coords; 0 = x, 1 = y, 2 = x, etc.
+	public final float[]	steps;
+
+	public Move(Entity mover, Type type, Vector2 start, float nx, float ny, float duration, boolean isSolid) {
+		this.mover = mover;
+
+		this.type = type;
+
+		this.start = start;
+
+		this.nx = nx;
+		this.ny = ny;
+
+		this.currentStep = 0;
+		this.stepCount = calcStepCount();
+
+		this.durationRemaining = duration;
+		this.stepTime = 0.0f;
+		this.timePerStep = durationRemaining / (float) this.stepCount;
+
+		this.isSolid = isSolid;
+
+		float[] stepsTemp = new float[2 * stepCount];
+
+		final float xDiff = nx - start.x;
+		final float yDiff = ny - start.y;
+
+		final float xStepSize = xDiff / stepCount;
+		final float yStepSize = yDiff / stepCount;
+
+		for (int i = 0; i < 2 * stepCount; i += 2) {
+			if (i == 0) {
+				stepsTemp[i] = start.x;
+				stepsTemp[i + 1] = start.y;
+			} else if (i == (2 * stepCount) - 2) {
+				stepsTemp[i] = nx;
+				stepsTemp[i + 1] = ny;
+			} else {
+				stepsTemp[i] = start.x + xStepSize * (i / 2);
+				stepsTemp[i + 1] = start.y + yStepSize * (i / 2);
+			}
+		}
+
+		steps = stepsTemp;
+	}
+
+	public boolean update(float deltaTime) {
+		durationRemaining -= deltaTime;
+		stepTime += deltaTime;
+
+		final int stepsThisTick = (int) (stepTime / timePerStep);
+
+		if (stepsThisTick > 0) {
+			stepTime = stepTime % timePerStep;
+			currentStep += stepsThisTick;
+
+			if (currentStep >= stepCount) {
+				currentStep = stepCount - 1;
+			}
+		}
+
+		return isDone();
+	}
+
+	public boolean isDone() {
+		return durationRemaining <= 0.0f;
+	}
+
+	public float getCurrentX() {
+		return steps[currentStep * 2];
+	}
+
+	public float getCurrentY() {
+		return steps[currentStep * 2 + 1];
+	}
+
+	// only meaningful at constructor, returns min of 1
+	private int calcStepCount() {
+		float dist = (float) Math.sqrt(Math.pow(ny - start.y, 2) + Math.pow(nx - start.x, 2));
+		int stepCount = (int) Math.ceil(dist / WorldConstants.MOVE_STEP_LENGTH);
+
+		return (stepCount == 0 ? 1 : stepCount);
+	}
+}

core/src/uk/org/ulcompsoc/tesseract/TesseractMain.java

@@ -10,22 +10,27 @@
 import uk.org.ulcompsoc.tesseract.components.Position;
 import uk.org.ulcompsoc.tesseract.components.RelativePosition;
 import uk.org.ulcompsoc.tesseract.components.Renderable;
+import uk.org.ulcompsoc.tesseract.components.Renderable.Facing;
 import uk.org.ulcompsoc.tesseract.components.Stats;
 import uk.org.ulcompsoc.tesseract.components.Text;
+import uk.org.ulcompsoc.tesseract.components.WorldPlayerInputListener;
 import uk.org.ulcompsoc.tesseract.systems.BattleAttackSystem;
 import uk.org.ulcompsoc.tesseract.systems.BattleDialogRenderSystem;
 import uk.org.ulcompsoc.tesseract.systems.BattleInputSystem;
 import uk.org.ulcompsoc.tesseract.systems.BattleMessageSystem;
 import uk.org.ulcompsoc.tesseract.systems.FocusTakingSystem;
+import uk.org.ulcompsoc.tesseract.systems.MovementSystem;
 import uk.org.ulcompsoc.tesseract.systems.RenderSystem;
 import uk.org.ulcompsoc.tesseract.systems.TextRenderSystem;
+import uk.org.ulcompsoc.tesseract.systems.WorldPlayerInputSystem;
 import uk.org.ulcompsoc.tesseract.tiled.TesseractMap;
 
 import com.badlogic.ashley.core.Engine;
 import com.badlogic.ashley.core.Entity;
 import com.badlogic.gdx.Application;
 import com.badlogic.gdx.ApplicationAdapter;
 import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
 import com.badlogic.gdx.graphics.Camera;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.GL20;
@@ -40,6 +45,8 @@
 import com.badlogic.gdx.math.Rectangle;
 
 public class TesseractMain extends ApplicationAdapter {
+	public static final String		PLAYER_NAME			= "Valiant Hero™";
+
 	private SpriteBatch				batch				= null;
 	private Camera					camera				= null;
 
@@ -68,8 +75,10 @@ public class TesseractMain extends ApplicationAdapter {
 	private Entity					rageText			= null;
 
 	public static final String[]	mapNames			= { "world1/world1.tmx" };
-	private TesseractMap[]			maps				= null;
-	public static TesseractMap		currentMap			= null;
+	public static final Color[]		mapColors			= { new Color(80.0f / 255.0f, 172.0f / 255.0f, 61.0f / 255.0f,
+																1.0f) };
+	private static TesseractMap[]	maps				= null;
+	public static int				currentMapIndex		= 0;
 
 	@SuppressWarnings("unused")
 	private GameState				gameState			= null;
@@ -95,27 +104,11 @@ public void create() {
 
 		batch = new SpriteBatch();
 		camera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
-		((OrthographicCamera) camera).setToOrtho(false, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight() / 2);
 
-		// if (Gdx.app.getType() == ApplicationType.WebGL) {
 		font = new BitmapFont(Gdx.files.internal("fonts/robotobm16.fnt"), Gdx.files.internal("fonts/robotobm16.png"),
 				false);
 		bigFont = new BitmapFont(Gdx.files.internal("fonts/robotobm24.fnt"),
 				Gdx.files.internal("fonts/robotobm24.png"), false);
-		// } else {
-		// com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator
-		// fontGenerator = new
-		// com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator(
-		// Gdx.files.internal("fonts/RobotoRegular.ttf"));
-		// com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator.FreeTypeFontParameter
-		// parameter = new
-		// com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator.FreeTypeFontParameter();
-		// parameter.size = 16;
-		// font = fontGenerator.generateFont(parameter);
-		// parameter.size = 24;
-		// bigFont = fontGenerator.generateFont(parameter);
-		// fontGenerator.dispose();
-		// }
 
 		playerTexture = new Texture(Gdx.files.internal("player/basicPlayer.png"));
 		playerRegions = TextureRegion.split(playerTexture, WorldConstants.TILE_WIDTH, WorldConstants.TILE_HEIGHT)[0];
@@ -133,19 +126,40 @@ public void create() {
 		initBattleEngine(battleEngine);
 		initWorldEngine(worldEngine);
 
-		currentEngine = worldEngine;
+		changeToWorld();
 	}
 
 	@Override
 	public void render() {
 		float deltaTime = Gdx.graphics.getDeltaTime();
 
-		Gdx.gl.glClearColor(0.0f, 0.8f, 0.0f, 0.0f);
+		Gdx.gl.glClearColor(mapColors[currentMapIndex].r, mapColors[currentMapIndex].g, mapColors[currentMapIndex].b,
+				mapColors[currentMapIndex].a);
 		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
 
+		if (Gdx.input.isKeyJustPressed(Keys.F10)) {
+			if (currentEngine.equals(battleEngine)) {
+				changeToWorld();
+			} else {
+				changeToBattle();
+			}
+		}
 		currentEngine.update(deltaTime);
 	}
 
+	public void changeToBattle() {
+		this.currentEngine = battleEngine;
+
+		((OrthographicCamera) camera).setToOrtho(false, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+		camera.update();
+	}
+
+	public void changeToWorld() {
+		this.currentEngine = worldEngine;
+		((OrthographicCamera) camera).setToOrtho(false, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight() / 2);
+		camera.update();
+	}
+
 	public void initWorldEngine(Engine engine) {
 		maps = new TesseractMap[mapNames.length];
 		TmxMapLoader mapLoader = new TmxMapLoader();
@@ -163,39 +177,44 @@ public void initWorldEngine(Engine engine) {
 			engine.addEntity(maps[i].zLayerEntity);
 		}
 
-		currentMap = maps[0];
+		currentMapIndex = 0;
 
 		worldPlayerEntity = new Entity();
-		worldPlayerEntity.add(new Renderable(playerRegions[1], playerRegions[0], playerRegions[3], playerRegions[2])
-				.setPrioritity(50));
-		worldPlayerEntity.add(currentMap.findPlayerPosition());
+		worldPlayerEntity.add(new Renderable(Facing.DOWN, playerRegions[1], playerRegions[0], playerRegions[3],
+				playerRegions[2]).setPrioritity(50));
+		worldPlayerEntity.add(getCurrentMap().findPlayerPosition());
 		worldPlayerEntity.add(new FocusTaker(camera));
+		worldPlayerEntity.add(new Player(PLAYER_NAME));
+		worldPlayerEntity.add(new WorldPlayerInputListener());
 
 		engine.addEntity(worldPlayerEntity);
 
+		engine.addSystem(new WorldPlayerInputSystem(50));
+		engine.addSystem(new MovementSystem(getCurrentMap(), 75));
+		engine.addSystem(new FocusTakingSystem(100));
 		engine.addSystem(new RenderSystem(batch, camera, 1000));
-		engine.addSystem(new FocusTakingSystem(10));
 	}
 
 	public void initBattleEngine(Engine engine) {
-		final int yTile = 12;
+		final float yTile = 12 * WorldConstants.TILE_HEIGHT;
 
 		battlePlayerEntity = new Entity();
 
-		battlePlayerEntity.add(new Position(17, yTile));
-		battlePlayerEntity.add(new Renderable(playerRegions[1], playerRegions[0], playerRegions[3], playerRegions[2])
-				.setPrioritity(50));
+		battlePlayerEntity.add(new Position(17 * WorldConstants.TILE_WIDTH, yTile));
+		battlePlayerEntity.add(new Renderable(Facing.DOWN, playerRegions[1], playerRegions[0], playerRegions[3],
+				playerRegions[2]).setPrioritity(50));
 		battlePlayerEntity.add(new Stats(100, 25, 4));
 
-		Player playerComp = new Player();
+		Player playerComp = new Player(PLAYER_NAME);
 		battlePlayerEntity.add(playerComp);
 		battlePlayerEntity.add(new Named(playerComp.name));
 
 		TextureRegion slimeRegion = TextureRegion.split(slimeTexture, WorldConstants.TILE_WIDTH,
 				WorldConstants.TILE_HEIGHT)[0][0];
 
 		slimeEntity = new Entity();
-		slimeEntity.add(new Position(3, yTile)).add(new Renderable(slimeRegion).setPrioritity(50));
+		slimeEntity.add(new Position(3 * WorldConstants.TILE_WIDTH, yTile)).add(
+				new Renderable(slimeRegion).setPrioritity(50));
 		slimeEntity.add(new Stats(50, 2, 2));
 
 		Enemy slime1 = new Enemy("Green Ooze");
@@ -271,6 +290,10 @@ public void initBattleEngine(Engine engine) {
 		engine.addSystem(new TextRenderSystem(batch, font, 3000));
 	}
 
+	public static TesseractMap getCurrentMap() {
+		return maps[currentMapIndex];
+	}
+
 	@Override
 	public void dispose() {
 		super.dispose();

core/src/uk/org/ulcompsoc/tesseract/WorldConstants.java

@@ -4,9 +4,14 @@
  * @author Ashley Davis (SgtCoDFish)
  */
 public class WorldConstants {
-	public static boolean		DEBUG		= false;
-	public static Difficulty	DIFFICULTY	= Difficulty.EASY;
+	public static boolean		DEBUG				= false;
+	public static Difficulty	DIFFICULTY			= Difficulty.EASY;
 
-	public static final int		TILE_WIDTH	= 32;
-	public static final int		TILE_HEIGHT	= 32;
+	public static final int		TILE_WIDTH			= 32;
+	public static final int		TILE_HEIGHT			= 32;
+
+	public static final float	TILE_DIAG			= (float) Math.sqrt(TILE_WIDTH * TILE_WIDTH + TILE_HEIGHT
+															* TILE_HEIGHT);
+	public static final float	STEPS_PER_TILE_DIAG	= 8.0f;
+	public static final float	MOVE_STEP_LENGTH	= TILE_DIAG / STEPS_PER_TILE_DIAG;
 }

core/src/uk/org/ulcompsoc/tesseract/animations/AnimationFrameResolver.java

@@ -0,0 +1,17 @@
+package uk.org.ulcompsoc.tesseract.animations;
+
+import com.badlogic.gdx.graphics.g2d.Animation;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+
+/**
+ * @author Ashley Davis (SgtCoDFish)
+ */
+public abstract class AnimationFrameResolver {
+	public float	animTime	= 0.0f;
+
+	public abstract float resolveTime(float deltaTime);
+
+	public TextureRegion resolveFrame(Animation anim, float deltaTime) {
+		return anim.getKeyFrame(resolveTime(deltaTime));
+	}
+}

core/src/uk/org/ulcompsoc/tesseract/animations/PingPongFrameResolver.java

@@ -0,0 +1,22 @@
+package uk.org.ulcompsoc.tesseract.animations;
+
+/**
+ * @author Ashley Davis (SgtCoDFish)
+ */
+public class PingPongFrameResolver extends AnimationFrameResolver {
+
+	public PingPongFrameResolver() {
+		this(0.0f);
+	}
+
+	public PingPongFrameResolver(float startTime) {
+		this.animTime = startTime;
+	}
+
+	@Override
+	public float resolveTime(float deltaTime) {
+		animTime += deltaTime;
+		return animTime;
+	}
+
+}

core/src/uk/org/ulcompsoc/tesseract/battle/BattlePerformers.java

@@ -37,7 +37,7 @@ public void perform(Entity invoker, Engine engine) {
 			if (enemies != null) {
 				for (int i = 0; i < enemies.size(); i++) {
 					Entity e = enemies.get(i);
-					GridPoint2 pos = posMapper.get(e).position;
+					GridPoint2 pos = posMapper.get(e).getGridPosition();
 
 					e.add(new TargetMarker());
 					e.add(new MouseClickListener(new Rectangle(pos.x * WorldConstants.TILE_WIDTH, pos.y

core/src/uk/org/ulcompsoc/tesseract/components/Moving.java

@@ -0,0 +1,17 @@
+package uk.org.ulcompsoc.tesseract.components;
+
+import uk.org.ulcompsoc.tesseract.Move;
+
+import com.badlogic.ashley.core.Component;
+
+/**
+ * @author Ashley Davis (SgtCoDFish)
+ */
+public class Moving extends Component {
+	public Move	move	= null;
+
+	public Moving(Move move) {
+		this.move = move;
+	}
+
+}