Character - Ship function, bug (Map Rand)

src/pathgame/PathGame.java

@@ -3,35 +3,23 @@ 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.gameplay.Level;
-import pathgame.gameplay.Player;
-import pathgame.rendering.TileMapRenderer;
 import pathgame.gameplay.menu.Menu;
-import pathgame.rendering.HUDRenderer;
+import pathgame.rendering.LevelRenderer;
 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 Level level = new Level();
-
-    private final PlayerRenderer playerRenderer = new PlayerRenderer();
-    private final TileMapRenderer mapRenderer = new TileMapRenderer();
-
+    private final LevelRenderer levelRenderer = new LevelRenderer();
+    
     private final Menu menu = new Menu();
     private final MenuRenderer menuRenderer = new MenuRenderer();
-    private final HUDRenderer hudRenderer = new HUDRenderer();
-
-    private final Camera cam = new Camera();
 
     public PathGame()
     {
@@ -40,20 +28,11 @@ public class PathGame implements IGame
     @Override
     public void tick()
     {
-        cam.tick(level, gamestate);
-
-        level.getMap().tick();
-        mapRenderer.tick();
-        if(gamestate.getState() == Gamestates.GAMEPLAY)
-        {
-            level.getPlayer().tick(level.getMap());
-            if(level.getPlayer().isMoving())
-            {
-                cam.reset();
-            }
-        }
+        level.tick(gamestate);
+        levelRenderer.tick(level, gamestate);
+        
         menu.tick(gamestate, level);
-
+        
         if(Keys.TEST_KEY.getTime() == 1)
         {
             level.nextLevel();
@@ -66,73 +45,17 @@ public class PathGame implements IGame
     {
         if(gamestate.is(Gamestates.MENU))
         {
-            lag = 0.0f;
-        }
-        
-        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(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())
-        {
-            case GAMEPLAY:
-                playerRenderer.renderTick(map, mapRenderer, r, player, lag, offX, offY);
-                hudRenderer.renderTick(r, player, lag);
-                break;
-            case MENU:
-                menuRenderer.renderTick(r, lag, menu);
-                break;
-        }
-    }
-
-    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;
-
-        float minOffX = -mapRenderer.getWidth(map) + r.getViewWidth();
-        if(offX < minOffX)
-        {
-            return cam.getCamOffsetX(minOffX, minOffX, lag, interScale);
-        }
-        else if(offX > 0.0f)
-        {
-            return cam.getCamOffsetX(0.0f, minOffX, lag, interScale);
-        }
-        return cam.getCamOffsetX(offX, minOffX, lag, 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 + viewHeight * 0.5f) - TileRenderer.TILE_SIZE * 0.5f * interScale;
-
-        float minOffY = -mapRenderer.getHeight(map) + viewHeight;
-        if(offY < minOffY)
-        {
-            return cam.getCamOffsetY(minOffY, minOffY, lag, interScale);
+            levelRenderer.renderTick(r, 0.0f, level, gamestate);
+            menuRenderer.renderTick(r, 0.0f, menu);
         }
-        else if(offY > 0.0f)
+        else
         {
-            return cam.getCamOffsetY(0.0f, minOffY, lag, interScale);
+            levelRenderer.renderTick(r, lag, level, gamestate);
         }
-        return cam.getCamOffsetY(offY, minOffY, lag, interScale);
     }
 
     @Override
     public void onStop()
     {
     }
-}
+}

src/pathgame/gameplay/Level.java

@@ -8,18 +8,27 @@ public final class Level
     private final Player player = new Player();
     private int level = 1;
     private TileMap map = null;
-    
+
     public Level()
     {
         reset();
     }
-    
+
+    public void tick(Gamestate gamestate)
+    {
+        map.tick();
+        if(gamestate.is(Gamestates.GAMEPLAY))
+        {
+            player.tick(map);
+        }
+    }
+
     public void nextLevel()
     {
         level++;
         reset();
     }
-    
+
     public void reset()
     {
         player.reset();
@@ -42,4 +51,4 @@ public final class Level
     {
         return level;
     }
-}
+}

src/pathgame/gameplay/Player.java

@@ -75,7 +75,7 @@ public class Player
 
         int currentTileX = Math.round(x);
         int currentTileY = Math.round(y);
-
+        //System.out.println(currentTileY + " " + y);
         //TODO: Bug beheben: Exception, wenn Spieler sofort an den unteren Levelrand geht (auch am rechten Levelrand)
         //ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 10
         //System.out.println(currentTileY);
@@ -92,10 +92,6 @@ public class Player
             velY = 0.0f;
             if(isMoving)
             {
-                //if(currentTile == Tiles.FOREST) //TODO: check for port with onEnter() or if
-                {
-                    //isSailing = !isSailing;
-                }
                 currentTile.onEnter(this, map, currentTileX, currentTileY);
                 steps.addLast(new MinusStepsValues(currSpeedSlowdown));
                 energyUsed += currSpeedSlowdown;
@@ -103,50 +99,29 @@ public class Player
             isMoving = false;
         }
 
-        if(Keys.LEFT_KEY.isDown() && !isMoving && x > 0 && !map.getTile(currentTileX - 1, currentTileY).isBlockingMovement())
+        if(Keys.LEFT_KEY.isDown() && !isMoving && currentTileX > 0 && !map.getTile(currentTileX - 1, currentTileY).isBlockingMovement(this))
         {
-            if((!isSailing && map.getTile(currentTileX - 1, currentTileY) != Tiles.DEEP_WATER)
-                    || (isSailing && (map.getTile(currentTileX - 1, currentTileY) == Tiles.SHALLOW_WATER
-                    || map.getTile(currentTileX - 1, currentTileY) == Tiles.DEEP_WATER))) // TODO: or is port
-            {
-                velX = -SPEED;
-                isMoving = true;
-                currentTile.onLeave(this, map, currentTileX, currentTileY);
-            }
+            velX = -SPEED;
+            isMoving = true;
+            currentTile.onLeave(this, map, currentTileX, currentTileY);
         }
-        else if(Keys.RIGHT_KEY.isDown() && !isMoving && x < map.getWidth() - 1 && !map.getTile(currentTileX + 1, currentTileY).isBlockingMovement())
+        else if(Keys.RIGHT_KEY.isDown() && !isMoving && currentTileX < map.getWidth() - 1 && !map.getTile(currentTileX + 1, currentTileY).isBlockingMovement(this))
         {
-            if((!isSailing && map.getTile(currentTileX + 1, currentTileY) != Tiles.DEEP_WATER)
-                    || (isSailing && (map.getTile(currentTileX + 1, currentTileY) == Tiles.SHALLOW_WATER
-                    || map.getTile(currentTileX + 1, currentTileY) == Tiles.DEEP_WATER))) // TODO: or is port
-            {
-                velX = SPEED;
-                isMoving = true;
-                currentTile.onLeave(this, map, currentTileX, currentTileY);
-            }
+            velX = SPEED;
+            isMoving = true;
+            currentTile.onLeave(this, map, currentTileX, currentTileY);
         }
-        else if(Keys.UP_KEY.isDown() && !isMoving && y > 0 && !map.getTile(currentTileX, currentTileY - 1).isBlockingMovement())
+        else if(Keys.UP_KEY.isDown() && !isMoving && currentTileY > 0 && !map.getTile(currentTileX, currentTileY - 1).isBlockingMovement(this))
         {
-            if((!isSailing && map.getTile(currentTileX, currentTileY - 1) != Tiles.DEEP_WATER)
-                    || (isSailing && (map.getTile(currentTileX, currentTileY - 1) == Tiles.SHALLOW_WATER
-                    || map.getTile(currentTileX, currentTileY - 1) == Tiles.DEEP_WATER))) // TODO: or is port
-                    
-            {
-                velY = -SPEED;
-                isMoving = true;
-                currentTile.onLeave(this, map, currentTileX, currentTileY);
-            }
+            velY = -SPEED;
+            isMoving = true;
+            currentTile.onLeave(this, map, currentTileX, currentTileY);
         }
-        else if(Keys.DOWN_KEY.isDown() && !isMoving && y < map.getHeight() - 1 && !map.getTile(currentTileX, currentTileY + 1).isBlockingMovement())
+        else if(Keys.DOWN_KEY.isDown() && !isMoving && currentTileY < map.getHeight() - 1 && !map.getTile(currentTileX, currentTileY + 1).isBlockingMovement(this))
         {
-            if((!isSailing && map.getTile(currentTileX, currentTileY + 1) != Tiles.DEEP_WATER)
-                    || (isSailing && (map.getTile(currentTileX, currentTileY + 1) == Tiles.SHALLOW_WATER
-                    || map.getTile(currentTileX, currentTileY + 1) == Tiles.DEEP_WATER))) // TODO: or is port
-            {
-                velY = SPEED;
-                isMoving = true;
-                currentTile.onLeave(this, map, currentTileX, currentTileY);
-            }
+            velY = SPEED;
+            isMoving = true;
+            currentTile.onLeave(this, map, currentTileX, currentTileY);
         }
 
         float moveX = Math.abs(velX / currSpeedSlowdown);
@@ -302,10 +277,14 @@ public class Player
         return isMoving;
     }
 
+    public void switchSailing()
+    {
+        isSailing = !isSailing;
+    }
+    
     public boolean isSailing()
     {
-        return false; //TODO: delete line
-        //return isSailing;
+        return isSailing;
     }
 
     public Tile getCurrTile()

src/pathgame/rendering/LevelRenderer.java

@@ -0,0 +1,88 @@
+package pathgame.rendering;
+
+import me.hammerle.snuviengine.api.Renderer;
+import pathgame.gameplay.Camera;
+import pathgame.gameplay.Gamestate;
+import pathgame.gameplay.Gamestates;
+import pathgame.gameplay.Level;
+import pathgame.gameplay.Player;
+import pathgame.tilemap.TileMap;
+
+public class LevelRenderer
+{
+
+    private final PlayerRenderer playerRenderer = new PlayerRenderer();
+    private final TileMapRenderer mapRenderer = new TileMapRenderer();
+    private final HUDRenderer hudRenderer = new HUDRenderer();
+    private final Camera cam = new Camera();
+
+    public void tick(Level level, Gamestate gamestate)
+    {
+        cam.tick(level, gamestate);
+        mapRenderer.tick();
+        if(level.getPlayer().isMoving())
+        {
+            cam.reset();
+        }
+    }
+
+    public void renderTick(Renderer r, float lag, Level level, Gamestate gamestate)
+    {
+        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(map, player, r, lag, interScale);
+        float offY = getMapOffsetY(map, player, r, lag, interScale) + HUDRenderer.OFFSET_Y;
+
+        mapRenderer.renderTick(map, r, false, offX, offY);
+
+        if(gamestate.is(Gamestates.GAMEPLAY))
+        {
+            playerRenderer.renderTick(map, mapRenderer, r, player, lag, offX, offY);
+            hudRenderer.renderTick(r, player, lag);
+        }
+    }
+
+    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;
+
+        float minOffX = -mapRenderer.getWidth(map) + r.getViewWidth();
+        if(offX < minOffX)
+        {
+            return cam.getCamOffsetX(minOffX, minOffX, lag, interScale);
+        }
+        else if(offX > 0.0f)
+        {
+            return cam.getCamOffsetX(0.0f, minOffX, lag, interScale);
+        }
+        return cam.getCamOffsetX(offX, minOffX, lag, 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 + viewHeight * 0.5f) - TileRenderer.TILE_SIZE * 0.5f * interScale;
+
+        float minOffY = -mapRenderer.getHeight(map) + viewHeight;
+        if(offY < minOffY)
+        {
+            return cam.getCamOffsetY(minOffY, minOffY, lag, interScale);
+        }
+        else if(offY > 0.0f)
+        {
+            return cam.getCamOffsetY(0.0f, minOffY, lag, interScale);
+        }
+        return cam.getCamOffsetY(offY, minOffY, lag, interScale);
+    }
+}

src/pathgame/tilemap/Tile.java

@@ -17,6 +17,7 @@ public class Tile
         private Function<PlayerAbilities, Integer> speedUp = (pa) -> 0;
         private boolean canHostTown = true;
         private boolean blocksMovement = false;
+        private TileType type = TileType.LAND;
         
         private TileBuilder()
         {
@@ -57,9 +58,15 @@ public class Tile
             return this;
         }
         
+        public TileBuilder setType(TileType type)
+        {
+            this.type = type;
+            return this;
+        }
+        
         public Tile build()
         {
-            return new Tile(energyCost, forestReplaceChance, speedUp, canHostTown, blocksMovement);
+            return new Tile(energyCost, forestReplaceChance, speedUp, canHostTown, blocksMovement, type);
         }
     }
     
@@ -98,8 +105,10 @@ public class Tile
     private final Function<PlayerAbilities, Integer> speedUp;
     private final boolean canHostTown;
     private final boolean blocksMovement;
+    private final TileType type;
     
-    protected Tile(int energyCost, float forestReplaceChance, Function<PlayerAbilities, Integer> speedUp, boolean canHostTown, boolean blocksMovement)
+    protected Tile(int energyCost, float forestReplaceChance, Function<PlayerAbilities, Integer> speedUp, 
+            boolean canHostTown, boolean blocksMovement, TileType type)
     {
         id = addTile(this);
         this.energyCost = energyCost;
@@ -107,6 +116,7 @@ public class Tile
         this.speedUp = speedUp;
         this.canHostTown = canHostTown;
         this.blocksMovement = blocksMovement;
+        this.type = type;
     }
 
     /** Returns the id of the tile.
@@ -165,10 +175,21 @@ public class Tile
 
     /** Returns true if this tile blocks movement.
      *
+     * @param p the player
      * @return true if this tile blocks movement
      */
-    public boolean isBlockingMovement()
+    public boolean isBlockingMovement(Player p)
+    {
+        return blocksMovement || (p.isSailing() && type == TileType.LAND) || 
+                (!p.isSailing() && type == TileType.DEEP_WATER);
+    }
+    
+    /** Returns the type of the tile.
+     *
+     * @return the type of the tile
+     */
+    public TileType getType()
     {
-        return blocksMovement;
+        return type;
     }
 }

src/pathgame/tilemap/TilePort.java

@@ -0,0 +1,17 @@
+package pathgame.tilemap;
+
+import pathgame.gameplay.Player;
+
+public class TilePort extends Tile
+{
+    public TilePort()
+    {
+        super(1, 0.0f, (pa) -> 0, false, false, TileType.PORT);
+    }
+
+    @Override
+    public void onEnter(Player p, TileMap map, int x, int y)
+    {
+        p.switchSailing();
+    }
+}

src/pathgame/tilemap/TileTown.java

@@ -6,20 +6,18 @@ public class TileTown extends Tile
 {
     public TileTown()
     {
-        super(1, 0.0f, (pa) -> 0, false, false);
+        super(1, 0.0f, (pa) -> 0, false, false, TileType.LAND);
     }
 
     @Override
     public void onEnter(Player p, TileMap map, int x, int y)
     {
         p.visitTown();
-        System.out.println("Enter Town " + x + " " + y);
     }
 
     @Override
     public void onLeave(Player p, TileMap map, int x, int y)
     {
-        System.out.println("Leave Town " + x + " " + y);
         map.convertTown(x, y);
     }
 }

src/pathgame/tilemap/TileType.java

@@ -0,0 +1,6 @@
+package pathgame.tilemap;
+
+public enum TileType
+{
+    PORT, LAND, SHALLOW_WATER, DEEP_WATER
+}

src/pathgame/tilemap/Tiles.java

@@ -33,12 +33,14 @@ public class Tiles
             .setForestReplaceChance(0.0f)
             .setSpeedUp((pa) -> pa.getFasterShallowWater())
             .noTown()
+            .setType(TileType.SHALLOW_WATER)
             .build();
     public final static Tile DEEP_WATER = Tile.TileBuilder.create()
             .setEnergyCost(3)
             .setForestReplaceChance(0.0f)
             .setSpeedUp((pa) -> pa.getFasterDeepWater())
             .noTown()
+            .setType(TileType.DEEP_WATER)
             .build();
     public final static Tile HILL = Tile.TileBuilder.create()
             .setEnergyCost(3)
@@ -62,10 +64,7 @@ public class Tiles
         TOWN_BLOCKED_1, TOWN_BLOCKED_2, TOWN_BLOCKED_3, TOWN_BLOCKED_4
     };
     
-    public final static Tile PORT = Tile.TileBuilder.create()
-            .noTown()
-            .setForestReplaceChance(0.0f)
-            .build();
+    public final static Tile PORT = new TilePort();
     
     public final static Tile buildGrass()
     {
@@ -87,7 +86,6 @@ public class Tiles
         return Tile.TileBuilder.create()
                 .setForestReplaceChance(0.0f)
                 .noTown()
-                .noMovement()
                 .build();
     }
 }