552 lines
20 KiB
Java
552 lines
20 KiB
Java
package de.lunarakai.minecleaner;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.World;
|
|
import org.bukkit.block.BlockFace;
|
|
import org.bukkit.block.data.BlockData;
|
|
import org.bukkit.configuration.ConfigurationSection;
|
|
import org.bukkit.entity.Display;
|
|
import org.bukkit.entity.Display.Brightness;
|
|
import org.bukkit.entity.Entity;
|
|
import org.bukkit.entity.ItemDisplay;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.util.Transformation;
|
|
import org.joml.Vector2i;
|
|
import org.joml.Vector3f;
|
|
import com.google.common.base.Preconditions;
|
|
import de.lunarakai.minecleaner.game.BoardSize;
|
|
import de.lunarakai.minecleaner.game.Cell;
|
|
import de.lunarakai.minecleaner.game.Game;
|
|
import de.lunarakai.minecleaner.utils.MinecleanerHeads;
|
|
import net.md_5.bungee.api.ChatColor;
|
|
import net.md_5.bungee.api.ChatMessageType;
|
|
import net.md_5.bungee.api.chat.TextComponent;
|
|
|
|
public class MinecleanerArena {
|
|
private final MinecleanerPlugin plugin;
|
|
private final String name;
|
|
private final Location location;
|
|
private final Location centerLocation;
|
|
private int widthIndex = 0;
|
|
private final BlockFace orientation;
|
|
private ArenaStatus arenaStatus = ArenaStatus.INACTIVE;
|
|
private UUID[] blockDisplays;
|
|
// private UUID[] textDisplays;
|
|
private boolean hasMadeFirstClick = false;
|
|
|
|
private int flagsPlaced = 0;
|
|
|
|
private Player currentPlayer;
|
|
private long currentGameStartTime;
|
|
private Game currentMinecleanerGame;
|
|
|
|
private final Location tempLoc = new Location(null, 0, 0, 0);
|
|
|
|
public static final MinecleanerHeads[] MINECLEANER_HEADS = {
|
|
MinecleanerHeads.MINESWEEPER_TILE_0,
|
|
MinecleanerHeads.MINESWEEPER_TILE_1,
|
|
MinecleanerHeads.MINESWEEPER_TILE_2,
|
|
MinecleanerHeads.MINESWEEPER_TILE_3,
|
|
MinecleanerHeads.MINESWEEPER_TILE_4,
|
|
MinecleanerHeads.MINESWEEPER_TILE_5,
|
|
MinecleanerHeads.MINESWEEPER_TILE_6,
|
|
MinecleanerHeads.MINESWEEPER_TILE_7,
|
|
MinecleanerHeads.MINESWEEPER_TILE_8,
|
|
MinecleanerHeads.MINESWEEPER_TILE_FLAG,
|
|
MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN,
|
|
};
|
|
|
|
public MinecleanerArena(MinecleanerPlugin plugin, ConfigurationSection arenaSection) {
|
|
this.plugin = plugin;
|
|
this.name = Preconditions.checkNotNull(arenaSection.getString("name"));
|
|
this.location = Preconditions.checkNotNull(arenaSection.getLocation("location"));
|
|
this.widthIndex = Preconditions.checkNotNull(arenaSection.getInt("fieldwidth"));
|
|
this.blockDisplays = new UUID[BoardSize.boardSizes[widthIndex] * BoardSize.boardSizes[widthIndex]];
|
|
// this.textDisplays = new UUID[1];
|
|
|
|
BlockFace orientation = BlockFace.NORTH;
|
|
try {
|
|
orientation = BlockFace.valueOf(arenaSection.getString("orientation"));
|
|
} catch(IllegalArgumentException ignored) {
|
|
|
|
}
|
|
this.orientation = orientation;
|
|
|
|
this.centerLocation = location.clone().add(0.5, 0, 0.5);
|
|
|
|
List<String> list = arenaSection.getStringList("blockdisplays");
|
|
for(int i = 0; i < list.size(); i++) {
|
|
String blockDisplay = list.get(i);
|
|
if(blockDisplay != null) {
|
|
blockDisplays[i] = UUID.fromString(blockDisplay);
|
|
}
|
|
}
|
|
|
|
// List<String> textList = arenaSection.getStringList("textdisplay");
|
|
// for(int i = 0; i < textList.size(); i++) {
|
|
// String textString = list.get(i);
|
|
// if(textString != null) {
|
|
// textDisplays[0] = UUID.fromString(textString);
|
|
// }
|
|
// }
|
|
}
|
|
|
|
public MinecleanerArena(MinecleanerPlugin plugin, String name, Location location, int widthIndex, BlockFace orientation) {
|
|
this.plugin = plugin;
|
|
this.name = Preconditions.checkNotNull(name, "name");
|
|
this.location = Preconditions.checkNotNull(location, "location");
|
|
this.widthIndex = Preconditions.checkNotNull(widthIndex, ("fieldwidth"));
|
|
this.blockDisplays = new UUID[BoardSize.boardSizes[widthIndex] * BoardSize.boardSizes[widthIndex]];
|
|
//this.textDisplays = new UUID[1];
|
|
|
|
Preconditions.checkArgument(Math.abs(orientation.getModX()) + Math.abs(orientation.getModZ()) == 1, "no cardinal direction");
|
|
this.orientation = orientation;
|
|
int d0x = orientation.getModX();
|
|
int d0z = orientation.getModZ();
|
|
int d1x = -d0z;
|
|
int d1z = d0x;
|
|
this.centerLocation = location.clone().add(0.5, 0, 0.5);
|
|
}
|
|
|
|
public void generateBackgroundBlocks() {
|
|
World world = location.getWorld();
|
|
int d0x = orientation.getModX();
|
|
int d0z = orientation.getModZ();
|
|
int d1x = -d0z;
|
|
int d1z = d0x;
|
|
Location loc = location.clone();
|
|
|
|
BlockData block0 = Material.NETHER_BRICKS.createBlockData();
|
|
BlockData block1 = Material.BRICKS.createBlockData();
|
|
|
|
for (int fx = -1 - widthIndex; fx < 2 ; fx++) {
|
|
for (int fy = -1; fy < 2 + widthIndex; fy++) {
|
|
loc.set(location.getX() + d1x * fx, location.getY() + fy, location.getZ() + d1z * fx);
|
|
boolean f = (fx + fy) % 2 == 0;
|
|
world.setBlockData(loc, f ? block0 : block1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Bei Größen WidthIndex 1 + 2 -> Mitte = ein Block nach Links unten versetzt
|
|
*/
|
|
public void generateBlockDisplays() {
|
|
int size = BoardSize.boardSizes[widthIndex];
|
|
|
|
World world = location.getWorld();
|
|
for(UUID id : blockDisplays) {
|
|
if(id != null) {
|
|
Entity blockdisplay = world.getEntity(id);
|
|
if(blockdisplay instanceof Display) {
|
|
blockdisplay.remove();
|
|
}
|
|
}
|
|
}
|
|
Arrays.fill(blockDisplays, null);
|
|
|
|
float rotation0 = 0;
|
|
double eastWestGapFixX = 0.0;
|
|
double eastWestGapFixZ = 0.0;
|
|
|
|
double southGapFixX = 0.0;
|
|
double southGapFixZ = 0.0;
|
|
if(orientation == BlockFace.EAST) {
|
|
rotation0 = 90;
|
|
eastWestGapFixX = 0.5;
|
|
eastWestGapFixZ = -0.55;
|
|
} else if(orientation == BlockFace.SOUTH) {
|
|
rotation0 = 180;
|
|
southGapFixX = 1.02;
|
|
southGapFixZ = -0.05;
|
|
} else if(orientation == BlockFace.WEST) {
|
|
rotation0 = 270;
|
|
eastWestGapFixX = 0.55;
|
|
eastWestGapFixZ = 0.5;
|
|
}
|
|
|
|
float rotation = rotation0;
|
|
|
|
int d0x = orientation.getModX();
|
|
int d0z = orientation.getModZ();
|
|
int d1x = -d0z;
|
|
int d1z = d0x;
|
|
|
|
Location loc = location.clone();
|
|
|
|
for(int fx = 0; fx < size; fx++) {
|
|
final int fxf = fx;
|
|
for(int fz = 0; fz < size; fz++) {
|
|
final int fzf = fz;
|
|
|
|
loc.set(location.getX() - 0.016 + eastWestGapFixX + southGapFixX - (d1x * fz) / 3.0 + d0x * 0.55 + d1x * 1.847,
|
|
location.getY() - 0.8225 + fxf / 3.0,
|
|
location.getZ() + 0.525 + eastWestGapFixZ + southGapFixZ - (d1z * fz) / 3.0 + d0z * 0.55 + d1z * 1.847);
|
|
|
|
Display blockDisplay = world.spawn(loc, ItemDisplay.class, blockdisplay -> {
|
|
Transformation transformation = blockdisplay.getTransformation();
|
|
Transformation newTransform;
|
|
Vector3f newTranslationScale = new Vector3f(0.60f, 0.60f, 0.60f);
|
|
newTransform = new Transformation(
|
|
transformation.getTranslation(),
|
|
transformation.getLeftRotation(),
|
|
newTranslationScale,
|
|
transformation.getRightRotation());
|
|
|
|
blockdisplay.setTransformation(newTransform);
|
|
blockdisplay.setRotation(rotation, -90);
|
|
blockdisplay.setBrightness(new Brightness(15, 15));
|
|
|
|
blockdisplay.setItemStack(MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN.getHead());
|
|
});
|
|
|
|
|
|
if(blockDisplay != null) {
|
|
blockDisplays[fxf + fzf * size] = blockDisplay.getUniqueId();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Location textLocation = location.clone();
|
|
// TextDisplay textDisplay = world.spawn(textLocation.add(-1, 2 + widthIndex, -0.25), TextDisplay.class, textdisplay -> {
|
|
// Transformation transformation = textdisplay.getTransformation();
|
|
// Transformation newTransformation;
|
|
// newTransformation = new Transformation(
|
|
// transformation.getTranslation(),
|
|
// transformation.getLeftRotation(),
|
|
// transformation.getTranslation(),
|
|
// transformation.getRightRotation());
|
|
|
|
// textdisplay.setTransformation(newTransformation);
|
|
// textdisplay.setRotation(rotation, 0);
|
|
|
|
// billboardmode = fixed
|
|
// textdisplay.setVisibleByDefault(true);
|
|
// textdisplay.setDisplayHeight(3);
|
|
// textdisplay.setDisplayWidth(9);
|
|
// textdisplay.setText("Minecleaner");
|
|
// });
|
|
|
|
// if(textDisplay != null) {
|
|
// textDisplays[0] = textDisplay.getUniqueId();
|
|
// }
|
|
|
|
// show Displays
|
|
|
|
//showStartHeads();
|
|
}
|
|
|
|
public void save(ConfigurationSection arenaSection) {
|
|
arenaSection.set("name", this.name);
|
|
arenaSection.set("location", this.location);
|
|
arenaSection.set("fieldwidth", this.widthIndex);
|
|
arenaSection.set("orientation", this.orientation.name());
|
|
List<String> blockDisplays = new ArrayList<>();
|
|
for(UUID uuid : this.blockDisplays) {
|
|
blockDisplays.add(uuid == null ? null : uuid.toString());
|
|
}
|
|
arenaSection.set("blockdisplays", blockDisplays);
|
|
// List<String> textd = new ArrayList<>();
|
|
// for(UUID uuid : this.textDisplays) {
|
|
// textd.add(uuid == null ? null : uuid.toString());
|
|
// }
|
|
// arenaSection.set("textdisplay", textd);
|
|
}
|
|
|
|
private void setDiplayBlock(int x, int y, MinecleanerHeads head) {
|
|
int size = BoardSize.boardSizes[widthIndex];
|
|
|
|
UUID blockDisplayId = blockDisplays[x + y * size];
|
|
Entity blockDisplay = blockDisplayId != null ? location.getWorld().getEntity(blockDisplayId) : null;
|
|
if(blockDisplay instanceof ItemDisplay) {
|
|
ItemDisplay display = (ItemDisplay) blockDisplay;
|
|
display.setItemStack(head.getHead());
|
|
}
|
|
}
|
|
|
|
public void startNewGame() {
|
|
currentMinecleanerGame = new Game(plugin, BoardSize.boardSizes[widthIndex], BoardSize.mineCounter[widthIndex]);
|
|
currentMinecleanerGame.start();
|
|
//removeStartHeads();
|
|
flagsPlaced = 0;
|
|
hasMadeFirstClick = false;
|
|
arenaStatus = ArenaStatus.PLAYING;
|
|
currentGameStartTime = System.currentTimeMillis();
|
|
}
|
|
|
|
public void addJoiningPlayer(Player player) {
|
|
Preconditions.checkNotNull(player);
|
|
Preconditions.checkState(arenaStatus == ArenaStatus.INACTIVE);
|
|
this.arenaStatus = ArenaStatus.CONFIRM_PLAYING;
|
|
this.currentPlayer = player;
|
|
}
|
|
|
|
public void removePlayer() {
|
|
int size = BoardSize.boardSizes[widthIndex];
|
|
|
|
this.arenaStatus = ArenaStatus.INACTIVE;
|
|
this.currentPlayer = null;
|
|
this.currentMinecleanerGame = null;
|
|
|
|
for(int x = 0; x < size; x++) {
|
|
for(int y = 0; y < size; y++) {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
}
|
|
}
|
|
//showStartHeads();
|
|
}
|
|
|
|
// public void showStartHeads() {
|
|
// setDiplayBlock(4+widthIndex, 2+widthIndex+1, MinecleanerHeads.RAINBOW_S);
|
|
// setDiplayBlock(4+widthIndex, 3+widthIndex+1, MinecleanerHeads.RAINBOW_T);
|
|
// setDiplayBlock(4+widthIndex, 4+widthIndex+1, MinecleanerHeads.RAINBOW_A);
|
|
// setDiplayBlock(4+widthIndex, 5+widthIndex+1, MinecleanerHeads.RAINBOW_R);
|
|
// setDiplayBlock(4+widthIndex, 6+widthIndex+1, MinecleanerHeads.RAINBOW_T);
|
|
// }
|
|
|
|
// public void removeStartHeads() {
|
|
// setDiplayBlock(4+widthIndex, 2+widthIndex+1, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
// setDiplayBlock(4+widthIndex, 3+widthIndex+1, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
// setDiplayBlock(4+widthIndex, 4+widthIndex+1, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
// setDiplayBlock(4+widthIndex, 5+widthIndex+1, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
// setDiplayBlock(4+widthIndex, 6+widthIndex+1, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
// }
|
|
|
|
public void removeBlockDisplays() {
|
|
int size = BoardSize.boardSizes[widthIndex];
|
|
|
|
World world = location.getWorld();
|
|
for(int fx = 0; fx < size; fx++) {
|
|
for(int fy = 0; fy < size; fy++) {
|
|
UUID blockDisplayUuid = blockDisplays[fx + fy * size];
|
|
Entity blockDisplayEntity = blockDisplayUuid != null ? world.getEntity(blockDisplayUuid) : null;
|
|
if(blockDisplayEntity instanceof Display blockdisplay) {
|
|
blockDisplayEntity.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void flagCell(int x, int y) {
|
|
if(currentMinecleanerGame != null && !currentMinecleanerGame.gameover) {
|
|
Cell cell = currentMinecleanerGame.getCell(x, y);
|
|
if(!cell.isRevealed()) {
|
|
Player player = this.currentPlayer;
|
|
|
|
currentMinecleanerGame.flag(x, y);
|
|
if(currentMinecleanerGame.gameover) {
|
|
plugin.getManager().handleGameover(player, this, true);
|
|
}
|
|
|
|
if(cell.isFlagged() == true) {
|
|
flagsPlaced = flagsPlaced + 1;
|
|
sendActionBarMessage(player);
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_FLAG);
|
|
}
|
|
|
|
if(cell.isFlagged() == false) {
|
|
flagsPlaced = flagsPlaced - 1;
|
|
sendActionBarMessage(player);
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_UNKNOWN);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public void revealCell(int x, int y) {
|
|
if(currentMinecleanerGame != null && !currentMinecleanerGame.gameover) {
|
|
Cell cell = currentMinecleanerGame.getCell(x, y);
|
|
if(!cell.isFlagged()) {
|
|
Player player = this.currentPlayer;
|
|
|
|
if(!hasMadeFirstClick) {
|
|
currentMinecleanerGame.firstClick(x, y);
|
|
hasMadeFirstClick = true;
|
|
}
|
|
|
|
currentMinecleanerGame.reveal(x, y);
|
|
setBlockForCellType(x, y, cell);
|
|
|
|
if(currentMinecleanerGame.gameover) {
|
|
plugin.getManager().handleGameover(player, this, !(cell.isRevealed() && cell.isExploded()));
|
|
} else {
|
|
sendActionBarMessage(player);
|
|
}
|
|
|
|
ArrayList<Cell> floodedCells = currentMinecleanerGame.getfloodedCells();
|
|
if(floodedCells != null) {
|
|
for(int i = 0; i < floodedCells.size(); i++) {
|
|
Vector2i pos = floodedCells.get(i).position;
|
|
setBlockForCellType(pos.x, pos.y, floodedCells.get(i));
|
|
}
|
|
flagsPlaced = flagsPlaced - currentMinecleanerGame.getFloodedFlaggedCells();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void sendActionBarMessage(Player player) {
|
|
TextComponent textComponent = new TextComponent("Flaggen gesetzt: " + flagsPlaced + " Minen insgesamt: " + BoardSize.mineCounter[widthIndex]);
|
|
textComponent.setColor(ChatColor.GOLD);
|
|
player.sendMessage(ChatMessageType.ACTION_BAR, textComponent);
|
|
}
|
|
|
|
public void showMines() {
|
|
ArrayList<Cell> explodedCells = currentMinecleanerGame.getExplodedCells();
|
|
if(explodedCells != null) {
|
|
for(int i = 0; i < explodedCells.size(); i++) {
|
|
Vector2i pos = explodedCells.get(i).position;
|
|
setBlockForCellType(pos.x, pos.y, explodedCells.get(i));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void setBlockForCellType(int x, int y, Cell cell) {
|
|
switch (cell.getType()) {
|
|
case Empty: {
|
|
if(!cell.isRevealed() || !cell.isFlagged() || !cell.isExploded()) {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_0);
|
|
}
|
|
break;
|
|
}
|
|
case Number: {
|
|
if(!cell.isRevealed() || !cell.isFlagged() || !cell.isExploded()) {
|
|
switch(cell.number) {
|
|
case 1: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_1);
|
|
break;
|
|
}
|
|
case 2: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_2);
|
|
break;
|
|
}
|
|
case 3: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_3);
|
|
break;
|
|
}
|
|
case 4: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_4);
|
|
break;
|
|
}
|
|
case 5: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_5);
|
|
break;
|
|
}
|
|
case 6: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_6);
|
|
break;
|
|
}
|
|
case 7: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_7);
|
|
break;
|
|
}
|
|
case 8: {
|
|
setDiplayBlock(x, y, MinecleanerHeads.MINESWEEPER_TILE_8);
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Mine: {
|
|
if(cell.isExploded()) {
|
|
setDiplayBlock(x, y, MinecleanerHeads.EXPLODED);
|
|
} else {
|
|
setDiplayBlock(x, y, MinecleanerHeads.TNT);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
// Invalid
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public List<Location> getBlocks() {
|
|
ArrayList<Location> blocks = new ArrayList<>();
|
|
int d0x = orientation.getModX();
|
|
int d0z = orientation.getModZ();
|
|
int d1x = -d0z;
|
|
int d1z = d0x;
|
|
|
|
Location loc = location.clone();
|
|
|
|
for(int fx = -1 - widthIndex; fx < 2; fx++) {
|
|
for(int fy = -1; fy < 2 + widthIndex; fy++) {
|
|
loc.set(location.getX() + d1x * fx, location.getY() + fy, location.getZ() + d1z * fx);
|
|
blocks.add(loc.clone());
|
|
}
|
|
}
|
|
return blocks;
|
|
}
|
|
|
|
public boolean isTooFarAway(Player player) {
|
|
if(currentMinecleanerGame != null && currentMinecleanerGame.gameover) return false;
|
|
if(player.getWorld() != location.getWorld()) {
|
|
return true;
|
|
}
|
|
player.getLocation(tempLoc);
|
|
double dist = tempLoc.distanceSquared(centerLocation);
|
|
switch (widthIndex) {
|
|
case 0:
|
|
return dist > 64.0;
|
|
case 1:
|
|
return dist > 96.0;
|
|
case 2:
|
|
return dist > 128.0;
|
|
}
|
|
return dist > 64.0;
|
|
}
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
public boolean hasPlayer() {
|
|
return currentPlayer != null;
|
|
}
|
|
|
|
public Player getCurrentPlayer() {
|
|
return currentPlayer;
|
|
}
|
|
|
|
public Location getLocation() {
|
|
return location;
|
|
}
|
|
|
|
public BlockFace getOrientation() {
|
|
return orientation;
|
|
}
|
|
|
|
public ArenaStatus getArenaStatus() {
|
|
return arenaStatus;
|
|
}
|
|
|
|
public UUID[] getBlockDisplays() {
|
|
return blockDisplays;
|
|
}
|
|
|
|
public int getSize() {
|
|
return BoardSize.boardSizes[widthIndex];
|
|
}
|
|
|
|
public long getCurrentGameStartTime() {
|
|
return currentGameStartTime;
|
|
}
|
|
|
|
public int getWidthIndex() {
|
|
return widthIndex;
|
|
}
|
|
}
|