diff --git a/maps/world1.map b/maps/world1.map
index 27d8a48..c9d48aa 100644
Binary files a/maps/world1.map and b/maps/world1.map differ
diff --git a/src/sig/RabiClone.java b/src/sig/RabiClone.java
index 1915bf5..b493c90 100644
--- a/src/sig/RabiClone.java
+++ b/src/sig/RabiClone.java
@@ -58,6 +58,8 @@ public class RabiClone {
 	static long lastReportedTime = System.currentTimeMillis();
 	public static long TIME = 0;
 
+	public static boolean COLLISION[] = new boolean[BASE_WIDTH*BASE_HEIGHT];
+
 	public static void main(String[] args) {
 		System.setProperty("sun.java2d.transaccel", "True");
 		System.setProperty("sun.java2d.d3d", "True");
diff --git a/src/sig/map/Tile.java b/src/sig/map/Tile.java
index 342ec7b..d2c4fdc 100644
--- a/src/sig/map/Tile.java
+++ b/src/sig/map/Tile.java
@@ -5,8 +5,8 @@ public enum Tile {
     WALL(0,0,CollisionType.BLOCK),
     FLOOR(1,0,CollisionType.BLOCK),
     PLATFORM_LEDGE(2,0,CollisionType.BLOCK),
-    INVISIBLE_WALL(0,0,true,CollisionType.BLOCK),
-    HIGHLIGHTED_TILE(3,0,CollisionType.BLOCK),
+    INVISIBLE_WALL(0,0,true,CollisionType.NONE),
+    HIGHLIGHTED_TILE(3,0,CollisionType.NONE),
     SMALL_SLOPE_LEFT(0,1,CollisionType.SLOPE),
     SMALL_SLOPE_RIGHT(1,1,CollisionType.SLOPE),
     BIG_SLOPE_LEFT1(2,1,CollisionType.SLOPE),
diff --git a/src/sig/objects/LevelRenderer.java b/src/sig/objects/LevelRenderer.java
index 9016cde..a2450ac 100644
--- a/src/sig/objects/LevelRenderer.java
+++ b/src/sig/objects/LevelRenderer.java
@@ -1,15 +1,19 @@
 package sig.objects;
 
+import java.util.Arrays;
+
 import sig.RabiClone;
 import sig.engine.Alpha;
 import sig.engine.AnimatedObject;
 import sig.engine.Font;
 import sig.engine.Object;
+import sig.engine.PaletteColor;
 import sig.engine.Panel;
 import sig.engine.Sprite;
 import sig.engine.Transform;
 import sig.engine.String;
 import sig.map.Background;
+import sig.map.CollisionType;
 import sig.map.Map;
 import sig.map.Tile;
 
@@ -21,7 +25,38 @@ public class LevelRenderer extends Object{
     }
 
    @Override 
-    public void update(double updateMult) {}
+    public void update(double updateMult) {
+        Arrays.fill(RabiClone.COLLISION, false);
+        CreateCollisionGrid();
+    }
+
+    private void CreateCollisionGrid() {
+        for (int y=(int)(this.getY()/Tile.TILE_HEIGHT);y<(int)(RabiClone.BASE_HEIGHT/Tile.TILE_HEIGHT+this.getY()/Tile.TILE_HEIGHT+1);y++) {
+            if (y<0||y>Map.MAP_HEIGHT) {
+                continue;
+            }
+            for (int x=(int)(0+this.getX()/Tile.TILE_WIDTH);x<(int)(RabiClone.BASE_WIDTH/Tile.TILE_WIDTH+this.getX()/Tile.TILE_WIDTH+1);x++) {
+                if (x<0||x>Map.MAP_WIDTH) {
+                    continue;
+                }
+                if (RabiClone.CURRENT_MAP.getTile(x,y).getCollision()==CollisionType.BLOCK||RabiClone.CURRENT_MAP.getTile(x,y).getCollision()==CollisionType.SLOPE) {
+                    byte[] spritesheet = Sprite.TILE_SHEET.getBi_array();
+                    int tileX = RabiClone.CURRENT_MAP.getTile(x,y).getSpriteSheetX()*Tile.TILE_WIDTH;
+                    int tileY = RabiClone.CURRENT_MAP.getTile(x,y).getSpriteSheetY()*Tile.TILE_HEIGHT;
+                    for (int yy=0;yy<Tile.TILE_HEIGHT;yy++) {
+                        for (int xx=0;xx<Tile.TILE_WIDTH;xx++) {
+                            if (spritesheet[(tileY+yy)*Sprite.TILE_SHEET.getCanvasWidth()+(tileX+xx)]!=(byte)32) {
+                                int xpos=(int)(x*Tile.TILE_WIDTH-this.getX()+xx),ypos=(int)(y*Tile.TILE_HEIGHT-this.getY()+yy);
+                                if (xpos>=0&&xpos<RabiClone.BASE_WIDTH&&ypos>=0&&ypos<RabiClone.BASE_HEIGHT) {
+                                    RabiClone.COLLISION[ypos*RabiClone.BASE_WIDTH+xpos]=true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 
     @Override
     public void draw(byte[] p) {
@@ -44,6 +79,13 @@ public class LevelRenderer extends Object{
             Draw_Text(4,4,new String(RabiClone.player.x_velocity),Font.PROFONT_12);
             Draw_Text(4,4+Font.PROFONT_12.getGlyphHeight(),new String(RabiClone.player.slide_time3),Font.PROFONT_12);
         }
+        for (int y=0;y<RabiClone.BASE_HEIGHT;y++) {
+            for (int x=0;x<RabiClone.BASE_WIDTH;x++) {
+                if (RabiClone.COLLISION[y*RabiClone.BASE_WIDTH+x]) {
+                    p[y*RabiClone.BASE_WIDTH+x]=(byte)PaletteColor.CRIMSON.ordinal();
+                }
+            }
+        }
     }
 
     @Override
diff --git a/src/sig/objects/Player.java b/src/sig/objects/Player.java
index 1183aff..d99777f 100644
--- a/src/sig/objects/Player.java
+++ b/src/sig/objects/Player.java
@@ -12,7 +12,7 @@ import sig.map.View;
 import sig.objects.actor.State;
 import sig.utils.TimeUtils;
 
-public class Player extends AnimatedObject{
+public class Player extends AnimatedObject {
     final static double GRAVITY = 1300;
     final static double NORMAL_FRICTION = 6400;
     final static double NORMAL_JUMP_VELOCITY = -300;
@@ -42,13 +42,13 @@ public class Player extends AnimatedObject{
 
     double jump_velocity = NORMAL_JUMP_VELOCITY;
 
-    int maxJumpCount=2;
-    int jumpCount=maxJumpCount;
+    int maxJumpCount = 2;
+    int jumpCount = maxJumpCount;
     State state = State.IDLE;
     State prvState = state;
 
-    final double viewBoundaryX=RabiClone.BASE_WIDTH/3;
-    final double viewBoundaryY=RabiClone.BASE_HEIGHT/3;
+    final double viewBoundaryX = RabiClone.BASE_WIDTH / 3;
+    final double viewBoundaryY = RabiClone.BASE_HEIGHT / 3;
     View lastCameraView = View.FIXED;
 
     boolean groundCollision = false;
@@ -65,97 +65,95 @@ public class Player extends AnimatedObject{
     final static long slideBufferTime = TimeUtils.millisToNanos(200);
     long slidePressed = -1;
 
+    boolean onSlope = false;
+
     public Player(Panel panel) {
-        super(Sprite.ERINA,5,panel);
-        setX(RabiClone.BASE_WIDTH/2-getAnimatedSpr().getWidth()/2);
-        setY(RabiClone.BASE_HEIGHT*(2/3d)-getAnimatedSpr().getHeight()/2);
+        super(Sprite.ERINA, 5, panel);
+        setX(RabiClone.BASE_WIDTH / 2 - getAnimatedSpr().getWidth() / 2);
+        setY(RabiClone.BASE_HEIGHT * (2 / 3d) - getAnimatedSpr().getHeight() / 2);
     }
 
-
     @Override
     public void update(double updateMult) {
         super.update(updateMult);
         handleMovementPhysics(updateMult);
         handleCameraRoomMovement();
 
-        switch(state){
+        switch (state) {
             case ATTACK:
                 break;
             case FALLING:
-                if(prvState!=State.FALLING){
+                if (prvState != State.FALLING) {
                     jump_slide_fall_StartAnimationTimer = RabiClone.TIME;
                     setAnimatedSpr(Sprite.ERINA_JUMP_FALL1);
                 }
-                if(RabiClone.TIME-jump_slide_fall_StartAnimationTimer>jump_fall_AnimationWaitTime){
+                if (RabiClone.TIME - jump_slide_fall_StartAnimationTimer > jump_fall_AnimationWaitTime) {
                     setAnimatedSpr(Sprite.ERINA_JUMP_FALL);
-                    jump_slide_fall_StartAnimationTimer=-1;
+                    jump_slide_fall_StartAnimationTimer = -1;
                 }
                 break;
             case IDLE:
-                if (RabiClone.TIME-slidePressed<=slideBufferTime) {
+                if (RabiClone.TIME - slidePressed <= slideBufferTime) {
                     performSlide();
                     break;
                 }
 
                 jump_velocity = NORMAL_JUMP_VELOCITY;
                 horizontal_friction = NORMAL_FRICTION;
-                jump_slide_fall_StartAnimationTimer=-1;
+                jump_slide_fall_StartAnimationTimer = -1;
 
-                if(x_velocity!=0){
+                if (x_velocity != 0) {
                     setAnimatedSpr(Sprite.ERINA_WALK);
-                    if (x_velocity>0) {
-                        facing_direction=RIGHT;
-                    } else 
-                    if (x_velocity<0) {
-                        facing_direction=LEFT;
+                    if (x_velocity > 0) {
+                        facing_direction = RIGHT;
+                    } else if (x_velocity < 0) {
+                        facing_direction = LEFT;
                     }
-                }
-                else{
+                } else {
                     setAnimatedSpr(Sprite.ERINA);
                 }
                 break;
             case JUMP:
-                if(prvState==State.SLIDE){
-                    //jump_velocity=-500;
+                if (prvState == State.SLIDE) {
+                    // jump_velocity=-500;
                 }
-                if(jump_slide_fall_StartAnimationTimer==-1){
+                if (jump_slide_fall_StartAnimationTimer == -1) {
                     jump_slide_fall_StartAnimationTimer = RabiClone.TIME;
                     setAnimatedSpr(Sprite.ERINA_JUMP_RISE1);
                 }
-                if(RabiClone.TIME-jump_slide_fall_StartAnimationTimer>jump_fall_AnimationWaitTime){
+                if (RabiClone.TIME - jump_slide_fall_StartAnimationTimer > jump_fall_AnimationWaitTime) {
                     setAnimatedSpr(Sprite.ERINA_JUMP_RISE);
                 }
                 break;
             case SLIDE:
-                horizontal_friction=0;
-                if(jump_slide_fall_StartAnimationTimer==-1){
+                horizontal_friction = 0;
+                if (jump_slide_fall_StartAnimationTimer == -1) {
                     jump_slide_fall_StartAnimationTimer = RabiClone.TIME;
                     setAnimatedSpr(Sprite.ERINA_SLIDE1);
                 }
-                if(RabiClone.TIME-jump_slide_fall_StartAnimationTimer>slide_AnimationWaitTime){
+                if (RabiClone.TIME - jump_slide_fall_StartAnimationTimer > slide_AnimationWaitTime) {
                     setAnimatedSpr(Sprite.ERINA_SLIDE);
                 }
-                if(RabiClone.TIME-slide_time>slide_duration){
-                    if(KeyHeld(Action.MOVE_LEFT)){
-                        facing_direction=LEFT;
+                if (RabiClone.TIME - slide_time > slide_duration) {
+                    if (KeyHeld(Action.MOVE_LEFT)) {
+                        facing_direction = LEFT;
                     }
-                    if(KeyHeld(Action.MOVE_RIGHT)){
-                        facing_direction=RIGHT;
+                    if (KeyHeld(Action.MOVE_RIGHT)) {
+                        facing_direction = RIGHT;
                     }
-                    state=State.IDLE;
-                    slide_time3 = (System.nanoTime()-slide_time2);
+                    state = State.IDLE;
+                    slide_time3 = (System.nanoTime() - slide_time2);
                 }
-                if (KeyHeld(Action.MOVE_LEFT)&&!KeyHeld(Action.MOVE_RIGHT)) {
-                    if (facing_direction==LEFT&&x_velocity>-sliding_velocity*1.5||
-                        facing_direction==RIGHT&&x_velocity>sliding_velocity*0.5) {
-                            x_velocity-=sliding_acceleration*updateMult;
-                        }
-                } else
-                if (KeyHeld(Action.MOVE_RIGHT)&&!KeyHeld(Action.MOVE_LEFT)) {
-                    if (facing_direction==LEFT&&x_velocity<-sliding_velocity*0.5||
-                        facing_direction==RIGHT&&x_velocity<sliding_velocity*1.5) {
-                            x_velocity+=sliding_acceleration*updateMult;
-                        }
+                if (KeyHeld(Action.MOVE_LEFT) && !KeyHeld(Action.MOVE_RIGHT)) {
+                    if (facing_direction == LEFT && x_velocity > -sliding_velocity * 1.5 ||
+                            facing_direction == RIGHT && x_velocity > sliding_velocity * 0.5) {
+                        x_velocity -= sliding_acceleration * updateMult;
+                    }
+                } else if (KeyHeld(Action.MOVE_RIGHT) && !KeyHeld(Action.MOVE_LEFT)) {
+                    if (facing_direction == LEFT && x_velocity < -sliding_velocity * 0.5 ||
+                            facing_direction == RIGHT && x_velocity < sliding_velocity * 1.5) {
+                        x_velocity += sliding_acceleration * updateMult;
+                    }
                 }
                 break;
             case STAGGER:
@@ -166,25 +164,23 @@ public class Player extends AnimatedObject{
                 break;
         }
         prvState = state;
-        if (KeyHeld(Action.JUMP)&&RabiClone.TIME-spacebarPressed<jumpHoldTime) {
-            y_velocity=jump_velocity;
+        if (KeyHeld(Action.JUMP) && RabiClone.TIME - spacebarPressed < jumpHoldTime) {
+            y_velocity = jump_velocity;
         }
-        //System.out.println(state);
+        // System.out.println(state);
     }
 
-
     @Override
     protected void KeyReleased(Action a) {
-        if (a==Action.JUMP) {
-            spacebarPressed=0;
-            spacebarReleased=true;
+        if (a == Action.JUMP) {
+            spacebarPressed = 0;
+            spacebarReleased = true;
         }
-        if(state!=State.SLIDE){
-            if((a==Action.MOVE_LEFT)&&(KeyHeld(Action.MOVE_RIGHT))){
-                facing_direction=RIGHT;
-            } else
-            if((a==Action.MOVE_RIGHT)&&(KeyHeld(Action.MOVE_LEFT))){
-                facing_direction=LEFT;
+        if (state != State.SLIDE) {
+            if ((a == Action.MOVE_LEFT) && (KeyHeld(Action.MOVE_RIGHT))) {
+                facing_direction = RIGHT;
+            } else if ((a == Action.MOVE_RIGHT) && (KeyHeld(Action.MOVE_LEFT))) {
+                facing_direction = LEFT;
             }
         }
     }
@@ -192,25 +188,25 @@ public class Player extends AnimatedObject{
     @Override
     @SuppressWarnings("incomplete-switch")
     protected void KeyPressed(Action a) {
-        switch(state){
+        switch (state) {
             case ATTACK:
                 break;
             case IDLE:
-                if(a==Action.SLIDE||a==Action.FALL){
+                if (a == Action.SLIDE || a == Action.FALL) {
                     performSlide();
                 }
                 break;
             case FALLING:
-                if (a==Action.SLIDE||a==Action.FALL) {
-                    slidePressed=RabiClone.TIME;
-                    //System.out.println("Queue up slide.");
+                if (a == Action.SLIDE || a == Action.FALL) {
+                    slidePressed = RabiClone.TIME;
+                    // System.out.println("Queue up slide.");
                 }
             case JUMP:
-                if(jumpCount>0 && spacebarReleased && (a==Action.JUMP)){
-                    jumpCount=0;
+                if (jumpCount > 0 && spacebarReleased && (a == Action.JUMP)) {
+                    jumpCount = 0;
                     y_velocity = jump_velocity;
-                    spacebarReleased=false;
-                    spacebarPressed=RabiClone.TIME;
+                    spacebarReleased = false;
+                    spacebarPressed = RabiClone.TIME;
                 }
                 break;
             case SLIDE:
@@ -223,130 +219,127 @@ public class Player extends AnimatedObject{
                 break;
         }
         if (groundCollision) {
-            if (spacebarReleased&&(a==Action.JUMP)&&jumpCount>0) {
+            if (spacebarReleased && (a == Action.JUMP) && jumpCount > 0) {
                 state = State.JUMP;
                 jumpCount--;
                 y_velocity = jump_velocity;
-                spacebarReleased=false;
-                spacebarPressed=RabiClone.TIME;
-                //System.out.println("Jump");
+                spacebarReleased = false;
+                spacebarPressed = RabiClone.TIME;
+                // System.out.println("Jump");
             }
         }
-        if(state!=State.SLIDE){
-            switch(a){
+        if (state != State.SLIDE) {
+            switch (a) {
                 case MOVE_LEFT:
-                    facing_direction=LEFT;
-                break;
+                    facing_direction = LEFT;
+                    break;
                 case MOVE_RIGHT:
-                    facing_direction=RIGHT;
-                break;
-            }   
+                    facing_direction = RIGHT;
+                    break;
+            }
         }
     }
 
-
     private void performSlide() {
         slide_time = RabiClone.TIME;
         slide_time2 = System.nanoTime();
-        if(facing_direction){
-            x_velocity=sliding_velocity;
-        }
-        else{
-            x_velocity=-sliding_velocity;
+        if (facing_direction) {
+            x_velocity = sliding_velocity;
+        } else {
+            x_velocity = -sliding_velocity;
         }
-        state=State.SLIDE;
+        state = State.SLIDE;
     }
 
-
     private void handleCameraRoomMovement() {
-        int tileX = (int)(getX())/Tile.TILE_WIDTH;
-        int tileY = (int)(getY())/Tile.TILE_HEIGHT;
-        double newX=RabiClone.level_renderer.getX(),newY=RabiClone.level_renderer.getY(); //By default we use a fixed view.
+        int tileX = (int) (getX()) / Tile.TILE_WIDTH;
+        int tileY = (int) (getY()) / Tile.TILE_HEIGHT;
+        double newX = RabiClone.level_renderer.getX(), newY = RabiClone.level_renderer.getY(); // By default we use a
+                                                                                               // fixed view.
         View currentView = RabiClone.CURRENT_MAP.getView(tileX, tileY);
-        if (currentView!=lastCameraView) {
-            lastCameraView=currentView;
-            newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
-            newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
+        if (currentView != lastCameraView) {
+            lastCameraView = currentView;
+            newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+            newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
         } else
-        switch (currentView) {
-            case LIGHT_FOLLOW:
-                if (getX()-RabiClone.level_renderer.getX()<viewBoundaryX) {
-                    newX=getX()-viewBoundaryX;
-                    int newTileX = (int)(newX)/Tile.TILE_WIDTH;
-                    View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
-                    if (newView!=currentView) {
-                        newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
-                    }
-                } else if (getX()-RabiClone.level_renderer.getX()>RabiClone.BASE_WIDTH-viewBoundaryX) {
-                    newX=getX()-(RabiClone.BASE_WIDTH-viewBoundaryX);
-                    int newTileX = (int)(getX()+viewBoundaryX)/Tile.TILE_WIDTH;
-                    View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
-                    if (newView!=currentView) {
-                        newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
-                    }
-                }
-                if (getY()-RabiClone.level_renderer.getY()<viewBoundaryY) {
-                    newY=getY()-viewBoundaryY;
-                    int newTileY = (int)(getY()-viewBoundaryY)/Tile.TILE_HEIGHT;
-                    View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
-                    if (newView!=currentView) {
-                        newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
-                    }
-                } else if (getY()-RabiClone.level_renderer.getY()>RabiClone.BASE_HEIGHT-viewBoundaryY) {
-                    newY=getY()-(RabiClone.BASE_HEIGHT-viewBoundaryY);
-                    int newTileY = (int)(getY()+viewBoundaryY)/Tile.TILE_HEIGHT;
-                    View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
-                    if (newView!=currentView) {
-                        newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
-                    }
-                }
-                break;
-            case LIGHT_HORIZONTAL_FOLLOW:
-                if (getX()-RabiClone.level_renderer.getX()<viewBoundaryX) {
-                    newX=getX()-viewBoundaryX;
-                    int newTileX = (int)(newX)/Tile.TILE_WIDTH;
-                    View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
-                    if (newView!=currentView) {
-                        newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
+            switch (currentView) {
+                case LIGHT_FOLLOW:
+                    if (getX() - RabiClone.level_renderer.getX() < viewBoundaryX) {
+                        newX = getX() - viewBoundaryX;
+                        int newTileX = (int) (newX) / Tile.TILE_WIDTH;
+                        View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
+                        if (newView != currentView) {
+                            newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+                        }
+                    } else if (getX() - RabiClone.level_renderer.getX() > RabiClone.BASE_WIDTH - viewBoundaryX) {
+                        newX = getX() - (RabiClone.BASE_WIDTH - viewBoundaryX);
+                        int newTileX = (int) (getX() + viewBoundaryX) / Tile.TILE_WIDTH;
+                        View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
+                        if (newView != currentView) {
+                            newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+                        }
                     }
-                } else if (getX()-RabiClone.level_renderer.getX()>RabiClone.BASE_WIDTH-viewBoundaryX) {
-                    newX=getX()-(RabiClone.BASE_WIDTH-viewBoundaryX);
-                    int newTileX = (int)(getX()+viewBoundaryX)/Tile.TILE_WIDTH;
-                    View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
-                    if (newView!=currentView) {
-                        newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
+                    if (getY() - RabiClone.level_renderer.getY() < viewBoundaryY) {
+                        newY = getY() - viewBoundaryY;
+                        int newTileY = (int) (getY() - viewBoundaryY) / Tile.TILE_HEIGHT;
+                        View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
+                        if (newView != currentView) {
+                            newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
+                        }
+                    } else if (getY() - RabiClone.level_renderer.getY() > RabiClone.BASE_HEIGHT - viewBoundaryY) {
+                        newY = getY() - (RabiClone.BASE_HEIGHT - viewBoundaryY);
+                        int newTileY = (int) (getY() + viewBoundaryY) / Tile.TILE_HEIGHT;
+                        View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
+                        if (newView != currentView) {
+                            newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
+                        }
                     }
-                }
-                newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
-                break;
-            case LIGHT_VERTICAL_FOLLOW:
-                newX=(tileX/Tile.TILE_SCREEN_COUNT_X)*Map.MAP_WIDTH;
-                if (getY()-RabiClone.level_renderer.getY()<viewBoundaryY) {
-                    newY=getY()-viewBoundaryY;
-                    int newTileY = (int)(getY()-viewBoundaryY)/Tile.TILE_HEIGHT;
-                    View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
-                    if (newView!=currentView) {
-                        newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
+                    break;
+                case LIGHT_HORIZONTAL_FOLLOW:
+                    if (getX() - RabiClone.level_renderer.getX() < viewBoundaryX) {
+                        newX = getX() - viewBoundaryX;
+                        int newTileX = (int) (newX) / Tile.TILE_WIDTH;
+                        View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
+                        if (newView != currentView) {
+                            newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+                        }
+                    } else if (getX() - RabiClone.level_renderer.getX() > RabiClone.BASE_WIDTH - viewBoundaryX) {
+                        newX = getX() - (RabiClone.BASE_WIDTH - viewBoundaryX);
+                        int newTileX = (int) (getX() + viewBoundaryX) / Tile.TILE_WIDTH;
+                        View newView = RabiClone.CURRENT_MAP.getView(newTileX, tileY);
+                        if (newView != currentView) {
+                            newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+                        }
                     }
-                } else if (getY()-RabiClone.level_renderer.getY()>RabiClone.BASE_HEIGHT-viewBoundaryY) {
-                    newY=getY()-(RabiClone.BASE_HEIGHT-viewBoundaryY);
-                    int newTileY = (int)(getY()+viewBoundaryY)/Tile.TILE_HEIGHT;
-                    View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
-                    if (newView!=currentView) {
-                        newY=(tileY/Tile.TILE_SCREEN_COUNT_Y)*Map.MAP_HEIGHT;
+                    newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
+                    break;
+                case LIGHT_VERTICAL_FOLLOW:
+                    newX = (tileX / Tile.TILE_SCREEN_COUNT_X) * Map.MAP_WIDTH;
+                    if (getY() - RabiClone.level_renderer.getY() < viewBoundaryY) {
+                        newY = getY() - viewBoundaryY;
+                        int newTileY = (int) (getY() - viewBoundaryY) / Tile.TILE_HEIGHT;
+                        View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
+                        if (newView != currentView) {
+                            newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
+                        }
+                    } else if (getY() - RabiClone.level_renderer.getY() > RabiClone.BASE_HEIGHT - viewBoundaryY) {
+                        newY = getY() - (RabiClone.BASE_HEIGHT - viewBoundaryY);
+                        int newTileY = (int) (getY() + viewBoundaryY) / Tile.TILE_HEIGHT;
+                        View newView = RabiClone.CURRENT_MAP.getView(tileX, newTileY);
+                        if (newView != currentView) {
+                            newY = (tileY / Tile.TILE_SCREEN_COUNT_Y) * Map.MAP_HEIGHT;
+                        }
                     }
-                }
-                break;
-            case FIXED:
-                break;
-            default:
-                break;
-        }
-        RabiClone.level_renderer.setX(newX<0?0:newX);
-        RabiClone.level_renderer.setY(newY<0?0:newY);
+                    break;
+                case FIXED:
+                    break;
+                default:
+                    break;
+            }
+        RabiClone.level_renderer.setX(newX < 0 ? 0 : newX);
+        RabiClone.level_renderer.setY(newY < 0 ? 0 : newY);
     }
 
-
     private void handleMovementPhysics(double updateMult) {
         int right = KeyHeld(Action.MOVE_RIGHT)?1:0;
         int left = KeyHeld(Action.MOVE_LEFT)?1:0;
@@ -364,6 +357,7 @@ public class Player extends AnimatedObject{
                 :y_velocity+y_acceleration*updateMult;
         double displacement_y = y_velocity*updateMult;
         double displacement_x = x_velocity*updateMult;
+
         boolean sideCollision = false;
         for(int i=0;i<4;i++){
             double check_distance_x = (displacement_x/4)*(i+1);
@@ -406,28 +400,28 @@ public class Player extends AnimatedObject{
         } else {
             //System.out.println(x_velocity);
             //System.out.println(((int)(getX()+getAnimatedSpr().getWidth()/2+displacement_x)/Tile.TILE_WIDTH)+"//"+((int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT));
-            boolean collisionOccured=false;
-            for(int i=0;i<4;i++){
-                double check_distance_y = (displacement_y/4)*(i+1);
-                Tile checked_tile_bottom_right = RabiClone.CURRENT_MAP.getTile((int)(getX()+getAnimatedSpr().getWidth()/2-4)/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2+check_distance_y)/Tile.TILE_HEIGHT);
-                Tile checked_tile_bottom_left = RabiClone.CURRENT_MAP.getTile((int)(getX()-getAnimatedSpr().getWidth()/2+4)/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2+check_distance_y)/Tile.TILE_HEIGHT);
-                Tile checked_tile_bottom_center = RabiClone.CURRENT_MAP.getTile((int)(getX())/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT);
-                if(checked_tile_bottom_center.getCollision()==CollisionType.SLOPE
-                && getY()+check_distance_y>ySlopeCollisionPoint(checked_tile_bottom_center))
-                {
-                    moveUpSlope(checked_tile_bottom_center);
-                    collisionOccured = groundCollision(check_distance_y);
-                    break;
+                boolean collisionOccured=false;
+                for(int i=0;i<4;i++){
+                    double check_distance_y = (displacement_y/4)*(i+1);
+                    Tile checked_tile_bottom_right = RabiClone.CURRENT_MAP.getTile((int)(getX()+getAnimatedSpr().getWidth()/2-4)/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2+check_distance_y)/Tile.TILE_HEIGHT);
+                    Tile checked_tile_bottom_left = RabiClone.CURRENT_MAP.getTile((int)(getX()-getAnimatedSpr().getWidth()/2+4)/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2+check_distance_y)/Tile.TILE_HEIGHT);
+                    Tile checked_tile_bottom_center = RabiClone.CURRENT_MAP.getTile((int)(getX())/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT);
+                    if(checked_tile_bottom_center.getCollision()==CollisionType.SLOPE
+                    && getY()+check_distance_y>ySlopeCollisionPoint(checked_tile_bottom_center))
+                    {
+                        moveUpSlope(checked_tile_bottom_center);
+                        collisionOccured = groundCollision(0);
+                        break;
+                    }
+                    //System.out.println((int)getX()/Tile.TILE_WIDTH);
+                    if(checked_tile_bottom_right.getCollision()==CollisionType.BLOCK||checked_tile_bottom_left.getCollision()==CollisionType.BLOCK){
+                        collisionOccured = groundCollision(check_distance_y);
+                        break;
+                    }
                 }
-                //System.out.println((int)getX()/Tile.TILE_WIDTH);
-                if(checked_tile_bottom_right.getCollision()==CollisionType.BLOCK||checked_tile_bottom_left.getCollision()==CollisionType.BLOCK){
-                    collisionOccured = groundCollision(check_distance_y);
-                    break;
+                if (!collisionOccured) {
+                    groundCollision=false;
                 }
-            }
-            if (!collisionOccured) {
-                groundCollision=false;
-            }
         }
         if (!groundCollision){
             this.setY(this.getY()+displacement_y);
@@ -441,94 +435,91 @@ public class Player extends AnimatedObject{
             }
         } else {
             if (!sideCollision) {
-                Tile checked_tile_bottom_center = RabiClone.CURRENT_MAP.getTile((int)(getX())/Tile.TILE_WIDTH, (int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT);
                 handleKeyboardMovement(updateMult, right-left, horizontal_friction, horizontal_drag);
                 this.setX(this.getX()+displacement_x);
-                if(displacement_x>0){
-                    if(checked_tile_bottom_center==Tile.SMALL_SLOPE_RIGHT){
-                        setY(getY()+displacement_x);
-                        System.out.println("We're in RIGHT.");
-                    }
-                }
-                else{
-                    if(checked_tile_bottom_center==Tile.SMALL_SLOPE_LEFT){
-                        setY(getY()-displacement_x);
-                        System.out.println("We're in it for LEFT.");
-
-                    }
-                }
             }
         }
     }
 
-
     private double ySlopeCollisionPoint(Tile tile) {
-        switch(tile){
+        switch (tile) {
             case BIG_SLOPE_LEFT1:
-            return -(getX()%Tile.TILE_WIDTH/2)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4);
+                return -(getX() % Tile.TILE_WIDTH / 2)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4);
 
             case BIG_SLOPE_LEFT2:
-            return -(getX()%Tile.TILE_WIDTH/2)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4)-Tile.TILE_WIDTH/2;
+                return -(getX() % Tile.TILE_WIDTH / 2)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4) - Tile.TILE_WIDTH / 2;
 
             case BIG_SLOPE_RIGHT1:
-            return (getX()%Tile.TILE_WIDTH/2)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4)-Tile.TILE_WIDTH;
+                return (getX() % Tile.TILE_WIDTH / 2)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4) - Tile.TILE_WIDTH;
 
             case BIG_SLOPE_RIGHT2:
-            return (getX()%Tile.TILE_WIDTH/2)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4)-Tile.TILE_WIDTH+Tile.TILE_WIDTH/2;
+                return (getX() % Tile.TILE_WIDTH / 2)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4) - Tile.TILE_WIDTH + Tile.TILE_WIDTH / 2;
 
             case SMALL_SLOPE_LEFT:
-            return -(getX()%Tile.TILE_WIDTH)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4);
-            
+                return -(getX() % Tile.TILE_WIDTH)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4);
+
             case SMALL_SLOPE_RIGHT:
-            return (getX()%Tile.TILE_WIDTH)+(int)(getY()+getAnimatedSpr().getHeight()/2)/Tile.TILE_HEIGHT*Tile.TILE_HEIGHT+(getAnimatedSpr().getHeight()/2-4)-Tile.TILE_WIDTH;
+                return (getX() % Tile.TILE_WIDTH)
+                        + (int) (getY() + getAnimatedSpr().getHeight() / 2) / Tile.TILE_HEIGHT * Tile.TILE_HEIGHT
+                        + (getAnimatedSpr().getHeight() / 2 - 4) - Tile.TILE_WIDTH;
         }
         return 0;
     }
 
-
     private void moveUpSlope(Tile checked_tile_bottom_center) {
         setY(ySlopeCollisionPoint(checked_tile_bottom_center));
     }
 
     private boolean groundCollision(double check_distance_y) {
         boolean collisionOccured;
-        setY((getY()-check_distance_y));
+        setY((getY() - check_distance_y));
         y_acceleration = 0;
         y_velocity = 0;
-        groundCollision=true;
-        collisionOccured=true;
-        if(state!=State.SLIDE){
+        groundCollision = true;
+        collisionOccured = true;
+        if (state != State.SLIDE) {
             state = State.IDLE;
         }
         return collisionOccured;
     }
 
-
     private void handleKeyboardMovement(double updateMult, int movement, double friction, double drag) {
-        if (movement!=0&&Math.abs(x_velocity)<WALKING_SPEED_LIMIT) {
-            x_acceleration=drag*(movement);
+        if (movement != 0 && Math.abs(x_velocity) < WALKING_SPEED_LIMIT) {
+            x_acceleration = drag * (movement);
         } else {
-            if (x_velocity!=0) {
-                x_velocity=x_velocity>0
-                    ?x_velocity-friction*updateMult>0
-                        ?x_velocity-friction*updateMult
-                        :0
-                    :x_velocity+friction*updateMult<0
-                        ?x_velocity+friction*updateMult
-                        :0;
+            if (x_velocity != 0) {
+                x_velocity = x_velocity > 0
+                        ? x_velocity - friction * updateMult > 0
+                                ? x_velocity - friction * updateMult
+                                : 0
+                        : x_velocity + friction * updateMult < 0
+                                ? x_velocity + friction * updateMult
+                                : 0;
             }
-            x_acceleration=0;
+            x_acceleration = 0;
         }
     }
 
     @Override
-    public void draw(byte[] p) {}
-
+    public void draw(byte[] p) {
+    }
 
     @Override
     public String toString() {
-        return "Player [facing_direction=" + (facing_direction?"RIGHT":"LEFT") + ", groundCollision=" + groundCollision + ", jumpCount="
-                + jumpCount + ", x_velocity=" + x_velocity + ", y_velocity=" + y_velocity + ", x=" + getX() + ", y=" + getY() + "]";
+        return "Player [facing_direction=" + (facing_direction ? "RIGHT" : "LEFT") + ", groundCollision="
+                + groundCollision + ", jumpCount="
+                + jumpCount + ", x_velocity=" + x_velocity + ", y_velocity=" + y_velocity + ", x=" + getX() + ", y="
+                + getY() + "]";
     }
-    
+
 }