Cześć piszę sobie grę i mam taki problem, bo gracz reaguje mi tylko na 1 płytę z trzech rodzajów (w sensie po jednej z trzech) na całej mapie. Tym czasem tych płytek na które powinien zareagować jest dużo więcej. Czy widzicie mój błąd i macie pomysł jak rozwiązać ten problem? Poniżej wrzucam potrzebne klasy do analizy.
Klasa Tile:
import java.awt.*;
import java.awt.image.BufferedImage;
public class Tile {
private Rectangle rectangle = null;
private BufferedImage bufferedImage;
private boolean collision;
public Tile(boolean hasCollision) {
this.collision = hasCollision;
if (hasCollision) {
this.rectangle = new Rectangle();
}
}
public void setParameters(int x, int y, int width, int height) {
rectangle.x = x;
rectangle.y = y;
rectangle.width = width;
rectangle.height = height;
}
public Rectangle getRectangle() {
return rectangle;
}
public BufferedImage getBufferedImage() {
return bufferedImage;
}
public void setBufferedImage(BufferedImage bufferedImage) {
this.bufferedImage = bufferedImage;
}
public boolean isCollision() {
return collision;
}
public void draw(Graphics2D g2d) {
g2d.setColor(Color.RED);
g2d.drawOval(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
}
}
Klasa TileManager:
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class TileManager {
//Jedna płytka powinna mieć wymiary 40x40
//Dla szerokości 800 powinno być 20 płytek
//Dla długości 600 powinno być 15 płytek
private static final int SPEED = 2;
private static final int MAX_WORLD_COLUMNS = 50;
private static final int MAX_WORLD_ROWS = 50;
private static final int TILE_SIZE = 40;
private static final Tile[] tiles = new Tile[6];
private static final ProportionCalculator pc = new ProportionCalculator();
private static final int[][] mapTileNumbers = new int[MAX_WORLD_COLUMNS][MAX_WORLD_ROWS];
private final String path;
private int x;
private int y;
private int speedY;
private int speedX;
private boolean up;
private boolean down;
private boolean left;
private boolean right;
public TileManager(String path) {
this.path = path;
getTileImage();
loadMap(path);
}
private void loadMap(String path) {
try {
InputStream inputStream = getClass().getResourceAsStream(path);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
int col = 0;
int row = 0;
while (col < MAX_WORLD_COLUMNS && row < MAX_WORLD_ROWS) {
String line = bufferedReader.readLine();
while (col < MAX_WORLD_COLUMNS) {
String[] numbers = line.split(" ");
int number = Integer.parseInt(numbers[col]);
mapTileNumbers[col][row] = number;
col++;
}
if (col == MAX_WORLD_COLUMNS) {
col = 0;
row++;
}
}
bufferedReader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private void getTileImage() {
try {
tiles[0] = new Tile(false);
tiles[0].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/grass.png")));
tiles[1] = new Tile(true);
tiles[1].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/wall.png")));
tiles[2] = new Tile(true);
tiles[2].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/water.png")));
tiles[3] = new Tile(false);
tiles[3].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/earth.png")));
tiles[4] = new Tile(true);
tiles[4].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/tree.png")));;
tiles[5] = new Tile(false);
tiles[5].setBufferedImage(ImageIO.read(getClass().getResourceAsStream("/tiles/sand.png")));
} catch (IOException e) {
e.printStackTrace();
}
}
public void onKeyPressed(KeyEvent key) {
if (up) {
if (key.getKeyCode() == KeyEvent.VK_UP) {
speedY = SPEED;
}
} else {
speedY = 0;
}
if (down) {
if (key.getKeyCode() == KeyEvent.VK_DOWN) {
speedY = -SPEED;
}
} else {
speedY = 0;
}
if (left) {
if (key.getKeyCode() == KeyEvent.VK_LEFT) {
speedX = SPEED;
}
} else {
speedX = 0;
}
if (right) {
if (key.getKeyCode() == KeyEvent.VK_RIGHT) {
speedX = -SPEED;
}
} else {
speedX = 0;
}
}
public void onKeyReleased(KeyEvent key) {
if (key.getKeyCode() == KeyEvent.VK_UP) {
speedY = 0;
}
if (key.getKeyCode() == KeyEvent.VK_DOWN) {
speedY = 0;
}
if (key.getKeyCode() == KeyEvent.VK_LEFT) {
speedX = 0;
}
if (key.getKeyCode() == KeyEvent.VK_RIGHT) {
speedX = 0;
}
}
public void update(Player player) {
xMove(player);
yMove(player);
}
private void xMove(Player player) {
left = true;
right = true;
//Collision X
if (speedX < 0) {
for (int i = 0; i < tiles.length; i++) {
if (tiles[i].isCollision()) {
if (player.getEntityCollisionLeft().getRectangle().intersects(tiles[i].getRectangle())) {
left = false;
}
}
}
} else if (speedX > 0) {
for (int i = 0; i < tiles.length; i++) {
if (tiles[i].isCollision()) {
if (player.getEntityCollisionRight().getRectangle().intersects(tiles[i].getRectangle())) {
right = false;
}
}
}
}
if (speedX < 0 && left) {
x += speedX;
} else if (speedX > 0 && right) {
x += speedX;
}
}
private void yMove(Player player) {
up = true;
down = true;
//Collision Y
if (speedY < 0) {
for (int i = 0; i < tiles.length; i++) {
if (tiles[i].isCollision()) {
if (player.getEntityCollisionUp().getRectangle().intersects(tiles[i].getRectangle())) {
up = false;
}
}
}
} else if (speedY > 0) {
for (int i = 0; i < tiles.length; i++) {
if (tiles[i].isCollision()) {
if (player.getEntityCollisionDown().getRectangle().intersects(tiles[i].getRectangle())) {
down = false;
}
}
}
}
if (speedY < 0 && up) {
y += speedY;
} else if (speedY > 0 && down) {
y += speedY;
}
}
public void draw(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
int col = 0;
int row = 0;
int x = 0;
int y = 0;
while (col < MAX_WORLD_COLUMNS && row < MAX_WORLD_ROWS) {
int tileNumber = mapTileNumbers[col][row];
g2d.drawImage(
tiles[tileNumber].getBufferedImage(),
x + this.x,
y + this.y,
pc.getCalculatedImageWidth(TILE_SIZE),
pc.getCalculatedImageHeight(TILE_SIZE),
null);
if (tiles[tileNumber].isCollision()) {
tiles[tileNumber].setParameters(
x + this.x,
y + this.y,
pc.getCalculatedImageWidth(TILE_SIZE),
pc.getCalculatedImageHeight(TILE_SIZE));
tiles[tileNumber].draw(g2d);
}
col++;
x += pc.getCalculatedImageWidth(TILE_SIZE);
if (col == MAX_WORLD_COLUMNS) {
col = 0;
x = 0;
row++;
y += pc.getCalculatedImageHeight(TILE_SIZE);
}
}
}
}
Klasa EntityCollision:
import java.awt.*;
public class EntityCollision {
private final String direction;
private Rectangle rectangle;
public EntityCollision(int xPos, int yPos, int width, int height, String direction) {
this.direction = direction;
this.rectangle = new Rectangle(xPos, yPos, width, height);
}
public Rectangle getRectangle() {
return rectangle;
}
public void draw(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
if (direction.equals("up")) {
g2d.setColor(Color.RED);
}
if (direction.equals("down")) {
g2d.setColor(Color.YELLOW);
}
if (direction.equals("left")) {
g2d.setColor(Color.BLUE);
}
if (direction.equals("right")) {
g2d.setColor(Color.CYAN);
}
g2d.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
}
}
Dodaje też zrzuty ekranu z zaznaczonym kafelkami na których następuje blokada gracza.
