Java Platform Game Collision

Question

I'm trying to make the player not be able to go through the platform from the left and right, and make the player stop on top of the platform. All I have for collision so far is left and right but the right isn't working and the left is bugging. I can't figure out how to do the basic collision of a platform game, can anyone give me a working solution?

Player class code:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;


public class Player implements KeyListener
{
int x, y, width, height;

boolean jump, left, right;

PlayerThread playerThread;

int maxHeight = 40;
double heightC = 0;
boolean onPlatform = false;
boolean landed = true;
int prevY;
int prevX;
Rectangle playRect = new Rectangle();
boolean leftCollision = false;
boolean rightCollision = false;
Platform p;

public Player()
{
    x = 500;
    y = 350;
    width = 40;
    height = 50;
    playerThread = new PlayerThread();
    playerThread.start();
}

public void paint(Graphics g)
{
    String str = String.valueOf(x);
    String str2 = String.valueOf(y);

    g.setColor(Color.RED);
    playRect.setBounds(x, y, width, height);
    g.fillRect(x, y, width, height);

    g.drawString("X: " + str + ", Y: " + str2, 100, 100);
}

public void update(Platform p)
{
    this.p = p;
    CheckForCollision(p);

}

public void CheckForCollision(Platform p)
{
    int pX = p.getX();
    int pY = p.getY();
    int pWidth = p.getWidth();
    int pHeight = p.getHeight();

    //COLLISION WITH PLATFORM CODE
    if (playRect.intersects(p.plat) && left == true && !jump && !right && landed)
    {
        System.out.println("LEFT");
        x = prevX;
        leftCollision = true;
    }
    else
    {
        leftCollision = false;
    }

    if (playRect.intersects(p.plat) && right == true && !jump && !right && landed)
    {
        System.out.println("RIGHT");
        x = prevX;
        rightCollision = true;
    }
    else
    {
        rightCollision = false;
    }
}

public class PlayerThread extends Thread implements Runnable
{
    public void run()
    {
        while (true)
        {
            if (left && !leftCollision)
            {

                prevX = x;
                x -= 2;

            }

            if (right && !rightCollision)
            {
                prevX = x;
                x += 2;
            }

            if (jump)
            {
                if (heightC >= maxHeight)
                {
                    System.out.println(heightC);
                    jump = false;
                    heightC = 0;
                }
                else
                {
                    heightC += 1.5;
                    prevY = y;
                    y -= 5;
                    landed = false;
                }
            }

            //GRAVITY CODE
            if (!jump && !landed)
            {
                if (y < 400 - height)
                {
                    prevY = y;
                    y += 5;
                    //landed = false;
                }
            }

            if (y >= 400 - height && !landed)
            {
                y = 400 - height;
                landed = true;
            }

            try
            {
                sleep(17);
            } 
            catch (InterruptedException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

@Override
public void keyPressed(KeyEvent e)
{
    switch (e.getKeyCode())
    {
    case KeyEvent.VK_LEFT:

        left = true;
        break;
    case KeyEvent.VK_RIGHT:
        right = true;
        break;
    case KeyEvent.VK_SPACE:
        if (landed)
        {
        jump = true;
        }
        break;
    }
}

@Override
public void keyReleased(KeyEvent e)
{
    switch (e.getKeyCode())
    {
    case KeyEvent.VK_LEFT:
        left = false;
        break;
    case KeyEvent.VK_RIGHT:
        right = false;
        break;
    case KeyEvent.VK_SPACE:
        break;
    }
}



public int getX()
{
    return x;
}

public void setX(int x)
{
    this.x = x;
}

public int getY()
{
    return y;
}

public void setY(int y)
{
    this.y = y;
}

public int getWidth()
{
    return width;
}

public void setWidth(int width)
{
    this.width = width;
}

public int getHeight()
{
    return height;
}

public void setHeight(int height)
{
    this.height = height;
}

@Override
public void keyTyped(KeyEvent e)
{
    // TODO Auto-generated method stub

}
}

Answer 1

This is something that I struggled with for a long time and I know there are a number of solutions for this.Obviously you need to reset your players position based on whatever side of the platform the collision occured on.

So what I do is I check if the rectangles are intersecting first. Then i try to figure out what side of the platform it is colliding with. I do that by creating a rectangle on the outside of each side of the player rectangle. then I get the intersection of the platform rectangle with each side rectangle. Then I calculate the area of the intersections.Whichever side has the greatest area of intersection is the side the collision occured on. Then you can reset the players position based on the side of the platform he collided with. I created a Mask class that makes this very easy to use in my game engine

The complicated part looks something like this. A Mask is the class i use to represent a rectangle

this method returns an array of booleans the one that is true is the side that the collision occurs on

public static int left=2,top=3,right=0,bottom=1;
public boolean[] collisionSide(Mask m){

    boolean[] leftUp = new boolean[4];

    Rectangle[] boxes = new Rectangle[4];
    boxes[0] = new Rectangle(this.getRect().x-1, this.getRect().y, 1, this.getRect().height);
    boxes[1] = new Rectangle(this.getRect().x, this.getRect().y-1, this.getRect().width, 1);
    boxes[2] = new Rectangle(this.getRect().x + this.getRect().width, this.getRect().y, 1, this.getRect().height);
    boxes[3] = new Rectangle(this.getRect().x, this.getRect().y+this.getRect().height, this.getRect().width, 1);

    double greatestArea = 0;
    int greatest = 0;

    for( int bbb = 0; bbb<4; bbb++){
        if( Calc.getArea( boxes[bbb].createIntersection(m.getRect() ) ) > greatestArea){
            greatestArea = Calc.getArea( boxes[bbb].createIntersection(m.getRect() ) );
            greatest = bbb;
        }
    }

    for(int b=0; b<4; b++)
        leftUp[b] = false;

    leftUp[greatest] = true;

    return leftUp;
}