Problema de colisão de inimigos em java

Programação Java
,
#1

olá, esses últimos dias estive programando um jogo em java, porém por algum motivo a entidade enemy(inimigo do meu jogo) sem motivo algum começou a atravessar paredes e correr mais rápido em direções específicas, exemplo: ele atravessa as paredes e corre mais rápido somente quando vai para direita ou para baixo, mas para esquerda e para cima a colisão e a velocidade funcionam normal.
eu tentei varias formas e já revirei todas as classes do meu projeto, e não consegui resolver o erro, também já tentei procurar na internet, mas não acho nada relacionado a isso, por favor, preciso de ajuda.
segue código da classe Enemy abaixo:

package com.vlasstudios.entities;

import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;

import com.vlasstudios.main.Game;
import com.vlasstudios.world.World;

public class Enemy extends Entity {

	private double speed = 1;
	
	private int frames = 0,maxFrames = 3,index = 0,maxIndex = 2;
	
	private BufferedImage[] sprites;
	
	public Enemy(int x, int y, int width, int height, BufferedImage sprite) {
		super(x, y, width, height, null);
		sprites = new BufferedImage[3];
		sprites[0] = Game.spritesheet.getSprite(112, 16, 16, 16);
		sprites[1] = Game.spritesheet.getSprite(128, 16, 16, 16);
		sprites[2] = Game.spritesheet.getSprite(144, 16, 16, 16);

	}
	
	public void tick() {
		
		if((int)x > Game.player.getX() && World.isFree((int)(x-speed),(int)this.getY())
				&& !isColidding((int)(x-speed),(int)this.getY())) {
			x-=speed;
		}
		else if((int)x < Game.player.getX() && World.isFree((int)(x+speed),(int)this.getY())
				&& !isColidding((int)(x+speed),(int)this.getY())) {
			x+=speed;
		}
		if(y > Game.player.getY() && World.isFree(this.getX(),(int)(y-speed))
				&& !isColidding(this.getX(),(int)(y-speed))) {
			y-=speed;
		}
		else if(y < Game.player.getY() && World.isFree(this.getX(),(int)(y-speed))
				&& !isColidding(this.getX(),(int)(y+speed))) {
			y+=speed;
		}
		frames++;
		if(frames == maxFrames) {
			frames = 0;
		    index++;
		    if(index > maxIndex) {
		    	index = 0;
		    }
 }
		}
		public boolean isColidding(int xnext, int ynext){
        Rectangle enemyCurrent = new Rectangle(xnext,ynext,World.TILE_SIZE,World.TILE_SIZE);
        for(int i =0; i < Game.enemies.size(); i++) {
        	Enemy e = Game.enemies.get(i);
        	if(e == this)
        		continue;
        	Rectangle targetEnemy = new Rectangle(e.getX(),e.getY(),World.TILE_SIZE,World.TILE_SIZE);
        	if(enemyCurrent.intersects(targetEnemy)) {
        		return true;
        	}
        }
        
        return false;
		}
	public void render(Graphics g) {
		g.drawImage(sprites[index], this.getX(), this.getY(), null);
		
	}
}
#2

Como está o método isFree?

#3

vou mandar a classe na qual está o método.

package com.vlasstudios.world;

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

import com.vlasstudios.entities.*;
import com.vlasstudios.main.Game;

public class World {

public static Tile[] tiles;
public static int WIDTH,HEIGHT;
public static final int TILE_SIZE = 16;

public World(String path) {
	try {
		BufferedImage map = ImageIO.read(getClass().getResource(path));
		int[] pixels = new int[map.getWidth() * map.getHeight()];
		WIDTH = map.getWidth();
		HEIGHT = map.getHeight();
		tiles = new Tile[map.getWidth() * map.getHeight()];
		map.getRGB(0, 0,map.getWidth(),map.getHeight(),pixels,0,map.getWidth());
		for(int xx = 0; xx < map.getWidth(); xx++) {
			for(int yy = 0; yy < map.getHeight(); yy++ ) {
				int pixelAtual = pixels[xx + yy * map.getWidth()];
				tiles[xx + (yy * WIDTH)] = new FloorTile(xx*16,yy*16,Tile.TILE_FLOOR);
				if(pixelAtual == 0xFF000000) {
				//floor
					tiles[xx + (yy * WIDTH)] = new FloorTile(xx*16,yy*16,Tile.TILE_FLOOR);
				}else if(pixelAtual == 0xFFFFFFFF) {
					//parede
					tiles[xx + (yy * WIDTH)] = new WallTile(xx*16,yy*16,Tile.TILE_WALL);
				}else if(pixelAtual == 0xFF1900FF) {
					//player
					Game.player.setX(xx*16);
					Game.player.setY(yy*16);
				}else if(pixelAtual == 0xFFFF0000) {
					//enemy
					Enemy en = new Enemy(xx*16,yy*16,16,16,Entity.ENEMY_EN);
					Game.entities.add(en);
					Game.enemies.add(en);
				}else if(pixelAtual == 0xFFFF8000) {
					//arma
					Game.entities.add(new Weapon(xx*16,yy*16,16,16,Entity.WEAPON_EN));
				}else if(pixelAtual == 0xFFFFFF00) {
					//bala
					Game.entities.add(new Bullet(xx*16,yy*16,16,16,Entity.BULLET_EN));
				}else if(pixelAtual == 0xFFFF00CB) {
					//lifepack
					Game.entities.add(new Lifepack(xx*16,yy*16,16,16,Entity.LIFEPACK_EN));
			}
			}
		}
	}
	 catch (IOException e) {
		e.printStackTrace();
	}
}

public static boolean isFree(int xnext, int ynext) {
	int x1 = xnext / TILE_SIZE;
	int y1 = ynext / TILE_SIZE;
	
	int x2 = (xnext + TILE_SIZE -2) / TILE_SIZE;
	int y2 = ynext / TILE_SIZE;
	
	int x3 = xnext / TILE_SIZE;
	int y3 = (ynext + TILE_SIZE - 2) / TILE_SIZE;
	
	int x4 = (xnext + TILE_SIZE -2 )/ TILE_SIZE;
	int y4 = (ynext + TILE_SIZE - 2) / TILE_SIZE;
	
 return !   ((tiles[x1 + (y1 * World.WIDTH)] instanceof WallTile) ||
			(tiles[x2 + (y2 * World.WIDTH)] instanceof WallTile) ||
			(tiles[x3 + (y3 * World.WIDTH)] instanceof WallTile )||
			(tiles[x4 + (y4 * World.WIDTH)] instanceof WallTile));
}

public void render(Graphics g) {
	int xstart = Camera.x >> 4;
	int ystart = Camera.y >> 4;
	
	int xfinal = xstart + (Game.WIDTH >> 2);
	int yfinal = ystart + (Game.HEIGHT >> 2);
	for(int xx = xstart; xx <= xfinal; xx++) {
		for(int yy = ystart; yy <= yfinal; yy++) {
			if(xx < 0 || yy < 0 || xx >= WIDTH || yy >= HEIGHT)
				continue;
			Tile tile = tiles[xx + (yy*WIDTH)];
			tile.render(g);
		}
	}
}

}