Java平台游戏冲突

我试图让玩家不能从左右穿过站台，让玩家停在站台顶部。到目前为止，我所能做的只是左右碰撞，但右侧不工作，左侧正在窃听。我不知道如何做一个平台游戏的基本碰撞，有人能给我一个工作的解决方案吗

玩家等级代码：

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

}
}

导入java.awt.Color；
导入java.awt.Graphics；
导入java.awt.Rectangle；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
公共类播放器实现KeyListener
{
整数x，y，宽度，高度；
布尔跳跃，左，右；
PlayerThread PlayerThread；
int maxHeight=40；
双高c=0；
平台上的布尔值=false；
布尔值=真；
国际货币基金组织；
int-prevX；
矩形playRect=新矩形（）；
布尔leftCollision=false；
布尔rightCollision=false；
平台p；
公共玩家（）
{
x=500；
y=350；
宽度=40；
高度=50；
playerThread=新的playerThread（）；
playerThread.start（）；
}
公共空间涂料（图g）
{
String str=String.valueOf（x）；
String str2=String.valueOf（y）；
g、 setColor（Color.RED）；
playRect.立根（x、y、宽度、高度）；
g、 fillRect（x，y，宽度，高度）；
g、 抽绳（“X:+str+”，Y:+STR21000）；
}
公共作废更新（平台p）
{
这个，p=p；
碰撞检查（p）；
}
公共无效碰撞检查（p站台）
{
int pX=p.getX（）；
int pY=p.getY（）；
int pWidth=p.getWidth（）；
int-pHeight=p.getHeight（）；
//与平台代码冲突
if（playRect.相交（p.plat）&&left==true&&&！跳跃&&！右&&landed）
{
系统输出打印项次（“左”）；
x=prevX；
leftCollision=true；
}
其他的
{
leftCollision=false；
}
如果（playRect.相交（p.plat）&&right==true&&&！跳跃&&！右侧&&Land）
{
System.out.println（“右”）；
x=prevX；
rightCollision=true；
}
其他的
{
rightCollision=false；
}
}
公共类PlayerThread扩展线程实现可运行
{
公开募捐
{
while（true）
{
if（左&&！左碰撞）
{
prevX=x；
x-=2；
}
如果（右&！右碰撞）
{
prevX=x；
x+=2；
}
如果（跳转）
{
如果（高度C>=最大高度）
{
系统输出打印LN（高度C）；
跳跃=假；
高度c=0；
}
其他的
{
高度c+=1.5；
prevY=y；
y-=5；
登陆=假；
}
}
//重力代码
如果（！跳跃&&！着陆）
{
如果（y<400-高度）
{
prevY=y；
y+=5；
//登陆=假；
}
}
如果（y>=400-高度和着陆高度）
{
y=400——高度；
着陆=真；
}
尝试
{
睡眠（17）；
} 
捕捉（中断异常e）
{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
}
@凌驾
按下公共无效键（按键事件e）
{
开关（如getKeyCode（））
{
case KeyEvent.VK_左：
左=真；
打破
case KeyEvent.VK_RIGHT：
右=真；
打破
case KeyEvent.VK_空间：
如果（着陆）
{
跳跃=真；
}
打破
}
}
@凌驾
公共无效密钥已释放（密钥事件e）
{
开关（如getKeyCode（））
{
case KeyEvent.VK_左：
左=假；
打破
case KeyEvent.VK_RIGHT：
右=假；
打破
case KeyEvent.VK_空间：
打破
}
}
公共int getX（）
{
返回x；
}
公共无效集合x（整数x）
{
这个.x=x；
}
公共int getY（）
{
返回y；
}
公共空间设置（整数y）
{
这个。y=y；
}
公共int getWidth（）
{
返回宽度；
}
公共void setWidth（int-width）
{
这个。宽度=宽度；
}
公共整数getHeight（）
{
返回高度；
}
公共空间设置高度（内部高度）
{
高度=高度；
}
@凌驾
public void keyTyped（KeyEvent e）
{
//TODO自动生成的方法存根
}
}

这是我长期以来一直在努力解决的问题，我知道有很多解决方案。显然，你需要根据发生碰撞的平台的任何一侧重置玩家的位置

所以我要做的是检查矩形是否首先相交。然后我试着找出它与平台的哪一侧相撞。我通过在播放器矩形的每一侧外侧创建一个矩形来实现这一点。然后我得到平台矩形与每个边矩形的交点。然后我计算出交叉口的面积，无论哪一侧的交叉口面积最大，都是发生碰撞的那一侧。然后你可以根据他碰撞的平台侧面重置球员的位置。我创建了一个Mask类，使它在中非常容易使用

复杂的部分看起来像这样。 掩码是我用来表示矩形的类

此方法返回一个布尔数组，其中一个为true的数组是发生碰撞的一侧

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;
}

publicstatic int left=2，top=3，right=0，bottom=1；
公共布尔[]冲突侧（掩码m）{
boolean[]leftUp=新的boolean[4]；
矩形[]框=新矩形[4]；
框[0]=新矩形（this.getRect（）.x-1，this.getRect（）.y，1，this.getRect（）.height）；
框[1]=新矩形（this.getRect（）.x，this.getRect（）.y-1，this.getRect（）.width，1）；
框[2]=新矩形