如果没有玩家1的代码,为什么玩家2的移动方法不能正常工作?

时间:2012-05-27 21:56:15

标签: java move keylistener

//我正在尝试对播放器2的代码进行一些编辑,所以我删除了涉及播放器1的所有内容。但由于某种原因,如果没有播放器1的代码,播放器2根本不做任何事情。(它应该是使用键i,j,k和l移动。)所以我的问题是“如何在没有player1代码的情况下让播放器2的移动方法工作?”这也是我能提供的最好的SSCCE。我删除了任何不涉及创建JFrame和播放器2的代码。我还保持代码负责播放器2的移动。

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;

public class Collision extends JFrame {

// JFrame的

    final int WIDTH = 900, HEIGHT = 650;
    double p1Speed = .5, p2Speed = .5;
    final int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;
    int p1Direction = UP;
    int p2Direction = UP;

//创建播放器2的代码

Rectangle p2 = new Rectangle(((WIDTH / 9) + ((int) ((WIDTH / 9) * 1.5) / 2)), (HEIGHT / 2)    
+ (HEIGHT / 10), WIDTH / 30, WIDTH / 30);

    public Collision() {

        super("Radical Racing");
        setSize(WIDTH, HEIGHT);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);


      Move2 m2 = new Move2();
      m2.start();

    }

    public void paint(Graphics g) {
        super.paint(g);


        g.setColor(Color.DARK_GRAY);
        g.fillRect(0, 0, WIDTH, HEIGHT);
        g.setColor(Color.GREEN);
        g.setColor(Color.red);
        g.fill3DRect(p2.x, p2.y, p2.width, p2.height, true);

    }

//这是p2 move方法。我以为我的错误会在这里,但我会完全从书中复制出来。

private class Move2 extends Thread implements KeyListener {

        public void run() {

            addKeyListener(this);


            while (true) {

                try {

                    repaint();

                    //increase speed a bit
                    if (p2Speed <= 5) {
                        p2Speed = .2;
                    }

//这些将基于方向移动玩家

                    if (p2Direction == UP) {
                        p2.y -= (int) p2Speed;
                    }
                    if (p2Direction == DOWN) {
                        p2.y += (int) p2Speed;
                    }
                    if (p2Direction == LEFT) {
                        p2.x -= (int) p2Speed;
                    }
                    if (p2Direction == RIGHT) {
                        p2.x += (int) p2Speed;
                    }

                    Thread.sleep(75);
                } catch (Exception e) {


                }

            }
        }

        //you must also implement this method from key listener
        public void keyPressed(KeyEvent event) {
        }

        public void keyReleased(KeyEvent event) {
        }

        public void keyTyped(KeyEvent event) {
            if (event.getKeyChar() == 'j') {
                p2Direction = LEFT;
            }
            if (event.getKeyChar() == 'k') {
                p2Direction = DOWN;
            }
            if (event.getKeyChar() == 'l') {
                p2Direction = RIGHT;
            }
            if (event.getKeyChar() == 'i') {
                p2Direction = UP;
            }
        }
    }

    //This starts the program by calling the constructor:
    public static void main(String[] args) {
        new Collision();
    }
}

3 个答案:

答案 0 :(得分:3)

我自己并不擅长java,但是;

    if (p2Direction == UP) {
                    p2.y -= (int) p1Speed;
    }
    if (p2Direction == DOWN) {
                    p2.y += (int) p1Speed;
                }
                if (p2Direction == LEFT) {
                    p2.x -= (int) p1Speed;
                }
                if (p2Direction == RIGHT) {
                    p2.x += (int) p1Speed;
                }

不应该是

    if (p2Direction == UP) {
                    p2.y -= (int) p2Speed;
    }
    if (p2Direction == DOWN) {
                    p2.y += (int) p2Speed;
                }
                if (p2Direction == LEFT) {
                    p2.x -= (int) p2Speed;
                }
                if (p2Direction == RIGHT) {
                    p2.x += (int) p2Speed;
                }

对不起,如果我错了:p

答案 1 :(得分:1)

// Joris,这是完整的代码。没有SSCCE。它完全出书了。此代码包含与您的书匹配的编辑,但是如果您更改它以匹配我之前更正的错误,您将注意到p2将移动,但是当p1与墙碰撞时,p2将发生碰撞并且p2正好穿过墙。

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;

public class Collision extends JFrame {

final int WIDTH = 900, HEIGHT = 650;
double p1Speed = .5, p2Speed = .5;

//这些是代表方向的整数

final int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;

//这些将跟踪球员的方向(默认=上)

int p1Direction = UP;
int p2Direction = UP;
Rectangle left = new Rectangle(0, 0, WIDTH / 9, HEIGHT);
Rectangle right = new Rectangle((WIDTH / 9) * 8, 0, WIDTH / 9, HEIGHT);
Rectangle top = new Rectangle(0, 0, WIDTH, HEIGHT / 9);
Rectangle bottom = new Rectangle(0, (HEIGHT / 9) * 8, WIDTH, HEIGHT / 9);
Rectangle center = new Rectangle((int) ((WIDTH / 9) * 2.5), (int) ((HEIGHT / 9) * 2.5), 
(int) ((WIDTH / 9) * 5), (HEIGHT / 9) * 4);
Rectangle obstacle = new Rectangle(WIDTH / 2, (int) ((HEIGHT / 9) * 7), WIDTH / 10, HEIGHT 
/ 9);
Rectangle obstacle2 = new Rectangle(WIDTH / 3, (int) ((HEIGHT / 9) * 5), WIDTH / 10, 
HEIGHT / 4);
Rectangle obstacle3 = new Rectangle(2 * (WIDTH / 3), (int) ((HEIGHT / 9) * 5), WIDTH / 10, 
HEIGHT / 4);
Rectangle obstacle4 = new Rectangle(WIDTH / 3, HEIGHT / 9, WIDTH / 30, HEIGHT / 9);
Rectangle obstacle5 = new Rectangle(WIDTH / 2, (int) ((HEIGHT / 9) * 1.5), WIDTH / 30, 
HEIGHT / 4);
Rectangle finish = new Rectangle(WIDTH / 9, (HEIGHT / 2) - HEIGHT / 9, (int) ((WIDTH / 9) 
* 1.5), HEIGHT / 70);
Rectangle p1 = new Rectangle(WIDTH / 9, HEIGHT / 2, WIDTH / 30, WIDTH / 30);
Rectangle p2 = new Rectangle(((WIDTH / 9) + ((int) ((WIDTH / 9) * 1.5) / 2)), (HEIGHT / 2) 
+ (HEIGHT / 10), WIDTH / 30, WIDTH / 30);

public Collision() {

//以下代码创建JFrame

    super("Radical Racing");
    setSize(WIDTH, HEIGHT);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);

//启动内部类(由于它是一个线程,它可以自行运行)

    Move1 m1 = new Move1();
    Move2 m2 = new Move2();
    m1.start();
    m2.start();

}

public void paint(Graphics g) {
    super.paint(g);

//为赛道绘制bckround

    g.setColor(Color.DARK_GRAY);
    g.fillRect(0, 0, WIDTH, HEIGHT);

//当我们绘制边框时将为绿色

    g.setColor(Color.GREEN);

//以下矩形是外部玩家的起始线

    Rectangle lineO = new Rectangle(WIDTH / 9, HEIGHT / 2, (int) ((WIDTH / 9) * 1.5) / 2, 
    HEIGHT / 140);

//以下rctangle是内置播放器的起始行

    Rectangle lineI = new Rectangle(((WIDTH / 9) + ((int) ((WIDTH / 9) * 1.5) / 2)), 
    (HEIGHT / 2) + (HEIGHT / 10), (int) ((WIDTH / 9) * 1.5) / 2, HEIGHT / 140);

//现在使用矩形,画出

    g.fillRect(left.x, left.y, left.width, left.height);
    g.fillRect(right.x, right.y, right.width, right.height);
    g.fillRect(top.x, top.y, top.width, top.height);
    g.fillRect(bottom.x, bottom.y, bottom.width, bottom.height);
    g.fillRect(center.x, center.y, center.width, center.height);
    g.fillRect(obstacle.x, obstacle.y, obstacle.width, obstacle.height);
    g.fillRect(obstacle2.x, obstacle2.y, obstacle2.width, obstacle2.height);
    g.fillRect(obstacle3.x, obstacle3.y, obstacle3.width, obstacle3.height);
    g.fillRect(obstacle4.x, obstacle4.y, obstacle4.width, obstacle4.height);
    g.fillRect(obstacle5.x, obstacle5.y, obstacle5.width, obstacle5.height);

//设置起始线颜色

    g.setColor(Color.WHITE);

//绘制起跑线

    g.fillRect(lineO.x, lineO.y, lineO.width, lineO.height);
    g.fillRect(lineI.x, lineI.y, lineI.width, lineI.height);

//将终点线的颜色设置为黄色

    g.setColor(Color.YELLOW);
    g.fillRect(finish.x, finish.y, finish.width, finish.height);

//将p1的颜色设置为蓝色

    g.setColor(Color.BLUE);

//现在绘制实际玩家

    g.fill3DRect(p1.x, p1.y, p1.width, p1.height, true);

//为p2

设置颜色为红色
    g.setColor(Color.red);

//现在绘制实际玩家

    g.fill3DRect(p2.x, p2.y, p2.width, p2.height, true);

}

private class Move1 extends Thread implements KeyListener {

    public void run() {

//添加代码以使KeyListener“唤醒”

        addKeyListener(this);

//现在,把代码放在一个无限循环中,所以重复这个过程。

        while (true) {

//现在这应该在“try”块中。如果出现错误,这将让程序退出。

            try {

//首先刷新屏幕:

                repaint();

//检查汽车是否撞到了墙外。 //如果是这样的话,可以通过将速度设置为.4来降低速度。

                if (p1.intersects(left) || p1.intersects(right)
                        || p1.intersects(top) || p1.intersects(bottom)
                        || p1.intersects(obstacle) || p1.intersects(obstacle2)
                        || p1.intersects(p2) || p1.intersects(obstacle3)
                        || p1.intersects(obstacle4) || p1.intersects(obstacle5)) {
                    p1Speed = -4;
                }

//如果汽车撞到中心,请执行与上面相同的操作,但速度为-2.5。

                if (p1.intersects(center)) {
                    p1Speed = -2.5;
                }

//稍微提高速度

                if (p1Speed <= 5) {
                    p1Speed += .2;
                }

//这些将根据方向移动玩家

                if (p1Direction == UP) {
                    p1.y -= (int) p1Speed;
                }
                if (p1Direction == DOWN) {
                    p1.y += (int) p1Speed;
                }
                if (p1Direction == LEFT) {
                    p1.x -= (int) p1Speed;
                }
                if (p1Direction == RIGHT) {
                    p1.x += (int) p1Speed;
                }

//这会延迟刷新率

                Thread.sleep(75);
            } catch (Exception e) {

//如果有异常(错误),退出循环

                break;
            }
        }
    }

//您还必须从Key Listener

实现此方法
    public void keyPressed(KeyEvent event) {
    }

//您还必须从密钥监听器

实现此方法
    public void keyReleased(KeyEvent event) {
    }

//您还必须从密钥监听器

实现此方法
    public void keyTyped(KeyEvent event) {

        if (event.getKeyChar() == 'a') {
            p1Direction = LEFT;
        }
        if (event.getKeyChar() == 's') {
            p1Direction = DOWN;
        }
        if (event.getKeyChar() == 'd') {
            p1Direction = RIGHT;
        }
        if (event.getKeyChar() == 'w') {
            p1Direction = UP;
        }
    }
}

private class Move2 extends Thread implements KeyListener {

    public void run() {

//添加代码以使密钥监听器唤醒

        addKeyListener(this);

//现在这应该都是一个无限循环,以便重复该过程

        while (true) {

//现在将代码放在try块中。如果出现错误,这将让程序退出

            try {

//首先刷新屏幕

                repaint();

//检查汽车是否撞到了外墙。 //如果是这样,通过将速度设置为-4来降低速度。

                if (p2.intersects(left) || p2.intersects(right)
                        || p2.intersects(top) || p2.intersects(bottom)
                        || p2.intersects(obstacle) || p2.intersects(obstacle2)) {
                    p2Speed = -4;
                }

//如果汽车撞到中心,请执行与上面相同的操作,但速度为-2.5。

                if (p2.intersects(center)) {
                    p2Speed = -2.5;
                }

//稍微提高速度

                if (p2Speed <= 5) {
                    p2Speed = .2;
                }

//这些将基于方向移动玩家

                if (p2Direction == UP) {
                    p2.y-= (int) p2Speed;
                }
                if (p2Direction == DOWN) {
                    p2.y+= (int) p2Speed;
                }
                if (p2Direction == LEFT) {
                    p2.x-= (int) p2Speed;
                }
                if (p2Direction == RIGHT) {
                    p2.x+= (int) p2Speed;
                }

//这会延迟刷新率:

                Thread.sleep(75);
            } catch (Exception e) {

//如果有异常,退出循环。

                break;

            }

        }
    }

//您还必须从密钥监听器

实现此方法
    public void keyPressed(KeyEvent event) {
    }

    public void keyReleased(KeyEvent event) {
    }

    public void keyTyped(KeyEvent event) {
        if (event.getKeyChar() == 'j') {
            p2Direction = LEFT;
        }
        if (event.getKeyChar() == 'k') {
            p2Direction = DOWN;
        }
        if (event.getKeyChar() == 'l') {
            p2Direction = RIGHT;
        }
        if (event.getKeyChar() == 'i') {
            p2Direction = UP;
        }
    }
}

//这通过调用构造函数来启动程序:

public static void main(String[] args) {
    new Collision();
}

}

答案 2 :(得分:1)

让我的一个朋友看一下并为你修好

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

import javax.swing.JFrame;

public class RadicalRacing extends JFrame {
private static final long serialVersionUID = 1L;

// Environment size
final int WIDTH = 900, HEIGHT = 650;
// Player speed
double p1Speed = .5, p2Speed = .5;
// Integer values that represent directions
final int UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3;
// These keep track of the players directions(default = up)
int p1Direction = UP;
int p2Direction = UP;

// Environment objects
Rectangle left = new Rectangle(0, 0, WIDTH / 9, HEIGHT);
Rectangle right = new Rectangle((WIDTH / 9) * 8, 0, WIDTH / 9, HEIGHT);
Rectangle top = new Rectangle(0, 0, WIDTH, HEIGHT / 9);
Rectangle bottom = new Rectangle(0, (HEIGHT / 9) * 8, WIDTH, HEIGHT / 9);
Rectangle center = new Rectangle((int) ((WIDTH / 9) * 2.5),
(int) ((HEIGHT / 9) * 2.5), (int) ((WIDTH / 9) * 5),
(HEIGHT / 9) * 4);
Rectangle obstacle = new Rectangle(WIDTH / 2, (int) ((HEIGHT / 9) * 7),
WIDTH / 10, HEIGHT / 9);
Rectangle obstacle2 = new Rectangle(WIDTH / 3, (int) ((HEIGHT / 9) * 5),
WIDTH / 10, HEIGHT / 4);
Rectangle obstacle3 = new Rectangle(2 * (WIDTH / 3),
(int) ((HEIGHT / 9) * 5), WIDTH / 10, HEIGHT / 4);
Rectangle obstacle4 = new Rectangle(WIDTH / 3, HEIGHT / 9, WIDTH / 30,
HEIGHT / 9);
Rectangle obstacle5 = new Rectangle(WIDTH / 2, (int) ((HEIGHT / 9) * 1.5),
WIDTH / 30, HEIGHT / 4);
Rectangle finish = new Rectangle(WIDTH / 9, (HEIGHT / 2) - HEIGHT / 9,
(int) ((WIDTH / 9) * 1.5), HEIGHT / 70);
Rectangle p1 = new Rectangle(WIDTH / 9, HEIGHT / 2, WIDTH / 30, WIDTH / 30);
Rectangle p2 = new Rectangle(
((WIDTH / 9) + ((int) ((WIDTH / 9) * 1.5) / 2)), (HEIGHT / 2)
+ (HEIGHT / 10), WIDTH / 30, WIDTH / 30);

// Start the program by calling the non-static constructor.
public static void main(String[] args) { new RadicalRacing(); }

// Constructor. 
public RadicalRacing() {
super("Radical Racing"); // title of the window
setSize(WIDTH, HEIGHT);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);

// A thread is nessicary to run the environment graphics and controls
// at the same time. The graphics will run on the main thread and
// the controls will be operated on a second thread.
Movement m = new Movement();
m.start();

try { 
while(true) {
// Delay the refresh rate of the graphics.
Thread.sleep(50);
// Update the environment graphics with new positioning, etc
repaint(); 
}
} catch(Exception e) { }
}

@Override
public void paint(Graphics g) {
// The racetrack itself is the background of the interface.
g.setColor(Color.DARK_GRAY);
g.fillRect(0, 0, WIDTH, HEIGHT);

// Draw the environment outside of the race track
g.setColor(Color.BLACK);
g.fillRect(left.x, left.y, left.width, left.height);
g.fillRect(right.x, right.y, right.width, right.height);
g.fillRect(top.x, top.y, top.width, top.height);
g.fillRect(bottom.x, bottom.y, bottom.width, bottom.height);
g.fillRect(center.x, center.y, center.width, center.height);
g.fillRect(obstacle.x, obstacle.y, obstacle.width, obstacle.height);
g.fillRect(obstacle2.x, obstacle2.y, obstacle2.width, obstacle2.height);
g.fillRect(obstacle3.x, obstacle3.y, obstacle3.width, obstacle3.height);
g.fillRect(obstacle4.x, obstacle4.y, obstacle4.width, obstacle4.height);
g.fillRect(obstacle5.x, obstacle5.y, obstacle5.width, obstacle5.height);

// Draw the starting lines.
g.setColor(Color.WHITE);
// ..outer player starting line..
Rectangle lineO = new Rectangle(WIDTH / 9, HEIGHT / 2, (int) ((WIDTH / 9) * 1.5) / 2, HEIGHT / 140);
// ..inner player starting line..
Rectangle lineI = new Rectangle(
((WIDTH / 9) + ((int) ((WIDTH / 9) * 1.5) / 2)), (HEIGHT / 2)
+ (HEIGHT / 10), (int) ((WIDTH / 9) * 1.5) / 2,
HEIGHT / 140);
g.fillRect(lineO.x, lineO.y, lineO.width, lineO.height);
g.fillRect(lineI.x, lineI.y, lineI.width, lineI.height);

// Draw the finish line.
g.setColor(Color.YELLOW);
g.fillRect(finish.x, finish.y, finish.width, finish.height);

// Draw player #1
g.setColor(Color.BLUE);
g.fillRect(p1.x, p1.y, p1.width, p1.height);

// Draw player #2
g.setColor(Color.red);
g.fillRect(p2.x, p2.y, p2.width, p2.height);
}

private class Movement extends Thread implements KeyListener {

public void run() {

// Activate keyboard controls
addKeyListener(this);

try {

while(true) {
    // Delay the rate at which these variables are calculated.
    // Higher the number, the slower the race will feel.
    // Lower the number, the faster.
    // Too low and the game will be glitchy.
    Thread.sleep(75);

    // Check to see if the car hits the outside of the walls.
    // If so, slow it's speed temporarily.
    if(    p1.intersects(left)
    ||  p1.intersects(right)
    ||  p1.intersects(top)
    ||  p1.intersects(bottom)
    ||  p1.intersects(obstacle)
    ||    p1.intersects(obstacle2)
    ||  p1.intersects(p2)
    ||  p1.intersects(obstacle3)
    ||  p1.intersects(obstacle4)
    ||  p1.intersects(obstacle5))
    { p1Speed = -4; }

    if(    p2.intersects(left)
    ||  p2.intersects(right)
    ||  p2.intersects(top)
    ||  p2.intersects(bottom)
    ||  p2.intersects(obstacle)
    ||    p2.intersects(obstacle2)
    ||  p2.intersects(p1)
    ||  p2.intersects(obstacle3)
    ||  p2.intersects(obstacle4)
    ||  p2.intersects(obstacle5))
    { p2Speed = -4; }

    // If the car hits the center, slow it's speed just a little bit.
    if(p1.intersects(center)) p1Speed = -2.5;
    if(p2.intersects(center)) p2Speed = -2.5;

    // Now increase speed some.
    if(p1Speed <= 5) p1Speed += .2;
    if(p2Speed <= 5) p2Speed += .2;

    // Now move the player in the direction they're facing.
    if(p1Direction == UP)  p1.y -= (int)p1Speed;
    if(p1Direction == DOWN)  p1.y += (int)p1Speed;
    if(p1Direction == LEFT)  p1.x -= (int)p1Speed;
    if(p1Direction == RIGHT)  p1.x += (int)p1Speed;

    if(p2Direction == UP)  p2.y -= (int)p2Speed;
    if(p2Direction == DOWN)  p2.y += (int)p2Speed;
    if(p2Direction == LEFT)  p2.x -= (int)p2Speed;
    if(p2Direction == RIGHT)  p2.x += (int)p2Speed;
}

} catch (Exception e) { e.printStackTrace(); }
}

// Unused methods required for implementation.
public void keyPressed(KeyEvent event)  { }
public void keyReleased(KeyEvent event) { }

public void keyTyped(KeyEvent event) {
char c = event.getKeyChar();
if(c == 'a') p1Direction = LEFT;
if(c == 's') p1Direction = DOWN;
if(c == 'd') p1Direction = RIGHT;
if(c == 'w') p1Direction = UP;

if(c == 'j') p2Direction = LEFT;
        if(c == 'k') p2Direction = DOWN;
        if(c == 'l') p2Direction = RIGHT;
        if(c == 'i') p2Direction = UP;
 }
 }

 }

间距可能是关闭的,但这并不重要xD