Detect Collision of multiple BufferedImages Java

Question

I am making a 2d rpg game in java and I have run into a problem. I can make the player move around the stage and I have rocks, trees, walls, etc. on the stage as well. I don't know how to detect the collision and make it to where the player can't move through the object. The code that reads map file and draws image on the canvas is as follows:

public void loadLevel(BufferedImage levelImage){
    tiles = new int[levelImage.getWidth()][levelImage.getHeight()];
    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            Color c = new Color(levelImage.getRGB(x, y));
            String h = String.format("%02x%02x%02x", c.getRed(),c.getGreen(),c.getBlue());

            switch(h){
            case "00ff00"://GRASS Tile - 1
                tiles[x][y] = 1;
                break;
            case "808080"://Stone -2
                tiles[x][y] = 2;
                break;
            case "894627"://Dirt -3
                tiles[x][y] = 3;
                break;
            case "404040"://Rock on Grass -4
                tiles[x][y] = 4;
                break;
            case "00b700"://Tree -5
                tiles[x][y] = 5;
                break;
            case"000000"://Wall -6
                tiles[x][y] = 6;
                break;
            case "cccccc"://Rock on stone -7
                tiles[x][y] = 7;
                break;
            default:
                tiles[x][y] = 1;
                System.out.println(h);
                break;

            }
        }
    }
}

And the player class is as follows:

public class Player {

private int x,y;
public int locx,locy;
private Rectangle playerR;

private ImageManager im;
public boolean up =false,dn = false,lt=false,rt=false,moving = false,canMove = true;
private final int SPEED =2;

public Player(int x, int y, ImageManager im){
    this.x = x;
    this.y = y;
    this.im = im;
    locx = x;
    locy = y;
    playerR = new Rectangle(x,y,16,16);
}                                       

public void tick(){
    if (up) {
        if(canMove){
        y -= SPEED;
        locx = x;
        locy = y;
        playerR.setLocation(locx, locy);
        moving = true;
        }
        else{
            y += 1;
            canMove=true;
        }
    }
    if (dn) {

        y +=SPEED;
        locx = x;
        locy = y;
        moving = true;
        }
    }
    if (lt) {
        x -= SPEED;
        locx = x;
        locy = y;
        moving = true;

    }
    if (rt) {
        x+=SPEED;
        locx = x;
        locy = y;
        moving = true;
        }
    }
    if(moving){
        System.out.println("PLAYER\tX:"+locx+" Y:"+locy);
        moving = false;
    }
}

public void render(Graphics g){
    g.drawImage(im.player, x, y, Game.TILESIZE*Game.SCALE, Game.TILESIZE*Game.SCALE, null);
}   

}

I don't really know how to do collision, but i googled it and people said to make a rectangle for the player and all the objects that the player should collide with, and every time the player moves, move the player's rectangle. Is this the right way to do this?

EDIT EDIT EDIT EDIT

code for when collision is true:

if (rt) {
        x+=SPEED;
        locx = x;
        locy = y;
        playerR.setLocation(locx, locy);
        for(int i = 0;i<Level.collisions.size();i++){
            if(intersects(playerR,Level.collisions.get(i))==true){
                x-=SPEED;
                locx = x;
                playerR.setLocation(locx, locy);
            }
        }
        moving = true;
    }

And the intersects method is as follows:

private boolean intersects(Rectangle r1, Rectangle r2){
    return r1.intersects(r2);
}

Answer 1

I'm going to focus on your tick method since that is where most of this logic is going. There are a couple changes here. Most notably, we only move the rectangle before checking for collisions. Then loop through all the collideable objects in your level. Once one is found, we reset our x and y and break out of the loop (no sense in looking at any of the other objects since we already found the one we collided with). Then we update our player position. By doing it this way, I centralized the code so it is not being repeated. If you ever see yourself repeating code, there is a pretty good chance that it can be pulled out to a common place, or to a method.

public void tick() {

    if (up) {
        y -= SPEED;
    } else if (dn) {
        y += SPEED;
    } else if (lt) {
        x -= SPEED;
    } else if (rt) {
        x += SPEED;
    }

    playerR.setLocation(x, y);

    for (Rectangle collideable : Level.collisions) {
        if (intersects(playerR, collideable)) {
            x = locx;
            y = locy;
            playerR.setLocation(x, y);
            break;
        }
    }

    locx = x;
    locy = y;

}