Map - Scrolling, Menü - Character selection , HUD-bereich frei lassen, Character reset after level reload

src/pathgame/PathGame.java

@@ -3,36 +3,34 @@ package pathgame;
 import me.hammerle.snuviengine.api.IGame;
 import me.hammerle.snuviengine.api.Renderer;
 import pathgame.algorithm.TravellingSalesAlg;
+import pathgame.gameplay.Camera;
 import pathgame.gameplay.Gamestate;
 import pathgame.gameplay.Gamestates;
 import pathgame.gameplay.Keys;
-import pathgame.rendering.TileMapRenderer;
-import pathgame.tilemap.TileMap;
-import pathgame.tilemap.TileMapGenerator;
+import pathgame.gameplay.Level;
 import pathgame.gameplay.Player;
-import pathgame.gameplay.PlayerAbilities;
+import pathgame.rendering.TileMapRenderer;
 import pathgame.gameplay.menu.Menu;
 import pathgame.rendering.HUDRenderer;
 import pathgame.rendering.MenuRenderer;
 import pathgame.rendering.PlayerRenderer;
 import pathgame.rendering.TileRenderer;
+import pathgame.tilemap.TileMap;
 
 public class PathGame implements IGame
 {
     private final Gamestate gamestate = new Gamestate();
 
-    private final TileMapRenderer mapRenderer = new TileMapRenderer();
-    private TileMap map = TileMapGenerator.getMap(50, 50, 15);
-
+    private final Level level = new Level();
+    
     private final PlayerRenderer playerRenderer = new PlayerRenderer();
-    private final Player player = new Player(1000, 10, PlayerAbilities.NORMAL);
+    private final TileMapRenderer mapRenderer = new TileMapRenderer();
 
     private final Menu menu = new Menu();
     private final MenuRenderer menuRenderer = new MenuRenderer();
     private final HUDRenderer hudRenderer = new HUDRenderer();
 
-    private float lastScale = 1.0f;
-    private float scale = 1.0f;
+    private final Camera cam = new Camera();
 
     public PathGame()
     {
@@ -41,40 +39,43 @@ public class PathGame implements IGame
     @Override
     public void tick()
     {
-        map.tick();
+        cam.tick(level);
+
+        level.getMap().tick();
         mapRenderer.tick();
         if(gamestate.getState() == Gamestates.GAMEPLAY)
         {
-            player.tick(map);
-        }
-        menu.tick(gamestate);
-
-        lastScale = scale;
-        if(Keys.ZOOM_IN_KEY.isDown())
-        {
-            scale *= 1.1f;
+            level.getPlayer().tick(level.getMap());
+            if(level.getPlayer().isMoving())
+            {
+                cam.reset();
+            }
         }
-        else if(Keys.ZOOM_OUT_KEY.isDown())
-        {
-            scale /= 1.1f;
-        }
-        
+        menu.tick(gamestate, level);
+  
         if(Keys.TEST_KEY.getTime() == 1)
         {
-            map = TileMapGenerator.getMap(50, 50, 15);
-            System.out.println(map.getNumberOfTowns());
-            TravellingSalesAlg.calcSalesPathLen(map);
+            level.nextLevel();
+            TravellingSalesAlg.calcSalesPathLen(level.getMap());
         }
     }
 
     @Override
     public void renderTick(Renderer r, float lag)
     {
-        float interScale = lastScale + (scale - lastScale) * lag;
+        TileMap map = level.getMap();
+        Player player = level.getPlayer();
+        
+        float zoomRestrictionX = r.getViewWidth() / (map.getWidth() * TileRenderer.TILE_SIZE);
+        float zoomRestrictionY = (r.getViewHeight() - HUDRenderer.OFFSET_Y) / (map.getHeight() * TileRenderer.TILE_SIZE);
+    
+        cam.limitScale(Math.max(zoomRestrictionX, zoomRestrictionY));
+        float interScale = cam.getInterpolatedScale(lag);
+        
         mapRenderer.setScale(interScale);
 
-        float offX = getMapOffsetX(r, lag, interScale);
-        float offY = getMapOffsetY(r, lag, interScale);
+        float offX = getMapOffsetX(map, player, r, lag, interScale);
+        float offY = getMapOffsetY(map, player, r, lag, interScale) + HUDRenderer.OFFSET_Y;
 
         mapRenderer.renderTick(map, r, false, offX, offY);
         switch(gamestate.getState())
@@ -86,42 +87,44 @@ public class PathGame implements IGame
             case MENU:
                 menuRenderer.renderTick(r, lag, menu);
                 break;
-
         }
     }
 
-    private float getMapOffsetX(Renderer r, float lag, float interScale)
+    private float getMapOffsetX(TileMap map, Player player, 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())
+        float minOffX = -mapRenderer.getWidth(map) + r.getViewWidth();
+        if(offX < minOffX)
         {
-            return -mapRenderer.getWidth(map) + r.getViewWidth();
+            return cam.getCamOffsetX(minOffX, minOffX, lag, interScale);
         }
         else if(offX > 0.0f)
         {
-            return 0.0f;
+            return cam.getCamOffsetX(0.0f, minOffX, lag, interScale);
         }
-        return offX;
+        return cam.getCamOffsetX(offX, minOffX, lag, interScale);
     }
 
-    private float getMapOffsetY(Renderer r, float lag, float interScale)
+    private float getMapOffsetY(TileMap map, Player player, Renderer r, float lag, float interScale)
     {
+        float viewHeight = r.getViewHeight() - HUDRenderer.OFFSET_Y;
         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;
+        float offY = (-iy + viewHeight * 0.5f) - TileRenderer.TILE_SIZE * 0.5f * interScale;
 
-        if(offY < -mapRenderer.getHeight(map) + r.getViewHeight())
+        float minOffY = -mapRenderer.getHeight(map) + viewHeight;
+        if(offY < minOffY)
         {
-            return -mapRenderer.getHeight(map) + r.getViewHeight();
+            return cam.getCamOffsetY(minOffY, minOffY, lag, interScale);
         }
         else if(offY > 0.0f)
         {
-            return 0.0f;
+            return cam.getCamOffsetY(0.0f, minOffY, lag, interScale);
         }
-        return offY;
+        return cam.getCamOffsetY(offY, minOffY, lag, interScale);
     }
-
+    
     @Override
     public void onStop()
     {

src/pathgame/gameplay/Camera.java

@@ -0,0 +1,125 @@
+package pathgame.gameplay;
+
+public class Camera
+{
+
+    private final static int CAM_SPEED = 64;
+
+    private float lastScale = 1.0f;
+    private float scale = 1.0f;
+
+    private float lastCamOffsetX = 0.0f;
+    private float lastCamOffsetY = 0.0f;
+    private float camOffsetX = 0.0f;
+    private float camOffsetY = 0.0f;
+
+    public void tick(Level level)
+    {
+        lastCamOffsetX = camOffsetX;
+        lastCamOffsetY = camOffsetY;
+        lastScale = scale;
+
+        if(Keys.ZOOM_IN_KEY.isDown())
+        {
+            scale *= 1.1f;
+        }
+        else if(Keys.ZOOM_OUT_KEY.isDown())
+        {
+            scale /= 1.1f;
+        }
+
+        if(!level.getPlayer().isMoving())
+        {
+            if(Keys.CAM_UP_KEY.isDown())
+            {
+                camOffsetY += CAM_SPEED;
+            }
+            if(Keys.CAM_DOWN_KEY.isDown())
+            {
+                camOffsetY -= CAM_SPEED;
+            }
+            if(Keys.CAM_LEFT_KEY.isDown())
+            {
+                camOffsetX += CAM_SPEED;
+            }
+            if(Keys.CAM_RIGHT_KEY.isDown())
+            {
+                camOffsetX -= CAM_SPEED;
+            }
+        }
+    }
+
+    public void limitScale(float zoomRestriction)
+    {
+        if(scale <= zoomRestriction)
+        {
+            scale = zoomRestriction;
+        }
+        if(lastScale <= zoomRestriction)
+        {
+            lastScale = zoomRestriction;
+        }
+
+    }
+    
+    public void reset()
+    {
+        camOffsetX = 0.0f;
+        camOffsetY = 0.0f;
+        lastCamOffsetX = 0.0f;
+        lastCamOffsetY = 0.0f;
+    }
+
+    public float getInterpolatedScale(float lag)
+    {
+        return lastScale + (scale - lastScale) * lag;
+    }
+    
+    public float getCamOffsetX(float offX, float minOffX, float lag, float interScale)
+    {
+        float interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
+        if(offX + interCamX > 0.0f)
+        {
+            camOffsetX = -offX;
+            if(lastCamOffsetX > camOffsetX)
+            {
+                lastCamOffsetX = camOffsetX;
+            }
+            interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
+        }
+        if(offX + interCamX < minOffX)
+        {
+            camOffsetX = minOffX - offX;
+            if(lastCamOffsetX < camOffsetX)
+            {
+                lastCamOffsetX = camOffsetX;
+            }
+            interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
+        }
+        return offX + interCamX;
+    }
+    
+    public float getCamOffsetY(float offY, float minOffY, float lag, float interScale)
+    {
+        float interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
+        if(offY + interCamY > 0.0f)
+        {
+            camOffsetY = -offY;
+            if(lastCamOffsetY > camOffsetY)
+            {
+                lastCamOffsetY = camOffsetY;
+            }
+            interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
+        }
+        if(offY + interCamY < minOffY)
+        {
+            camOffsetY = minOffY - offY;
+            if(lastCamOffsetY < camOffsetY)
+            {
+                lastCamOffsetY = camOffsetY;
+            }
+            interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
+        }
+        return offY + interCamY;
+    }
+}

src/pathgame/gameplay/Keys.java

@@ -14,5 +14,9 @@ public class Keys
     public static final KeyBinding ZOOM_OUT_KEY = KeyHandler.register(GLFW.GLFW_KEY_O);
     public static final KeyBinding CONFIRM_KEY = KeyHandler.register(GLFW.GLFW_KEY_ENTER);
     public static final KeyBinding ESCAPE_KEY = KeyHandler.register(GLFW.GLFW_KEY_ESCAPE);
+    public static final KeyBinding CAM_UP_KEY = KeyHandler.register(GLFW.GLFW_KEY_UP);
+    public static final KeyBinding CAM_DOWN_KEY = KeyHandler.register(GLFW.GLFW_KEY_DOWN);
+    public static final KeyBinding CAM_LEFT_KEY = KeyHandler.register(GLFW.GLFW_KEY_LEFT);
+    public static final KeyBinding CAM_RIGHT_KEY = KeyHandler.register(GLFW.GLFW_KEY_RIGHT);
     public static final KeyBinding TEST_KEY = KeyHandler.register(GLFW.GLFW_KEY_T);
 }

src/pathgame/gameplay/Level.java

@@ -0,0 +1,45 @@
+package pathgame.gameplay;
+
+import pathgame.tilemap.TileMap;
+import pathgame.tilemap.TileMapGenerator;
+
+public final class Level
+{
+    private final Player player = new Player();
+    private int level = 1;
+    private TileMap map = null;
+    
+    public Level()
+    {
+        reset();
+    }
+    
+    public void nextLevel()
+    {
+        level++;
+        reset();
+    }
+    
+    public void reset()
+    {
+        player.reset();
+        map = TileMapGenerator.getMap(5 + 5 * level, 5 + 5 * level, level, 2 + level);
+        player.setEnergySupply(100); // ToDo: insert value of algorithm
+        player.setObjectivesAmount(map.getNumberOfTowns());
+    }
+
+    public TileMap getMap()
+    {
+        return map;
+    }
+
+    public Player getPlayer()
+    {
+        return player;
+    }
+
+    public int getLevel()
+    {
+        return level;
+    }
+}

src/pathgame/gameplay/Player.java

@@ -4,14 +4,12 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import pathgame.tilemap.Tile;
 import pathgame.tilemap.TileMap;
-import pathgame.tilemap.TileTown;
 
 public class Player
 {
-
     private static final float SPEED = 0.125f;
 
-    private PlayerAbilities abilities;
+    private PlayerAbilities abilities = PlayerAbilities.NORMAL;
 
     private float lastX = 0;
     private float lastY = 0;
@@ -28,13 +26,9 @@ public class Player
     private int objectivesAmount;
     private int objectivesVisited = 0;
     private final LinkedList<MinusStepsValues> steps = new LinkedList<>();
-    //private int minusEnergy = 0;
 
-    public Player(int energySupply, int objectivesAmount, PlayerAbilities abilities)
+    public Player()
     {
-        this.energySupply = energySupply;
-        this.objectivesAmount = objectivesAmount;
-        this.abilities = abilities;
     }
 
     public float getLastX()
@@ -89,10 +83,6 @@ public class Player
             if(isMoving)
             {
                 currentTile.onEnter(this, map, currentTileX, currentTileY);
-                if(currentTile instanceof TileTown)
-                {
-                    ++objectivesVisited;
-                }
                 steps.addLast(new MinusStepsValues(currSpeedSlowdown));
                 energyUsed += currSpeedSlowdown;
             }
@@ -200,11 +190,21 @@ public class Player
     {
         return objectivesAmount;
     }
+    
+    public void setObjectivesAmount(int objectivesAmount)
+    {
+        this.objectivesAmount = objectivesAmount;
+    }
 
     public int getObjectivesVisited()
     {
         return objectivesVisited;
     }
+    
+    public void visitTown()
+    {
+        objectivesVisited++;
+    }
 
     public LinkedList<MinusStepsValues> getLastSteps()
     {
@@ -226,11 +226,6 @@ public class Player
         this.energySupply = energySupply;
     }
 
-    public void setObjectivesAmount(int objectivesAmount)
-    {
-        this.objectivesAmount = objectivesAmount;
-    }
-
     public boolean hasWon()
     {
         return objectivesVisited >= objectivesAmount;
@@ -266,4 +261,9 @@ public class Player
     {
         reset(1000, 10, PlayerAbilities.NORMAL);
     }
+
+    public boolean isMoving()
+    {
+        return isMoving;
+    }
 }

src/pathgame/gameplay/PlayerAbilities.java

@@ -2,6 +2,7 @@ package pathgame.gameplay;
 
 public class PlayerAbilities
 {
+    private final String name;
     private final int fasterGrass;
     private final int fasterForest;
     private final int fasterShallowWater;
@@ -10,9 +11,10 @@ public class PlayerAbilities
     private final int fasterMountain;
     private final int fasterSwamp;
     
-    public PlayerAbilities(int fasterGrass, int fasterForest, int fasterShallowWater, 
+    public PlayerAbilities(String name, int fasterGrass, int fasterForest, int fasterShallowWater, 
             int fasterDeepWater, int fasterHill, int fasterMountain, int fasterSwamp)
     {
+        this.name = name;
         this.fasterGrass = fasterGrass;
         this.fasterForest = fasterForest;
         this.fasterShallowWater = fasterShallowWater;
@@ -22,12 +24,17 @@ public class PlayerAbilities
         this.fasterSwamp = fasterSwamp;
     }
 
-    public final static PlayerAbilities NORMAL = new PlayerAbilities(0, 0, 0, 0, 0, 0, 0);
-    public final static PlayerAbilities HIKER = new PlayerAbilities(0, 0, 0, 0, 1, 0, 0);
-    public final static PlayerAbilities CLIMBER = new PlayerAbilities(0, 0, 0, 0, 0, 1, 0);
-    public final static PlayerAbilities FOREST = new PlayerAbilities(0, 1, 0, 0, 0, 0, 0);
-    public final static PlayerAbilities SWIMMER = new PlayerAbilities(0, 0, 2, 0, 0, 0, 0);
-    public final static PlayerAbilities SAILOR = new PlayerAbilities(0, 0, 0, 1, 0, 0, 0);
+    public final static PlayerAbilities NORMAL = new PlayerAbilities("Normal", 0, 0, 0, 0, 0, 0, 0);
+    public final static PlayerAbilities HIKER = new PlayerAbilities("Hiker", 0, 0, 0, 0, 1, 0, 0);
+    public final static PlayerAbilities CLIMBER = new PlayerAbilities("Climber", 0, 0, 0, 0, 0, 1, 0);
+    public final static PlayerAbilities HUNTER = new PlayerAbilities("Hunter", 0, 1, 0, 0, 0, 0, 0);
+    public final static PlayerAbilities SWIMMER = new PlayerAbilities("Swimmer", 0, 0, 2, 0, 0, 0, 0);
+    public final static PlayerAbilities SAILOR = new PlayerAbilities("Sailor", 0, 0, 0, 1, 0, 0, 0);
+    
+    public final static PlayerAbilities[] ABILITIES = new PlayerAbilities[] 
+    {
+        NORMAL, HIKER, CLIMBER, HUNTER, SWIMMER, SAILOR
+    };
 
     public int getFasterGrass()
     {
@@ -63,4 +70,9 @@ public class PlayerAbilities
     {
         return fasterSwamp;
     }
+
+    public String getName()
+    {
+        return name;
+    }
 }

src/pathgame/gameplay/menu/BaseMenu.java

@@ -2,6 +2,7 @@ package pathgame.gameplay.menu;
 
 import pathgame.gameplay.Gamestate;
 import pathgame.gameplay.Keys;
+import pathgame.gameplay.Level;
 
 public abstract class BaseMenu
 {
@@ -25,7 +26,7 @@ public abstract class BaseMenu
         return false;
     }
     
-    public int tick(Gamestate gamestate)
+    public int tick(Gamestate gamestate, Level level)
     {
         returnId = id;
         if(isUpPressed())
@@ -39,7 +40,7 @@ public abstract class BaseMenu
         }
         else if(isEnterPressed())
         {
-            getOptions()[index].run(gamestate);
+            getOptions()[index].run(gamestate, level);
         }
         if(returnId != id)
         {

src/pathgame/gameplay/menu/CharacterMenu.java

@@ -0,0 +1,41 @@
+package pathgame.gameplay.menu;
+
+import pathgame.gameplay.Gamestates;
+import pathgame.gameplay.PlayerAbilities;
+
+public class CharacterMenu extends BaseMenu
+{
+    private final MenuOption[] options;
+
+    public CharacterMenu(int id, int mainId)
+    {
+        super(id);
+
+        options = new MenuOption[PlayerAbilities.ABILITIES.length + 1];
+
+        for(int i = 0; i < options.length - 1; ++i)
+        {
+            options[i] = getAbilityOption(PlayerAbilities.ABILITIES[i]);
+        }
+        options[options.length - 1] = new MenuOption("Back", (gamestate) ->
+        {
+            setReturnId(mainId);
+        });
+    }
+
+    private static MenuOption getAbilityOption(PlayerAbilities pa)
+    {
+        return new MenuOption(pa.getName(), (gamestate, level) ->
+        {
+            level.reset();
+            level.getPlayer().setAbilities(pa);
+            gamestate.setState(Gamestates.GAMEPLAY);
+        });
+    }
+
+    @Override
+    public MenuOption[] getOptions()
+    {
+        return options;
+    }
+}

src/pathgame/gameplay/menu/MainMenu.java

@@ -1,13 +1,12 @@
 package pathgame.gameplay.menu;
 
 import me.hammerle.snuviengine.api.Engine;
-import pathgame.gameplay.Gamestates;
 
 public class MainMenu extends BaseMenu
 {
     private final MenuOption[] options;
     
-    public MainMenu(int id, int optionsId)
+    public MainMenu(int id, int optionsId, int charaterId)
     {
         super(id);
         
@@ -15,7 +14,7 @@ public class MainMenu extends BaseMenu
         {
             new MenuOption("Start", (gamestate) -> 
             {
-                gamestate.setState(Gamestates.GAMEPLAY);
+                setReturnId(charaterId);
             }),
             new MenuOption("Options", (gamestate) -> 
             {

src/pathgame/gameplay/menu/Menu.java

@@ -3,12 +3,14 @@ package pathgame.gameplay.menu;
 import pathgame.gameplay.Gamestate;
 import pathgame.gameplay.Gamestates;
 import pathgame.gameplay.Keys;
+import pathgame.gameplay.Level;
 
 public class Menu
 {
     private final static int MAIN_ID;
     private final static int ESCAPE_ID;
     private final static int OPTION_ID;
+    private final static int CHARACTER_ID;
     
     static
     {
@@ -16,22 +18,24 @@ public class Menu
         MAIN_ID = id++;
         ESCAPE_ID = id++;
         OPTION_ID = id++;
+        CHARACTER_ID = id++;
     }
     
     private final BaseMenu[] menus = new BaseMenu[] 
     { 
-        new MainMenu(MAIN_ID, OPTION_ID), 
+        new MainMenu(MAIN_ID, OPTION_ID, CHARACTER_ID), 
         new EscMenu(ESCAPE_ID, MAIN_ID), 
-        new OptionMenu(OPTION_ID, MAIN_ID) 
+        new OptionMenu(OPTION_ID, MAIN_ID), 
+        new CharacterMenu(CHARACTER_ID, MAIN_ID) 
     };
     
     private int currentIndex = 0;
     
-    public void tick(Gamestate gamestate)
+    public void tick(Gamestate gamestate, Level level)
     {
         if(gamestate.getState() == Gamestates.MENU)
         {
-            currentIndex = menus[currentIndex].tick(gamestate);
+            currentIndex = menus[currentIndex].tick(gamestate, level);
             if(currentIndex == ESCAPE_ID && Keys.ESCAPE_KEY.getTime() == 1)
             {
                 gamestate.setState(Gamestates.GAMEPLAY);

src/pathgame/gameplay/menu/MenuOption.java

@@ -1,26 +1,33 @@
 package pathgame.gameplay.menu;
 
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import pathgame.gameplay.Gamestate;
+import pathgame.gameplay.Level;
 
 public class MenuOption
 {
     private final String name;
-    private final Consumer<Gamestate> r;
+    private final BiConsumer<Gamestate, Level> r;
     
-    public MenuOption(String name, Consumer<Gamestate> r)
+    public MenuOption(String name, BiConsumer<Gamestate, Level> r)
     {
         this.name = name;
         this.r = r;
     }
+    
+    public MenuOption(String name, Consumer<Gamestate> r)
+    {
+        this(name, (gamestate, level) -> r.accept(gamestate));
+    }
 
     public String getName()
     {
         return name;
     }
     
-    public void run(Gamestate gamestate)
+    public void run(Gamestate gamestate, Level level)
     {
-        r.accept(gamestate);
+        r.accept(gamestate, level);
     }
 }

src/pathgame/rendering/HUDRenderer.java

@@ -8,8 +8,9 @@ import pathgame.gameplay.Player;
 
 public class HUDRenderer
 {
-    private static final Texture ENERGYBAR = new Texture("res/energyBar.png");
-    private static final Texture ENERGYBARGREY = new Texture("res/energyBarGrey.png");
+    public static final float OFFSET_Y = 40;
+    private static final Texture ENERGYBAR = new Texture("resources/energyBar.png");
+    private static final Texture ENERGYBARGREY = new Texture("resources/energyBarGrey.png");
 
     public void renderTick(Renderer r, Player p, float lag)//TileMap map, TileMapRenderer map, float lag, float offX, float offY)
     {
@@ -32,7 +33,7 @@ public class HUDRenderer
         r.setTextureEnabled(false);
         r.setBlendingEnabled(true);
 
-        r.getColorRenderer().drawRectangle(0, 0, r.getViewWidth(), 20, 0x33_00_00_00);//ABGR
+        r.getColorRenderer().drawRectangle(0, 0, r.getViewWidth(), 20, 0xFF_00_00_00);//ABGR
     }
 
     void renderObjectiveTracker(Renderer r, Player p)

src/pathgame/rendering/MenuRenderer.java

@@ -47,7 +47,7 @@ public class MenuRenderer
         r.setTextureEnabled(false);
         r.setBlendingEnabled(true);
 
-        r.getColorRenderer().drawRectangle(windowWidth * 0.10f, y - textBoxPaddingY * 0.5f, windowWidth * 0.90f, y + textBoxHeight + textBoxPaddingY * 0.5f, 0x33000000);
+        r.getColorRenderer().drawRectangle(windowWidth * 0.10f, y - textBoxPaddingY * 0.5f, windowWidth * 0.90f, y + textBoxHeight + textBoxPaddingY * 0.5f, 0x50000000);
 
         r.setTextureEnabled(true);
 

src/pathgame/rendering/PlayerRenderer.java

@@ -20,7 +20,6 @@ public class PlayerRenderer
         r.translateTo(0.0f, 0.0f);
         r.updateMatrix();
 
-        //TODO: insert animations
         float yIndex;
         float baseX = (p.getLastX() + (p.getX() - p.getLastX()) * lag);
         float ix = baseX * mapR.getScale() * TileRenderer.TILE_SIZE + offX;
@@ -38,25 +37,25 @@ public class PlayerRenderer
         {
             //go right
             yIndex = 2;
-            tIndex = checkForAnimationIndex(baseX, 2);
+            tIndex = checkForAnimationIndex(baseX);
         }
         else if(p.getVelX() < 0)
         {
             //go left
             yIndex = 1;
-            tIndex = checkForAnimationIndex(baseX, 2);
+            tIndex = checkForAnimationIndex(baseX);
         }
         else if(p.getVelY() > 0)
         {
             //go down
             yIndex = 0;
-            tIndex = checkForAnimationIndex(baseY, 2);
+            tIndex = checkForAnimationIndex(baseY);
         }
         else if(p.getVelY() < 0)
         {
             //go up
             yIndex = 3;
-            tIndex = checkForAnimationIndex(baseY, 2);
+            tIndex = checkForAnimationIndex(baseY);
         }
         else
         {
@@ -67,8 +66,8 @@ public class PlayerRenderer
                 tIndex * 0.25f, yIndex * 0.25f, (tIndex + 1) * 0.25f, yIndex * 0.25f + 0.25f);
     }
 
-    private int checkForAnimationIndex(float base, int speed)
+    private int checkForAnimationIndex(float base)
     {
-        return (int) (Math.ceil(base / (0.125f / speed)) / 3)%4;
+        return ((int) (base * 4 * 2)) % 4;
     }
 }

src/pathgame/tilemap/TileTown.java

@@ -12,6 +12,7 @@ public class TileTown extends Tile
     @Override
     public void onEnter(Player p, TileMap map, int x, int y)
     {
+        p.visitTown();
         System.out.println("Enter Town " + x + " " + y);
     }