EpicKnarvik97/PlotSquared
EpicKnarvik97/PlotSquared
1
0
Fork 0
mirror of https://github.com/IntellectualSites/PlotSquared.git synced 2024-11-22 05:06:44 +01:00
Code Issues Projects Releases Wiki Activity

feat: Better deciding of heights to use for generation and schematics (#3300)

Browse Source 
* Better deciding of heights to use for generation and schematics
 - If bedrock is disabled, we should still be filling the space with something
 - Use minBuildHeight instead of hardcoding "1" for schematics (it is still 1 by default) to ensure all-encompassing schematics
 - Schematic generation/handling for roads etc. should be accounting for all of wall, road, and plot heights for deciding point of origin
 - Fixes #3269
 - Starts to address #3175

* Also do for HybridPlotManager clear
This commit is contained in:
Jordan 2021-11-11 17:33:38 +00:00 committed by GitHub
parent 87a2e81ec3
commit 823e78377b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 115 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
Core/src/main/java/com/plotsquared/core/backup/PlayerBackupProfile.java
View File

@ -193,19 +193,28 @@ public class PlayerBackupProfile implements BackupProfile {
future.completeExceptionally(new IllegalArgumentException( future.completeExceptionally(new IllegalArgumentException(
"The backup is non-existent or not in the correct format")); "The backup is non-existent or not in the correct format"));
} else { } else {
this.schematicHandler.paste(schematic, plot, 0, 1, 0, false, player, new RunnableVal<Boolean>() { this.schematicHandler.paste(
@Override schematic,
public void run(Boolean value) { plot,
if (value) { 0,
future.complete(null); plot.getArea().getMinBuildHeight(),
} else { 0,
future.completeExceptionally(new RuntimeException(MINI_MESSAGE.stripTokens( false,
TranslatableCaption player,
.of("schematics.schematic_paste_failed") new RunnableVal<>() {
.getComponent(ConsolePlayer.getConsole())))); @Override
public void run(Boolean value) {
if (value) {
future.complete(null);
} else {
future.completeExceptionally(new RuntimeException(MINI_MESSAGE.stripTokens(
TranslatableCaption
.of("schematics.schematic_paste_failed")
.getComponent(ConsolePlayer.getConsole()))));
}
}
} }
} );
});
} }
}); });
} }

2
Core/src/main/java/com/plotsquared/core/command/Load.java
View File

@ -149,7 +149,7 @@ public class Load extends SubCommand {
0, 0,
false, false,
player, player,
new RunnableVal<Boolean>() { new RunnableVal<>() {
@Override @Override
public void run(Boolean value) { public void run(Boolean value) {
plot.removeRunning(); plot.removeRunning();

2
Core/src/main/java/com/plotsquared/core/command/SchematicCmd.java
View File

@ -166,7 +166,7 @@ public class SchematicCmd extends SubCommand {
0, 0,
false, false,
player, player,
new RunnableVal<Boolean>() { new RunnableVal<>() {
@Override @Override
public void run(Boolean value) { public void run(Boolean value) {
SchematicCmd.this.running = false; SchematicCmd.this.running = false;

48
Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java
View File

@ -506,16 +506,32 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at( Location.at(
classicPlotWorld.getWorldName(), classicPlotWorld.getWorldName(),
sx, sx,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, Math.min(
classicPlotWorld.PLOT_HEIGHT,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT)
) + 1,
sz + 1 sz + 1
), ),
Location.at(classicPlotWorld.getWorldName(), ex, maxY, ez - 1), BlockTypes.AIR.getDefaultState() Location.at(classicPlotWorld.getWorldName(), ex, maxY, ez - 1), BlockTypes.AIR.getDefaultState()
); );
queue.setCuboid( if (classicPlotWorld.PLOT_BEDROCK) {
Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1), queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), ex, 0, ez - 1), Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
BlockUtil.get((short) 7, (byte) 0) Location.at(classicPlotWorld.getWorldName(), ex, 0, ez - 1),
); BlockTypes.BEDROCK.getDefaultState()
);
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
classicPlotWorld.WALL_FILLING.toPattern()
);
} else {
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
classicPlotWorld.WALL_FILLING.toPattern()
);
}
queue.setCuboid( queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1), Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1), Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
@ -568,7 +584,10 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at( Location.at(
classicPlotWorld.getWorldName(), classicPlotWorld.getWorldName(),
sx + 1, sx + 1,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, Math.min(
classicPlotWorld.PLOT_HEIGHT,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT)
) + 1,
sz sz
), ),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getPlotManager().getWorldHeight(), ez), Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
@ -663,7 +682,10 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at( Location.at(
classicPlotWorld.getWorldName(), classicPlotWorld.getWorldName(),
sx, sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, Math.min(
classicPlotWorld.PLOT_HEIGHT,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT)
) + 1,
sz sz
), ),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez), Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
@ -703,7 +725,10 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at( Location.at(
classicPlotWorld.getWorldName(), classicPlotWorld.getWorldName(),
sx, sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, Math.min(
classicPlotWorld.PLOT_HEIGHT,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT)
) + 1,
sz sz
), ),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez), Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
@ -742,7 +767,10 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at( Location.at(
classicPlotWorld.getWorldName(), classicPlotWorld.getWorldName(),
sx, sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, Math.min(
classicPlotWorld.PLOT_HEIGHT,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT)
) + 1,
sz sz
), ),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez), Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),

15
Core/src/main/java/com/plotsquared/core/generator/HybridGen.java
View File

@ -63,7 +63,7 @@ public class HybridGen extends IndependentPlotGenerator {
&& Settings.Schematics.PASTE_ON_TOP)) { && Settings.Schematics.PASTE_ON_TOP)) {
minY = world.SCHEM_Y; minY = world.SCHEM_Y;
} else { } else {
minY = 1; minY = world.getMinBuildHeight();
} }
BaseBlock[] blocks = world.G_SCH.get(MathMan.pair(relativeX, relativeZ)); BaseBlock[] blocks = world.G_SCH.get(MathMan.pair(relativeX, relativeZ));
if (blocks != null) { if (blocks != null) {
@ -156,11 +156,12 @@ public class HybridGen extends IndependentPlotGenerator {
} }
} }
// generation // generation
int startY = hybridPlotWorld.PLOT_BEDROCK ? 1 : 0;
for (short x = 0; x < 16; x++) { for (short x = 0; x < 16; x++) {
if (insideRoadX[x]) { if (insideRoadX[x]) {
for (short z = 0; z < 16; z++) { for (short z = 0; z < 16; z++) {
// Road // Road
for (int y = 1; y <= hybridPlotWorld.ROAD_HEIGHT; y++) { for (int y = startY; y <= hybridPlotWorld.ROAD_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
} }
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) { if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
@ -171,7 +172,7 @@ public class HybridGen extends IndependentPlotGenerator {
for (short z = 0; z < 16; z++) { for (short z = 0; z < 16; z++) {
if (insideRoadZ[z]) { if (insideRoadZ[z]) {
// road // road
for (int y = 1; y <= hybridPlotWorld.ROAD_HEIGHT; y++) { for (int y = startY; y <= hybridPlotWorld.ROAD_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
} }
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) { if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
@ -181,7 +182,7 @@ public class HybridGen extends IndependentPlotGenerator {
} }
} else { } else {
// wall // wall
for (int y = 1; y <= hybridPlotWorld.WALL_HEIGHT; y++) { for (int y = startY; y <= hybridPlotWorld.WALL_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern());
} }
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) { if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
@ -201,7 +202,7 @@ public class HybridGen extends IndependentPlotGenerator {
for (short z = 0; z < 16; z++) { for (short z = 0; z < 16; z++) {
if (insideRoadZ[z]) { if (insideRoadZ[z]) {
// road // road
for (int y = 1; y <= hybridPlotWorld.ROAD_HEIGHT; y++) { for (int y = startY; y <= hybridPlotWorld.ROAD_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
} }
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) { if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
@ -211,7 +212,7 @@ public class HybridGen extends IndependentPlotGenerator {
} }
} else if (insideWallZ[z]) { } else if (insideWallZ[z]) {
// wall // wall
for (int y = 1; y <= hybridPlotWorld.WALL_HEIGHT; y++) { for (int y = startY; y <= hybridPlotWorld.WALL_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern());
} }
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) { if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
@ -227,7 +228,7 @@ public class HybridGen extends IndependentPlotGenerator {
} }
} else { } else {
// plot // plot
for (int y = 1; y < hybridPlotWorld.PLOT_HEIGHT; y++) { for (int y = startY; y < hybridPlotWorld.PLOT_HEIGHT; y++) {
result.setBlock(x, y, z, hybridPlotWorld.MAIN_BLOCK.toPattern()); result.setBlock(x, y, z, hybridPlotWorld.MAIN_BLOCK.toPattern());
} }
result.setBlock(x, hybridPlotWorld.PLOT_HEIGHT, z, result.setBlock(x, hybridPlotWorld.PLOT_HEIGHT, z,

9
Core/src/main/java/com/plotsquared/core/generator/HybridPlotManager.java
View File

@ -154,7 +154,7 @@ public class HybridPlotManager extends ClassicPlotManager {
if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad && Settings.Schematics.PASTE_ON_TOP)) { if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad && Settings.Schematics.PASTE_ON_TOP)) {
minY = hybridPlotWorld.SCHEM_Y; minY = hybridPlotWorld.SCHEM_Y;
} else { } else {
minY = 1; minY = hybridPlotWorld.getMinBuildHeight();
} }
BaseBlock airBlock = BlockTypes.AIR.getDefaultState().toBaseBlock(); BaseBlock airBlock = BlockTypes.AIR.getDefaultState().toBaseBlock();
for (int x = pos1.getX(); x <= pos2.getX(); x++) { for (int x = pos1.getX(); x <= pos2.getX(); x++) {
@ -251,12 +251,11 @@ public class HybridPlotManager extends ClassicPlotManager {
final Pattern plotfloor = hybridPlotWorld.TOP_BLOCK.toPattern(); final Pattern plotfloor = hybridPlotWorld.TOP_BLOCK.toPattern();
final Pattern filling = hybridPlotWorld.MAIN_BLOCK.toPattern(); final Pattern filling = hybridPlotWorld.MAIN_BLOCK.toPattern();
final BlockState bedrock; final Pattern bedrock;
final BlockState air = BlockTypes.AIR.getDefaultState();
if (hybridPlotWorld.PLOT_BEDROCK) { if (hybridPlotWorld.PLOT_BEDROCK) {
bedrock = BlockTypes.BEDROCK.getDefaultState(); bedrock = BlockTypes.BEDROCK.getDefaultState();
} else { } else {
bedrock = air; bedrock = hybridPlotWorld.MAIN_BLOCK.toPattern();
} }
final BiomeType biome = hybridPlotWorld.getPlotBiome(); final BiomeType biome = hybridPlotWorld.getPlotBiome();
@ -276,7 +275,7 @@ public class HybridPlotManager extends ClassicPlotManager {
// Each component has a different layer // Each component has a different layer
queue.setCuboid(pos1.withY(1), pos2.withY(hybridPlotWorld.PLOT_HEIGHT - 1), filling); queue.setCuboid(pos1.withY(1), pos2.withY(hybridPlotWorld.PLOT_HEIGHT - 1), filling);
queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT), pos2.withY(hybridPlotWorld.PLOT_HEIGHT), plotfloor); queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT), pos2.withY(hybridPlotWorld.PLOT_HEIGHT), plotfloor);
queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT + 1), pos2.withY(getWorldHeight()), air); queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT + 1), pos2.withY(getWorldHeight()), BlockTypes.AIR.getDefaultState());
queue.setBiomeCuboid(pos1, pos2, biome); queue.setBiomeCuboid(pos1, pos2, biome);
} else { } else {
queue.setRegenRegion(new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3())); queue.setRegenRegion(new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()));

34
Core/src/main/java/com/plotsquared/core/generator/HybridPlotWorld.java
View File

@ -253,22 +253,32 @@ public class HybridPlotWorld extends ClassicPlotWorld {
int shift = this.ROAD_WIDTH / 2; int shift = this.ROAD_WIDTH / 2;
int oddshift = (this.ROAD_WIDTH & 1) == 0 ? 0 : 1; int oddshift = (this.ROAD_WIDTH & 1) == 0 ? 0 : 1;
SCHEM_Y = Math.min(PLOT_HEIGHT, ROAD_HEIGHT); SCHEM_Y = Math.min(PLOT_HEIGHT, Math.min(WALL_HEIGHT, ROAD_HEIGHT));
int plotY = PLOT_HEIGHT - SCHEM_Y; int plotY = PLOT_HEIGHT - SCHEM_Y;
int roadY = ROAD_HEIGHT - SCHEM_Y; int roadY = Math.min(ROAD_HEIGHT, WALL_HEIGHT) - SCHEM_Y;
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() == 256) { if (schematic3 != null) {
SCHEM_Y = 0; if (schematic3.getClipboard().getDimensions().getY() == 256) {
plotY = 0; SCHEM_Y = plotY = 0;
roadY = ROAD_HEIGHT; } else if (!Settings.Schematics.PASTE_ON_TOP) {
SCHEM_Y = plotY = getMinBuildHeight();
}
} }
if (schematic1 != null && schematic1.getClipboard().getDimensions().getY() == 256) { if (schematic1 != null) {
SCHEM_Y = 0; if (schematic1.getClipboard().getDimensions().getY() == 256) {
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256) { SCHEM_Y = roadY = 0;
plotY = PLOT_HEIGHT; if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256
&& !Settings.Schematics.PASTE_ON_TOP) {
plotY = PLOT_HEIGHT;
}
} else if (!Settings.Schematics.PASTE_ROAD_ON_TOP) {
SCHEM_Y = roadY = getMinBuildHeight();
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256
&& !Settings.Schematics.PASTE_ON_TOP) {
plotY = PLOT_HEIGHT;
}
} }
roadY = 0;
} }
if (schematic3 != null) { if (schematic3 != null) {
@ -324,7 +334,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
LOGGER.info("- plot schematic: {}", schematic3File.getPath()); LOGGER.info("- plot schematic: {}", schematic3File.getPath());
} }
} }
if (schematic1 == null || schematic2 == null || this.ROAD_WIDTH == 0) { if ((schematic1 == null&& schematic2 == null) || this.ROAD_WIDTH == 0) {
if (Settings.DEBUG) { if (Settings.DEBUG) {
LOGGER.info("- schematic: false"); LOGGER.info("- schematic: false");
} }

3
Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java
View File

@ -504,9 +504,10 @@ public class HybridUtils {
Location top = plot.getTopAbs(); Location top = plot.getTopAbs();
final HybridPlotWorld plotworld = (HybridPlotWorld) plot.getArea(); final HybridPlotWorld plotworld = (HybridPlotWorld) plot.getArea();
PlotManager plotManager = plotworld.getPlotManager(); PlotManager plotManager = plotworld.getPlotManager();
int schemY = Math.min(plotworld.PLOT_HEIGHT, Math.min(plotworld.WALL_HEIGHT, plotworld.ROAD_HEIGHT));
int sx = bot.getX() - plotworld.ROAD_WIDTH + 1; int sx = bot.getX() - plotworld.ROAD_WIDTH + 1;
int sz = bot.getZ() + 1; int sz = bot.getZ() + 1;
int sy = Settings.Schematics.PASTE_ROAD_ON_TOP ? plotworld.ROAD_HEIGHT : 1; int sy = Settings.Schematics.PASTE_ROAD_ON_TOP ? schemY : plot.getArea().getMinBuildHeight();
int ex = bot.getX(); int ex = bot.getX();
int ez = top.getZ(); int ez = top.getZ();
int ey = get_ey(plotManager, queue, sx, ex, sz, ez, sy); int ey = get_ey(plotManager, queue, sx, ex, sz, ez, sy);

27
Core/src/main/java/com/plotsquared/core/plot/Plot.java
View File

@ -1733,16 +1733,25 @@ public class Plot {
e.printStackTrace(); e.printStackTrace();
return true; return true;
} }
schematicHandler.paste(sch, this, 0, 1, 0, Settings.Schematics.PASTE_ON_TOP, player, new RunnableVal<>() { schematicHandler.paste(
@Override sch,
public void run(Boolean value) { this,
if (value) { 0,
player.sendMessage(TranslatableCaption.of("schematics.schematic_paste_success")); getArea().getMinBuildHeight(),
} else { 0,
player.sendMessage(TranslatableCaption.of("schematics.schematic_paste_failed")); Settings.Schematics.PASTE_ON_TOP,
player,
new RunnableVal<>() {
@Override
public void run(Boolean value) {
if (value) {
player.sendMessage(TranslatableCaption.of("schematics.schematic_paste_success"));
} else {
player.sendMessage(TranslatableCaption.of("schematics.schematic_paste_failed"));
}
}
} }
} );
});
} }
plotworld.getPlotManager().claimPlot(this, null); plotworld.getPlotManager().claimPlot(this, null);
return true; return true;