当每个块到达屏幕一侧的某个点时，我如何使它们朝相反的方向移动？

Question

我试图让三个不同的块从屏幕的一侧前后移动到另一侧。如果最右边的方块达到游戏画面的宽度，它的速度会反转，并开始向左移动。然而，我的问题存在于另外两个街区。我在代码中加入了一个方法，说明一旦第二个方块达到（游戏宽度-100），100只是每个方块的宽度，它的速度应该是相反的。第三个方块除了到达x点（游戏宽度-200）外，其他功能都是一样的。在下面发布的PlayState类中的UpdateBlocks方法下，可以看到我试图改变第二个和第三个块的速度。

我想指出的另一件事是，在block类中的update方法中，x值也被反转。起初我试图让它从播放状态读取块，然后改变相应的速度，但我得到了一个线程错误。这就是为什么我要把我目前的困境告诉你们。

下面是block类：

package com.jamescho.game.model;

import java.awt.Rectangle;

import com.jamescho.framework.util.RandomNumberGenerator;
import com.jamescho.game.main.GameMain;
import com.jamescho.game.state.PlayState;

public class Block {
private float x, y;
private int width, height, velX = 700;
private Rectangle rect;
private PlayState play;
private boolean visible;
private static final int UPPER_Y = 275;
private static final int LOWER_Y = 355;

public Block(float x, float y, int width, int height) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
    rect = new Rectangle((int) x, (int) y, width, height);
    visible = false;
}

// Note: Velocity value will be passed in from PlayState!
public void update(float delta) {
    x += velX * delta;
    if (x <= 0 || x >= GameMain.GAME_WIDTH - 100) {
        velX = -velX;
    }
    updateRect();
}

public void updateRect() {
    rect.setBounds((int) x, (int) y, width, height);
}

public void invisible() {
    visible = false;
}

public void visible() {
    visible = true;
}

public void stop() {
    velX = 0;
}

public void reverse() {
    velX = -velX;
}
public float getX() {
    return x;
}

public float getY() {
    return y;
}

public boolean isVisible() {
    return visible;
}

public Rectangle getRect() {
    return rect;
}
}

这里是一切都在进行的游戏状态：

package com.jamescho.game.state;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.util.ArrayList;

import com.jamescho.game.main.GameMain;
import com.jamescho.game.main.Resources;
import com.jamescho.game.model.Block;


public class PlayState extends State {

private ArrayList<Block> row1;
private ArrayList<Block> row2;
private ArrayList<Block> row3;

private Block block;
private Font scoreFont;
private int playerScore = 0;

private static final int BLOCK_HEIGHT = 100;
private static final int BLOCK_WIDTH = 100;
private int blockSpeed = -200;

private static final int PLAYER_WIDTH = 66;
private static final int PLAYER_HEIGHT = 92;

@Override
public void init() {

    row1 = new ArrayList<Block>();
    row2 = new ArrayList<Block>();

    scoreFont = new Font("SansSerif", Font.BOLD, 25);
    for (int i = 0; i < 3; i++) {
        Block b = new Block(i * 105, GameMain.GAME_HEIGHT - 101,
                BLOCK_WIDTH, BLOCK_HEIGHT);
        row1.add(b);
        b.visible();

    for (int h = 0; h < 3; h++) {
        Block b2 = new Block(h * 105, b.getY() - 208,
            BLOCK_WIDTH, BLOCK_HEIGHT);
            row2.add(b2);
            b2.invisible();
            }

    }

}

@Override
public void update(float delta) {

    playerScore += 1;
    if (playerScore % 500 == 0 && blockSpeed > -280) {
        blockSpeed -= 10;
    }

    Resources.runAnim.update(delta);// starts iterating through its frames

    updateBlocks(delta); 
}

private void updateBlocks(float delta) { // time from last update
    for (Block b : row1) { //foreach statement; for each iteration of "b" the     code is executed, one "b" at a time
        if(row1.get(1).getX() == GameMain.GAME_WIDTH - BLOCK_WIDTH - 5) {
            row1.get(1).reverse();
        }
        else if(row1.get(2).getX() == GameMain.GAME_WIDTH - 2 * BLOCK_WIDTH - 5) {
            row1.get(2).reverse();
        }
        b.update(delta);

}
    for (Block c : row2) { //foreach statement; for each iteration of "b" the code is executed, one "b" at a time
        // used with objects; can't use primitive
        c.update(delta);
        if (c.isVisible()) {

        }
    }
}


@Override
public void render(Graphics g) {
    g.setColor(Color.BLACK);
    g.fillRect(0, 0, GameMain.GAME_WIDTH, GameMain.GAME_HEIGHT);
    renderPlayer(g);
    renderBlocks(g);
    renderScore(g);
}

private void renderScore(Graphics g) {
    g.setFont(scoreFont);
    g.setColor(Color.GRAY);
    g.drawString("" + playerScore / 100, 20, 30);
}

private void renderPlayer(Graphics g) {

    }


private void renderBlocks(Graphics g) {
    for (Block b : row1) {
        if (b.isVisible()) {
            g.drawImage(Resources.blue_panel, (int) b.getX(), (int) b.getY(),
                    BLOCK_WIDTH, BLOCK_HEIGHT, null); // change null if you want the object to know about object
        }
    }
    for (Block c : row2) {
        if (c.isVisible()) {
            g.drawImage(Resources.blue_panel, (int) c.getX(), (int) c.getY()+105,
                    BLOCK_WIDTH, BLOCK_HEIGHT, null); // change null if you want the object to know about object
        }
    }
}

@Override
public void onClick(MouseEvent e) {
}

@Override
public void onKeyPress(KeyEvent e) {
    if (e.getKeyCode() == KeyEvent.VK_SPACE) {
        for (Block b : row1) {
            b.stop();
        for (Block c : row2) {
            if (c.isVisible() == true) {
                c.stop();
            }
            }
        }
    }

     else if (e.getKeyCode() == KeyEvent.VK_DOWN) {

    }
}

@Override
public void onKeyRelease(KeyEvent e) {
    if(e.getKeyCode() == KeyEvent.VK_SPACE) {
        for (Block c: row2) {
            c.visible();
        }
    }
}

public float getb1X() {
    return row1.get(1).getX();
}
}

Answer 1

对不起，我还没看完你的全部密码。但我会这样做：

int x，int y——是屏幕上每个块的坐标。

一个块可以在屏幕上以4种方式/方向/象限移动：

1) x = x + deltaX, y = y + deltaY  
2) x = x - deltaX, y = y + deltaY  
3) x = x + deltaX, y = y - deltaY
4) x = x - deltaX, y = y - deltaY

因此，为了在块击中任何一侧时更改方向，如果它击中左侧或右侧，您应该将deltaX与-1相乘，如果它击中底部或顶部，则将deltaY与-1相乘。这将逆转其方向。