refactoring (double -> float, cleanup), moved most texture into an atlas, redesign of several components, new collision system, level rendering

slot1.txt

@@ -1,6 +1,6 @@
-level.00-Tech Demo=true
-level.00-Tech Demo.bottles=8
-level.00-Tech Demo.time=4.125000000000025
-level.01-Parabola=true
-level.01-Parabola.bottles=4
-level.01-Parabola.time=12.074999999999848
+level.00-Tech_Demo.map=true
+level.00-Tech_Demo.map.bottles=9
+level.00-Tech_Demo.map.time=1.9124999999999952
+level.01-Parabola.map=true
+level.01-Parabola.map.bottles=1
+level.01-Parabola.map.time=1.6249999999999962

src/me/hammerle/supersnuvi/Game.java

@@ -1,6 +1,7 @@
 package me.hammerle.supersnuvi;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import me.hammerle.snuviengine.api.ColorRenderer;
@@ -15,6 +16,13 @@ import me.hammerle.supersnuvi.util.SoundUtils;
 
 public class Game extends Engine
 {
+    private static final int MS_PER_TICK = 50;
+    
+    public static int getTicksForMillis(int millis)
+    {
+        return millis / MS_PER_TICK;
+    }
+    
     private static Game instance;
     
     public static Game get()
@@ -23,7 +31,7 @@ public class Game extends Engine
     }
     
     // constants
-    public static final ColoredBaseTile FALLBACK_TILE = new ColoredBaseTile(0, 0, 0, 0);
+    public static final NullTile FALLBACK_TILE = new NullTile();
     
     // tiles
     private final HashMap<Integer, Tile> registeredTiles = new HashMap<>();;
@@ -59,18 +67,23 @@ public class Game extends Engine
         
         File[] files = new File("./levels").listFiles();
         Arrays.sort(files, (o1, o2) -> o1.compareTo(o2));
-        levels = new Level[files.length];
-        for(int i = 0; i < levels.length; i++)
+        ArrayList<Level> levelList = new ArrayList<>();
+        for(File file : files)
         {
-            levels[i] = new Level(files[i]);
+            if(file.isFile())
+            {
+                Level l = new Level(file);
+                levelList.add(l);
+            }
         }
+        levels = levelList.toArray(new Level[levelList.size()]);
     }
     
     @Override
     public void init()
     {
         setMaxFps(120);
-        setNanosPerTick(50_000_000);
+        setNanosPerTick(MS_PER_TICK * 1_000_000);
     }
     
     // -------------------------------------------------------------------------
@@ -90,7 +103,7 @@ public class Game extends Engine
             // doing that here to prevent concurent modification
             if(currentLevel.shouldFinish())
             {
-                String base = "level." + currentLevel.getName();
+                String base = "level." + currentLevel.getFileName();
                 SimpleConfig sp = saveSlots[slotScreenIndex];
                 
                 // save success
@@ -284,9 +297,11 @@ public class Game extends Engine
     {
         if(currentLevel != null)
         {
-            currentLevel.render(lag);
+            currentLevel.renderTick(lag);
             return;
         }
+        Shader.translateTo(0.0f, 0.0f);
+        Shader.updateMatrix();
         switch(screen)
         {
             case 0:
@@ -549,18 +564,19 @@ public class Game extends Engine
         // dirt
         for(int i = 0; i < 16; i++)
         {
-            registeredTiles.put(i, new BaseBoxTile("dirt/dirt" + i));
+            registeredTiles.put(i, new BaseBoxTile(0.125f, 0.0f, 0.1875f, 0.0625f));
         }
         
         // grass
-        registeredTiles.put(20, new BaseBoxTile("grass/grass4"));
-        registeredTiles.put(21, new BaseBoxTile("grass/grass9"));
-        registeredTiles.put(22, new BaseBoxTile("grass/grass8"));
-        registeredTiles.put(23, new BaseBoxTile("grass/grass10"));
-        registeredTiles.put(28, new BaseBoxTile("grass/grass7"));
-        registeredTiles.put(29, new BaseBoxTile("grass/grass15"));
-        registeredTiles.put(30, new BaseBoxTile("grass/grass16"));
-        registeredTiles.put(31, new BaseBoxTile("grass/grass14"));
+        BaseBoxTile grass = new BaseBoxTile(0.0625f, 0.0f, 0.125f, 0.0625f);
+        registeredTiles.put(20, grass);
+        registeredTiles.put(21, grass);
+        registeredTiles.put(22, grass);
+        registeredTiles.put(23, grass);
+        registeredTiles.put(28, grass);
+        registeredTiles.put(29, grass);
+        registeredTiles.put(30, grass);
+        registeredTiles.put(31, grass);
         
         // bottled soul
         registeredTiles.put(32, new BottledSoulTile(1));
@@ -577,8 +593,10 @@ public class Game extends Engine
         registeredTiles.put(80, new SpikeTile());
         
         // water
-        registeredTiles.put(96, new WaterTile(true));
-        registeredTiles.put(97, new WaterTile(false));
+        for(int i = 0; i < 16; i++)
+        {
+            registeredTiles.put(96 + i, new WaterTile(15 - i));
+        }
         
         // snuvi start block
         registeredTiles.put(StartTile.ID, new StartTile());
@@ -586,36 +604,34 @@ public class Game extends Engine
         // sky
         registeredTiles.put(128, new SkyTile());
         
-        // ice
-        registeredTiles.put(144, new SlipperyTile("ice/ice"));
-        
         // slippery slime
-        registeredTiles.put(148, new SlipperyTile("slippery_slime/slippery_slime148"));
-        registeredTiles.put(149, new SlipperyTile("slippery_slime/slippery_slime149"));
-        registeredTiles.put(150, new SlipperyTile("slippery_slime/slippery_slime150"));
-        registeredTiles.put(151, new SlipperyTile("slippery_slime/slippery_slime151"));
-        registeredTiles.put(156, new SlipperyTile("slippery_slime/slippery_slime156"));
-        registeredTiles.put(157, new SlipperyTile("slippery_slime/slippery_slime157"));
-        registeredTiles.put(158, new SlipperyTile("slippery_slime/slippery_slime158"));
-        registeredTiles.put(159, new SlipperyTile("slippery_slime/slippery_slime159"));
+        SlipperyTile slime = new SlipperyTile();
+        registeredTiles.put(148, slime);
+        registeredTiles.put(149, slime);
+        registeredTiles.put(150, slime);
+        registeredTiles.put(151, slime);
+        registeredTiles.put(156, slime);
+        registeredTiles.put(157, slime);
+        registeredTiles.put(158, slime);
+        registeredTiles.put(159, slime);
         
         // end level
-        registeredTiles.put(160, new GoalTile("end/end"));
-        registeredTiles.put(161, new GoalTile("end/end2"));
+        registeredTiles.put(160, new GoalTile(0.25f, 0.125f, 0.3125f, 0.1875f));
+        registeredTiles.put(161, new GoalTile(0.25f, 0.0625f, 0.3125f, 0.125f));
         
         // thorns
-        registeredTiles.put(176, new KillTile("thorns/thorns_bottom", 2));
-        registeredTiles.put(177, new KillTile("thorns/thorns_mid", 2));
-        registeredTiles.put(178, new KillTile("thorns/thorns_top", 2));
-        registeredTiles.put(179, new KillTile("thorns/thorns_bottom", -3));
-        registeredTiles.put(180, new KillTile("thorns/thorns_mid", -3));
-        registeredTiles.put(181, new KillTile("thorns/thorns_top", -3));
+        registeredTiles.put(176, new KillTile(0.0f, 0.125f, 0.0625f, 0.1875f, 2));
+        registeredTiles.put(177, new KillTile(0.0625f, 0.125f, 0.125f, 0.1875f, 2));
+        registeredTiles.put(178, new KillTile(0.125f, 0.125f, 0.1875f, 0.1875f, 2));
+        registeredTiles.put(179, new KillTile(0.0f, 0.125f, 0.0625f, 0.1875f, -3));
+        registeredTiles.put(180, new KillTile(0.0625f, 0.125f, 0.125f, 0.1875f, -3));
+        registeredTiles.put(181, new KillTile(0.125f, 0.125f, 0.1875f, 0.1875f, -3));
         
         // decoration shrooms
-        registeredTiles.put(208, new DecoShroomTile("shrooms/shroom"));
-        registeredTiles.put(209, new DecoShroomTile("shrooms/shroom2"));
-        registeredTiles.put(210, new DecoShroomTile("shrooms/shroom3"));
-        registeredTiles.put(211, new DecoShroomTile("shrooms/shroom4"));
+        registeredTiles.put(208, new DecoShroomTile(0.0f, 0.21875f, 0.0625f, 0.25f));
+        registeredTiles.put(209, new DecoShroomTile(0.0f, 0.1875f, 0.0625f, 0.21875f));
+        registeredTiles.put(210, new DecoShroomTile(0.0625f, 0.21875f, 0.125f, 0.25f));
+        registeredTiles.put(211, new DecoShroomTile(0.0625f, 0.1875f, 0.125f, 0.21875f));
         
         // fog, starting late to make length changes possible
         for(int i = 0; i < 16; i++)
@@ -624,18 +640,18 @@ public class Game extends Engine
         }
         
         // london stuff
-        registeredTiles.put(224, new BaseBoxTile("london_background/london_background"));
+        //registeredTiles.put(224, new BaseBoxTile("london_background/london_background"));
         
         // london streets
         for(int i = 0; i < 16; i++)
         {
-            registeredTiles.put(240 + i, new BaseBoxTile("london_streets/london_streets" + i));
+            //registeredTiles.put(240 + i, new BaseBoxTile("london_streets/london_streets" + i));
         }
         
         // london street light
         for(int i = 0; i < 25; i++)
         {
-            registeredTiles.put(256 + i, new BaseBoxTile("street_light/street_light" + (i % 5) + "_" + (i / 5)));
+            //registeredTiles.put(256 + i, new BaseBoxTile("street_light/street_light" + (i % 5) + "_" + (i / 5)));
         }
     }
     

src/me/hammerle/supersnuvi/entity/Entity.java

@@ -1,89 +1,79 @@
 package me.hammerle.supersnuvi.entity;
 
-import me.hammerle.supersnuvi.entity.components.animator.EntityAnimator;
-import me.hammerle.supersnuvi.entity.components.ai.EntityController;
-import java.util.LinkedList;
+import java.util.List;
+import me.hammerle.supersnuvi.entity.components.animator.Renderer;
+import me.hammerle.supersnuvi.entity.components.ai.Controller;
 import me.hammerle.supersnuvi.entity.components.Energy;
 import me.hammerle.supersnuvi.entity.components.Health;
 import me.hammerle.supersnuvi.entity.components.ItemCollector;
 import me.hammerle.supersnuvi.entity.components.Movement;
-import me.hammerle.supersnuvi.entity.components.MovementPenalty;
 import me.hammerle.supersnuvi.gamelogic.Level;
-import me.hammerle.supersnuvi.rendering.OldGame;
-import me.hammerle.supersnuvi.tiles.Location;
 import me.hammerle.supersnuvi.util.CollisionBox;
 import me.hammerle.supersnuvi.util.Face;
 import me.hammerle.supersnuvi.util.Utils;
 
 public final class Entity
 {
-    // 1 Tile = 1 m
-    // Pixel    m       s      Pixel
-    // ----- * --- * ------ = -------
-    //   m      s     Tick     Tick
-    // added correction factor, real life gravity seems to strong
-    public static double GRAVITY = OldGame.TILE_SIZE * 9.81 / 60 * 0.1;
-    
-    private double posX;
-    private double posY;
-    private final double width;
-    private final double height;
-    private final double cWidth;
-    private final double cHeight;
-    
-    private double prevPosX;
-    private double prevPrevY;
-    
-    private double prevMotionX;
-    private double prevMotionY;
-    private double motionX;
-    private double motionY;
-    private boolean onGround;
-    
-    private final CollisionBox collisionBox;
-    
+    public static float GRAVITY = 8.0f;
+    public static float STEP = 0.0625f;
+    
+    // the last position is used for interpolation during rendering
+    private float lastPosX;
+    private float lastPosY;
+    // the current position of the entity
+    private float posX;
+    private float posY;
+    
+    // the collision box of the entity
+    private final CollisionBox box;
+    
+    // the motion before the movement collision check
+    private float preMotionX;
+    private float preMotionY;
+    // the motion after the movement collision check
+    private float motionX;
+    private float motionY;
+    
+    // a flag indicating that the entity is on the ground
+    private boolean onGround = false;
+    
+    // the level of the entity
     private final Level level;
     
-    // components
-    protected EntityAnimator animator;   
-    protected EntityController controller;
+    // entity components
+    protected Renderer renderer;   
+    protected Controller controller;
     protected Health health;
     protected Energy energy;
     protected Movement move;
     protected ItemCollector itemCollector;
-    protected MovementPenalty movePenalty;
     
-    protected Entity(Level level, double x, double y, double width, double height, double cWidth, double cHeight)
+    protected Entity(Level level, float x, float y, CollisionBox box)
     {
+        lastPosX = x;
+        lastPosY = y;
+        posX = x;
+        posY = y;
+
+        // ensure the box cannot be modified from the outside
+        this.box = box.copy().offset(x, y);
+        
+        preMotionX = 0.0f;
+        preMotionY = 0.0f;
+        motionX = 0.0f;
+        motionY = 0.0f;
+        
         this.level = level;
-        this.posX = x;
-        this.posY = y;
-        this.prevPosX = x;
-        this.prevPrevY = y;
-        this.motionX = 0;
-        this.motionY = 0;
-        this.onGround = false;
-        this.collisionBox = new CollisionBox(0, 0, cWidth, cHeight);
-        this.width = width;
-        this.height = height;
-        this.cWidth = cWidth;
-        this.cHeight = cHeight;
         
         // components
-        this.animator = EntityAnimator.NULL;
-        this.controller = EntityController.NULL;
+        this.renderer = Renderer.NULL;
+        this.controller = Controller.NULL;
         this.health = Health.NULL;
         this.energy = Energy.NULL;
         this.move =  Movement.NULL;
         this.itemCollector =  ItemCollector.NULL;
-        this.movePenalty = MovementPenalty.NULL;
     }
     
-    protected Entity(Level level, double x, double y, double width, double height)
-    {
-        this(level, x, y, width, height, width, height);
-    }
-
     public Level getLevel()
     {
         return level;
@@ -93,14 +83,9 @@ public final class Entity
     // components
     //--------------------------------------------------------------------------
     
-    public EntityController getController()
-    {
-        return controller;
-    }
-    
-    public EntityAnimator getAnimator()
+    public boolean isAnimated()
     {
-        return animator;
+        return renderer.isAnimated();
     }
     
     public Health getHealth()
@@ -123,522 +108,247 @@ public final class Entity
         return itemCollector;
     }
     
-    public MovementPenalty getMovementPenalty()
-    {
-        return movePenalty;
-    }
-    
     //--------------------------------------------------------------------------
     // basic stuff
     //--------------------------------------------------------------------------
     
-    public double squaredDistance(Entity other)
+    public float getSquaredDistance(Entity e)
     {
-        return (posX - other.posX) * (posX - other.posX) + (posY - other.posY) * (posY - other.posY);
+        return Utils.getSquaredDistance(
+                posX + box.getWidth() * 0.5f, posY + box.getHeight() * 0.5f, 
+                e.posX + e.box.getWidth() * 0.5f, e.posY + e.box.getHeight() * 0.5f);
     }
     
-    public double signedDistanceX(Entity other)
+    public float getX()
     {
-        if(posX < other.posX)
-        {
-            return Math.min(0.0, posX + cWidth - other.posX);
-        }
-        return Math.max(0.0, posX - (other.posX + other.cWidth));
+        return posX;
     }
     
-    public double getWidth()
+    public float getY()
     {
-        return width;
+        return posY;
     }
     
-    public double getHeight()
+    public float getLastX()
     {
-        return height;
+        return lastPosX;
     }
     
-    public double getCollisionWidth()
+    public float getLastY()
     {
-        return cWidth;
+        return lastPosY;
     }
     
-    public double getCollisionHeight()
+    public float getCenterX()
     {
-        return cHeight;
+        return posX + box.getWidth() * 0.5f;
     }
     
-    public double getX()
+    public float getCenterY()
     {
-        return posX;
+        return posY + box.getHeight() * 0.5f;
     }
     
-    public double getY()
+    public Face getFace()
     {
-        return posY;
+        return preMotionX > 0.0f ? Face.RIGHT : Face.LEFT;
     }
     
-    public boolean isOutOfMap()
+    public float getMotionX()
     {
-        return posY < -height;
+        return motionX;
     }
     
-    //--------------------------------------------------------------------------
-    // ticking
-    //--------------------------------------------------------------------------
+    public void setMotionX(float motionX)
+    {
+        this.motionX = motionX;
+    }
     
-    public void tick() 
+    public float getMotionY()
     {
-        controller.tick();
-        health.tick();
-        movePenalty.reset();
-        
-        if(move.isAffectedByGravity())
-        {
-            motionY -= GRAVITY * move.getGravityFactor();
-        }
-        
-        prevMotionX = motionX;
-        prevMotionY = motionY;
-        
-        prevPosX = posX;
-        prevPrevY = posY;
-        
-        boolean check = !move.canMoveEverywhere();
-        if(check)
-        {
-            setAllowedMotion();
-        }
-        
-        if(!move.blockHorizontal())
-        {
-            posX += motionX;   
-        }
-        posY += motionY;   
-        
-        motionX = Utils.round(motionX);
-        motionY = Utils.round(motionY);
-        
-        if(motionY != 0)
-        {
-            onGround = false;
-        }
-        
-        posX = Utils.round(posX);
-        posY = Utils.round(posY);
-        
-        if(check)
-        {
-            LinkedList<CollisionBox> list = level.getMovementBoxesAt(this, getBox());
-            if(!list.isEmpty())
-            {
-                //System.out.println(getBox());
-                //list.forEach(s -> System.out.println(s));
-                //System.out.println("WELL");
-                posX = prevPosX;
-                posY = prevPrevY;
-            }
-        }
-        
-        movePenalty.setFriction(0.7);
-        doCollision();
-        movePenalty.applyFriction();
-        energy.tick();
-        animator.tick();
+        return motionY;
     }
     
-    //--------------------------------------------------------------------------
-    // gravity, friction
-    //--------------------------------------------------------------------------
+    public void setMotionY(float motionY)
+    {
+        this.motionY = motionY;
+    }
     
-    public boolean isOnGround()
+    public float getPreMotionX()
     {
-        return onGround;
-    }   
+        return preMotionX;
+    }
     
-    public void setNoGround()
+    public float getPreMotionY()
     {
-        onGround = false;
-    }   
+        return preMotionY;
+    }
     
     //--------------------------------------------------------------------------
-    // collision stuff
+    // ticking
     //--------------------------------------------------------------------------
     
-    public CollisionBox getBox() 
-    {
-        return collisionBox.reset().offset(posX, posY);
-    }
-    
-    private void setAllowedMotion()
+    public void tick() 
     {
-        if(motionX == 0 && motionY == 0)
-        {
-            return;
-        }
-        double dirX = motionX;
-        double dirY = motionY;
-        double startX = posX;
-        double startY = posY;
-        double endX = startX + dirX;
-        double endY = startY + dirY;
+        lastPosX = posX;
+        lastPosY = posY;
         
-        CollisionBox eBox = getBox();
-        double halfWidth = eBox.getWidth() / 2;
-        double halfHeight = eBox.getHeight() / 2;
-        eBox = eBox.copy();
-        
-        startX += halfWidth;
-        startY += halfHeight;
-        endX += halfWidth;
-        endY += halfHeight;
+        controller.tick();
+        health.tick();
+        energy.tick();
         
-        // expanding area by the size of the entity
-        CollisionBox expandedBox = eBox.copy().expand(motionX, motionY);
+        preMotionX = motionX;
+        preMotionY = motionY;
         
-        LinkedList<CollisionBox> allBoxes = level.getMovementBoxesAt(this, expandedBox);
-        if(allBoxes.isEmpty())
+        if(move.hasGravity())
         {
-            return;
-        }        
-        
-        double x;
-        double y;
-        char lastWall = 0;
-                
-        if(dirX >= 0)
+            preMotionY += GRAVITY * move.getGravityFactor();
+        }
+
+        if(move.canMoveEverywhere())
         {
-            if(dirY <= 0) // Right - Down
+            motionX = preMotionX;
+            motionY = preMotionY;
+        }
+        else
+        {
+            CollisionBox testBox = box.copy().expand(preMotionX, preMotionY);
+            List<CollisionBox> boxes = level.getMovementBoxesAt(testBox);
+            if(!boxes.isEmpty())
             {
-                for(CollisionBox box : allBoxes)
-                {
-                    box.grow(halfWidth, halfHeight);
-                    if(endX <= box.getMinX() || endY >= box.getMaxY() ||
-                        startX >= box.getMaxX() || startY <= box.getMinY())
-                    {
-                        continue;
-                    }
-                    x = Utils.interpolateX(startX, startY, endX, endY, box.getMaxY());
-                    y = Utils.interpolateY(startX, startY, endX, endY, box.getMinX());
-                    if(y > box.getMinY() && y < box.getMaxY())
-                    {
-                        endX = box.getMinX();
-                        endY = y;
-                        lastWall = 'x';
-                    }
-                    else if(x > box.getMinX() && x < box.getMaxX())
-                    {
-                        endY = box.getMaxY();
-                        endX = x;
-                        lastWall = 'y';
-                    }
-                    else if(x >= box.getMinX() && x <= box.getMaxX())
-                    {
-                        lastWall = 'y';
-                    }
-                }
-                if(lastWall == 'x')
+                float mx = preMotionX;
+                float my = preMotionY;
+                
+                testBox.reset();
+                
+                float oldX = testBox.getMinX();
+                float oldY = testBox.getMinY();
+                
+                while(mx != 0.0 || my != 0.0)
                 {
-                    double lineEndY = startY + dirY;
-                    for(CollisionBox box : allBoxes)
+                    testBox.save();
+
+                    if(mx < 0.0)
                     {
-                        if(endX <= box.getMinX() || lineEndY >= box.getMaxY() ||
-                            endX >= box.getMaxX() || endY <= box.getMinY())
+                        if(mx > -STEP)
                         {
-                            continue;
+                            testBox.offsetX(mx);
+                            mx = 0.0f;
                         }
-                        lineEndY = box.getMaxY();
-                    }
-                    endY = lineEndY;
-                }
-                else if(lastWall == 'y')
-                {
-                    double lineEndX = startX + dirX;
-                    for(CollisionBox box : allBoxes)
-                    {
-                        if(lineEndX <= box.getMinX() || endY >= box.getMaxY() ||
-                            endX >= box.getMaxX() || endY <= box.getMinY())
+                        else
                         {
-                            continue;
+                            testBox.offsetX(-STEP);
+                            mx += STEP;
                         }
-                        lineEndX = box.getMinX();
-                    }
-                    endX = lineEndX;
-                }
-            }
-            else // Right - Up
-            {
-                for(CollisionBox box : allBoxes)
-                {
-                    box.grow(halfWidth, halfHeight);
-                    if(endX <= box.getMinX() || endY <= box.getMinY() ||
-                        startX >= box.getMaxX() || startY >= box.getMaxY())
-                    {
-                        continue;
-                    }
-                    x = Utils.interpolateX(startX, startY, endX, endY, box.getMinY());
-                    y = Utils.interpolateY(startX, startY, endX, endY, box.getMinX());
-                    if(y > box.getMinY() && y < box.getMaxY())
-                    {
-                        endX = box.getMinX();
-                        endY = y;
-                        lastWall = 'x';
-                    }
-                    else if(x > box.getMinX() && x < box.getMaxX())
-                    {
-                        endY = box.getMinY();
-                        endX = x;
-                        lastWall = 'y';
                     }
-                    else if(x >= box.getMinX() && x <= box.getMaxX())
+                    else if(mx > 0.0)
                     {
-                        lastWall = 'y';
-                    }
-                }
-                if(lastWall == 'x')
-                {
-                    double lineEndY = startY + dirY;
-                    for(CollisionBox box : allBoxes)
-                    {
-                        if(endX <= box.getMinX() || lineEndY <= box.getMinY() ||
-                            endX >= box.getMaxX() || endY >= box.getMaxY())
+                        if(mx < STEP)
                         {
-                            continue;
+                            testBox.offsetX(mx);
+                            mx = 0.0f;
                         }
-                        lineEndY = box.getMinY();
-                    }
-                    endY = lineEndY;
-                }
-                else if(lastWall == 'y')
-                {
-                    double lineEndX = startX + dirX;
-                    for(CollisionBox box : allBoxes)
-                    {
-                        if(lineEndX <= box.getMinX() || endY >= box.getMaxY() ||
-                            endX >= box.getMaxX() || endY <= box.getMinY())
+                        else
                         {
-                            continue;
+                            testBox.offsetX(STEP);
+                            mx -= STEP;
                         }
-                        lineEndX = box.getMinX();
                     }
-                    endX = lineEndX;
-                }
-            }
-        }
-        else
-        {
-            if(dirY <= 0) // Left - Down
-            {
-                for(CollisionBox box : allBoxes)
-                {
-                    box.grow(halfWidth, halfHeight);
-                    if(endX >= box.getMaxX() || endY >= box.getMaxY() ||
-                        startX <= box.getMinX() || startY <= box.getMinY())
-                    {
-                        continue;
-                    }
-                    x = Utils.interpolateX(startX, startY, endX, endY, box.getMaxY());
-                    y = Utils.interpolateY(startX, startY, endX, endY, box.getMaxX());
-                    if(y > box.getMinY() && y < box.getMaxY())
-                    {
-                        endX = box.getMaxX();
-                        endY = y;
-                        lastWall = 'x';
-                    }
-                    else if(x > box.getMinX() && x < box.getMaxX())
-                    {
-                        endY = box.getMaxY();
-                        endX = x;
-                        lastWall = 'y';
-                    }
-                    else if(x >= box.getMinX() && x <= box.getMaxX())
-                    {
-                        lastWall = 'y';
-                    }
-                }
-                if(lastWall == 'x')
-                {
-                    double lineEndY = startY + dirY;
-                    for(CollisionBox box : allBoxes)
+
+                    for(CollisionBox cb : boxes)
                     {
-                        if(endX <= box.getMinX() || lineEndY >= box.getMaxY() ||
-                            endX >= box.getMaxX() || endY <= box.getMinY())
+                        if(cb.isColliding(testBox))
                         {
-                            continue;
+                            mx = 0.0f;
+                            testBox.reset();
+                            break;
                         }
-                        lineEndY = box.getMaxY();
                     }
-                    endY = lineEndY;
-                }
-                else if(lastWall == 'y')
-                {
-                    double lineEndX = startX + dirX;
-                    for(CollisionBox box : allBoxes)
+                    
+                    testBox.save();
+
+                    if(my < 0.0)
                     {
-                        if(lineEndX >= box.getMaxX() || endY >= box.getMaxY() ||
-                            endX <= box.getMinX() || endY <= box.getMinY())
+                        if(my > -STEP)
                         {
-                            continue;
+                            testBox.offsetY(my);
+                            my = 0.0f;
+                        }
+                        else
+                        {
+                            testBox.offsetY(-STEP);
+                            my += STEP;
                         }
-                        lineEndX = box.getMaxX();
-                    }
-                    endX = lineEndX;
-                }
-            }
-            else  // Left - Up
-            {
-                for(CollisionBox box : allBoxes)
-                {
-                    box.grow(halfWidth, halfHeight);
-                    if(endX >= box.getMaxX() || endY <= box.getMinY() ||
-                        startX <= box.getMinX() || startY >= box.getMaxY())
-                    {
-                        continue;
-                    }
-                    x = Utils.interpolateX(startX, startY, endX, endY, box.getMinY());
-                    y = Utils.interpolateY(startX, startY, endX, endY, box.getMaxX());
-                    if(y > box.getMinY() && y < box.getMaxY())
-                    {
-                        endX = box.getMaxX();
-                        endY = y;
-                        lastWall = 'x';
-                    }
-                    else if(x > box.getMinX() && x < box.getMaxX())
-                    {
-                        endY = box.getMinY();
-                        endX = x;
-                        lastWall = 'y';
-                    }
-                    else if(x >= box.getMinX() && x <= box.getMaxX())
-                    {
-                        lastWall = 'y';
                     }
-                }
-                if(lastWall == 'x')
-                {
-                    double lineEndY = startY + dirY;
-                    for(CollisionBox box : allBoxes)
+                    else if(my > 0.0)
                     {
-                        if(endX <= box.getMinX() || lineEndY <= box.getMinY() ||
-                            endX >= box.getMaxX() || endY >= box.getMaxY())
+                        if(my < STEP)
                         {
-                            continue;
+                            testBox.offsetY(my);
+                            my = 0.0f;
+                        }
+                        else
+                        {
+                            testBox.offsetY(STEP);
+                            my -= STEP;
                         }
-                        lineEndY = box.getMinY();
                     }
-                    endY = lineEndY;
-                }
-                else if(lastWall == 'y')
-                {
-                    double lineEndX = startX + dirX;
-                    for(CollisionBox box : allBoxes)
+
+                    for(CollisionBox cb : boxes)
                     {
-                        if(lineEndX >= box.getMaxX() || endY >= box.getMaxY() ||
-                            endX <= box.getMinX() || endY <= box.getMinY())
+                        if(cb.isColliding(testBox))
                         {
-                            continue;
+                            my = 0.0f;
+                            testBox.reset();
+                            break;
                         }
-                        lineEndX = box.getMaxX();
                     }
-                    endX = lineEndX;
                 }
+                
+                motionX = testBox.getMinX() - oldX;
+                motionY = testBox.getMinY() - oldY;
+            }
+            else
+            {
+                motionX = preMotionX;
+                motionY = preMotionY;
             }
         }
         
-        motionX = endX - startX;
-        motionY = endY - startY;
+        posX += motionX;
+        posY += motionY;
+        box.reset().offset(posX, posY);
         
-        if(dirY < 0 && motionY == 0)
-        {
-            onGround = true;
-        }
-        
-        if(Math.abs(motionY) >= 1000 || Math.abs(motionX) >= 1000)
-        {
-            System.err.println("illegal movement " + motionX + " " + motionY);
-            System.exit(0);
-        }
+        onGround = preMotionY > 0.0f && motionY == 0;
         
-        /*if(!onGround && Math.abs(dirY) - Math.abs(motionY) > 1)
-        {
-            System.out.println("\nVORHER " + dirX + " " + dirY);
-            System.out.println("NACHHER " + motionX + " " + motionY);
-            System.out.println("\nPOS " + posX + " " + posY);
-            System.exit(0);
-        }*/
-        //System.exit(0);
-    }
-    
-    private void doCollision()
-    {
-        CollisionBox box = getBox().copy();
+        move.setInWater(false);
+        move.setFrictionFactor(0.7f);
+        // apply collision
+        CollisionBox cb = box.copy();
         for(Face f : Face.values())
         {
-            box.reset();
-            box.expand(f.getCollisionOffsetX(), f.getCollisionOffsetY());
-            level.getEntitiesCollidingWith(this, box).forEach(ent -> this.onCollideWithEntity(ent, f));
-            level.getTilesCollidingWith(box).forEach(loc -> 
+            cb.reset();
+            cb.expand(f.getCollisionOffsetX(), f.getCollisionOffsetY());
+            level.getEntitiesCollidingWith(this, box).forEach(ent -> ent.controller.onCollideWithEntity(ent, f));
+            level.getCollisionBoxesAt(cb).forEach(loc -> 
             {
-                this.onCollideWithTile(loc, f);
-                loc.getTile().onEntityCollide(this, loc.getX(), loc.getY(), f);
+                controller.onCollideWithTile(loc, f);
+                loc.getTile().onEntityCollide(this, loc.getX(), loc.getY(), f.getOpposite());
             });
         }
     }
     
-    public void onCollideWithTile(Location loc, Face face)
+    public void renderTick(float lag)
     {
-        controller.onCollideWithTile(loc, face);
-    }
-    
-    public void onCollideWithEntity(Entity ent, Face face)
-    {
-        controller.onCollideWithEntity(ent, face);
+        renderer.renderTick(lag);
     }
     
     //--------------------------------------------------------------------------
-    // basic coord and motion stuff
+    // gravity, friction
     //--------------------------------------------------------------------------
     
-    public double getPreviousX()
-    {
-        return prevPosX;
-    }
-    
-    public double getPreviousY()
-    {
-        return prevPrevY;
-    }
-    
-    public boolean isMoving()
-    {
-        return motionX != 0.0 || motionY != 0.0;
-    }
-    
-    public final double getMotionX()
-    {
-        return motionX;
-    }
-    
-    public final void setMotionX(double motionX)
-    {
-        this.motionX = motionX;
-    }
-    
-    public final double getMotionY()
-    {
-        return motionY;
-    }
-    
-    public final void setMotionY(double motionY)
-    {
-        this.motionY = motionY;
-    }
-    
-    public final double getPreviousMotionX()
-    {
-        return prevMotionX;
-    }
-    
-    public final double getPreviousMotionY()
+    public boolean isOnGround()
     {
-        return prevMotionY;
-    }
+        return onGround;
+    }   
 }

src/me/hammerle/supersnuvi/entity/EntityBuilder.java

@@ -2,82 +2,63 @@ package me.hammerle.supersnuvi.entity;
 
 import me.hammerle.supersnuvi.entity.components.DefaultHealth;
 import me.hammerle.supersnuvi.entity.components.DefaultMovement;
-import me.hammerle.supersnuvi.entity.components.Death;
-import me.hammerle.supersnuvi.entity.components.DefaultDespawn;
 import me.hammerle.supersnuvi.entity.components.DefaultEnergy;
-import me.hammerle.supersnuvi.entity.components.Health;
-import me.hammerle.supersnuvi.entity.components.Movement;
-import me.hammerle.supersnuvi.entity.components.HeroItemCollector;
-import me.hammerle.supersnuvi.entity.components.LandMovement;
-import me.hammerle.supersnuvi.entity.components.MovementPenalty;
 import me.hammerle.supersnuvi.entity.components.StoneMovement;
-import me.hammerle.supersnuvi.entity.components.ai.EntityController;
 import me.hammerle.supersnuvi.entity.components.ai.HumanController;
 import me.hammerle.supersnuvi.entity.components.ai.LondonerController;
 import me.hammerle.supersnuvi.entity.components.animator.StoneAnimator;
 import me.hammerle.supersnuvi.entity.components.animator.HeroAnimator;
-import me.hammerle.supersnuvi.entity.components.animator.EntityAnimator;
 import me.hammerle.supersnuvi.entity.components.animator.LondonerAnimator;
 import me.hammerle.supersnuvi.gamelogic.Level;
-import me.hammerle.supersnuvi.rendering.OldGame;
+import me.hammerle.supersnuvi.tiles.Tile;
+import me.hammerle.supersnuvi.entity.components.IDeath;
+import me.hammerle.supersnuvi.entity.components.ItemCollector;
+import me.hammerle.supersnuvi.entity.components.NoHealth;
+import me.hammerle.supersnuvi.util.CollisionBox;
 
 public final class EntityBuilder 
 {
-    public static EntityBuilder newBuilder(Level level, double x, double y, double width, double height, double cWidth, double cHeight)
+    public static Entity buildHero(Level level, float x, float y)
     {
-        return new EntityBuilder(new Entity(level, x, y, width, height, cWidth, cHeight));
-    }
-    
-    public static Entity buildHero(Level level, double x, double y)
-    {
-        double w = OldGame.TILE_SIZE;
-        double h = OldGame.TILE_SIZE * 2;
+        float w = Tile.SIZE;
+        float h = Tile.SIZE * 2;
         
-        Entity hero = new Entity(level, x, y, w, h, w * 0.90625, h * 0.921875);
-        hero.animator = new HeroAnimator(hero);
+        Entity hero = new Entity(level, x, y, new CollisionBox(0.0f, 0.0f, w * 0.90625f, h * 0.921875f));
+        hero.renderer = new HeroAnimator(hero);
         hero.controller = new HumanController(hero);
-        hero.health = new DefaultHealth(hero, new Death() 
-                {
-                    @Override
-                    public void onDeath(Entity ent) 
-                    {
-                        ent.getLevel().scheduleReset();
-                    }
-                }, 100.0);
-        hero.energy = new DefaultEnergy(hero, 100.0);
-        hero.move = new DefaultMovement(hero, ent -> level.getData().getInt("jump", 24));
-        hero.itemCollector = new HeroItemCollector(hero);
-        hero.movePenalty = new LandMovement(hero);
+        hero.health = new DefaultHealth(hero, (ent) -> ent.getLevel().scheduleReset(), 100.0f, null, null, null);
+        hero.energy = new DefaultEnergy(hero, 100.0f);
+        hero.move = new DefaultMovement(hero, 3f, 3f, 50.0f);
+        hero.itemCollector = ItemCollector.HERO;
         return hero;
     }
     
-    public static Entity buildLondoner(Level level, double x, double y, boolean evil)
+    public static Entity buildLondoner(Level level, float x, float y, boolean evil)
     {
-        double w = OldGame.TILE_SIZE;
-        double h = OldGame.TILE_SIZE * 2;
+        float w = Tile.SIZE;
+        float h = Tile.SIZE * 2;
 
-        Entity hero = new Entity(level, x, y, w, h, w * 0.4375, h * 0.703125);
-        hero.animator = new LondonerAnimator(hero);
+        Entity hero = new Entity(level, x, y, new CollisionBox(0.0f, 0.0f, w * 0.4375f, h * 0.703125f));
+        hero.renderer = new LondonerAnimator(hero);
         //hero.controller = new FollowHeroController(hero, 2);
         hero.controller = new LondonerController(hero, evil);
-        hero.health = new DefaultHealth(hero, evil ? Death.DROP_BOTTLE : Death.NULL, 100.0);
-        hero.energy = new DefaultEnergy(hero, 100.0);
-        hero.move = new DefaultMovement(hero, ent -> level.getData().getInt("jump", 24));
+        hero.health = new DefaultHealth(hero, IDeath.NULL, 100.0f, null, null, null);
+        hero.energy = new DefaultEnergy(hero, 100.0f);
+        hero.move = new DefaultMovement(hero, 3f, 3f, 24.0f);
         //hero.itemCollector = new HeroItemCollector(hero);
-        hero.movePenalty = new LandMovement(hero);
         return hero;
     }
     
-    public static Entity buildCrumblingStone(Level level, double x, double y)
+    public static Entity buildCrumblingStone(Level level, float x, float y)
     {
-        Entity stone = new Entity(level, x, y, OldGame.TILE_SIZE, OldGame.TILE_SIZE * 10);
-        stone.animator = new StoneAnimator(stone);
+        Entity stone = new Entity(level, x, y, new CollisionBox(0.0f, 0.0f, Tile.SIZE, Tile.SIZE * 10f));
+        stone.renderer = new StoneAnimator(stone);
         stone.move = new StoneMovement(stone);
-        stone.health = new DefaultDespawn(stone);
+        stone.health = new NoHealth(stone);
         return stone;
     }
     
-    public static Entity fromId(int id, Level level, double x, double y)
+    public static Entity fromId(int id, Level level, float x, float y)
     {
         switch(id)
         {
@@ -88,43 +69,4 @@ public final class EntityBuilder
         }
         return null;
     }
-    
-    
-    
-    private final Entity ent;
-    
-    private EntityBuilder(Entity ent)
-    {
-        this.ent = ent;
-    }
-    
-    public EntityBuilder setController(EntityController controller)
-    {
-        ent.controller = controller;
-        return this;
-    }
-    
-    public EntityBuilder setAnimator(EntityAnimator animator)
-    {
-        ent.animator = animator;
-        return this;
-    }
-    
-    public EntityBuilder setHealth(Health health)
-    {
-        ent.health = health;
-        return this;
-    }
-    
-    public EntityBuilder setMovement(Movement move)
-    {
-        ent.move = move;
-        return this;
-    }
-    
-    public EntityBuilder setMovementPenalty(MovementPenalty move)
-    {
-        ent.movePenalty = move;
-        return this;
-    }
 }

src/me/hammerle/supersnuvi/entity/components/Component.java

@@ -1,13 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public abstract class Component 
-{
-    protected final Entity ent;
-    
-    protected Component(Entity ent)
-    {
-        this.ent = ent;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/Death.java

@@ -1,30 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.gamelogic.Level;
-import me.hammerle.supersnuvi.util.SoundUtils;
-
-public abstract class Death
-{
-    public static final Death NULL = new Death() 
-    {
-        @Override
-        public void onDeath(Entity ent) 
-        {
-        }
-    };
-    
-    public static final Death DROP_BOTTLE = new Death() 
-    {
-        @Override
-        public void onDeath(Entity ent) 
-        {
-            Level l = ent.getLevel();
-            SoundUtils.playSound(SoundUtils.Sound.COLLECT);
-            l.increaseSouls(1);
-            l.getHero().getHealth().addHealthPercent(0.143);
-        }
-    };
-    
-    public abstract void onDeath(Entity ent);
-}

src/me/hammerle/supersnuvi/entity/components/DefaultEnergy.java

@@ -1,13 +1,16 @@
 package me.hammerle.supersnuvi.entity.components;
 
+import me.hammerle.supersnuvi.Game;
 import me.hammerle.supersnuvi.entity.Entity;
 
 public class DefaultEnergy extends Energy
 {
-    private final double maxEnergy;
-    private double energy;
+    private final float maxEnergy;
+    private float energy;
     
-    public DefaultEnergy(Entity ent, double maxEnergy) 
+    private static final float BASE = 1.0f / Game.getTicksForMillis(3000);
+    
+    public DefaultEnergy(Entity ent, float maxEnergy) 
     {
         super(ent);
         this.maxEnergy = maxEnergy;
@@ -17,39 +20,43 @@ public class DefaultEnergy extends Energy
     @Override
     public void tick() 
     {
-        if(!ent.isMoving())
+        float mx = ent.getMotionX();
+        float my = ent.getMotionX();
+        
+        if(mx == 0.0f && my == 0.0f)
         {
-            addEnergy(0.25);
+            addEnergyPercent(BASE);
         }
-        else if(!ent.getController().isRunning())
+        else if(Math.abs(mx) <= ent.getMovement().getVelocityX() &&
+                Math.abs(my) <= ent.getMovement().getVelocityY())
         {
-            addEnergy(0.1);
+            addEnergyPercent(BASE * 0.5f);
         }
     }
 
     @Override
-    public double getMaxEnergy() 
+    public float getMaxEnergy() 
     {
         return maxEnergy;
     }
 
     @Override
-    public double getEnergy() 
+    public float getEnergy() 
     {
         return energy;
     }
 
     @Override
-    public void addEnergy(double h) 
+    public void addEnergy(float h) 
     {
         energy += h;
         if(energy > maxEnergy)
         {
             energy = maxEnergy;
         }
-        else if(energy < 0.0)
+        else if(energy < 0.0f)
         {
-            energy = 0.0;
+            energy = 0.0f;
         }
     }
 }

src/me/hammerle/supersnuvi/entity/components/DefaultHealth.java

@@ -1,24 +1,34 @@
 package me.hammerle.supersnuvi.entity.components;
 
+import me.hammerle.supersnuvi.Game;
 import me.hammerle.supersnuvi.entity.Entity;
 import me.hammerle.supersnuvi.util.SoundUtils;
+import me.hammerle.supersnuvi.util.SoundUtils.Sound;
 
 public class DefaultHealth extends Health
 {
-    private final double maxHealth;
-    private double health;
+    private final float maxHealth;
+    private float health;
     
     private int hurtTicks = 0;
     private int invincibility = 0;
     
-    private int deathTicks = -1;
-    private boolean isDead = false;
+    private final IDeath death;
     
-    public DefaultHealth(Entity ent, Death death, double maxHealth) 
+    private final Sound soundHeal;
+    private final Sound soundHurt;
+    private final Sound soundDeath;
+    
+    public DefaultHealth(Entity ent, IDeath death, float maxHealth, 
+            Sound soundHeal, Sound soundHurt, Sound soundDeath) 
     {
-        super(ent, death);
+        super(ent);
+        this.death = death;
         this.maxHealth = maxHealth;
         this.health = maxHealth;
+        this.soundHeal = soundHeal;
+        this.soundHurt = soundHurt;
+        this.soundDeath = soundDeath;
     }
 
     @Override
@@ -38,32 +48,22 @@ public class DefaultHealth extends Health
             hurtTicks++;
         }
         
-        if(deathTicks != -1)
-        {
-            deathTicks++;
-            if(deathTicks > ent.getAnimator().getDeathTicks())
-            {
-                death.onDeath(ent);
-                isDead = true;
-            }
-        }
-        else if(ent.isOutOfMap())
+        if(shouldDespawn())
         {
             death.onDeath(ent);
-            isDead = true;
         }
     }
 
     @Override
     public boolean isDead() 
     {
-        return deathTicks != -1;
+        return health <= 0.0f;
     }
     
     @Override
     public boolean shouldDespawn() 
     {
-        return isDead;
+        return isDead() && !ent.isAnimated();
     }
     
     @Override
@@ -72,12 +72,6 @@ public class DefaultHealth extends Health
         return hurtTicks > 0;
     }
 
-    @Override
-    public boolean hasInvincibility() 
-    {
-        return invincibility > 0;
-    }
-
     @Override
     public boolean wasHealed() 
     {
@@ -85,19 +79,19 @@ public class DefaultHealth extends Health
     }
 
     @Override
-    public double getMaxHealth() 
+    public float getMaxHealth() 
     {
         return maxHealth;
     }
 
     @Override
-    public double getHealth() 
+    public float getHealth() 
     {
         return health;
     }
 
     @Override
-    public void addHealth(double h) 
+    public void addHealth(float h) 
     {
         if(h < 0)
         {
@@ -105,39 +99,24 @@ public class DefaultHealth extends Health
             {
                 return;
             }
-            invincibility = 100;
-            ent.getAnimator().resetHeadFrames();
-            hurtTicks = 15;
+            invincibility = Game.getTicksForMillis(1000);
+            hurtTicks = Game.getTicksForMillis(500);
+            SoundUtils.playSound(soundHurt);
         }
         else
         {
-            hurtTicks = -5;
+            hurtTicks = -Game.getTicksForMillis(500);
+            SoundUtils.playSound(soundHeal);
         }
         health += h;
         if(health > maxHealth)
         {
             health = maxHealth;
         }
-        else if(health < 0.0)
+        else if(health < 0.0f)
         {
-            health = 0.0;
-            if(deathTicks == -1)
-            {
-                deathTicks = 0;
-                ent.getAnimator().resetFrames();
-            }
-        }
-        
-        if(h < 0 && ent.getItemCollector().isHero())
-        {
-            if(health == 0.0)
-            {
-                SoundUtils.playSound(SoundUtils.Sound.MIRROR_BREAK);
-            }
-            else
-            {
-                SoundUtils.playSound(SoundUtils.Sound.MIRROR_CRACK);
-            }
+            health = 0.0f;
+            SoundUtils.playSound(soundDeath);
         }
     }
 }

src/me/hammerle/supersnuvi/entity/components/DefaultMovement.java

@@ -4,12 +4,34 @@ import me.hammerle.supersnuvi.entity.Entity;
 
 public class DefaultMovement extends Movement
 {
-    private final IJump jump;
+    private final float jumpPower;
+    private boolean inWater = false;
+    private final float vx;
+    private final float vy;
     
-    public DefaultMovement(Entity ent, IJump jump) 
+    public DefaultMovement(Entity ent, float vx, float vy, float jumpPower) 
     {
         super(ent);
-        this.jump = jump;
+        this.jumpPower = jumpPower;
+        this.vx = vx;
+        this.vy = vy;
+    }
+    
+    private float getFactor()
+    {
+        return inWater ? 0.65f : 1.0f;
+    }
+
+    @Override
+    public float getVelocityX()
+    {
+        return vx * getFactor();
+    }
+
+    @Override
+    public float getVelocityY()
+    {
+        return vy * getFactor();
     }
 
     @Override
@@ -17,22 +39,27 @@ public class DefaultMovement extends Movement
     {
         if(ent.isOnGround())
         {
-            ent.setNoGround();
-            ent.setMotionY(ent.getMotionY() + getJumpPower());
+            ent.setMotionY(ent.getMotionY() - getJumpPower());
             return true;
         }
         return false;
     }
 
     @Override
-    public double getJumpPower() 
+    public float getJumpPower() 
     {
-        return jump.getJumpPower(ent) * ent.getMovementPenalty().getFactor();
+        return jumpPower * getFactor();
     }
 
     @Override
-    public boolean isAffectedByGravity()
+    public boolean hasGravity()
     {
         return true;
     }
+
+    @Override
+    public void setInWater(boolean b)
+    {
+        inWater = b;
+    }
 }

src/me/hammerle/supersnuvi/entity/components/Energy.java

@@ -2,40 +2,42 @@ package me.hammerle.supersnuvi.entity.components;
 
 import me.hammerle.supersnuvi.entity.Entity;
 
-public class Energy extends Component
+public class Energy
 {
     public final static Energy NULL = new Energy(null);
     
+    protected final Entity ent;
+    
     protected Energy(Entity ent)
     {
-        super(ent);
+        this.ent = ent;
     }
     
     public void tick()
     {
     }
 
-    public void addEnergy(double e)
+    public void addEnergy(float e)
     {
     }
     
-    public final void addEnergyPercent(double percent)
+    public final void addEnergyPercent(float percent)
     {
         addEnergy(percent * getMaxEnergy());
     }
     
-    public double getMaxEnergy()
+    public float getMaxEnergy()
     {
-        return 0.0;
+        return 0.0f;
     }
     
-    public double getEnergyPercent()
+    public float getEnergyPercent()
     {
         return getEnergy() / getMaxEnergy();
     }
     
-    public double getEnergy()
+    public float getEnergy()
     {
-        return 0.0;
+        return 0.0f;
     }
 }

src/me/hammerle/supersnuvi/entity/components/Health.java

@@ -2,16 +2,15 @@ package me.hammerle.supersnuvi.entity.components;
 
 import me.hammerle.supersnuvi.entity.Entity;
 
-public class Health extends Component
+public class Health
 {
-    public final static Health NULL = new Health(null, null);
+    public final static Health NULL = new Health(null);
     
-    protected final Death death;
+    protected final Entity ent;
     
-    protected Health(Entity ent, Death death)
+    protected Health(Entity ent)
     {
-        super(ent);
-        this.death = death;
+        this.ent = ent;
     }
     
     public void tick()
@@ -23,17 +22,12 @@ public class Health extends Component
         return false;
     }
     
-    public boolean shouldDespawn() 
-    {
-        return ent.isOutOfMap();
-    }
-    
-    public boolean wasHurt()
+    public boolean shouldDespawn()
     {
         return false;
     }
     
-    public boolean hasInvincibility()
+    public boolean wasHurt()
     {
         return false;
     }
@@ -43,32 +37,27 @@ public class Health extends Component
         return false;
     }
     
-    public void addHealth(double h)
+    public void addHealth(float h)
     {
     }
     
-    public final void addHealthPercent(double percent)
+    public final void addHealthPercent(float percent)
     {
         addHealth(percent * getMaxHealth());
     }
     
-    public double getMaxHealth()
+    public float getMaxHealth()
     {
-        return 0.0;
+        return 0.0f;
     }
     
-    public double getHealthPercent()
+    public float getHealthPercent()
     {
         return getHealth() / getMaxHealth();
     }
     
-    public double getHealth()
-    {
-        return 0.0;
-    }
-    
-    public int getSlot()
+    public float getHealth()
     {
-        return -1;
+        return 0.0f;
     }
 }

src/me/hammerle/supersnuvi/entity/components/HeroItemCollector.java

@@ -1,23 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public class HeroItemCollector extends ItemCollector
-{
-    public HeroItemCollector(Entity ent) 
-    {
-        super(ent);
-    }
-
-    @Override
-    public boolean canCollect() 
-    {
-        return true;
-    }
-
-    @Override
-    public boolean isHero() 
-    {
-        return true;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/IDeath.java

@@ -0,0 +1,10 @@
+package me.hammerle.supersnuvi.entity.components;
+
+import me.hammerle.supersnuvi.entity.Entity;
+
+public interface IDeath
+{
+    public static final IDeath NULL = (Entity ent) -> {};
+    
+    public void onDeath(Entity ent);
+}

src/me/hammerle/supersnuvi/entity/components/IJump.java

@@ -1,8 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public interface IJump 
-{
-    public double getJumpPower(Entity ent);
-}

src/me/hammerle/supersnuvi/entity/components/ItemCollector.java

@@ -1,23 +1,26 @@
 package me.hammerle.supersnuvi.entity.components;
 
-import me.hammerle.supersnuvi.entity.Entity;
-
-public class ItemCollector extends Component
+public class ItemCollector
 {
-    public final static ItemCollector NULL = new ItemCollector(null);
+    public final static ItemCollector NULL = new ItemCollector(false, false);
+    public final static ItemCollector HERO = new ItemCollector(true, true);
+    
+    private final boolean canCollect;
+    private final boolean isHero;
     
-    public ItemCollector(Entity ent) 
+    private ItemCollector(boolean canCollect, boolean isHero) 
     {
-        super(ent);
+        this.canCollect = canCollect;
+        this.isHero = isHero;
     }
     
     public boolean canCollect()
     {
-        return false;
+        return canCollect;
     }
     
     public boolean isHero()
     {
-        return false;
+        return isHero;
     }
 }

src/me/hammerle/supersnuvi/entity/components/LandMovement.java

@@ -1,23 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public class LandMovement extends MovementPenalty
-{
-    public LandMovement(Entity ent) 
-    {
-        super(ent);
-    }
-
-    @Override
-    public boolean isSlowedByWater() 
-    {
-        return true;
-    }
-
-    @Override
-    public boolean isSlowedByLand() 
-    {
-        return false;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/Movement.java

@@ -2,33 +2,31 @@ package me.hammerle.supersnuvi.entity.components;
 
 import me.hammerle.supersnuvi.entity.Entity;
 
-public class Movement extends Component
+public class Movement
 {
     public final static Movement NULL = new Movement(null);
     
+    protected final Entity ent;
+    
     public Movement(Entity ent) 
     {
-        super(ent);
+        this.ent = ent;
     }
     
-    //--------------------------------------------------------------------------
-    // stuff for e.g. crumbling stones
-    //--------------------------------------------------------------------------
-    
-    public boolean canMoveEverywhere()
+    public float getVelocityX()
     {
-        return false;
+        return 0.0f;
     }
     
-    public boolean useCollisionBox() 
+    public float getVelocityY()
     {
-        return false;
+        return 0.0f;
     }
     
-    public boolean blockHorizontal() 
+    public boolean canMoveEverywhere()
     {
         return false;
-    } 
+    }
     
     //--------------------------------------------------------------------------
     // jumping
@@ -39,22 +37,34 @@ public class Movement extends Component
         return false;
     }
     
-    public double getJumpPower()
+    public float getJumpPower()
     {
-        return 0.0;
+        return 0.0f;
     }
     
     //--------------------------------------------------------------------------
     // gravity
     //--------------------------------------------------------------------------
     
-    public boolean isAffectedByGravity()
+    public boolean hasGravity()
     {
         return false;
     }
     
-    public double getGravityFactor()
+    public float getGravityFactor()
+    {
+        return 1.0f;
+    }
+    
+    //--------------------------------------------------------------------------
+    // friction
+    //--------------------------------------------------------------------------
+    
+    public void setInWater(boolean b)
+    {
+    }
+    
+    public void setFrictionFactor(float f)
     {
-        return 1.0;
     }
 }

src/me/hammerle/supersnuvi/entity/components/MovementPenalty.java

@@ -1,94 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public class MovementPenalty extends Component
-{
-    public final static MovementPenalty NULL = new MovementPenalty(null);
-    
-    private double friction;
-    private boolean inWater;
-    
-    public MovementPenalty(Entity ent)
-    {
-        super(ent);
-    }
-    
-    public final void reset()
-    {
-        inWater = false;
-    }
-    
-    public final void setInWater(boolean b)
-    {
-        inWater = b;
-    }
-    
-    public final boolean isInWater()
-    {
-        return inWater;
-    }
-    
-    public final double getFactor()
-    {
-        double factor = 1.0;
-        if(inWater)
-        {
-            if(isSlowedByWater())
-            {
-                factor *= 0.65;
-            }
-        }
-        else if(isSlowedByLand())
-        {
-            factor *= 0.65;
-        }
-        return factor;
-    }
-
-    public void setFriction(double friction) 
-    {
-        this.friction = friction;
-    }
-
-    public void applyFriction() 
-    {
-        if(ent == null)
-        {
-            return;
-        }
-        double motionX = ent.getMotionX();
-        if(motionX < 0.0)
-        {
-            motionX += friction;
-            if(motionX > 0.0)
-            {
-                motionX = 0.0;
-            }
-            ent.setMotionX(motionX);
-        }
-        else if(motionX > 0.0)
-        {
-            motionX -= friction;
-            if(motionX < 0.0)
-            {
-                motionX = 0.0;
-            }
-            ent.setMotionX(motionX);
-        }
-    }
-    
-    //--------------------------------------------------------------------------
-    // overwriteable data
-    //--------------------------------------------------------------------------
-    
-    public boolean isSlowedByWater()
-    {
-        return true;
-    }
-    
-    public boolean isSlowedByLand()
-    {
-        return true;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/DefaultDespawn.java → src/me/hammerle/supersnuvi/entity/components/NoHealth.java

@@ -2,16 +2,16 @@ package me.hammerle.supersnuvi.entity.components;
 
 import me.hammerle.supersnuvi.entity.Entity;
 
-public class DefaultDespawn extends Health
+public class NoHealth extends Health
 {
-    public DefaultDespawn(Entity ent) 
+    public NoHealth(Entity ent)
     {
-        super(ent, null);
+        super(ent);
     }
 
     @Override
     public boolean shouldDespawn()
     {
-        return ent.isOutOfMap();
+        return ent.getY() > ent.getLevel().getHeight();
     }
 }

src/me/hammerle/supersnuvi/entity/components/StoneMovement.java

@@ -10,27 +10,15 @@ public class StoneMovement extends Movement
     }
 
     @Override
-    public boolean isAffectedByGravity() 
+    public boolean hasGravity() 
     {
-        return ent.getAnimator().hasFinished();
-    }
-
-    @Override
-    public boolean blockHorizontal() 
-    {
-        return true;
-    }
-
-    @Override
-    public boolean useCollisionBox() 
-    {
-        return !ent.getAnimator().hasFinished();
+        return !ent.isAnimated();
     }
     
     @Override
-    public double getGravityFactor() 
+    public float getGravityFactor() 
     {
-        return 0.1;
+        return 0.1f;
     }
     
     @Override

src/me/hammerle/supersnuvi/entity/components/WaterMovement.java

@@ -1,23 +0,0 @@
-package me.hammerle.supersnuvi.entity.components;
-
-import me.hammerle.supersnuvi.entity.Entity;
-
-public class WaterMovement extends MovementPenalty
-{
-    public WaterMovement(Entity ent) 
-    {
-        super(ent);
-    }
-
-    @Override
-    public boolean isSlowedByWater() 
-    {
-        return false;
-    }
-
-    @Override
-    public boolean isSlowedByLand() 
-    {
-        return true;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/ai/Controller.java

@@ -0,0 +1,29 @@
+package me.hammerle.supersnuvi.entity.components.ai;
+
+import me.hammerle.supersnuvi.entity.Entity;
+import me.hammerle.supersnuvi.tiles.Location;
+import me.hammerle.supersnuvi.util.Face;
+
+public class Controller
+{
+    public final static Controller NULL = new Controller(null);
+    
+    protected final Entity ent;
+    
+    protected Controller(Entity ent)
+    {
+        this.ent = ent;
+    }
+    
+    public void tick()
+    {
+    }
+    
+    public void onCollideWithTile(Location loc, Face face)
+    {
+    }
+    
+    public void onCollideWithEntity(Entity ent, Face face)
+    {
+    }
+}

src/me/hammerle/supersnuvi/entity/components/ai/EntityController.java

@@ -1,68 +0,0 @@
-package me.hammerle.supersnuvi.entity.components.ai;
-
-import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.entity.components.Component;
-import me.hammerle.supersnuvi.tiles.Location;
-import me.hammerle.supersnuvi.util.Face;
-
-public class EntityController extends Component
-{
-    public final static EntityController NULL = new EntityController(null);
-    
-    protected EntityController(Entity ent)
-    {
-        super(ent);
-    }
-    
-    public void tick()
-    {
-    }
-    
-    public boolean isRunning()
-    {
-        return false;
-    }
-    
-    public boolean isInCombatMode()
-    {
-        return false;
-    }
-    
-    public int getCombatTimer() 
-    {
-        return 0;
-    }
-    
-    public boolean isBlocking()
-    {
-        return false;
-    }
-    
-    public boolean isAttacking()
-    {
-        return false;
-    }
-    
-    public boolean isDashing()
-    {
-        return false;
-    }
-    
-    public boolean isDodging()
-    {
-        return false;
-    }
-    
-    public boolean isEvil()
-    {
-        return false;
-    }
-    
-    public void onCollideWithTile(Location loc, Face face)
-    {
-    }
-    
-    public void onCollideWithEntity(Entity ent, Face face)
-    {
-    }
-}

src/me/hammerle/supersnuvi/entity/components/ai/FollowHeroController.java

@@ -1,23 +1,20 @@
 package me.hammerle.supersnuvi.entity.components.ai;
 
 import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.tiles.Location;
-import me.hammerle.supersnuvi.util.Face;
-import me.hammerle.supersnuvi.util.SoundUtils;
 
-public class FollowHeroController extends EntityController
+public class FollowHeroController extends Controller
 {
-    private final double motion;
+    private final float motion;
     private boolean jump;
     
-    public FollowHeroController(Entity ent, double motion)
+    public FollowHeroController(Entity ent, float motion)
     {
         super(ent);
         this.motion = motion;
         this.jump = false;
     }
 
-    @Override
+    /*@Override
     public void tick() 
     {
         if(ent.getHealth().isDead())
@@ -33,7 +30,7 @@ public class FollowHeroController extends EntityController
                 SoundUtils.playSound(SoundUtils.Sound.LONDONER_JUMP);
                 ent.getMovement().jump();
             }
-            double distance = ent.signedDistanceX(hero);
+            float distance = ent.signedDistanceX(hero);
             if(distance < 0)
             {
                 ent.setMotionX(motion * ent.getMovementPenalty().getFactor());
@@ -52,11 +49,11 @@ public class FollowHeroController extends EntityController
         {
             if(ent.getX() - this.ent.getX() > 0)
             {
-                ent.setMotionX(6.0);
+                ent.setMotionX(6.0f);
             }
             else
             {
-                ent.setMotionX(-6.0);
+                ent.setMotionX(-6.0f);
             }
             ent.getHealth().addHealth(-0.05);
             if(ent.getMovement().useCollisionBox())
@@ -75,5 +72,5 @@ public class FollowHeroController extends EntityController
         {
             jump = true;
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/entity/components/ai/HumanController.java

@@ -2,10 +2,10 @@ package me.hammerle.supersnuvi.entity.components.ai;
 
 import me.hammerle.supersnuvi.Keys;
 import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.rendering.OldGame;
+import me.hammerle.supersnuvi.tiles.Tile;
 import me.hammerle.supersnuvi.util.SoundUtils;
 
-public class HumanController extends EntityController
+public class HumanController extends Controller
 {
     private boolean combatMode = false;
     private int combatTimer = 0;
@@ -19,6 +19,35 @@ public class HumanController extends EntityController
         super(ent);
     }
     
+    @Override
+    public void tick()
+    {
+        float f = 12;
+        if(Keys.RUN.isDown())
+        {
+            f = 24;
+        }
+        
+        if(Keys.RIGHT.isDown())
+        {
+            ent.setMotionX(f);
+        }
+        else if(Keys.LEFT.isDown())
+        {
+            ent.setMotionX(-f);
+        }
+        else
+        {
+            ent.setMotionX(0.0f);
+        }
+        
+        if(Keys.JUMP.isDown())
+        {
+            ent.getMovement().jump();
+        }
+    }
+    
+    /*
     @Override
     public boolean isRunning() 
     {
@@ -111,8 +140,8 @@ public class HumanController extends EntityController
             {
                 attackTimer = -1;
                 
-                double sign = ent.getAnimator().drawImageFlipped() ? -1 : 1;
-                double extend = sign * OldGame.TILE_SIZE;
+                float sign = ent.getAnimator().drawImageFlipped() ? -1 : 1;
+                float extend = sign * Tile.SIZE;
                 boolean once = true;
                 for(Entity e : ent.getLevel().getEntitiesCollidingWith(ent, ent.getBox().expand(extend, 0)))
                 {
@@ -137,7 +166,7 @@ public class HumanController extends EntityController
             if(dodgeTimer > 12)
             {
                 dodgeTimer = -1;
-                ent.setMotionX(0.0);
+                ent.setMotionX(0.0f);
             }
             else
             {
@@ -151,7 +180,7 @@ public class HumanController extends EntityController
             if(dashTimer > 15)
             {
                 dashTimer = -1;
-                ent.setMotionX(0.0);
+                ent.setMotionX(0.0f);
             }
             else
             {
@@ -194,19 +223,19 @@ public class HumanController extends EntityController
                 SoundUtils.playSound(SoundUtils.Sound.JUMP);
             }
             
-            double speed;
+            float speed;
             if(ent.getController().isInCombatMode())
             {
-                speed = 3.0;
+                speed = 3.0f;
             }
             else
             {
-                speed = 6.0;
+                speed = 6.0f;
                 if(isRunning())
                 {
                     if(ent.getEnergy().getEnergyPercent() > 0.0)
                     {
-                        speed = 9.0;
+                        speed = 9.0f;
                     }
                     if(ent.isMoving())
                     {
@@ -239,5 +268,5 @@ public class HumanController extends EntityController
                 }           
             }
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/entity/components/ai/LondonerController.java

@@ -1,12 +1,12 @@
 package me.hammerle.supersnuvi.entity.components.ai;
 
 import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.rendering.OldGame;
 import me.hammerle.supersnuvi.tiles.Location;
+import me.hammerle.supersnuvi.tiles.Tile;
 import me.hammerle.supersnuvi.util.Face;
 import me.hammerle.supersnuvi.util.SoundUtils;
 
-public class LondonerController extends EntityController
+public class LondonerController extends Controller
 {
     private boolean combatMode = false;
     private int combatTimer = 0;
@@ -14,7 +14,7 @@ public class LondonerController extends EntityController
     private int attackCooldown = -1;
     private int dashTimer = -1;
     
-    private final double motion = 1.5;
+    private final float motion = 1.5f;
     
     private final boolean evil;
     
@@ -25,7 +25,7 @@ public class LondonerController extends EntityController
         super(ent);
         this.evil = evil;
     }
-
+    /*
     @Override
     public boolean isInCombatMode() 
     {
@@ -71,7 +71,7 @@ public class LondonerController extends EntityController
                 Entity hero = ent.getLevel().getHero();
                 if(hero.squaredDistance(ent) <= 65536)
                 {
-                    ent.setMotionX(0.0);
+                    ent.setMotionX(0.0f);
                     combatMode = true;
                     combatTimer = ent.getAnimator().getCombatStartTicks() - 1;
                     return;
@@ -98,8 +98,8 @@ public class LondonerController extends EntityController
             if(attackTimer >= ent.getAnimator().getAttackTicks())
             {
                 attackTimer = -1;
-                double sign = ent.getAnimator().drawImageFlipped() ? -1 : 1;
-                double extend = sign * OldGame.TILE_SIZE;
+                float sign = ent.getAnimator().drawImageFlipped() ? -1 : 1;
+                float extend = sign * Tile.SIZE;
                 boolean once = true;
                 for(Entity e : ent.getLevel().getEntitiesCollidingWith(ent, ent.getBox().expand(extend, 0)))
                 {
@@ -120,8 +120,8 @@ public class LondonerController extends EntityController
         else
         {
             Entity hero = ent.getLevel().getHero();
-            double distance = hero.signedDistanceX(ent);
-            if(Math.abs(distance) < (OldGame.TILE_SIZE >> 1))
+            float distance = hero.signedDistanceX(ent);
+            if(Math.abs(distance) < (Tile.SIZE >> 1))
             {
                 if(attackCooldown > 0)
                 {
@@ -140,7 +140,7 @@ public class LondonerController extends EntityController
             if(dashTimer > 15)
             {
                 dashTimer = -1;
-                ent.setMotionX(0.0);
+                ent.setMotionX(0.0f);
             }
             else
             {
@@ -204,5 +204,5 @@ public class LondonerController extends EntityController
                 ent.getAnimator().setFlipped(false);
             }
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/entity/components/ai/WalkController.java

@@ -4,11 +4,11 @@ import me.hammerle.supersnuvi.entity.Entity;
 import me.hammerle.supersnuvi.tiles.Location;
 import me.hammerle.supersnuvi.util.Face;
 
-public class WalkController extends EntityController
+public class WalkController extends Controller
 {
-    private double motion;
+    private float motion;
     
-    public WalkController(Entity ent, double motion)
+    public WalkController(Entity ent, float motion)
     {
         super(ent);
         this.motion = motion;
@@ -24,7 +24,7 @@ public class WalkController extends EntityController
         ent.setMotionX(motion);
     }
 
-    @Override
+    /*@Override
     public void onCollideWithEntity(Entity ent, Face face) 
     {
         switchDirection(face);
@@ -34,7 +34,7 @@ public class WalkController extends EntityController
     public void onCollideWithTile(Location loc, Face face) 
     {
         switchDirection(face);
-    }
+    }*/
     
     private void switchDirection(Face face)
     {

src/me/hammerle/supersnuvi/entity/components/animator/EntityAnimator.java

@@ -1,87 +0,0 @@
-package me.hammerle.supersnuvi.entity.components.animator;
-
-import me.hammerle.supersnuvi.entity.Entity;
-import me.hammerle.supersnuvi.rendering.IRenderer;
-
-public class EntityAnimator 
-{
-    public final static EntityAnimator NULL = new EntityAnimator(null);
-    
-    protected final Entity ent;
-    
-    protected EntityAnimator(Entity ent)
-    {
-        this.ent = ent;
-    }
-    
-    public void tick()
-    {
-    }
-    
-    public void render(IRenderer renderer)
-    {
-    }
-    
-    public final void resetFrames()
-    {
-        resetDefaultFrames();
-        resetIdleFrames();
-        resetHeadFrames();
-        resetBodyFrames();
-        resetArmsFrames();
-    }
-    
-    public void resetDefaultFrames()
-    {
-    }
-    
-    public void resetIdleFrames()
-    {
-    }
-    
-    public void resetHeadFrames()
-    {
-    }
-    
-    public void resetBodyFrames()
-    {
-    }
-    
-    public void resetArmsFrames()
-    {
-    }
-    
-    public int getAttackTicks() 
-    {
-        return 0;
-    }
-    
-    public int getCombatStartTicks() 
-    {
-        return 0;
-    }
-    
-    public int getBlockTicks()
-    {
-        return 0;
-    }
-    
-    public int getDeathTicks()
-    {
-        return 0;
-    }
-    
-    public boolean drawImageFlipped()
-    {
-        return false;
-    }
-    
-    public void setFlipped(boolean flipped)
-    {
-    }
-    
-    public boolean hasFinished()
-    {
-        return false;
-    }
-}

src/me/hammerle/supersnuvi/entity/components/animator/HeroAnimator.java

@@ -4,13 +4,12 @@ import me.hammerle.supersnuvi.Keys;
 import me.hammerle.supersnuvi.entity.Entity;
 import me.hammerle.supersnuvi.entity.components.Health;
 import me.hammerle.supersnuvi.javafx.Image;
-import me.hammerle.supersnuvi.rendering.OldGame;
 import me.hammerle.supersnuvi.rendering.IRenderer;
 import me.hammerle.supersnuvi.util.Utils;
 
-public class HeroAnimator extends EntityAnimator
+public class HeroAnimator extends Renderer
 {
-    private final static Image[] WALK = new Image[]
+    /*private final static Image[] WALK = new Image[]
     {
         Utils.getImage("snuvi/walk/walk_f1", true),
         Utils.getImage("snuvi/walk/walk_f2", true),
@@ -197,12 +196,12 @@ public class HeroAnimator extends EntityAnimator
     private int attackCounter = 0;
 
     private boolean flipped = false;
-    
+    */
     public HeroAnimator(Entity ent) 
     {
         super(ent);
     }
-
+    /*
     @Override
     public int getCombatStartTicks() 
     {
@@ -266,8 +265,8 @@ public class HeroAnimator extends EntityAnimator
     @Override
     public void render(IRenderer renderer) 
     {
-        double x = ent.getX() - 2 * OldGame.SCALE;
-        double y = ent.getY() + ent.getHeight() - 2 * OldGame.SCALE;
+        double x = ent.getX() - 2;
+        double y = ent.getY() + ent.getHeight() - 2;
         
         if(ent.getHealth().isDead())
         {
@@ -513,5 +512,5 @@ public class HeroAnimator extends EntityAnimator
                 image.bindSlot(-1);
             }
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/entity/components/animator/LondonerAnimator.java

@@ -3,13 +3,12 @@ package me.hammerle.supersnuvi.entity.components.animator;
 import me.hammerle.supersnuvi.entity.Entity;
 import me.hammerle.supersnuvi.entity.components.Health;
 import me.hammerle.supersnuvi.javafx.Image;
-import me.hammerle.supersnuvi.rendering.OldGame;
 import me.hammerle.supersnuvi.rendering.IRenderer;
 import me.hammerle.supersnuvi.util.Utils;
 
-public class LondonerAnimator extends EntityAnimator
+public class LondonerAnimator extends Renderer
 {
-    private final static Image[] EVIL_ATTACK = new Image[]
+    /*private final static Image[] EVIL_ATTACK = new Image[]
     {
         Utils.getImage("londoner/KnC1_a_f1", true),
         Utils.getImage("londoner/KnC1_a_f2", true),
@@ -77,12 +76,12 @@ public class LondonerAnimator extends EntityAnimator
     private int frame = 0;
     
     private boolean flipped = false;
-    
+    */
     public LondonerAnimator(Entity ent) 
     {
         super(ent);
     }
-
+    /*
     @Override
     public int getCombatStartTicks() 
     {
@@ -112,8 +111,8 @@ public class LondonerAnimator extends EntityAnimator
     public void render(IRenderer renderer) 
     {
         boolean flip = drawImageFlipped();
-        double x = ent.getX() - 9 * OldGame.SCALE;
-        double y = ent.getY() + ent.getHeight() - 2 * OldGame.SCALE;
+        double x = ent.getX() - 9;
+        double y = ent.getY() + ent.getHeight() - 2;
         double w = ent.getWidth() * 2;
         double h = ent.getHeight();
         
@@ -238,5 +237,5 @@ public class LondonerAnimator extends EntityAnimator
                 image.bindSlot(-1);
             }
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/entity/components/animator/Renderer.java

@@ -0,0 +1,24 @@
+package me.hammerle.supersnuvi.entity.components.animator;
+
+import me.hammerle.supersnuvi.entity.Entity;
+
+public class Renderer 
+{
+    public final static Renderer NULL = new Renderer(null);
+    
+    protected final Entity ent;
+    
+    protected Renderer(Entity ent)
+    {
+        this.ent = ent;
+    }
+    
+    public void renderTick(float lag)
+    {
+    }
+    
+    public boolean isAnimated()
+    {
+        return false;
+    }
+}

src/me/hammerle/supersnuvi/entity/components/animator/StoneAnimator.java

@@ -5,9 +5,9 @@ import me.hammerle.supersnuvi.javafx.Image;
 import me.hammerle.supersnuvi.rendering.IRenderer;
 import me.hammerle.supersnuvi.util.Utils;
 
-public class StoneAnimator extends EntityAnimator
+public class StoneAnimator extends Renderer
 {
-    private static final Image[] BASE;
+    /*private static final Image[] BASE;
     
     static
     {
@@ -20,12 +20,12 @@ public class StoneAnimator extends EntityAnimator
     
     private int counter = 0;
     private int frame = 0;
-    
+    */
     public StoneAnimator(Entity ent) 
     {
         super(ent);
     }
-
+    /*
     @Override
     public boolean hasFinished() 
     {
@@ -62,5 +62,5 @@ public class StoneAnimator extends EntityAnimator
                 frame = 0;
             }  
         }
-    }
+    }*/
 }

src/me/hammerle/supersnuvi/gamelogic/Level.java

@@ -5,8 +5,9 @@ import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.TreeSet;
-import java.util.stream.Collectors;
 import me.hammerle.snuviengine.api.Shader;
+import me.hammerle.snuviengine.api.Texture;
+import me.hammerle.snuviengine.api.TextureRenderer;
 import me.hammerle.supersnuvi.Game;
 import me.hammerle.supersnuvi.entity.Entity;
 import me.hammerle.supersnuvi.entity.EntityBuilder;
@@ -19,6 +20,10 @@ import me.hammerle.supersnuvi.util.Utils;
 
 public final class Level 
 {
+    private final static float ERROR = 1f / 65536f;
+    
+    public final static Texture TILES = new Texture("resources/tiles.png");
+    
     private final boolean worldLoaded;
     private final LevelData data;
     
@@ -39,6 +44,17 @@ public final class Level
     private double time = 0.0;
     private double clockTick = 0.0;
     
+    private float cameraX = 0.0f;
+    private float cameraY = 0.0f;
+    private float oldCameraX = 0.0f;
+    private float oldCameraY = 0.0f;
+    
+    private final int meshSize = 16;
+    private final int meshLayers;
+    private final int meshWidth;
+    private final int meshHeight;
+    private final TextureRenderer[][][] meshes;
+    
     //private int tries = 7;
     
     private TreeSet<Point> spawns = new TreeSet<>();
@@ -52,6 +68,21 @@ public final class Level
         {
             this.name = data.getString("name", "error");
             
+            meshLayers = data.getLayers() - 1;
+            meshWidth = (int) Math.ceil((double) data.getWidth() / meshSize);
+            meshHeight = (int) Math.ceil((double) data.getHeight() / meshSize);
+            meshes = new TextureRenderer[meshLayers][meshWidth][meshHeight];
+            for(int l = 0; l < meshLayers; l++)
+            {
+                for(int mx = 0; mx < meshWidth; mx++)
+                {
+                    for(int my = 0; my < meshHeight; my++)
+                    {
+                        meshes[l][mx][my] = new TextureRenderer(meshSize * meshSize * 2);
+                    }
+                }
+            }
+            
             // debug stuff
             /*if(name.equals("00-Tech Demo"))
             {
@@ -110,7 +141,7 @@ public final class Level
                 
                 if(tile == StartTile.ID)
                 {
-                    spawns.add(new Point(x, y));
+                    spawns.add(new Point(x, y - 1));
                 }
             });
             data.forEachEntity((x, y, tile) -> 
@@ -125,6 +156,11 @@ public final class Level
         {
             this.name = f.getName();
             maxSouls = 0;
+            
+            meshLayers = 0;
+            meshWidth = 0;
+            meshHeight = 0;
+            meshes = new TextureRenderer[0][0][0];
         }
         fileName = f.getName();
         
@@ -141,6 +177,11 @@ public final class Level
     // basic stuff
     // -------------------------------------------------------------------------
 
+    public Entity getHero()
+    {
+        return hero;
+    }
+    
     public String getFileName() 
     {
         return fileName;
@@ -247,6 +288,16 @@ public final class Level
     {
         return time;
     }  
+    
+    public int getWidth()
+    {
+        return data.getWidth();
+    }
+    
+    public int getHeight()
+    {
+        return data.getHeight();
+    }
 
     // -------------------------------------------------------------------------
     // tick
@@ -291,6 +342,12 @@ public final class Level
                 spawnQueue.forEach(ent -> entities.put(entityCounter++, ent));
                 spawnQueue.clear();
             }
+            
+            // calculate new camera position
+            oldCameraX = cameraX;
+            oldCameraY = cameraY;
+            cameraX = -getViewX(hero.getCenterX());
+            cameraY = -getViewY(hero.getCenterY());
         }
     }   
     
@@ -421,7 +478,51 @@ public final class Level
         return y;
     }
     
-    public void render(float lag)
+    public void updateTile(int layer, int x, int y)
+    {
+        if(layer > data.getBackgroundIndex())
+        {
+            layer--;
+        }
+        meshes[layer][x / meshSize][y / meshSize].clear();
+    }
+    
+    public void updateTile(int x, int y)
+    {
+        updateTile(data.getBackgroundIndex(), x, y);
+    }
+    
+    private void drawMesh(int l, int tl, int mx, int my)
+    {
+        TextureRenderer tr = meshes[l][mx][my];
+        if(!tr.isBuilt())
+        {
+            int tsx = mx * meshSize;
+            int tsy = my * meshSize;
+            int tex = Math.min(tsx + meshSize, data.getWidth());
+            int tey = Math.min(tsy + meshSize, data.getHeight());
+            for(int x = tsx; x < tex; x++)
+            {
+                for(int y = tsy; y < tey; y++)
+                {
+                    Tile t = Game.get().getTile(data.getTile(tl, x, y));
+                    if(t.shouldRender(x, y))
+                    {
+                        float minX = x * Tile.SIZE + t.getOffsetX();
+                        float minY = y * Tile.SIZE + t.getOffsetY();
+                        tr.addRectangle(minX, minY, 
+                                minX + t.getWidth(), minY + t.getHeight(), 
+                                t.getTextureMinX() + ERROR, t.getTextureMinY() + ERROR,
+                                t.getTextureMaxX() - ERROR, t.getTextureMaxY() - ERROR);
+                    }
+                }
+            }
+            tr.build();
+        }
+        meshes[l][mx][my].draw();
+    }
+    
+    public void renderTick(float lag)
     {
         if(worldLoaded)
         {
@@ -429,61 +530,75 @@ public final class Level
             double rWidth = Shader.getViewWidth();
             double rHeight = Shader.getViewHeight();
             
-            float centerX = (float) (hero.getX() - hero.getWidth() / 2);
-            float centerY = (float) (hero.getY() - hero.getHeight() / 2);
-            
-            float cameraX = getViewX(centerX);
-            float cameraY = getViewY(centerY);
+            float camX = Utils.interpolate(oldCameraX, cameraX, lag);
+            float camY = Utils.interpolate(oldCameraY, cameraY, lag);
             
-            Shader.translateTo(-cameraX, -cameraY);
+            Shader.translateTo(camX, camY);
             Shader.updateMatrix();
+             
+            int startX = (int) (-camX / (meshSize * Tile.SIZE));
+            int startY = (int) (-camY / (meshSize * Tile.SIZE));
+            int endX = (int) Math.ceil((-camX + Shader.getViewWidth()) / (meshSize * Tile.SIZE));
+            int endY = (int) Math.ceil((-camY + Shader.getViewHeight()) / (meshSize * Tile.SIZE));
             
-            Shader.setColorEnabled(true);
-            Shader.setTextureEnabled(false);
-            Shader.getColorRenderer().drawRectangle(centerX - 5, centerY - 5, centerX + 5, centerY + 5, 0xFFFF0000);
+            startX = Math.min(Math.max(startX, 0), meshWidth);
+            startY = Math.min(Math.max(startY, 0), meshHeight);
+            endX = Math.min(Math.max(endX, 0), meshWidth);
+            endY = Math.min(Math.max(endY, 0), meshHeight);
             
-            /*data.forEachInteractTile((x, y, tile) -> 
+            // background
+            Shader.setColorEnabled(false);
+            Shader.setTextureEnabled(true);
+            Shader.setBlendingEnabled(true);
+            TILES.bind();
+            
+            int fromLayer = 0;
+            int toLayer = data.getBackgroundIndex() + 1;
+            
+            for(int l = fromLayer; l < toLayer; l++)
             {
-                if(tile <= 0)
+                for(int mx = startX; mx < endX; mx++)
                 {
-                    return;
+                    for(int my = startY; my < endY; my++)
+                    {
+                        drawMesh(l, l, mx, my);
+                    }
                 }
-                x *= Tile.SIZE;
-                y *= Tile.SIZE;
-                Shader.getColorRenderer().drawRectangle(x, y, x + Tile.SIZE, y  + Tile.SIZE, 0xFFFFFF00);
-            });*/
+            }
             
-            /*renderer.setViewCenter(centerX, centerY);
+            // entities
             
-            int startX = renderer.getFirstVisibleBlockX();
-            int startY = renderer.getFirstVisibleBlockY();
-            int endX = Math.min(renderer.getLastVisibleBlockX() + 1, data.getWidth());
-            int endY = Math.min(renderer.getLastVisibleBlockY() + 1, data.getHeight());*/
+            Shader.setBlendingEnabled(false);
+            Shader.setColorEnabled(true);
+            Shader.setTextureEnabled(false);
             
-            /*data.forEachBackground((x, y, tile) ->
-            {
-                if(tile != -1)
-                {
-                    Tile t = state.getTile(tile);
-                    t.preRender(renderer, x, y);
-                    renderer.drawBlockImage(t.getImage(x, y), x, y, t.getRenderOffsetX(), t.getRenderOffsetY());
-                    t.postRender(renderer, x, y);
-                }
-            }, startX, endX, startY, endY);
+            float xPos = Utils.interpolate(hero.getLastX(), hero.getX(), lag);
+            float yPos = Utils.interpolate(hero.getLastY(), hero.getY(), lag);
+            Shader.getColorRenderer().drawRectangle(xPos, yPos, 
+                    xPos + 29, yPos + 59, 
+                    0xFFFF0000);
             
-            entities.values().forEach(en -> en.getAnimator().render(renderer));
+            // foreground
+            Shader.setColorEnabled(false);
+            Shader.setTextureEnabled(true);
+            Shader.setBlendingEnabled(true);
+            TILES.bind();
             
-            data.forEachForeground((x, y, tile) ->
+            fromLayer = toLayer + 1;
+            toLayer = data.getLayers();
+            
+            for(int l = fromLayer; l < toLayer; l++)
             {
-                if(tile != -1)
+                for(int mx = startX; mx < endX; mx++)
                 {
-                    Tile t = state.getTile(tile);
-                    t.preRender(renderer, x, y);
-                    renderer.drawBlockImage(t.getImage(x, y), x, y, t.getRenderOffsetX(), t.getRenderOffsetY());
-                    t.postRender(renderer, x, y);
+                    for(int my = startY; my < endY; my++)
+                    {
+                        drawMesh(l - 1, l, mx, my);
+                    }
                 }
-            }, startX, endX, startY, endY);
+            }
             
+            /*
             // menu rendering
             // |-------------------------------------| 
             // | B00/00 | ENERGYENERGY | HPHP | TIME |
@@ -565,7 +680,7 @@ public final class Level
     // collision box, interaction layer
     // -------------------------------------------------------------------------
     
-    public Tile getInteractionTile(int x, int y)
+    private Tile getInteractionTile(int x, int y)
     {
         int i = data.getInteractionTile(x, y);
         if(i == -1)
@@ -575,39 +690,39 @@ public final class Level
         return Game.get().getTile(i);
     }
     
-    public CollisionBox getTileMovementBox(int x, int y)
+    private CollisionBox getMovementBox(int x, int y)
     {
         int i = data.getInteractionTile(x, y);
         if(i == -1)
         {
             return CollisionBox.NULL_BOX;
         }
-        Tile tile = Game.get().getTile(i);
-        return tile.getMovementBox(x, y).reset().offset(Utils.toCoord(x), Utils.toCoord(y));
+        return Game.get().getTile(i).getMovementBox(x, y).reset().offset(Utils.toCoord(x), Utils.toCoord(y));
     }
     
-    public LinkedList<Location> getTilesInMovementOf(CollisionBox cb)
+    public List<CollisionBox> getMovementBoxesAt(CollisionBox box)
     {
-        LinkedList<Location> boxes = new LinkedList<>();
-        int startX = Utils.toBlock(cb.getMinX());
-        int endX = Utils.toBlock(cb.getMaxX());
-        int startY = Utils.toBlock(cb.getMinY());
-        int endY = Utils.toBlock(cb.getMaxY());
+        LinkedList<CollisionBox> boxes = new LinkedList<>();
+        int startX = Utils.toBlock(box.getMinX());
+        int endX = Utils.toBlock(box.getMaxX());
+        int startY = Utils.toBlock(box.getMinY());
+        int endY = Utils.toBlock(box.getMaxY());
         
         for(int x = startX; x <= endX; x++)
         {
             for(int y = startY; y <= endY; y++)
             {
-                if(getTileMovementBox(x, y).intersects(cb))
+                CollisionBox cb = getMovementBox(x, y);
+                if(cb.isColliding(box) && cb != CollisionBox.NULL_BOX)
                 {
-                    boxes.add(new Location(getInteractionTile(x, y), x, y));
+                    boxes.add(cb.copy());
                 }
             }
         }
         return boxes;
     }
     
-    public CollisionBox getTileCollisionBox(int x, int y)
+    private CollisionBox getCollisionBox(int x, int y)
     {
         int i = data.getInteractionTile(x, y);
         if(i == -1)
@@ -618,7 +733,7 @@ public final class Level
         return tile.getCollisionBox(x, y).reset().offset(Utils.toCoord(x), Utils.toCoord(y));
     }
     
-    public LinkedList<Location> getTilesCollidingWith(CollisionBox cb)
+    public List<Location> getCollisionBoxesAt(CollisionBox cb)
     {
         LinkedList<Location> boxes = new LinkedList<>();
         int startX = Utils.toBlock(cb.getMinX());
@@ -630,7 +745,7 @@ public final class Level
         {
             for(int y = startY; y <= endY; y++)
             {
-                if(getTileCollisionBox(x, y).intersects(cb))
+                if(getCollisionBox(x, y).isColliding(cb))
                 {
                     boxes.add(new Location(getInteractionTile(x, y), x, y));
                 }
@@ -641,37 +756,7 @@ public final class Level
     
     public List<Entity> getEntitiesCollidingWith(Entity not, CollisionBox cb)
     {
-        return entities.values().stream().filter(ent -> ent != not && ent.getBox().intersects(cb)).collect(Collectors.toList());
-    }
-    
-    public LinkedList<CollisionBox> getMovementBoxesAt(Entity not, CollisionBox cb)
-    {
-        LinkedList<CollisionBox> boxes = new LinkedList<>(entities.values().stream()
-                            .filter(ent -> ent != not && ent.getMovement().useCollisionBox() && ent.getBox().intersects(cb))
-                            .map(ent -> ent.getBox())
-                            .collect(Collectors.toList()));
-        int startX = Utils.toBlock(cb.getMinX());
-        int endX = Utils.toBlock(cb.getMaxX());
-        int startY = Utils.toBlock(cb.getMinY());
-        int endY = Utils.toBlock(cb.getMaxY());
-        
-        CollisionBox box;
-        for(int x = startX; x <= endX; x++)
-        {
-            for(int y = startY; y <= endY; y++)
-            {
-                box = getTileMovementBox(x, y);
-                if(box.intersects(cb))
-                {
-                    boxes.add(box.copy());
-                }
-            }
-        }
-        return boxes;
-    }
-    
-    public Entity getHero()
-    {
-        return hero;
+        // TODO
+        return new LinkedList<>();
     }
 }

src/me/hammerle/supersnuvi/javafx/JavaRenderer.java

@@ -6,10 +6,8 @@ import javafx.scene.Group;
 import javafx.scene.Scene;
 import javafx.scene.canvas.Canvas;
 import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.input.KeyEvent;
 import javafx.scene.paint.Color;
 import javafx.stage.Stage;
-import me.hammerle.supersnuvi.rendering.OldGame;
 import me.hammerle.text.SnuviTextPainter;
 
 public class JavaRenderer extends Application implements IJavaRenderer
@@ -86,13 +84,11 @@ public class JavaRenderer extends Application implements IJavaRenderer
     // -------------------------------------------------------------------------
     
     private AnimationTimer timer = null;
-    private OldGame game;
     
     private void startLoop()
     {
         if(timer == null)
         {
-            game = new OldGame(this);
             timer = new AnimationTimer() 
             {
                 private long last = System.nanoTime();
@@ -105,9 +101,7 @@ public class JavaRenderer extends Application implements IJavaRenderer
                     last = now;
                     while(lag >= 12_500_000)
                     {
-                        game.update();
                         lag -= 12_500_000;
-                        game.render();
                     }
                 }
             };

src/me/hammerle/supersnuvi/rendering/OldGame.java

@@ -1,237 +0,0 @@
-package me.hammerle.supersnuvi.rendering;
-
-import me.hammerle.supersnuvi.javafx.IJavaRenderer;
-import me.hammerle.supersnuvi.javafx.Image;
-
-public class OldGame implements IRenderer
-{
-    // constants
-    public final static int TILE_SIZE = 64;
-    public final static double SCALE = TILE_SIZE / 32.0;
-    
-    // basic graphic stuff
-    private final IJavaRenderer renderer;
-    
-    // rendering
-    private double cameraX;
-    private double cameraY;
-    private double offsetX;
-    private double offsetY;
-    
-    public OldGame(IJavaRenderer renderer)
-    {
-        // basic graphic stuff
-        this.renderer = renderer;
-        // rendering
-        this.cameraX = 0;
-        this.cameraY = 0;
-        this.offsetX = 0;
-        this.offsetY = 0;
-    }
-    
-    public void update() 
-    {
-    }
-    
-    public void render() 
-    {
-        offsetX = -cameraX;
-        offsetY = renderer.getHeight() + cameraY;
-        renderer.prepareRendering();
-    }
-    
-    // -------------------------------------------------------------------------
-    // image rendering
-    // -------------------------------------------------------------------------
-    
-    @Override
-    public void drawImage(Image image, double x, double y)
-    {
-        renderer.drawImage(image, offsetX + x, offsetY - y);
-    }
-    
-    @Override
-    public void drawImage(Image image, double x, double y, boolean flipped)
-    {
-        if(flipped)
-        {
-            renderer.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), 
-                    offsetX + x + image.getWidth(), offsetY - y, -image.getWidth(), image.getHeight());
-        }
-        else
-        {
-            renderer.drawImage(image, offsetX + x, offsetY - y);
-        }
-    }
-    
-    @Override
-    public void drawImage(Image image, double x, double y, double w, double h, boolean flipped)
-    {
-        if(flipped)
-        {
-            renderer.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), 
-                    offsetX + x + w, offsetY - y, -w, h);
-        }
-        else
-        {
-            renderer.drawImage(image, offsetX + x, offsetY - y, w, h);
-        }
-    }
-    
-    @Override
-    public void drawFixedImage(Image image, double x, double y)
-    {
-        renderer.drawImage(image, x, y);
-    }
-    
-    @Override
-    public void drawFixedImage(Image image, double x, double y, double w, double h)
-    {
-        renderer.drawImage(image, x, y, w, h);
-    }
-    
-    @Override
-    public void drawFixedImagePart(Image image, double sx, double sy, double sw, double sh, double dx, double dy, double dw, double dh)
-    {
-        renderer.drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh);
-    }
-    
-    @Override
-    public void drawBlockImage(Image image, int x, int y, double offX, double offY)
-    {
-        renderer.drawImage(image, offsetX + x * TILE_SIZE + offX, offsetY - (y + 1) * TILE_SIZE + offY);
-    }
-    
-    // -------------------------------------------------------------------------
-    // primitive rendering
-    // -------------------------------------------------------------------------
-    
-    @Override
-    public double getWidth() 
-    {
-        return renderer.getWidth();
-    }
-
-    @Override
-    public double getHeight() 
-    {
-        return renderer.getHeight();
-    }
-    
-    @Override
-    public void save() 
-    {
-        renderer.save();
-    }
-
-    @Override
-    public void restore() 
-    {
-        renderer.restore();
-    }
-
-    @Override
-    public void setFillColor(int r, int g, int b, double alpha) 
-    {
-        renderer.setFillColor(r, g, b, alpha);
-    }
-
-    @Override
-    public void setStrokeColor(int r, int g, int b, double alpha) 
-    {
-        renderer.setStrokeColor(r, g, b, alpha);
-    }
-    
-    @Override
-    public void fillRectangle(double x, double y, double w, double h)
-    {
-        renderer.fillRectangle(x, y, w, h);
-    }
-    
-    @Override
-    public void setScale(double scale)
-    {
-        renderer.setScale(scale);
-    }
-    
-    // -------------------------------------------------------------------------
-    // text rendering
-    // -------------------------------------------------------------------------
-    
-    @Override
-    public void prepareTextDrawing(int r, int g, int b, double alpha, int width) 
-    {
-        renderer.prepareTextDrawing(r, g, b, alpha, width);
-    }
-    
-    @Override
-    public void stopTextDrawing() 
-    {
-        renderer.stopTextDrawing();
-    }
-
-    @Override
-    public void drawText(double x, double y, char[] text) 
-    {
-        renderer.drawText(x, y, text, text.length);
-    }
-    
-    @Override
-    public void drawText(double x, double y, char[] text, int max) 
-    {
-        renderer.drawText(x, y, text, max);
-    }
-
-    @Override
-    public double getTextWidth(int chars) 
-    {
-        return renderer.getTextWidth(chars);
-    }
-
-    @Override
-    public double getTextHeight(int lines) 
-    {
-        return renderer.getTextHeight(lines);
-    }
-    
-    // -------------------------------------------------------------------------
-    // rendering utils
-    // -------------------------------------------------------------------------
-    
-    @Override
-    public int getFirstVisibleBlockX()
-    {
-        return Math.max(0, (int) (cameraX / TILE_SIZE) - 1);
-    }
-    
-    @Override
-    public int getFirstVisibleBlockY()
-    {
-        return Math.max(0, (int) (cameraY / TILE_SIZE) - 1);
-    }
-    
-    @Override
-    public int getLastVisibleBlockX()
-    {
-        return getFirstVisibleBlockX() + (int) (renderer.getWidth() / TILE_SIZE) + 2;
-    }
-    
-    @Override
-    public int getLastVisibleBlockY()
-    {
-        return getFirstVisibleBlockY() + (int) (renderer.getHeight()/ TILE_SIZE) + 2;
-    }
-    
-    @Override
-    public void setViewCenter(double x, double y) 
-    {
-        cameraX = x;
-        cameraY = y;
-    }
-
-    @Override
-    public void setGlobalAlpha(double alpha) 
-    {
-        renderer.setGlobalAlpha(alpha);
-    }
-}