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:
`

[CODE] x = enemyX - 13;[/CODE]

`

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.

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

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

main.java

[CODE]//#1
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){}
}[/CODE]

player.java

[CODE]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 ***/[/CODE]

Edited 4 Years Ago by ~s.o.s~: changed thread title

Why not make use of the proven code in the Java API to do the work for you?
The Rectangle class has an intersects(Rectangle other) method.
It's trivial to update your main/enemy classes witha method to return the onbjects' bounding rectangle - new Rectangle(x,y,width,height) - then you can use the intersects method to see if those rectangles overlap anywhere.

Comments

i am new to game programming and i am not sure what is api and intersects method.

but i look it up google i think it's some thing like this

Rectangle player_rectangle = new Rectangle(player.getX(),player.getY(),32,32);

 Rectangle enemy_rectangle = new Rectangle(wall.getX(), wall.getY(), 32,32);

        if(player_rectangle.intersects(enemy_rectangle)) {
        //do some thing
        }

if i am on right track than i already have a player class where iam using a image as player. so do i make another class called player_rectangle?

Yes, you are on the right track.
The "API" (application Programming Interface) is all the classes that come with Java, as documented here. Searching and understanding the API documentation is an absolutely essential skill for every Java programmer.

You don't need to make another class. You can just add a method to the Player class, eg

public Rectangle getBounds() {
   return  new Rectangle(x, y, 32,32);
}

... and do the same for the enemy class, then you can code

if (player.getBounds().intersects(wall.getBounds())) { etc

... which is much simpler and clearer for anyone reading your program.

Edited 4 Years Ago by JamesCherrill

thank man. finally after 2 week got it to working :). just want to make sure i understant what is going on in thsi code.

not sure what is getbound but i think it create a rectangle around enemy.
and i can put this in enemy class.

public Rectangle getBounds() 
{return  new Rectangle(x, y, 32,32);}

than i can do same thing in player class. draw rectange around player.

public Rectangle getBounds() 
{return  new Rectangle(x, y, 32,32);}

here i am testing if player rectangle is toching enemy rectangle.

public void collsion(Main m, Player p, Enemy e){
if (p.getBounds().intersects(e.getBounds())) { etc
}

2nd question is that:
right now if player touch enmey from any side it go inside if statment

if (p.getBounds().intersects(e.getBounds())) 

what if i want it so if player only toch enemy from top it should go inside if statment but if player touchs enemy from right, left or bottom side than it should go inside else statment/

This article has been dead for over six months. Start a new discussion instead.