forked from SteamWar/SteamWar
324 lines
13 KiB
Java
324 lines
13 KiB
Java
/*
|
|
* This file is a part of the SteamWar software.
|
|
*
|
|
* Copyright (C) 2026 SteamWar.de-Serverteam
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package de.steamwar.bausystem.region;
|
|
|
|
import de.steamwar.bausystem.BauSystem;
|
|
import de.steamwar.bausystem.region.dynamic.DynamicRegion;
|
|
import de.steamwar.bausystem.region.dynamic.DynamicRegionRepository;
|
|
import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
|
|
import de.steamwar.bausystem.region.dynamic.Tile;
|
|
import de.steamwar.bausystem.utils.PasteBuilder;
|
|
import de.steamwar.core.SWPlayer;
|
|
import de.steamwar.entity.*;
|
|
import de.steamwar.inventory.SWInventory;
|
|
import de.steamwar.inventory.SWItem;
|
|
import de.steamwar.inventory.SWListInv;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.Listener;
|
|
import org.bukkit.event.player.PlayerMoveEvent;
|
|
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
public class DynamicRegionVisualizer implements SWPlayer.Component, Listener {
|
|
|
|
private final REntityServer entityServer;
|
|
private Player player;
|
|
private Location sourceLocation;
|
|
private Tile sourceTile;
|
|
|
|
private Placement placement = null;
|
|
|
|
public DynamicRegionVisualizer() {
|
|
this.entityServer = new REntityServer();
|
|
}
|
|
|
|
@Override
|
|
public void onMount(SWPlayer player) {
|
|
this.player = player.getPlayer();
|
|
sourceTile = Tile.fromLocation(player.getLocation()).orElse(null);
|
|
if (sourceTile == null) {
|
|
player.removeComponent(DynamicRegionVisualizer.class);
|
|
return;
|
|
}
|
|
sourceLocation = player.getLocation().add(0, -5, 0).getBlock().getLocation();
|
|
entityServer.addPlayer(player.getPlayer());
|
|
|
|
Bukkit.getPluginManager().registerEvents(this, BauSystem.getInstance());
|
|
|
|
renderTiles(0, 0);
|
|
}
|
|
|
|
@Override
|
|
public void onUnmount(SWPlayer player) {
|
|
Bukkit.getPluginManager().registerEvents(this, BauSystem.getInstance());
|
|
entityServer.close();
|
|
}
|
|
|
|
@EventHandler
|
|
public void onPlayerMove(PlayerMoveEvent event) {
|
|
if (event.getPlayer() != player) return;
|
|
Location position = event.getTo().getBlock().getLocation();
|
|
int dx = position.getBlockX() - sourceLocation.getBlockX();
|
|
int dz = position.getBlockZ() - sourceLocation.getBlockZ();
|
|
renderTiles(dx, dz);
|
|
}
|
|
|
|
private void renderTiles(int dx, int dz) {
|
|
Set<Tile> tileSet = entityServer.getEntitiesByType(CTile.class)
|
|
.stream()
|
|
.filter(cTile -> {
|
|
if (Math.abs(cTile.tile.getTileX() - dx) > 20 || Math.abs(cTile.tile.getTileZ() - dz) > 20) {
|
|
cTile.die();
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
})
|
|
.map(cTile -> cTile.tile)
|
|
.collect(Collectors.toSet());
|
|
|
|
for (int x = dx - 10; x <= dx + 10; x++) {
|
|
for (int z = dz - 10; z <= dz + 10; z++) {
|
|
Tile tile = sourceTile.add(x, z).orElse(null);
|
|
if (tile == null || tileSet.contains(tile)) continue;
|
|
new CTile(entityServer, tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resetTiles(Set<Tile> tiles) {
|
|
entityServer.getEntitiesByType(CTile.class)
|
|
.stream()
|
|
.filter(cTile -> tiles.contains(cTile.tile))
|
|
.peek(CTile::die)
|
|
.map(cTile -> cTile.tile)
|
|
.forEach(tile -> {
|
|
new CTile(entityServer, tile);
|
|
});
|
|
|
|
if (placement != null) {
|
|
placement.check();
|
|
}
|
|
}
|
|
|
|
private class CTile extends CEntity {
|
|
|
|
private final Tile tile;
|
|
|
|
public CTile(REntityServer server, Tile tile) {
|
|
super(server);
|
|
this.tile = tile;
|
|
|
|
RegionType regionType = DynamicRegionSystem.INSTANCE.get(tile).getType();
|
|
Material material = switch (regionType) {
|
|
case SPAWN, SPAWN_EXTENSION -> Material.LODESTONE;
|
|
case SPAWN_PATH, PATH -> Material.DIRT_PATH;
|
|
case DRY, DRY_SPECIAL -> Material.IRON_BLOCK;
|
|
case WET, WET_SPECIAL -> Material.LAPIS_BLOCK;
|
|
default -> Material.WHITE_CARPET;
|
|
};
|
|
Location location = sourceLocation.clone().add(tile.getTileX() - sourceTile.getTileX(), 0, tile.getTileZ() - sourceTile.getTileZ());
|
|
if (tile.equals(Tile.ZERO)) {
|
|
CCubedTextDisplay spawn = new CCubedTextDisplay(entityServer, location);
|
|
spawn.setText("§eSPAWN");
|
|
spawn.setBackgroundColor(0);
|
|
spawn.setShadowed(false);
|
|
entities.add(spawn);
|
|
} else if (tile.equals(sourceTile)) {
|
|
CCubedTextDisplay origin = new CCubedTextDisplay(entityServer, location);
|
|
origin.setText("§eORIGIN");
|
|
origin.setBackgroundColor(0);
|
|
origin.setShadowed(false);
|
|
entities.add(origin);
|
|
}
|
|
|
|
RBlockDisplay blockDisplay = new RBlockDisplay(entityServer, location);
|
|
blockDisplay.setBlock(material.createBlockData());
|
|
entities.add(blockDisplay);
|
|
|
|
RInteraction interaction = new RInteraction(entityServer, location.clone().add(0.5, 0, 0.5));
|
|
interaction.setInteraction((player, entityAction) -> {
|
|
if (placement != null) {
|
|
placement.click(tile, regionType.isGlobal());
|
|
return;
|
|
}
|
|
|
|
if (!regionType.isGlobal()) {
|
|
SWInventory inv = new SWInventory(player, 9, "Delete Region: " + tile.display());
|
|
inv.setItem(0, new SWItem(SWItem.getDye(10), "§8Cancel", click -> {
|
|
player.closeInventory();
|
|
}));
|
|
inv.setItem(8, new SWItem(SWItem.getDye(1), "§cDelete", click -> {
|
|
player.closeInventory();
|
|
Region region = DynamicRegionSystem.INSTANCE.get(tile);
|
|
Set<Tile> tiles = DynamicRegionSystem.INSTANCE.getTilesOfRegion(region);
|
|
region.delete();
|
|
|
|
SWPlayer.allWithSingleComponent(DynamicRegionVisualizer.class)
|
|
.forEach(pair -> {
|
|
pair.getComponent().resetTiles(tiles);
|
|
});
|
|
}));
|
|
inv.open();
|
|
} else {
|
|
List<SWListInv.SWListEntry<Map.Entry<Class<? extends DynamicRegion>, RegionConstructorData>>> entries = new ArrayList<>();
|
|
DynamicRegionSystem.constructorDataMap.entrySet()
|
|
.stream()
|
|
.filter(entry -> entry.getValue().placeable())
|
|
.sorted(Comparator.comparing(entry -> entry.getValue().name()))
|
|
.forEach(entry -> {
|
|
entries.add(new SWListInv.SWListEntry<>(new SWItem(entry.getValue().material(), entry.getValue().name()), entry));
|
|
});
|
|
|
|
SWListInv<Map.Entry<Class<? extends DynamicRegion>, RegionConstructorData>> listInv = new SWListInv<>(player, "Select Region for: " + tile.display(), entries, (click, entry) -> {
|
|
new Placement(entry.getKey(), entry.getValue(), tile);
|
|
player.closeInventory();
|
|
});
|
|
listInv.open();
|
|
}
|
|
});
|
|
entities.add(interaction);
|
|
}
|
|
}
|
|
|
|
private class Placement {
|
|
private final Class<? extends DynamicRegion> regionType;
|
|
private final RegionConstructorData constructorData;
|
|
|
|
private CWireframe wireframe;
|
|
private Tile sourceTile;
|
|
private int dx;
|
|
private int dz;
|
|
private boolean valid = false;
|
|
|
|
private Location getMinLocation() {
|
|
Tile tile = sourceTile.add(-DynamicRegionVisualizer.this.sourceTile.getTileX(), -DynamicRegionVisualizer.this.sourceTile.getTileZ()).orElseThrow();
|
|
return sourceLocation.clone().add(tile.getTileX(), 0, tile.getTileZ());
|
|
}
|
|
|
|
private Location getMaxLocation() {
|
|
Tile tile = sourceTile.add(-DynamicRegionVisualizer.this.sourceTile.getTileX(), -DynamicRegionVisualizer.this.sourceTile.getTileZ()).orElseThrow();
|
|
return sourceLocation.clone().add(tile.getTileX(), 0, tile.getTileZ()).add(dx, 0, dz);
|
|
}
|
|
|
|
public Placement(Class<? extends DynamicRegion> regionType, RegionConstructorData constructorData, Tile sourceTile) {
|
|
this.regionType = regionType;
|
|
this.constructorData = constructorData;
|
|
this.sourceTile = sourceTile;
|
|
dx = constructorData.widthX() / Tile.tileSize - 1;
|
|
dz = constructorData.widthZ() / Tile.tileSize - 1;
|
|
if (dx == 0 && dz == 0) {
|
|
place();
|
|
return;
|
|
}
|
|
|
|
placement = this;
|
|
wireframe = new CWireframe(entityServer);
|
|
check();
|
|
}
|
|
|
|
private void check() {
|
|
wireframe.setPos1And2(getMinLocation(), getMaxLocation());
|
|
for (int x = 0; x <= dx; x++) {
|
|
for (int z = 0; z <= dz; z++) {
|
|
if (!DynamicRegionSystem.INSTANCE.get(sourceTile.add(x, z).orElseThrow()).getType().isGlobal()) {
|
|
wireframe.setBlock(Material.RED_CONCRETE.createBlockData());
|
|
valid = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
wireframe.setBlock(Material.LIME_CONCRETE.createBlockData());
|
|
valid = true;
|
|
}
|
|
|
|
public void click(Tile tile, boolean global) {
|
|
if (tile.getTileX() >= sourceTile.getTileX() && tile.getTileX() <= sourceTile.getTileX() + dx && tile.getTileZ() >= sourceTile.getTileZ() && tile.getTileZ() <= sourceTile.getTileZ() + dz) {
|
|
SWInventory inv = new SWInventory(player, 9, "Place Region: " + constructorData.name());
|
|
inv.setItem(0, new SWItem(SWItem.getDye(1), "§cDeselect", click -> {
|
|
placement = null;
|
|
wireframe.die();
|
|
player.closeInventory();
|
|
}));
|
|
if (valid) {
|
|
inv.setItem(8, new SWItem(SWItem.getDye(10), "§aPlace", click -> {
|
|
player.closeInventory();
|
|
place();
|
|
}));
|
|
} else {
|
|
inv.setItem(8, new SWItem(SWItem.getDye(8), "§8Place", click -> {
|
|
}));
|
|
}
|
|
inv.open();
|
|
return;
|
|
}
|
|
|
|
if (!global) {
|
|
return;
|
|
}
|
|
|
|
Set<Tile> tiles = new HashSet<>();
|
|
for (int x = 0; x <= dx; x++) {
|
|
for (int z = 0; z <= dz; z++) {
|
|
tiles.add(Tile.fromTile(x + sourceTile.getTileX(), z + sourceTile.getTileZ()).orElseThrow());
|
|
}
|
|
}
|
|
Tile selected = tiles.stream().min(Comparator.comparing(current -> {
|
|
int dx = current.getTileX() - tile.getTileX();
|
|
int dz = current.getTileZ() - tile.getTileZ();
|
|
return dx * dx + dz * dz;
|
|
}))
|
|
.orElseThrow();
|
|
|
|
int dx = tile.getTileX() - selected.getTileX();
|
|
int dz = tile.getTileZ() - selected.getTileZ();
|
|
sourceTile = sourceTile.add(dx, dz).orElseThrow();
|
|
check();
|
|
}
|
|
|
|
private void place() {
|
|
DynamicRegion dynamicRegion = DynamicRegionRepository.constructRegion(regionType, UUID.randomUUID(), sourceTile.getMinX(), sourceTile.getMinZ());
|
|
if (dynamicRegion == null) {
|
|
// TODO: Give error to user
|
|
return;
|
|
}
|
|
|
|
dynamicRegion.getArea().place(new PasteBuilder(new PasteBuilder.FileProvider(dynamicRegion.getArea().getResetFile())), false);
|
|
dynamicRegion.updateNeighbours();
|
|
|
|
placement = null;
|
|
if (wireframe != null) wireframe.die();
|
|
Set<Tile> tiles = new HashSet<>();
|
|
for (int x = 0; x <= dx; x++) {
|
|
for (int z = 0; z <= dz; z++) {
|
|
tiles.add(Tile.fromTile(x + sourceTile.getTileX(), z + sourceTile.getTileZ()).orElseThrow());
|
|
}
|
|
}
|
|
SWPlayer.allWithSingleComponent(DynamicRegionVisualizer.class)
|
|
.forEach(pair -> pair.getComponent().resetTiles(tiles));
|
|
}
|
|
}
|
|
}
|