note x = player x postion
y = player y postion
so iam trying to set up collsion between player and enemy. i want it so my player touch the enemy than my player should stop. and not go though it.

this code below kind of works. if my player stand on left side of enemy than collsion work. but if my player stand is on right side of enemy than it dont work.

i belive the problem is in statment:
x = enemyX - 13;

like i said, if my player stand on left side it work bc i am setting my player x postion = to enemy x postion - 13 for width. as u can see if i stand on right than this wont work. i would have to do some thing like enemyX+ 13. but there got to be easier way.

my main goal is that player doesnt go though enemy, doesnt matter if my player touch the enmey from left or right.

if(x+13 >= enemyX && x <= enemyX + e.getWIDTH())
            {
                if(y >= enemyY && y <= enemyY+e.getHEIGHT())
                {
                    x = enemyX - 13;
                }
            }


here is full code if u dont understant what i am talking about:

main.java

public class Main extends Applet implements Runnable, /*TimerListener,*/ KeyListener
{
	//Double buffering variables
	Image dbImage;
	Graphics dbGraphics;
 
	Thread thread;
	Timer timer;
 
	//Class variables
	Ground ground_class;
	Player player_class;
	Platform platform_class;
	Shoot shoot_class;
	Enemy  enemy_class;
 
	Container c;
 
	/*** init method ***/
	@Override
	public void init() 
	{
		setSize(900, 400);
		addKeyListener(this);
	}/*** end of init method ***/
 
 
 
 
	/*** start method ***/
	@Override
	public void start()
	{
		ground_class = new Ground(0, this.getHeight()-20,this.getSize().width, 20); //x, y, widith, height
		player_class = new Player(700, 250);  //x, y
		platform_class = new Platform();
		shoot_class = new Shoot();
		enemy_class = new Enemy(500, 345);   //x, y
 
		thread = new Thread(this); //start run method
		thread.start();
		//timer = new Timer(1000,this); //1 sec
		//timer.start();
		//void stop()
		//void setDelay(int delay)
		//boolean isRunning()
		//int getDelay
	}/*** end of start method ***/
 
 
 
	/*** run method ***/
 
	public void run()
	{
		while(true) //player moves
		{
			ground_class.update(this, ground_class ,player_class);                         //ground + player collions
			player_class.PLAYER_MOVE(this, ground_class);                                  //player moves
			platform_class.update(this, player_class);
			shoot_class.PLAYER_SHOOT_MOVE(this, player_class, shoot_class);  //player shoot bullet moves
			player_class.PLAYER_ENEMY_COLLISION(this, enemy_class);          //player + enemy collision
 
			repaint();
			try
			{
				Thread.sleep(10);
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}/*** end of run method ***/
 
 
 
 
 
 
 
	/*** update method ***/
	@Override
	public void update(Graphics g) 
	{
		if(dbImage == null) //if image is empty than create new image
		{
			dbImage = createImage(this.getSize().width, this.getSize().height);
			dbGraphics = dbImage.getGraphics();
		}
		dbGraphics.setColor(getBackground());  //set the background color
		dbGraphics.fillRect(0, 0, this.getSize().width, this.getSize().height);
		dbGraphics.setColor(getForeground());
		paint(dbGraphics);     //call paint method
		g.drawImage(dbImage, 0, 0, this);
	}/*** end of update method ***/
 
 
 
 
 
 
	/*** paint method ***/
	@Override
	public void paint(Graphics g) 
	{
		ground_class.paint(g);             //call paint method from Ground class  //draw ground than player on top
		player_class.paint(g);             //call paint method from Player classr 
		platform_class.paint(g);
		shoot_class.paint(g); //draw bullet
		if(enemy_class.isDEAD() == false)  //draw enemy if it's not dead
		{
			enemy_class.paint(g);
		}
 
	}/*** end of paint method ***/
 
 
 
 
 
 
	/*** stop method ***/
	@Override
	public void stop()
	{
 
	}/*** end of stop method ***/
 
	/*** destroy method ***/
	@Override
	public void destroy()
	{
 
	}/*** end of destroy method ***/
 
 
 
 
 
 
 
 
 
 
 
 
 
	/************** key *********************/
	@Override
	public void keyPressed(KeyEvent e)
	{
		int keys = e.getKeyCode();
		if(keys == KeyEvent.VK_RIGHT) 
		{
			player_class.hitRIGHT();
		}
		else if(keys == KeyEvent.VK_LEFT)
		{
			player_class.hitLEFT();
		}	
		else if (keys == KeyEvent.VK_UP)
		{
			player_class.hitJUMP(ground_class);
		}
		else if(keys == KeyEvent.VK_SPACE)
		{
			shoot_class.hitSHOOT();
		}
	}
	@Override
	public void keyReleased(KeyEvent e)
	{
		int keys = e.getKeyCode();
		if(keys == KeyEvent.VK_RIGHT) 
		{
			player_class.stopRIGHT();
		}
		else if(keys == KeyEvent.VK_LEFT)
		{
			player_class.stopLEFT();
		}	
		else if(keys == KeyEvent.VK_SPACE)
		{
			shoot_class.stopSHOOT();
		}
	}
	@Override
	public void keyTyped(KeyEvent e){}
 
	/************    MOUSE  **********/
	public void mousePressed(MouseEvent e){}
	public void mouseReleased(MouseEvent e){}
	public void mouseClicked(MouseEvent e){}
	public void mouseEntered(MouseEvent e){}
	public void mouseExited(MouseEvent e){}
}


player.java
public class Player 
{
	//Player movement variable
	private int sx = 10;
	private int sy = 200;
	private int x;     //current x
	private int y;     //current y
	private int dx = 2;    //speed of player
 
	private double dy = 6.0;  //change in y over time
	private double gravity = 0.2;    
	private double dt = .2;  
 
	private boolean dead = false;
 
	private boolean look_right = true;
	private boolean walk_right;
	private boolean walk_left;
	private boolean jump = false;
	private boolean jump_lock = false;
	private boolean fall = false;                  
	private boolean hitSPACE = false;
 
	/*** image variable ***/
	private static ImageIcon player_walk_right = new ImageIcon("Image/player/player_walk_right.gif");
	private static ImageIcon player_walk_left = new ImageIcon("Image/player/player_walk_left.gif");
	private static ImageIcon player_stand_right = new ImageIcon("Image/player/player_stand_right.gif");
	private static ImageIcon player_stand_left = new ImageIcon("Image/player/player_stand_left.gif");
	private static ImageIcon player_jump_right = new ImageIcon("Image/player/player_jump_right.gif");
	private static ImageIcon player_jump_left = new ImageIcon("Image/player/player_jump_left.gif");
 
 
 
	/*** constructor Method ***/
	public Player()
	{
	}
	/*** constructor Method2 ***/
	public Player(int ix, int iy) 
	{
		x = ix;
		y = iy;
	}	
 
		/*** get/set method ***/
		//need these to draw image's
		public static Image get_player_walk_right()  
		{ return player_walk_right.getImage(); }
		public static Image get_player_walk_left()  
		{ return player_walk_left.getImage(); }
		public static Image get_player_stand_right()  
		{ return player_stand_right.getImage(); }
		public static Image get_player_stand_left()  
		{ return player_stand_left.getImage(); }
		public static Image get_player_jump_right()  
		{ return player_jump_right.getImage(); }
		public static Image get_player_jump_left()  
		{ return player_jump_left.getImage(); }
 
		public boolean isDEAD()
		{ return dead; }
		public void setDEAD(boolean value) 
		{ this.dead =  value; }
 
		public int getX()
		{ return x; }
		public void setX(int value) 
		{ this.x =  value; }
 
		public int getY()
		{ return y; }
		public void setY(int value) 
		{ this.y =  value; }
 
		public int getDX()
		{ return dx; }
		public void setDX(int value) 
		{ this.dx =  value; }
 
		public double getDY()
		{ return dy; }
	    public void setDY(double value) 
		{ this.dy =  value; }
 
 
 
		/*** main key methods ***/
		/*** RIGHT ***/
		public void hitRIGHT()  //if user hit right button
		{ 
			walk_right = true; 
			look_right = true;
		}
		public void stopRIGHT() //if user let go of right button
		{
			walk_right = false;  //stop 
			look_right = true;
		}
 
		/*** LEFT ***/
		public void hitLEFT()  //move left
		{
			walk_left = true;
			look_right = false;
		}
		public void stopLEFT()
		{
			walk_left = false;  //stop
			look_right = false;
		}
 
		/*** JUMP ***/
		public void hitJUMP(Ground g)
		{
			if(y >= g.getY()-30) 
			{
				jump = true;
				dy = 6.0;	//reset
			}
		}
 
 
 
 
 
		/**************************/
		/****** LOOP METHODS ******/
		/**************************/
		/*** player move method ***/
		public void PLAYER_MOVE(Main m, Ground g) //player move's
		{
			if(walk_right == true)
			{
					x += dx;
			}
			else if(walk_right == false)
			{
			}
 
			if(walk_left == true)  //walking left
			{
				if(x - dx < 0)  //cant go left
				{
					x = 0;
				}
				else
				{
					x -= dx;      //move left
				}
			}
			else if(walk_left == false)
			{
			}
 
 
 
 
			if(jump == true) 
			{
				y--; //move player down -start of game
 
				dy -= gravity;
				y -= dy;
 
				if(y >= g.getY()-30) //if on ground
				{
					jump = false;
				}
			}
			else if(jump == false) //move player down when game starts
			{
				y++;
			}
		}/***end of update method ***/
 
 
 
 
 
 
 
 
 
		/*** player + enemy collion ***/
		public void PLAYER_ENEMY_COLLISION(Main m, Enemy e)
		{
			int enemyX = e.getX();
			int enemyY = e.getY();
 
			System.out.println(x+"--"+enemyX);
 
			if(x+13 >= enemyX && x <= enemyX + e.getWIDTH())
			{
				if(y >= enemyY && y <= enemyY+e.getHEIGHT())
				{
					x = enemyX - 13;
				}
			}	
		}/*** end of PlAYER_ENEMY_COLLISION METHOD ***/
 
 
 
 
 
 
		/*** paint method ***/
		public void paint(Graphics g)
		{
			if(jump == false)
			{
				if(look_right == true)
					{
						if(walk_right == true)
						{
							g.drawImage(this.get_player_walk_right(), x, y, null);
						}
						else if(walk_right == false)
						{
							g.drawImage(this.get_player_stand_right(), x, y, null);
						}
					}
				else if(look_right == false)
				{
					if(walk_left == true)
						{
							g.drawImage(this.get_player_walk_left(), x, y, null);
						}
					else if(walk_left == false)
					{
						g.drawImage(this.get_player_stand_left(), x, y, null);
					}
				}	
			}
			else if(jump == true)
			{
				if (look_right == true)
				{
					g.drawImage(this.get_player_jump_right(), x, y, null);
				}
				else if(look_right == false)
				{
					g.drawImage(this.get_player_jump_left(), x, y, null);
				}
			}
		}
}/*** end of class ***/