evtl solution André Lopes collision doesSpriteFit

package br.enemies_aux;

import br.enemies.Enemy_Extend;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.math.Vector2;

/**
 *
 * @author André Vinícius Lopes  + Robin Stu ( Sorry for that ) :D
 */
public class EnemyMovement {

    private static final String BLOCKED = "blocked";
    private static final String SLOPED = "slope";
    public static final int DIRECTION_RIGHT = 0;
    public static final int DIRECTION_LEFT = -1;
    public static final int DIRECTION_VERY_CLOSE = 11;

    private static TiledMapTileLayer.Cell cellAnalyze;

    public static void updateMovementGround(float delta, Vector2 velocity, float gravity, float speed, TiledMapTileLayer collisionLayer, int tileWidth, int tileHeight, TextureRegion currentFrame, int direction, float jump, Enemy_Extend enemy) {

        //Initialize
        float oldX, oldY;
        boolean slopesBottom = false;
        boolean collidesBottom = false;
        boolean collidesRight = false;
        boolean collidesLeft = false;

        boolean slopesLeft = false;
        boolean slopesRight = false;
        boolean slopesTop;
        boolean collidesTop;

        oldX = enemy.getX();
        oldY = enemy.getY();

        velocity.y -= gravity * delta;

        if (velocity.y > speed) {
            velocity.y = speed;
        } else if (velocity.y < -speed) {
            velocity.y = -speed;
        }

        if (enemy.direction == DIRECTION_RIGHT) {
            enemy.velocity.x = enemy.speed;
        } else if (enemy.direction == DIRECTION_LEFT) {
            enemy.velocity.x = -enemy.speed;
        }

        enemy.setY((enemy.getY() + velocity.y * delta));

        if (velocity.y < 0) {
            slopesBottom = slopesBottom(collisionLayer, enemy);
            collidesBottom = collidesBottom(collisionLayer, enemy);
        }

        if (velocity.y > 0) {
            slopesTop = slopesTop(collisionLayer, enemy);
            collidesTop = collidesTop(collisionLayer, enemy);
        }

        if (collidesBottom && !slopesBottom) {
            enemy.velocity.y = 0;
            enemy.setY(oldY);
        }

        /////////////////////////
        //AnalyzeSlopes in Y
        if (slopesBottom) {
            enemy.setY(oldY + (0.8f * 4)); // Because its senofTheta
        }

//////////////////////////////////////////////////////////////////////////////
        //Analyze X
//////////////////////////////////////////////////////////////////////////////
        enemy.setX((enemy.getX() + velocity.x * delta));

        boolean canJumpObstacle = false;

        if (velocity.x < 0) {
            slopesLeft = slopesLeft(collisionLayer, enemy);
            collidesLeft = collidesLeft(collisionLayer, enemy);
        }
        if (velocity.x > 0) {
            slopesRight = slopesRight(collisionLayer, enemy);
            collidesRight = collidesRight(collisionLayer, enemy);
        }

        if (collidesRight) {
            enemy.setX(oldX);
            if (!slopesBottom && !slopesRight) {

            }
        }

        if (collidesLeft) {
            enemy.setX(oldX);
            if (!slopesBottom && !slopesLeft) {
                canJumpObstacle = canJumpObstacle(collisionLayer, enemy);
            }
        }
        System.out.println("\n" + System.nanoTime());
        System.out.println("Collides Right :" + collidesRight);
        System.out.println("Collides Left :" + collidesLeft);
        System.out.println("Can Jump Obstacle  :" + canJumpObstacle);

        if ((collidesRight || collidesLeft) && !canJumpObstacle) {

            if (enemy.direction == DIRECTION_LEFT) {
                enemy.direction = DIRECTION_RIGHT;
            } else {
                enemy.direction = DIRECTION_LEFT;
            }
        }

    }

    public static void updateMovementWizard(float delta, Vector2 velocity, float gravity, float speed, TiledMapTileLayer collisionLayer, int tileWidth, int tileHeight, TextureRegion currentFrame, int direction, float jump, int state, Enemy_Extend enemy) {

    }

    public static void updateMovementMovXAxis(float delta, Vector2 velocity, float gravity, float speed, TiledMapTileLayer collisionLayer, TextureRegion currentFrame, int xiLimit, int xfLimit, boolean limitIsValid, Enemy_Extend enemy) {

    }

//////////////////////////////////////////////////////////////////////////////
    //Cell Analyzers
//////////////////////////////////////////////////////////////////////////////
    private static boolean canJumpObstacle(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {

        System.out.println("VX = " + enemy.velocity.x);
        System.out.println("VY = " + enemy.velocity.y);

        if (enemy.velocity.x >= 0) {
            for (float tileEye = 0; tileEye <= (enemy.jump); tileEye += collisionLayer.getTileHeight() / 2) {

                float x = enemy.getX() + enemy.getWidth() + collisionLayer.getTileHeight() / 2;
                float y = enemy.getY() + tileEye;

                if (!isCellBlocked(x, y, collisionLayer)) {

                    boolean doesTheSpriteFit = doesTheSpriteFit(tileEye, collisionLayer, enemy);

                    if (doesTheSpriteFit) {
                        enemy.setY((y));
                        return true;
                    }
                }
            }
        } else if (enemy.velocity.x < 0) {

            for (float tileEye = 0; tileEye < enemy.getHeight() + (enemy.jump); tileEye += collisionLayer.getTileHeight() / 2) {

                float x = enemy.getX() - (collisionLayer.getTileHeight() / 2);
                float y = enemy.getY() + tileEye;

                if (!isCellBlocked(x, y, collisionLayer)) {

                    boolean doesTheSpriteFit = doesTheSpriteFit(tileEye, collisionLayer, enemy);

                    if (doesTheSpriteFit) {
                        enemy.setY((y));
                        return true;
                    }
                }
            }

        }

        return false;
    }

    private static boolean doesTheSpriteFit(float tileEye, TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {

        boolean spriteFit = true;

        if (enemy.velocity.x > 0) {
            for (float auxtileEye = tileEye; auxtileEye <= (enemy.getHeight()); auxtileEye += collisionLayer.getTileHeight() / 2) {

                float xi = enemy.getX() + enemy.getWidth() + collisionLayer.getTileHeight() / 2;
                float yi = enemy.getY() + auxtileEye;

                if (isCellBlocked(xi, yi, collisionLayer)) {
                    spriteFit = false;
                    break;
                }
            }

        }

        if (enemy.velocity.x == 0) {
        for (float auxtileEye = tileEye; auxtileEye <= (enemy.getHeight()); auxtileEye += collisionLayer.getTileHeight() / 2) {

                float xi = enemy.getX() + enemy.getWidth() / 2;
                float yi = enemy.getY() + auxtileEye;

                if (isCellBlocked(xi, yi, collisionLayer)) {
                    spriteFit = false;
                    break;
                }
            }
        }

        if (enemy.velocity.x < 0) {
            for (float auxtileEye = tileEye; auxtileEye <= (-enemy.getHeight()); auxtileEye -= collisionLayer.getTileHeight() / 2) {

                float xi = enemy.getX() + enemy.getWidth() - collisionLayer.getTileHeight() / 2;
                float yi = enemy.getY() - auxtileEye;

                if (isCellBlocked(xi, yi, collisionLayer)) {
                    spriteFit = false;
                    break;
                }

            }
        }

        return spriteFit;
    }

//////////////////////////////////////////////////////////////////////////////
    private static boolean isCellSloped(float x, float y, TiledMapTileLayer collisionLayer) {

        cellAnalyze = collisionLayer.getCell((int) (x / collisionLayer.getTileWidth()), (int) (y / collisionLayer.getTileHeight()));

        if (cellAnalyze != null && cellAnalyze.getTile() != null && cellAnalyze.getTile().getProperties().containsKey(SLOPED)) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean slopesRight(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getHeight(); step += collisionLayer.getTileHeight() / 2) {
            if (isCellSloped(enemy.getX() + enemy.getWidth(), enemy.getY() + step, collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    public static boolean slopesLeft(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getHeight(); step += collisionLayer.getTileHeight() / 2) {
            if (isCellSloped(enemy.getX(), enemy.getY() + step, collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    public static boolean slopesTop(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getWidth(); step += collisionLayer.getTileWidth() / 2) {
            if (isCellSloped(enemy.getX() + step, enemy.getY() + enemy.getHeight(), collisionLayer)) {
                return true;
            }
        }
        return false;

    }

    public static boolean slopesBottom(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getWidth(); step += collisionLayer.getTileWidth() / 2) {
            if (isCellSloped(enemy.getX() + step, enemy.getY(), collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    //Block :
    private static boolean isCellBlocked(float x, float y, TiledMapTileLayer collisionLayer) {

        cellAnalyze = collisionLayer.getCell((int) (x / collisionLayer.getTileWidth()), (int) (y / collisionLayer.getTileHeight()));

        if (cellAnalyze != null && cellAnalyze.getTile() != null && cellAnalyze.getTile().getProperties().containsKey(BLOCKED)) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean collidesRight(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getHeight(); step += collisionLayer.getTileHeight() / 2) {
            if (isCellBlocked(enemy.getX() + enemy.getWidth(), enemy.getY() + step, collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    public static boolean collidesLeft(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getHeight(); step += collisionLayer.getTileHeight() / 2) {
            if (isCellBlocked(enemy.getX(), enemy.getY() + step, collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    public static boolean collidesTop(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getWidth(); step += collisionLayer.getTileWidth() / 2) {
            if (isCellBlocked(enemy.getX() + step, enemy.getY() + enemy.getHeight(), collisionLayer)) {
                return true;
            }
        }
        return false;

    }

    public static boolean collidesBottom(TiledMapTileLayer collisionLayer, Enemy_Extend enemy) {
        for (float step = 0; step < enemy.getWidth(); step += collisionLayer.getTileWidth() / 2) {
            if (isCellBlocked(enemy.getX() + step, enemy.getY(), collisionLayer)) {
                return true;
            }
        }
        return false;
    }

    public static int getOpposedPlayedSide(int playerPosX, int enemyPosX) {
        if (playerPosX == enemyPosX) {
            //System.out.println("Dont Halt! - Too Close!");
            return DIRECTION_VERY_CLOSE;
        } else if (playerPosX > enemyPosX) {
            //System.out.println("Player is to the Right");
            return DIRECTION_LEFT;
        } else if (playerPosX < enemyPosX) {
            //System.out.println("Player is to the Left");
            return DIRECTION_RIGHT;
        }

        System.out.println("Error! EnemyMovement.Direction");
        return DIRECTION_VERY_CLOSE;
    }

    public static int getPlayerSide(int playerPosX, int enemyPosX) {
        if (playerPosX == enemyPosX) {
            //System.out.println("Halt! - Too Close!");
            return DIRECTION_VERY_CLOSE;
        } else if (playerPosX > enemyPosX) {
            //System.out.println("Player is to the Right");
            return DIRECTION_RIGHT;
        } else if (playerPosX < enemyPosX) {
            //System.out.println("Player is to the Left");
            return DIRECTION_LEFT;
        }

        System.out.println("Error! EnemyMovement.Direction");
        return DIRECTION_VERY_CLOSE;

    }

}