Merge branch 'master' of git.hammerle.me:kjhammerle/path-game into tilemap

src/pathgame/PathGame.java

@@ -1,77 +1,90 @@
 package pathgame;
 
 import me.hammerle.snuviengine.api.IGame;
-import me.hammerle.snuviengine.api.KeyBinding;
-import me.hammerle.snuviengine.api.KeyHandler;
 import me.hammerle.snuviengine.api.Renderer;
-import org.lwjgl.glfw.GLFW;
+import pathgame.gameplay.Keys;
 import pathgame.rendering.TileMapRenderer;
 import pathgame.tilemap.TileMap;
 import pathgame.utils.TestUtils;
+import pathgame.gameplay.Player;
+import pathgame.rendering.PlayerRenderer;
+import pathgame.rendering.TileRenderer;
 
 public class PathGame implements IGame
 {
     private final TileMapRenderer mapRenderer = new TileMapRenderer();
-    private final TileMap map = TestUtils.getTestMap(25, 15);
-    
-    private final static KeyBinding ZOOM_IN = KeyHandler.register(GLFW.GLFW_KEY_UP);
-    private final static KeyBinding ZOOM_OUT = KeyHandler.register(GLFW.GLFW_KEY_DOWN);
-    
-    private final static KeyBinding UP = KeyHandler.register(GLFW.GLFW_KEY_W);
-    private final static KeyBinding DOWN = KeyHandler.register(GLFW.GLFW_KEY_S);
-    private final static KeyBinding LEFT = KeyHandler.register(GLFW.GLFW_KEY_A);
-    private final static KeyBinding RIGHT = KeyHandler.register(GLFW.GLFW_KEY_D);
+    private final TileMap map = TestUtils.getTestMap(33, 25);
+
+    private final PlayerRenderer playerRenderer = new PlayerRenderer();
+    private final Player player = new Player();
     
-    private float x = 0.0f;
-    private float y = 0.0f;
+    private float lastScale = 1.0f;
+    private float scale = 1.0f;
     
     public PathGame()
     {
     }
-    
+
     @Override
     public void tick()
     {
         mapRenderer.tick();
+        player.tick(map);
         
-        if(ZOOM_IN.isDown())
+        lastScale = scale;
+        if(Keys.ZOOM_IN_KEY.isDown())
         {
-            mapRenderer.setScale(mapRenderer.getScale() * 1.05f);
+            scale *= 1.1f;
         }
-        if(ZOOM_OUT.isDown())
+        else if(Keys.ZOOM_OUT_KEY.isDown())
         {
-            mapRenderer.setScale(mapRenderer.getScale() / 1.05f);
+            scale /= 1.1f;
         }
+    }
+
+    @Override
+    public void renderTick(Renderer r, float lag)
+    {
+        float interScale = lastScale + (scale - lastScale) * lag;
+        mapRenderer.setScale(interScale);
         
-        if(UP.isDown())
+        float offX = getMapOffsetX(r, lag, interScale);
+        float offY = getMapOffsetY(r, lag, interScale);
+
+        mapRenderer.renderTick(map, r, false, offX, offY);
+        playerRenderer.renderTick(map, mapRenderer, r, player, lag, offX, offY);
+    }
+
+    private float getMapOffsetX(Renderer r, float lag, float interScale)
+    {
+        float ix = (player.getLastX() + (player.getX() - player.getLastX()) * lag) * interScale * TileRenderer.TILE_SIZE;
+        float offX = (-ix + r.getViewWidth() * 0.5f) - TileRenderer.TILE_SIZE * 0.5f * interScale;
+
+        if(offX < -mapRenderer.getWidth(map) + r.getViewWidth())
         {
-            y -= 20;
+            return -mapRenderer.getWidth(map) + r.getViewWidth();
         }
-        if(DOWN.isDown())
+        else if(offX > 0.0f)
         {
-            y += 20;
+            return 0.0f;
         }
-        if(LEFT.isDown())
+        return offX;
+    }
+
+    private float getMapOffsetY(Renderer r, float lag, float interScale)
+    {
+        float iy = (player.getLastY() + (player.getY() - player.getLastY()) * lag) * interScale * TileRenderer.TILE_SIZE;
+        float offY = (-iy + r.getViewHeight() * 0.5f) - TileRenderer.TILE_SIZE * 0.5f * interScale;
+
+        if(offY < -mapRenderer.getHeight(map) + r.getViewHeight())
         {
-            x -= 20;
+            return -mapRenderer.getHeight(map) + r.getViewHeight();
         }
-        if(RIGHT.isDown())
+        else if(offY > 0.0f)
         {
-            x += 20;
+            return 0.0f;
         }
-    }
-    
-    @Override
-    public void renderTick(Renderer r, float lag)
-    {
-        mapRenderer.renderTick(map, r, false, x, y);
-        
-        r.translateTo(0.0f, 0.0f);
-        r.updateMatrix();
-        r.setTextureEnabled(false);
-        r.setColorEnabled(true);
-        r.getColorRenderer().drawRectangle(0, 0, mapRenderer.getWidth(map), 10, 0xFF0000FF);
-        r.getColorRenderer().drawRectangle(0, 0, 10, mapRenderer.getHeight(map), 0xFF0000FF);
+        return offY;
     }
 
     @Override

src/pathgame/gameplay/Keys.java

@@ -0,0 +1,15 @@
+package pathgame.gameplay;
+
+import me.hammerle.snuviengine.api.KeyBinding;
+import me.hammerle.snuviengine.api.KeyHandler;
+import org.lwjgl.glfw.GLFW;
+
+public class Keys
+{
+    public static final KeyBinding UP_KEY = KeyHandler.register(GLFW.GLFW_KEY_W);
+    public static final KeyBinding DOWN_KEY = KeyHandler.register(GLFW.GLFW_KEY_S);
+    public static final KeyBinding LEFT_KEY = KeyHandler.register(GLFW.GLFW_KEY_A);
+    public static final KeyBinding RIGHT_KEY = KeyHandler.register(GLFW.GLFW_KEY_D);
+    public static final KeyBinding ZOOM_IN_KEY = KeyHandler.register(GLFW.GLFW_KEY_I);
+    public static final KeyBinding ZOOM_OUT_KEY = KeyHandler.register(GLFW.GLFW_KEY_O);
+}

src/pathgame/gameplay/Player.java

@@ -0,0 +1,89 @@
+package pathgame.gameplay;
+
+import pathgame.tilemap.Tile;
+import pathgame.tilemap.TileMap;
+
+public class Player
+{
+    private static final float SPEED = 0.125f;
+
+    private float lastX = 0;
+    private float lastY = 0;
+    private float x = 0;
+    private float y = 0;
+
+    private float velX = 0;
+    private float velY = 0;
+    private boolean isMoving = false;
+
+    public Player()
+    {
+    }
+
+    public float getLastX()
+    {
+        return lastX;
+    }
+
+    public float getLastY()
+    {
+        return lastY;
+    }
+
+    public float getX()
+    {
+        return x;
+    }
+
+    public float getY()
+    {
+        return y;
+    }
+
+    public void tick(TileMap map)
+    {
+        lastX = x;
+        lastY = y;
+
+        if(isOnTile())
+        {
+            velX = 0.0f;
+            velY = 0.0f;
+            if(isMoving)
+            {
+                //TODO: +Energy
+                //Tile currTile = map.getTile((int)x,(int) y);
+
+            }
+            isMoving = false;
+        }
+
+        if(Keys.LEFT_KEY.isDown() && !isMoving && x > 0)
+        {
+            velX = -SPEED;
+            isMoving = true;
+        }
+        else if(Keys.RIGHT_KEY.isDown() && !isMoving && x < map.getWidth() - 1)
+        {
+            velX = SPEED;
+            isMoving = true;
+        }
+        else if(Keys.UP_KEY.isDown() && !isMoving && y > 0)
+        {
+            velY = -SPEED;
+            isMoving = true;
+        }
+        else if(Keys.DOWN_KEY.isDown() && !isMoving && y < map.getHeight() - 1)
+        {
+            velY = SPEED;
+            isMoving = true;
+        }
+        x += velX;
+        y += velY;
+    }
+
+    private boolean isOnTile()
+    {
+        return Math.abs(x - Math.round(x)) < 0.01f && Math.abs(y - Math.round(y)) < 0.01f;
+    }
+}

src/pathgame/rendering/PlayerRenderer.java

@@ -0,0 +1,32 @@
+package pathgame.rendering;
+
+import me.hammerle.snuviengine.api.Renderer;
+import me.hammerle.snuviengine.api.Texture;
+import pathgame.gameplay.Player;
+import pathgame.tilemap.TileMap;
+
+public class PlayerRenderer
+{
+    private static final Texture CHARACTER = new Texture("res/character/characterFront.png");
+    //private static final Texture characterLeft = new Texture("res/character/characterLeft.png");
+    //private static final Texture characterRight = new Texture("res/character/characterRight.png");
+    //private static final Texture characterBack = new Texture("res/character/characterBack.png");
+
+    public void renderTick(TileMap map, TileMapRenderer mapR, Renderer r, Player p, float lag, float offX, float offY)
+    {
+        float playerSize = mapR.getScale() * TileRenderer.TILE_SIZE;
+
+        r.setMixColorEnabled(false);
+        r.setColorEnabled(false);
+        r.setTextureEnabled(true);
+
+        r.translateTo(0.0f, 0.0f);
+        r.updateMatrix();
+
+        CHARACTER.bind();
+        //TODO: animation with velocity
+        float ix = (p.getLastX() + (p.getX() - p.getLastX()) * lag) * mapR.getScale()*TileRenderer.TILE_SIZE + offX;
+        float iy = (p.getLastY() + (p.getY() - p.getLastY()) * lag) * mapR.getScale()*TileRenderer.TILE_SIZE + offY;
+        r.getTextureRenderer().drawRectangle(ix, iy, ix + playerSize, iy + playerSize, 0, 0, 1, 1); //TODO: change last 4 texture coordinates for animation 
+    }
+}