mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-08-24 23:05:36 +02:00
Compare commits
3 Commits
fix/genera
...
fix/v7/bac
| Author | SHA1 | Date | |
|---|---|---|---|
|
5f53ace8ea | ||
|
|
38904712e5 | ||
|
|
4d8d5b3a9f |
@@ -90,7 +90,12 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
|
||||
this.plotGenerator = generator;
|
||||
this.platformGenerator = this;
|
||||
this.populators = new ArrayList<>();
|
||||
this.populators.add(new BlockStatePopulator(this.plotGenerator));
|
||||
int minecraftMinorVersion = PlotSquared.platform().serverVersion()[1];
|
||||
if (minecraftMinorVersion >= 17) {
|
||||
this.populators.add(new BlockStatePopulator(this.plotGenerator));
|
||||
} else {
|
||||
this.populators.add(new LegacyBlockStatePopulator(this.plotGenerator));
|
||||
}
|
||||
this.full = true;
|
||||
this.useNewGenerationMethods = PlotSquared.platform().serverVersion()[1] >= 19;
|
||||
this.biomeProvider = new BukkitPlotBiomeProvider();
|
||||
|
||||
@@ -36,7 +36,6 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
@Deprecated(since = "TODO")
|
||||
final class LegacyBlockStatePopulator extends BlockPopulator {
|
||||
|
||||
private final IndependentPlotGenerator plotGenerator;
|
||||
|
||||
@@ -47,6 +47,7 @@ import org.bukkit.event.entity.LingeringPotionSplashEvent;
|
||||
import org.bukkit.event.entity.PotionSplashEvent;
|
||||
import org.bukkit.event.entity.ProjectileHitEvent;
|
||||
import org.bukkit.event.entity.ProjectileLaunchEvent;
|
||||
import org.bukkit.event.player.PlayerEggThrowEvent;
|
||||
import org.bukkit.projectiles.BlockProjectileSource;
|
||||
import org.bukkit.projectiles.ProjectileSource;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
@@ -157,14 +158,26 @@ public class ProjectileEventListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onProjectileHit(ProjectileHitEvent event) {
|
||||
Projectile entity = event.getEntity();
|
||||
if (cancelProjectileHit(event.getEntity())) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerEggThrow(PlayerEggThrowEvent event) {
|
||||
if (cancelProjectileHit(event.getEgg())) {
|
||||
event.setHatching(false);
|
||||
}
|
||||
}
|
||||
|
||||
private boolean cancelProjectileHit(Projectile entity) {
|
||||
Location location = BukkitUtil.adapt(entity.getLocation());
|
||||
if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
PlotArea area = location.getPlotArea();
|
||||
if (area == null) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
Plot plot = area.getPlot(location);
|
||||
ProjectileSource shooter = entity.getShooter();
|
||||
@@ -172,15 +185,14 @@ public class ProjectileEventListener implements Listener {
|
||||
if (!((Player) shooter).isOnline()) {
|
||||
if (plot != null) {
|
||||
if (plot.isAdded(((Player) shooter).getUniqueId()) || plot.getFlag(ProjectilesFlag.class)) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
} else if (PlotFlagUtil.isAreaRoadFlagsAndFlagEquals(area, ProjectilesFlag.class, true)) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
|
||||
PlotPlayer<?> pp = BukkitUtil.adapt((Player) shooter);
|
||||
@@ -189,38 +201,36 @@ public class ProjectileEventListener implements Listener {
|
||||
Permission.PERMISSION_ADMIN_PROJECTILE_UNOWNED
|
||||
)) {
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return true;
|
||||
}
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
if (plot.isAdded(pp.getUUID()) || pp.hasPermission(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER) || plot.getFlag(
|
||||
ProjectilesFlag.class) || (entity instanceof FishHook && plot.getFlag(
|
||||
FishingFlag.class))) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (!(shooter instanceof Entity) && shooter != null) {
|
||||
if (plot == null) {
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
Location sLoc =
|
||||
BukkitUtil.adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
|
||||
if (!area.contains(sLoc.getX(), sLoc.getZ())) {
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
Plot sPlot = area.getOwnedPlotAbs(sLoc);
|
||||
if (sPlot == null || !PlotHandler.sameOwners(plot, sPlot)) {
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -21,7 +21,6 @@ package com.plotsquared.bukkit.schematic;
|
||||
import com.destroystokyo.paper.profile.PlayerProfile;
|
||||
import com.destroystokyo.paper.profile.ProfileProperty;
|
||||
import com.plotsquared.bukkit.util.BukkitUtil;
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.sk89q.jnbt.ByteTag;
|
||||
import com.sk89q.jnbt.CompoundTag;
|
||||
import com.sk89q.jnbt.ListTag;
|
||||
@@ -37,8 +36,6 @@ import org.apache.logging.log4j.Logger;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.DyeColor;
|
||||
import org.bukkit.NamespacedKey;
|
||||
import org.bukkit.Registry;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.block.Banner;
|
||||
import org.bukkit.block.Block;
|
||||
@@ -47,36 +44,26 @@ import org.bukkit.block.Sign;
|
||||
import org.bukkit.block.Skull;
|
||||
import org.bukkit.block.banner.Pattern;
|
||||
import org.bukkit.block.banner.PatternType;
|
||||
import org.bukkit.block.sign.Side;
|
||||
import org.bukkit.block.sign.SignSide;
|
||||
import org.bukkit.enchantments.Enchantment;
|
||||
import org.bukkit.inventory.Inventory;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.jetbrains.annotations.ApiStatus;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.Objects;
|
||||
import java.util.UUID;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
// TODO: somehow unbreak this class so it doesn't fuck up the whole schematic population system due to MC updates
|
||||
@ApiStatus.Internal
|
||||
public class StateWrapper {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + StateWrapper.class.getSimpleName());
|
||||
private static final boolean MODERN_SIGNS = PlotSquared.platform().serverVersion()[1] > 19;
|
||||
private final Registry<PatternType> PATTERN_TYPE_REGISTRY = Objects.requireNonNull(Bukkit.getRegistry(PatternType.class));
|
||||
|
||||
private static boolean paperErrorTextureSent = false;
|
||||
|
||||
public CompoundTag tag;
|
||||
|
||||
private boolean paperErrorTextureSent = false;
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + StateWrapper.class.getSimpleName());
|
||||
|
||||
public StateWrapper(CompoundTag tag) {
|
||||
this.tag = tag;
|
||||
}
|
||||
@@ -225,9 +212,9 @@ public class StateWrapper {
|
||||
if (type == null) {
|
||||
continue;
|
||||
}
|
||||
int count = itemComp.containsKey("count") ? itemComp.getInt("count") : itemComp.getByte("Count");
|
||||
int count = itemComp.getByte("Count");
|
||||
int slot = itemComp.getByte("Slot");
|
||||
CompoundTag tag = (CompoundTag) itemComp.getValue().get(itemComp.containsKey("tag") ? "tag" : "components");
|
||||
CompoundTag tag = (CompoundTag) itemComp.getValue().get("tag");
|
||||
BaseItemStack baseItemStack = new BaseItemStack(type, tag, count);
|
||||
ItemStack itemStack = BukkitAdapter.adapt(baseItemStack);
|
||||
inv.setItem(slot, itemStack);
|
||||
@@ -236,62 +223,82 @@ public class StateWrapper {
|
||||
return true;
|
||||
}
|
||||
case "sign" -> {
|
||||
if (state instanceof Sign sign && this.restoreSign(sign)) {
|
||||
state.update(true, false);
|
||||
if (state instanceof Sign sign) {
|
||||
sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
|
||||
sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
|
||||
sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
|
||||
sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
|
||||
state.update(true);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
case "skull" -> {
|
||||
if (state instanceof Skull skull && this.restoreSkull(skull)) {
|
||||
skull.update(true, false);
|
||||
if (state instanceof Skull skull) {
|
||||
CompoundTag skullOwner = ((CompoundTag) this.tag.getValue().get("SkullOwner"));
|
||||
if (skullOwner == null) {
|
||||
return true;
|
||||
}
|
||||
String player = skullOwner.getString("Name");
|
||||
|
||||
if (player != null && !player.isEmpty()) {
|
||||
try {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(player));
|
||||
skull.update(true);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
final CompoundTag properties = (CompoundTag) skullOwner.getValue().get("Properties");
|
||||
if (properties == null) {
|
||||
return false;
|
||||
}
|
||||
final ListTag textures = properties.getListTag("textures");
|
||||
if (textures.getValue().isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
final CompoundTag textureCompound = (CompoundTag) textures.getValue().get(0);
|
||||
if (textureCompound == null) {
|
||||
return false;
|
||||
}
|
||||
String textureValue = textureCompound.getString("Value");
|
||||
if (textureValue == null) {
|
||||
return false;
|
||||
}
|
||||
if (!PaperLib.isPaper()) {
|
||||
if (!paperErrorTextureSent) {
|
||||
paperErrorTextureSent = true;
|
||||
LOGGER.error("Failed to populate skull data in your road schematic - This is a Spigot limitation.");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
|
||||
profile.setProperty(new ProfileProperty("textures", textureValue));
|
||||
skull.setPlayerProfile(profile);
|
||||
skull.update(true);
|
||||
return true;
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
case "banner" -> {
|
||||
if (state instanceof Banner banner) {
|
||||
List<CompoundTag> patterns;
|
||||
// "old" format
|
||||
if ((patterns = this.tag.getList("Patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
|
||||
banner.setPatterns(patterns.stream().map(compoundTag -> {
|
||||
DyeColor color = DyeColor.getByWoolData((byte) compoundTag.getInt("Color"));
|
||||
final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
|
||||
NamespacedKey.fromString(compoundTag.getString("Pattern"))
|
||||
));
|
||||
if (color == null || patternType == null) {
|
||||
return null;
|
||||
}
|
||||
return new Pattern(color, patternType);
|
||||
}).filter(Objects::nonNull).toList());
|
||||
banner.update(true, false);
|
||||
return true;
|
||||
List<Tag> patterns = this.tag.getListTag("Patterns").getValue();
|
||||
if (patterns == null || patterns.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// "new" format - since 1.21.3-ish
|
||||
if ((patterns = this.tag.getList("patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
|
||||
for (final CompoundTag patternTag : patterns) {
|
||||
final String color = patternTag.getString("color");
|
||||
if (color.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
final Tag pattern = patternTag.getValue().get("pattern");
|
||||
if (pattern instanceof StringTag patternString && !patternString.getValue().isEmpty()) {
|
||||
final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
|
||||
NamespacedKey.fromString(patternString.getValue())
|
||||
));
|
||||
if (patternType == null) {
|
||||
continue;
|
||||
}
|
||||
banner.addPattern(new Pattern(
|
||||
DyeColor.legacyValueOf(color.toUpperCase(Locale.ROOT)),
|
||||
patternType
|
||||
));
|
||||
}
|
||||
// not supporting banner pattern definitions (no API available)
|
||||
banner.setPatterns(patterns.stream().map(t -> (CompoundTag) t).map(compoundTag -> {
|
||||
DyeColor color = DyeColor.getByWoolData((byte) compoundTag.getInt("Color"));
|
||||
PatternType patternType = PatternType.getByIdentifier(compoundTag.getString("Pattern"));
|
||||
if (color == null || patternType == null) {
|
||||
return null;
|
||||
}
|
||||
banner.update(true, false);
|
||||
}
|
||||
return new Pattern(color, patternType);
|
||||
}).filter(Objects::nonNull).toList());
|
||||
banner.update(true);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -339,150 +346,4 @@ public class StateWrapper {
|
||||
return data;
|
||||
}
|
||||
|
||||
private boolean restoreSkull(Skull skull) {
|
||||
boolean updated = false;
|
||||
// can't support custom_name - Spigot does not provide any API for that
|
||||
if (this.tag.containsKey("note_block_sound")) {
|
||||
skull.setNoteBlockSound(NamespacedKey.fromString(this.tag.getString("note_block_sound")));
|
||||
updated = true;
|
||||
}
|
||||
// modern format - MC 1.21.3-ish
|
||||
if (this.tag.containsKey("profile")) {
|
||||
final Tag profile = this.tag.getValue().get("profile");
|
||||
if (profile instanceof StringTag stringTag) {
|
||||
final String name = stringTag.getValue();
|
||||
if (name != null && !name.isEmpty()) {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
|
||||
return true;
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
if (profile instanceof CompoundTag compoundTag) {
|
||||
final List<Tag> properties = compoundTag.getList("properties");
|
||||
if (properties != null && !properties.isEmpty()) {
|
||||
if (!PaperLib.isPaper()) {
|
||||
if (!paperErrorTextureSent) {
|
||||
paperErrorTextureSent = true;
|
||||
LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
for (final Tag propertyTag : properties) {
|
||||
if (!(propertyTag instanceof CompoundTag property)) {
|
||||
continue;
|
||||
}
|
||||
if (!property.getString("name").equals("textures")) {
|
||||
continue;
|
||||
}
|
||||
final String value = property.getString("value");
|
||||
final String signature = property.containsKey("signature") ? property.getString("signature") : null;
|
||||
final PlayerProfile playerProfile = Bukkit.createProfile(UUID.randomUUID());
|
||||
playerProfile.setProperty(new ProfileProperty("textures", value, signature));
|
||||
skull.setPlayerProfile(playerProfile);
|
||||
return true;
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
final int[] id = compoundTag.getIntArray("id");
|
||||
if (id != null && id.length == 4) {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(new UUID(
|
||||
(long) id[0] << 32 | (id[1] & 0xFFFFFFFFL),
|
||||
(long) id[2] << 32 | (id[3] & 0xFFFFFFFFL)
|
||||
)));
|
||||
return true;
|
||||
}
|
||||
final String name = compoundTag.getString("name");
|
||||
if (name != null && !name.isEmpty()) {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// "Old" MC format (idk when it got updated)
|
||||
if (this.tag.getValue().get("SkullOwner") instanceof CompoundTag skullOwner) {
|
||||
if (skullOwner.getValue().get("Name") instanceof StringTag ownerName && !ownerName.getValue().isEmpty()) {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(ownerName.getValue()));
|
||||
skull.update(true);
|
||||
return true;
|
||||
}
|
||||
if (skullOwner.getValue().get("Properties") instanceof CompoundTag properties) {
|
||||
if (!paperErrorTextureSent) {
|
||||
paperErrorTextureSent = true;
|
||||
LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
|
||||
return updated;
|
||||
}
|
||||
final List<CompoundTag> textures = properties.getList("textures", CompoundTag.class);
|
||||
if (textures.isEmpty()) {
|
||||
return updated;
|
||||
}
|
||||
final String value = textures.get(0).getString("Value");
|
||||
if (!value.isEmpty()) {
|
||||
final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
|
||||
profile.setProperty(new ProfileProperty("textures", value));
|
||||
skull.setPlayerProfile(profile);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
|
||||
private boolean restoreSign(Sign sign) {
|
||||
// "old" format (pre 1.20)
|
||||
if (this.tag.containsKey("Text1") || this.tag.containsKey("Text2")
|
||||
|| this.tag.containsKey("Text3") || this.tag.containsKey("Text4")) {
|
||||
if (!MODERN_SIGNS) {
|
||||
sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
|
||||
sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
|
||||
sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
|
||||
sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
|
||||
sign.setGlowingText(tag.getByte("GlowingText") == 1);
|
||||
if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
|
||||
sign.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
SignSide front = sign.getSide(Side.FRONT);
|
||||
front.setLine(0, jsonToColourCode(tag.getString("Text1")));
|
||||
front.setLine(1, jsonToColourCode(tag.getString("Text2")));
|
||||
front.setLine(2, jsonToColourCode(tag.getString("Text3")));
|
||||
front.setLine(3, jsonToColourCode(tag.getString("Text4")));
|
||||
front.setGlowingText(tag.getByte("GlowingText") == 1);
|
||||
if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
|
||||
front.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// "modern" format
|
||||
if (this.tag.containsKey("front_text") || this.tag.containsKey("back_text") || this.tag.containsKey("is_waxed")) {
|
||||
// the new format on older servers shouldn't be possible, I hope?
|
||||
sign.setWaxed(this.tag.getByte("is_waxed") == 1);
|
||||
BiConsumer<SignSide, CompoundTag> sideSetter = (signSide, compoundTag) -> {
|
||||
signSide.setGlowingText(compoundTag.getByte("has_glowing_text") == 1);
|
||||
if (tag.getValue().get("color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
|
||||
signSide.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
|
||||
}
|
||||
final List<Tag> lines = compoundTag.getList("messages");
|
||||
for (int i = 0; i < Math.min(lines.size(), 4); i++) {
|
||||
final Tag line = lines.get(i);
|
||||
if (line instanceof StringTag stringLine) {
|
||||
signSide.setLine(i, jsonToColourCode(stringLine.getValue()));
|
||||
continue;
|
||||
}
|
||||
// TODO: how tf support list of components + components - utilize paper + adventure?
|
||||
}
|
||||
};
|
||||
if (this.tag.getValue().get("front_text") instanceof CompoundTag frontText) {
|
||||
sideSetter.accept(sign.getSide(Side.FRONT), frontText);
|
||||
}
|
||||
if (this.tag.getValue().get("back_text") instanceof CompoundTag backText) {
|
||||
sideSetter.accept(sign.getSide(Side.BACK), backText);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -18,6 +18,8 @@
|
||||
*/
|
||||
package com.plotsquared.core.backup;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
import java.io.IOException;
|
||||
@@ -30,12 +32,14 @@ import java.nio.file.Path;
|
||||
*/
|
||||
public class Backup {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + Backup.class.getSimpleName());
|
||||
|
||||
private final BackupProfile owner;
|
||||
private final long creationTime;
|
||||
@Nullable
|
||||
private final Path file;
|
||||
|
||||
Backup(final BackupProfile owner, final long creationTime, final Path file) {
|
||||
Backup(final BackupProfile owner, final long creationTime, @Nullable final Path file) {
|
||||
this.owner = owner;
|
||||
this.creationTime = creationTime;
|
||||
this.file = file;
|
||||
@@ -49,7 +53,7 @@ public class Backup {
|
||||
try {
|
||||
Files.deleteIfExists(file);
|
||||
} catch (final IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error deleting back at {}", file, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,14 +21,15 @@ package com.plotsquared.core.backup;
|
||||
import com.google.inject.Inject;
|
||||
import com.google.inject.assistedinject.Assisted;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.player.ConsolePlayer;
|
||||
import com.plotsquared.core.exception.PlotSquaredException;
|
||||
import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
import com.plotsquared.core.plot.schematic.Schematic;
|
||||
import com.plotsquared.core.util.SchematicHandler;
|
||||
import com.plotsquared.core.util.task.RunnableVal;
|
||||
import com.plotsquared.core.util.task.TaskManager;
|
||||
import net.kyori.adventure.text.minimessage.MiniMessage;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
@@ -51,7 +52,7 @@ import java.util.concurrent.CompletableFuture;
|
||||
*/
|
||||
public class PlayerBackupProfile implements BackupProfile {
|
||||
|
||||
static final MiniMessage MINI_MESSAGE = MiniMessage.builder().build();
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + PlayerBackupProfile.class.getSimpleName());
|
||||
|
||||
private final UUID owner;
|
||||
private final Plot plot;
|
||||
@@ -87,7 +88,7 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
Files.createDirectory(path);
|
||||
}
|
||||
} catch (final Exception e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error resolving {} from {}", child, parent, e);
|
||||
}
|
||||
return path;
|
||||
}
|
||||
@@ -104,7 +105,7 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
try {
|
||||
Files.createDirectories(path);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error creating directory {}", path, e);
|
||||
return Collections.emptyList();
|
||||
}
|
||||
}
|
||||
@@ -117,11 +118,11 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
backups.add(
|
||||
new Backup(this, basicFileAttributes.creationTime().toMillis(), file));
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error getting attributes for file {} to create backup", file, e);
|
||||
}
|
||||
});
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error walking files from {}", path, e);
|
||||
}
|
||||
backups.sort(Comparator.comparingLong(Backup::getCreationTime).reversed());
|
||||
return (this.backupCache = backups);
|
||||
@@ -133,7 +134,7 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
public void destroy() {
|
||||
this.listBackups().whenCompleteAsync((backups, error) -> {
|
||||
if (error != null) {
|
||||
error.printStackTrace();
|
||||
LOGGER.error("Error while listing backups", error);
|
||||
}
|
||||
backups.forEach(Backup::delete);
|
||||
this.backupCache = null;
|
||||
@@ -141,10 +142,12 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
}
|
||||
|
||||
public @NonNull Path getBackupDirectory() {
|
||||
return resolve(resolve(
|
||||
resolve(backupManager.getBackupPath(), Objects.requireNonNull(plot.getArea().toString(), "plot area id")),
|
||||
Objects.requireNonNull(plot.getId().toDashSeparatedString(), "plot id")
|
||||
), Objects.requireNonNull(owner.toString(), "owner"));
|
||||
return resolve(
|
||||
resolve(
|
||||
resolve(backupManager.getBackupPath(), Objects.requireNonNull(plot.getArea().toString(), "plot area id")),
|
||||
Objects.requireNonNull(plot.getId().toDashSeparatedString(), "plot id")
|
||||
), Objects.requireNonNull(owner.toString(), "owner")
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -156,7 +159,8 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
backups.get(backups.size() - 1).delete();
|
||||
}
|
||||
final List<Plot> plots = Collections.singletonList(plot);
|
||||
final boolean result = this.schematicHandler.exportAll(plots, getBackupDirectory().toFile(),
|
||||
final boolean result = this.schematicHandler.exportAll(
|
||||
plots, getBackupDirectory().toFile(),
|
||||
"%world%-%id%-" + System.currentTimeMillis(), () ->
|
||||
future.complete(new Backup(this, System.currentTimeMillis(), null))
|
||||
);
|
||||
@@ -180,7 +184,7 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
try {
|
||||
schematic = this.schematicHandler.getSchematic(backup.getFile().toFile());
|
||||
} catch (SchematicHandler.UnsupportedFormatException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Unsupported format for backup {}", backup.getFile(), e);
|
||||
}
|
||||
if (schematic == null) {
|
||||
future.completeExceptionally(new IllegalArgumentException(
|
||||
@@ -200,10 +204,9 @@ public class PlayerBackupProfile implements BackupProfile {
|
||||
if (value) {
|
||||
future.complete(null);
|
||||
} else {
|
||||
future.completeExceptionally(new RuntimeException(MINI_MESSAGE.escapeTags(
|
||||
future.completeExceptionally(new PlotSquaredException(
|
||||
TranslatableCaption
|
||||
.of("schematics.schematic_paste_failed")
|
||||
.getComponent(ConsolePlayer.getConsole()))));
|
||||
.of("schematics.schematic_paste_failed")));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,6 +32,8 @@ import com.plotsquared.core.util.task.TaskManager;
|
||||
import net.kyori.adventure.text.Component;
|
||||
import net.kyori.adventure.text.minimessage.tag.Tag;
|
||||
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
@@ -47,6 +49,7 @@ import java.util.concurrent.TimeUnit;
|
||||
@Singleton
|
||||
public class SimpleBackupManager implements BackupManager {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + SimpleBackupManager.class.getSimpleName());
|
||||
private final Path backupPath;
|
||||
private final boolean automaticBackup;
|
||||
private final int backupLimit;
|
||||
@@ -112,7 +115,12 @@ public class SimpleBackupManager implements BackupManager {
|
||||
TagResolver.resolver("reason", Tag.inserting(Component.text(throwable.getMessage())))
|
||||
);
|
||||
}
|
||||
throwable.printStackTrace();
|
||||
LOGGER.error(
|
||||
"Error creating backup for plot {};{} and player {}",
|
||||
plot.getArea(),
|
||||
plot.getId(),
|
||||
player == null ? "null" : player.getName(), throwable
|
||||
);
|
||||
} else {
|
||||
if (player != null) {
|
||||
player.sendMessage(TranslatableCaption.of("backups.backup_automatic_finished"));
|
||||
@@ -128,6 +136,7 @@ public class SimpleBackupManager implements BackupManager {
|
||||
return this.automaticBackup;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public Path getBackupPath() {
|
||||
return this.backupPath;
|
||||
}
|
||||
|
||||
@@ -24,6 +24,7 @@ import com.plotsquared.core.backup.BackupProfile;
|
||||
import com.plotsquared.core.backup.NullBackupProfile;
|
||||
import com.plotsquared.core.backup.PlayerBackupProfile;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.exception.PlotSquaredException;
|
||||
import com.plotsquared.core.permissions.Permission;
|
||||
import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
@@ -32,6 +33,8 @@ import com.plotsquared.core.util.task.RunnableVal3;
|
||||
import net.kyori.adventure.text.Component;
|
||||
import net.kyori.adventure.text.minimessage.tag.Tag;
|
||||
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.nio.file.Files;
|
||||
@@ -57,6 +60,8 @@ import java.util.stream.Stream;
|
||||
permission = "plots.backup")
|
||||
public final class Backup extends Command {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + Backup.class.getSimpleName());
|
||||
|
||||
private final BackupManager backupManager;
|
||||
|
||||
@Inject
|
||||
@@ -326,20 +331,43 @@ public final class Backup extends Command {
|
||||
if (backupProfile instanceof NullBackupProfile) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_impossible"),
|
||||
TagResolver.resolver("plot", Tag.inserting(
|
||||
TranslatableCaption.of("generic.generic_other").toComponent(player)
|
||||
))
|
||||
TagResolver.resolver(
|
||||
"plot", Tag.inserting(
|
||||
TranslatableCaption.of("generic.generic_other").toComponent(player)
|
||||
)
|
||||
)
|
||||
);
|
||||
} else {
|
||||
backupProfile.listBackups().whenComplete((backups, throwable) -> {
|
||||
if (throwable != null) {
|
||||
Component reason;
|
||||
if (throwable instanceof PlotSquaredException pe) {
|
||||
reason = pe.getCaption().toComponent(player);
|
||||
} else {
|
||||
reason = Component.text(throwable.getMessage());
|
||||
}
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_load_failure"),
|
||||
TagResolver.resolver("reason", Tag.inserting(Component.text(throwable.getMessage())))
|
||||
TagResolver.resolver("reason", Tag.inserting(reason))
|
||||
);
|
||||
LOGGER.error("Error loading player ({}) backup", player.getName(), throwable);
|
||||
return;
|
||||
}
|
||||
if (number < 1 || number > backups.size()) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_impossible"),
|
||||
TagResolver.resolver(
|
||||
"plot",
|
||||
Tag.inserting(TranslatableCaption
|
||||
.of("generic.generic_invalid_choice")
|
||||
.toComponent(player))
|
||||
)
|
||||
);
|
||||
throwable.printStackTrace();
|
||||
} else {
|
||||
if (number < 1 || number > backups.size()) {
|
||||
final com.plotsquared.core.backup.Backup backup =
|
||||
backups.get(number - 1);
|
||||
if (backup == null || backup.getFile() == null || !Files
|
||||
.exists(backup.getFile())) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_impossible"),
|
||||
TagResolver.resolver(
|
||||
@@ -350,37 +378,23 @@ public final class Backup extends Command {
|
||||
)
|
||||
);
|
||||
} else {
|
||||
final com.plotsquared.core.backup.Backup backup =
|
||||
backups.get(number - 1);
|
||||
if (backup == null || backup.getFile() == null || !Files
|
||||
.exists(backup.getFile())) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_impossible"),
|
||||
TagResolver.resolver(
|
||||
"plot",
|
||||
Tag.inserting(TranslatableCaption
|
||||
.of("generic.generic_invalid_choice")
|
||||
.toComponent(player))
|
||||
)
|
||||
);
|
||||
} else {
|
||||
CmdConfirm.addPending(player, "/plot backup load " + number,
|
||||
() -> backupProfile.restoreBackup(backup, player)
|
||||
.whenComplete((n, error) -> {
|
||||
if (error != null) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_load_failure"),
|
||||
TagResolver.resolver(
|
||||
"reason",
|
||||
Tag.inserting(Component.text(error.getMessage()))
|
||||
)
|
||||
);
|
||||
} else {
|
||||
player.sendMessage(TranslatableCaption.of("backups.backup_load_success"));
|
||||
}
|
||||
})
|
||||
);
|
||||
}
|
||||
CmdConfirm.addPending(
|
||||
player, "/plot backup load " + number,
|
||||
() -> backupProfile.restoreBackup(backup, player)
|
||||
.whenComplete((n, error) -> {
|
||||
if (error != null) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("backups.backup_load_failure"),
|
||||
TagResolver.resolver(
|
||||
"reason",
|
||||
Tag.inserting(Component.text(error.getMessage()))
|
||||
)
|
||||
);
|
||||
} else {
|
||||
player.sendMessage(TranslatableCaption.of("backups.backup_load_success"));
|
||||
}
|
||||
})
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* PlotSquared, a land and world management plugin for Minecraft.
|
||||
* Copyright (C) IntellectualSites <https://intellectualsites.com>
|
||||
* Copyright (C) IntellectualSites team and contributors
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.plotsquared.core.exception;
|
||||
|
||||
import com.plotsquared.core.configuration.caption.Caption;
|
||||
import com.plotsquared.core.configuration.caption.LocaleHolder;
|
||||
|
||||
/**
|
||||
* Internal use only. Used to allow adventure captions to be used in an exception
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
public final class PlotSquaredException extends RuntimeException {
|
||||
|
||||
private final Caption caption;
|
||||
|
||||
/**
|
||||
* Create a new instance with the given caption
|
||||
*
|
||||
* @param caption caption
|
||||
*/
|
||||
public PlotSquaredException(Caption caption) {
|
||||
this.caption = caption;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new instance with the given caption and cause
|
||||
*
|
||||
* @param caption caption
|
||||
* @param cause cause
|
||||
*/
|
||||
public PlotSquaredException(Caption caption, Exception cause) {
|
||||
super(cause);
|
||||
this.caption = caption;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getMessage() {
|
||||
return caption.getComponent(LocaleHolder.console());
|
||||
}
|
||||
|
||||
public Caption getCaption() {
|
||||
return caption;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -135,6 +135,7 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
final String filename;
|
||||
final String website;
|
||||
final @Nullable UUID finalUuid = uuid;
|
||||
if (uuid == null) {
|
||||
uuid = UUID.randomUUID();
|
||||
website = Settings.Web.URL + "upload.php?" + uuid;
|
||||
@@ -144,10 +145,11 @@ public abstract class SchematicHandler {
|
||||
filename = file + '.' + extension;
|
||||
}
|
||||
final URL url;
|
||||
String uri = Settings.Web.URL + "?key=" + uuid + "&type=" + extension;
|
||||
try {
|
||||
url = URI.create(Settings.Web.URL + "?key=" + uuid + "&type=" + extension).toURL();
|
||||
url = URI.create(uri).toURL();
|
||||
} catch (MalformedURLException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Malformed URI `{}`", uri, e);
|
||||
whenDone.run();
|
||||
return;
|
||||
}
|
||||
@@ -193,7 +195,7 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
TaskManager.runTask(whenDone);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error while uploading schematic for UUID {}", finalUuid, e);
|
||||
TaskManager.runTask(whenDone);
|
||||
}
|
||||
});
|
||||
@@ -388,8 +390,14 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
queue.enqueue();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
TaskManager.runTask(whenDone);
|
||||
LOGGER.error(
|
||||
"Error pasting schematic to plot {};{} for player {}",
|
||||
plot.getArea(),
|
||||
plot.getId(),
|
||||
actor == null ? "null" : actor.getName(),
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -456,7 +464,7 @@ public abstract class SchematicHandler {
|
||||
Clipboard clip = reader.read();
|
||||
return new Schematic(clip);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error reading schematic from file {}", file.getAbsolutePath(), e);
|
||||
}
|
||||
} else {
|
||||
throw new UnsupportedFormatException("This schematic format is not recognised or supported.");
|
||||
@@ -470,7 +478,7 @@ public abstract class SchematicHandler {
|
||||
InputStream inputStream = Channels.newInputStream(readableByteChannel);
|
||||
return getSchematic(inputStream);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error reading schematic from {}", url, e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -486,7 +494,7 @@ public abstract class SchematicHandler {
|
||||
Clipboard clip = schematicReader.read();
|
||||
return new Schematic(clip);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error reading schematic", e);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
@@ -515,7 +523,7 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
return schematics;
|
||||
} catch (JsonParseException | IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error retrieving saves for UUID {}", uuid, e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -532,7 +540,7 @@ public abstract class SchematicHandler {
|
||||
try (NBTOutputStream nos = new NBTOutputStream(new GZIPOutputStream(output, true))) {
|
||||
nos.writeNamedTag("Schematic", tag);
|
||||
} catch (IOException e1) {
|
||||
e1.printStackTrace();
|
||||
LOGGER.error("Error uploading schematic for UUID {}", uuid, e1);
|
||||
}
|
||||
}
|
||||
}, whenDone);
|
||||
@@ -556,9 +564,9 @@ public abstract class SchematicHandler {
|
||||
nbtStream.writeNamedTag("Schematic", tag);
|
||||
}
|
||||
} catch (FileNotFoundException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error saving schematic at {}", path, e);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
LOGGER.error("Error saving schematic at {}", path, e);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@@ -581,7 +589,7 @@ public abstract class SchematicHandler {
|
||||
schematic.put("BlockData", new ByteArrayTag(buffer.toByteArray()));
|
||||
schematic.put("BlockEntities", new ListTag(CompoundTag.class, tileEntities));
|
||||
|
||||
if (biomeBuffer.size() == 0 || biomePalette.size() == 0) {
|
||||
if (biomeBuffer.size() == 0 || biomePalette.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -733,10 +741,7 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
BaseBlock block = aabb.getWorld().getFullBlock(point);
|
||||
if (block.getNbtData() != null) {
|
||||
Map<String, Tag> values = new HashMap<>();
|
||||
for (Map.Entry<String, Tag> entry : block.getNbtData().getValue().entrySet()) {
|
||||
values.put(entry.getKey(), entry.getValue());
|
||||
}
|
||||
Map<String, Tag> values = new HashMap<>(block.getNbtData().getValue());
|
||||
|
||||
// Positions are kept in NBT, we don't want that.
|
||||
values.remove("x");
|
||||
|
||||
Reference in New Issue
Block a user