From fb7bcef05fd10d5a500c42e2264d9229cdc5167c Mon Sep 17 00:00:00 2001 From: sauilitired Date: Mon, 17 Dec 2018 20:57:21 +0100 Subject: [PATCH] 1.13 shizzle --- Bukkit/build.gradle | 4 +- .../plotsquared/bukkit/BukkitMain.java | 107 ++- .../bukkit/listeners/PlayerEvents.java | 141 ++- .../bukkit/listeners/PlayerEvents_1_8.java | 14 +- .../bukkit/object/BukkitLazyBlock.java | 123 +-- .../bukkit/util/BukkitChunkManager.java | 37 +- .../bukkit/util/BukkitInventoryUtil.java | 8 +- .../bukkit/util/BukkitSchematicHandler.java | 2 +- .../plotsquared/bukkit/util/BukkitUtil.java | 41 +- .../bukkit/util/LegacyMappings.java | 905 ++++++++++++++++++ .../bukkit/util/block/BukkitLocalQueue.java | 61 +- .../util/block/BukkitLocalQueue_1_7.java | 129 --- .../util/block/BukkitLocalQueue_1_8.java | 341 ------- .../util/block/BukkitLocalQueue_1_8_3.java | 530 ---------- .../util/block/BukkitLocalQueue_1_9.java | 494 ---------- Bukkit/src/main/resources/plugin.yml | 1 + .../plotsquared/plot/commands/BO3.java | 53 - .../plotsquared/plot/commands/Download.java | 21 - .../plot/commands/MainCommand.java | 1 - .../plotsquared/plot/commands/Music.java | 5 +- .../plotsquared/plot/commands/Set.java | 4 +- .../plot/generator/ClassicPlotManager.java | 8 +- .../plot/generator/ClassicPlotWorld.java | 10 +- .../plot/generator/HybridPlotWorld.java | 2 +- .../plot/generator/HybridUtils.java | 9 +- .../plotsquared/plot/object/BO3.java | 75 -- .../plotsquared/plot/object/LazyBlock.java | 6 +- .../plot/object/LegacyPlotBlock.java | 62 ++ .../plotsquared/plot/object/Plot.java | 30 +- .../plotsquared/plot/object/PlotBlock.java | 80 +- .../plot/object/PlotItemStack.java | 14 +- .../plot/object/StringPlotBlock.java | 91 ++ .../plotsquared/plot/util/BO3Handler.java | 297 ------ .../plotsquared/plot/util/EventUtil.java | 24 +- .../plotsquared/plot/util/WorldUtil.java | 2 + .../plot/util/block/BasicLocalBlockQueue.java | 64 +- .../util/block/DelegateLocalBlockQueue.java | 4 + .../plot/util/block/LocalBlockQueue.java | 13 +- .../util/block/ScopedLocalBlockQueue.java | 5 + build.gradle | 1 - 40 files changed, 1487 insertions(+), 2332 deletions(-) create mode 100644 Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/LegacyMappings.java delete mode 100644 Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_7.java delete mode 100644 Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8.java delete mode 100644 Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8_3.java delete mode 100644 Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_9.java delete mode 100644 Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/BO3.java delete mode 100644 Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/BO3.java create mode 100644 Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LegacyPlotBlock.java create mode 100644 Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/StringPlotBlock.java delete mode 100644 Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/BO3Handler.java diff --git a/Bukkit/build.gradle b/Bukkit/build.gradle index 7ac4b10b5..62ee654b2 100644 --- a/Bukkit/build.gradle +++ b/Bukkit/build.gradle @@ -1,5 +1,5 @@ repositories { - maven { url "https://hub.spigotmc.org/nexus/content/groups/public/" } + maven { url "https://hub.spigotmc.org/nexus/content/repositories/snapshots/" } maven { url = "https://oss.sonatype.org/content/repositories/snapshots/" } maven { url "http://nexus.hc.to/content/repositories/pub_releases" } mavenLocal() @@ -7,7 +7,7 @@ repositories { dependencies { compile project(':Core') - compile 'org.spigotmc:spigot-api:1.12.1-R0.1-SNAPSHOT' + compile 'org.spigotmc:spigot-api:1.13-R0.1-SNAPSHOT' compile("net.milkbowl.vault:VaultAPI:1.6") { exclude module: 'bukkit' } diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/BukkitMain.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/BukkitMain.java index 5c569a296..e3535231b 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/BukkitMain.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/BukkitMain.java @@ -1,14 +1,46 @@ package com.github.intellectualsites.plotsquared.bukkit; +import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; + import com.github.intellectualsites.plotsquared.bukkit.database.plotme.ClassicPlotMeConnector; import com.github.intellectualsites.plotsquared.bukkit.database.plotme.LikePlotMeConverter; import com.github.intellectualsites.plotsquared.bukkit.database.plotme.PlotMeConnector_017; import com.github.intellectualsites.plotsquared.bukkit.generator.BukkitPlotGenerator; -import com.github.intellectualsites.plotsquared.bukkit.listeners.*; +import com.github.intellectualsites.plotsquared.bukkit.listeners.ChunkListener; +import com.github.intellectualsites.plotsquared.bukkit.listeners.EntityPortal_1_7_9; +import com.github.intellectualsites.plotsquared.bukkit.listeners.EntitySpawnListener; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlayerEvents; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlayerEvents183; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlayerEvents_1_8; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlayerEvents_1_9; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlotPlusListener; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlotPlusListener_1_12; +import com.github.intellectualsites.plotsquared.bukkit.listeners.PlotPlusListener_Legacy; +import com.github.intellectualsites.plotsquared.bukkit.listeners.SingleWorldListener; +import com.github.intellectualsites.plotsquared.bukkit.listeners.WorldEvents; import com.github.intellectualsites.plotsquared.bukkit.titles.DefaultTitle_111; -import com.github.intellectualsites.plotsquared.bukkit.util.*; -import com.github.intellectualsites.plotsquared.bukkit.util.block.*; -import com.github.intellectualsites.plotsquared.bukkit.uuid.*; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitChatManager; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitChunkManager; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitCommand; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitEconHandler; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitEventUtil; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitHybridUtils; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitInventoryUtil; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitSchematicHandler; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitSetupUtils; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitTaskManager; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil; +import com.github.intellectualsites.plotsquared.bukkit.util.BukkitVersion; +import com.github.intellectualsites.plotsquared.bukkit.util.LegacyMappings; +import com.github.intellectualsites.plotsquared.bukkit.util.Metrics; +import com.github.intellectualsites.plotsquared.bukkit.util.SendChunk; +import com.github.intellectualsites.plotsquared.bukkit.util.SetGenCB; +import com.github.intellectualsites.plotsquared.bukkit.util.block.BukkitLocalQueue; +import com.github.intellectualsites.plotsquared.bukkit.uuid.DefaultUUIDWrapper; +import com.github.intellectualsites.plotsquared.bukkit.uuid.FileUUIDHandler; +import com.github.intellectualsites.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper; +import com.github.intellectualsites.plotsquared.bukkit.uuid.OfflineUUIDWrapper; +import com.github.intellectualsites.plotsquared.bukkit.uuid.SQLUUIDHandler; import com.github.intellectualsites.plotsquared.configuration.ConfigurationSection; import com.github.intellectualsites.plotsquared.plot.IPlotMain; import com.github.intellectualsites.plotsquared.plot.PlotSquared; @@ -19,20 +51,55 @@ import com.github.intellectualsites.plotsquared.plot.generator.GeneratorWrapper; import com.github.intellectualsites.plotsquared.plot.generator.HybridGen; import com.github.intellectualsites.plotsquared.plot.generator.HybridUtils; import com.github.intellectualsites.plotsquared.plot.generator.IndependentPlotGenerator; -import com.github.intellectualsites.plotsquared.plot.object.*; +import com.github.intellectualsites.plotsquared.plot.object.Plot; +import com.github.intellectualsites.plotsquared.plot.object.PlotArea; +import com.github.intellectualsites.plotsquared.plot.object.PlotId; +import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer; +import com.github.intellectualsites.plotsquared.plot.object.RunnableVal; +import com.github.intellectualsites.plotsquared.plot.object.SetupObject; import com.github.intellectualsites.plotsquared.plot.object.chat.PlainChatManager; import com.github.intellectualsites.plotsquared.plot.object.worlds.PlotAreaManager; import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotArea; import com.github.intellectualsites.plotsquared.plot.object.worlds.SinglePlotAreaManager; import com.github.intellectualsites.plotsquared.plot.object.worlds.SingleWorldGenerator; -import com.github.intellectualsites.plotsquared.plot.util.*; +import com.github.intellectualsites.plotsquared.plot.util.AbstractTitle; +import com.github.intellectualsites.plotsquared.plot.util.ChatManager; +import com.github.intellectualsites.plotsquared.plot.util.ChunkManager; +import com.github.intellectualsites.plotsquared.plot.util.ConsoleColors; +import com.github.intellectualsites.plotsquared.plot.util.EconHandler; +import com.github.intellectualsites.plotsquared.plot.util.EventUtil; +import com.github.intellectualsites.plotsquared.plot.util.InventoryUtil; +import com.github.intellectualsites.plotsquared.plot.util.MainUtil; +import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils; +import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler; +import com.github.intellectualsites.plotsquared.plot.util.SetupUtils; +import com.github.intellectualsites.plotsquared.plot.util.StringMan; +import com.github.intellectualsites.plotsquared.plot.util.TaskManager; +import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler; +import com.github.intellectualsites.plotsquared.plot.util.UUIDHandlerImplementation; +import com.github.intellectualsites.plotsquared.plot.util.WorldUtil; import com.github.intellectualsites.plotsquared.plot.util.block.QueueProvider; import com.github.intellectualsites.plotsquared.plot.uuid.UUIDWrapper; import com.sk89q.worldedit.WorldEdit; +import java.io.File; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import javax.annotation.Nullable; import lombok.Getter; import lombok.NonNull; -import org.bukkit.*; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Chunk; import org.bukkit.Location; +import org.bukkit.OfflinePlayer; +import org.bukkit.World; import org.bukkit.command.PluginCommand; import org.bukkit.entity.Entity; import org.bukkit.entity.LivingEntity; @@ -45,15 +112,6 @@ import org.bukkit.plugin.Plugin; import org.bukkit.plugin.PluginManager; import org.bukkit.plugin.java.JavaPlugin; -import javax.annotation.Nullable; -import java.io.File; -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.*; -import java.util.concurrent.ConcurrentHashMap; - -import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; - public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain { @Getter private static WorldEdit worldEdit; @@ -138,6 +196,9 @@ public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain } this.pluginName = getDescription().getName(); getServer().getName(); + + LegacyMappings.initialize(); + new PlotSquared(this, "Bukkit"); if (Settings.Enabled_Components.METRICS) { new Metrics(this).start(); @@ -646,19 +707,7 @@ public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain SendChunk.class + " does not support " + StringMan.getString(getServerVersion())); MainUtil.canSendChunk = false; } - if (PlotSquared.get().checkVersion(getServerVersion(), BukkitVersion.v1_13_0)) { - return QueueProvider.of(BukkitLocalQueue.class, BukkitLocalQueue.class); - } - if (PlotSquared.get().checkVersion(getServerVersion(), BukkitVersion.v1_9_0)) { - return QueueProvider.of(BukkitLocalQueue_1_9.class, BukkitLocalQueue.class); - } - if (PlotSquared.get().checkVersion(getServerVersion(), BukkitVersion.v1_8_3)) { - return QueueProvider.of(BukkitLocalQueue_1_8_3.class, BukkitLocalQueue.class); - } - if (PlotSquared.get().checkVersion(getServerVersion(), BukkitVersion.v1_8_0)) { - return QueueProvider.of(BukkitLocalQueue_1_8.class, BukkitLocalQueue.class); - } - return QueueProvider.of(BukkitLocalQueue_1_7.class, BukkitLocalQueue.class); + return QueueProvider.of(BukkitLocalQueue.class, BukkitLocalQueue.class); } @Override public WorldUtil initWorldUtil() { diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents.java index fade7cdc2..c0dde8a91 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents.java @@ -5,6 +5,7 @@ import com.github.intellectualsites.plotsquared.bukkit.object.BukkitLazyBlock; import com.github.intellectualsites.plotsquared.bukkit.object.BukkitPlayer; import com.github.intellectualsites.plotsquared.bukkit.util.BukkitUtil; import com.github.intellectualsites.plotsquared.bukkit.util.BukkitVersion; +import com.github.intellectualsites.plotsquared.bukkit.util.LegacyMappings; import com.github.intellectualsites.plotsquared.plot.PlotSquared; import com.github.intellectualsites.plotsquared.plot.config.C; import com.github.intellectualsites.plotsquared.plot.config.Settings; @@ -230,21 +231,21 @@ public class PlayerEvents extends PlotListener implements Listener { Block block = event.getBlock(); switch (block.getType()) { case OBSERVER: - case REDSTONE_LAMP_OFF: + case LEGACY_REDSTONE_LAMP_OFF: case REDSTONE_WIRE: - case REDSTONE_LAMP_ON: - case PISTON_BASE: - case PISTON_STICKY_BASE: - case IRON_DOOR_BLOCK: + case LEGACY_REDSTONE_LAMP_ON: + case LEGACY_PISTON_BASE: + case LEGACY_PISTON_STICKY_BASE: + case LEGACY_IRON_DOOR_BLOCK: case LEVER: - case WOODEN_DOOR: - case FENCE_GATE: - case WOOD_BUTTON: + case LEGACY_WOODEN_DOOR: + case LEGACY_FENCE_GATE: + case LEGACY_WOOD_BUTTON: case STONE_BUTTON: - case IRON_PLATE: - case WOOD_PLATE: - case STONE_PLATE: - case GOLD_PLATE: + case LEGACY_IRON_PLATE: + case LEGACY_WOOD_PLATE: + case LEGACY_STONE_PLATE: + case LEGACY_GOLD_PLATE: case SPRUCE_DOOR: case BIRCH_DOOR: case JUNGLE_DOOR: @@ -312,8 +313,8 @@ public class PlayerEvents extends PlotListener implements Listener { @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void onPhysicsEvent(BlockPhysicsEvent event) { switch (event.getChangedType()) { - case REDSTONE_COMPARATOR_OFF: - case REDSTONE_COMPARATOR_ON: { + case LEGACY_REDSTONE_COMPARATOR_OFF: + case LEGACY_REDSTONE_COMPARATOR_ON: { Block block = event.getBlock(); Location loc = BukkitUtil.getLocation(block.getLocation()); PlotArea area = loc.getPlotArea(); @@ -352,8 +353,8 @@ public class PlayerEvents extends PlotListener implements Listener { if (Settings.Redstone.DETECT_INVALID_EDGE_PISTONS) { Block block = event.getBlock(); switch (block.getType()) { - case PISTON_BASE: - case PISTON_STICKY_BASE: + case LEGACY_PISTON_BASE: + case LEGACY_PISTON_STICKY_BASE: Location loc = BukkitUtil.getLocation(block.getLocation()); PlotArea area = loc.getPlotArea(); if (area == null) { @@ -919,7 +920,7 @@ public class PlayerEvents extends PlotListener implements Listener { Optional> destroy = plot.getFlag(Flags.BREAK); Block block = event.getBlock(); if (destroy.isPresent() && destroy.get() - .contains(PlotBlock.get((short) block.getTypeId(), block.getData()))) { + .contains(PlotBlock.get(block.getType().name()))) { return; } if (Permissions.hasPermission(plotPlayer, C.PERMISSION_ADMIN_DESTROY_OTHER)) { @@ -943,8 +944,8 @@ public class PlayerEvents extends PlotListener implements Listener { return; } if (PlotSquared.get().worldedit != null && pp.getAttribute("worldedit")) { - if (player.getItemInHand().getTypeId() == PlotSquared.get().worldedit - .getConfiguration().wandItem) { + if (player.getInventory().getItemInMainHand().getType() == LegacyMappings.fromLegacyId(PlotSquared.get().worldedit + .getConfiguration().wandItem).getMaterial()) { return; } } @@ -1118,7 +1119,7 @@ public class PlayerEvents extends PlotListener implements Listener { event.setCancelled(true); } break; - case MYCEL: + case LEGACY_MYCEL: if (Flags.MYCEL_GROW.isFalse(plot)) { event.setCancelled(true); } @@ -1202,7 +1203,7 @@ public class PlayerEvents extends PlotListener implements Listener { Optional> destroy = plot.getFlag(Flags.BREAK); Block block = event.getBlock(); if (destroy.isPresent() && destroy.get() - .contains(PlotBlock.get((short) block.getTypeId(), block.getData())) + .contains(PlotBlock.get(block.getType().name())) || Permissions.hasPermission(plotPlayer, C.PERMISSION_ADMIN_DESTROY_OTHER)) { return; } @@ -1242,7 +1243,7 @@ public class PlayerEvents extends PlotListener implements Listener { event.setCancelled(true); } break; - case SOIL: + case LEGACY_SOIL: if (Flags.SOIL_DRY.isFalse(plot)) { event.setCancelled(true); } @@ -1273,9 +1274,7 @@ public class PlayerEvents extends PlotListener implements Listener { if (Flags.LIQUID_FLOW.isFalse(plot)) { switch (to.getType()) { case WATER: - case STATIONARY_WATER: case LAVA: - case STATIONARY_LAVA: event.setCancelled(true); } } @@ -1356,7 +1355,7 @@ public class PlayerEvents extends PlotListener implements Listener { this.pistonBlocks = false; } } - if (!this.pistonBlocks && block.getType() != Material.PISTON_BASE) { + if (!this.pistonBlocks && block.getType() != Material.LEGACY_PISTON_BASE) { BlockFace dir = event.getDirection(); location = BukkitUtil.getLocation(block.getLocation() .add(dir.getModX() * 2, dir.getModY() * 2, dir.getModZ() * 2)); @@ -1397,7 +1396,7 @@ public class PlayerEvents extends PlotListener implements Listener { this.pistonBlocks = false; } } - if (!this.pistonBlocks && block.getType() != Material.PISTON_BASE) { + if (!this.pistonBlocks && block.getType() != Material.LEGACY_PISTON_BASE) { location = BukkitUtil.getLocation( block.getLocation().add(dir.getModX() * 2, dir.getModY() * 2, dir.getModZ() * 2)); if (!area.contains(location)) { @@ -1521,48 +1520,47 @@ public class PlayerEvents extends PlotListener implements Listener { case IRON_DOOR: case JUNGLE_DOOR: case SPRUCE_DOOR: - case TRAP_DOOR: + case LEGACY_TRAP_DOOR: case IRON_TRAPDOOR: - case WOOD_DOOR: - case WOODEN_DOOR: + case LEGACY_WOOD_DOOR: + case LEGACY_WOODEN_DOOR: case TRAPPED_CHEST: case ENDER_CHEST: case CHEST: case ACACIA_FENCE_GATE: case BIRCH_FENCE_GATE: case DARK_OAK_FENCE_GATE: - case FENCE_GATE: + case LEGACY_FENCE_GATE: case JUNGLE_FENCE_GATE: case SPRUCE_FENCE_GATE: case LEVER: - case DIODE: - case DIODE_BLOCK_OFF: - case DIODE_BLOCK_ON: - case COMMAND: - case REDSTONE_COMPARATOR: - case REDSTONE_COMPARATOR_OFF: - case REDSTONE_COMPARATOR_ON: + case LEGACY_DIODE: + case LEGACY_DIODE_BLOCK_OFF: + case LEGACY_DIODE_BLOCK_ON: + case COMMAND_BLOCK: + case LEGACY_REDSTONE_COMPARATOR: + case LEGACY_REDSTONE_COMPARATOR_OFF: + case LEGACY_REDSTONE_COMPARATOR_ON: case REDSTONE_ORE: - case WOOD_BUTTON: + case LEGACY_WOOD_BUTTON: case STONE_BUTTON: case BEACON: - case BED_BLOCK: + case LEGACY_BED_BLOCK: case SIGN: case WALL_SIGN: - case SIGN_POST: - case ENCHANTMENT_TABLE: + case LEGACY_ENCHANTMENT_TABLE: case BREWING_STAND: - case STANDING_BANNER: - case BURNING_FURNACE: + case LEGACY_STANDING_BANNER: + case LEGACY_BURNING_FURNACE: case FURNACE: - case CAKE_BLOCK: + case CAKE: case DISPENSER: case DROPPER: case HOPPER: case NOTE_BLOCK: case JUKEBOX: - case WORKBENCH: - case SILVER_SHULKER_BOX: + case CRAFTING_TABLE: + case LEGACY_SILVER_SHULKER_BOX: case BLACK_SHULKER_BOX: case BLUE_SHULKER_BOX: case RED_SHULKER_BOX: @@ -1578,8 +1576,8 @@ public class PlayerEvents extends PlotListener implements Listener { case LIME_SHULKER_BOX: case LIGHT_BLUE_SHULKER_BOX: case MAGENTA_SHULKER_BOX: - case COMMAND_REPEATING: - case COMMAND_CHAIN: + case LEGACY_COMMAND_REPEATING: + case LEGACY_COMMAND_CHAIN: eventType = PlayerBlockEventType.INTERACT_BLOCK; break; @@ -1592,7 +1590,7 @@ public class PlayerEvents extends PlotListener implements Listener { } break; } - lb = new BukkitLazyBlock(blockId, block); + lb = new BukkitLazyBlock(PlotBlock.get(block.getType().toString())); ItemStack hand = player.getItemInHand(); if (eventType != null && (eventType != PlayerBlockEventType.INTERACT_BLOCK || !player.isSneaking())) { @@ -1608,15 +1606,14 @@ public class PlayerEvents extends PlotListener implements Listener { location = BukkitUtil .getLocation(block.getRelative(event.getBlockFace()).getLocation()); eventType = PlayerBlockEventType.PLACE_BLOCK; - lb = new BukkitLazyBlock(id, block); break; } Material handType = hand.getType(); - lb = new BukkitLazyBlock(PlotBlock.get((short) handType.getId(), (byte) 0)); + lb = new BukkitLazyBlock(PlotBlock.get(handType.toString())); switch (handType) { - case FIREWORK: - case MONSTER_EGG: - case MONSTER_EGGS: + case LEGACY_FIREWORK: + case LEGACY_MONSTER_EGG: + case LEGACY_MONSTER_EGGS: eventType = PlayerBlockEventType.SPAWN_MOB; break; case ARMOR_STAND: @@ -1625,40 +1622,40 @@ public class PlayerEvents extends PlotListener implements Listener { eventType = PlayerBlockEventType.PLACE_MISC; break; case WRITTEN_BOOK: - case BOOK_AND_QUILL: + case LEGACY_BOOK_AND_QUILL: case BOOK: eventType = PlayerBlockEventType.READ; break; case APPLE: case BAKED_POTATO: - case MUSHROOM_SOUP: + case LEGACY_MUSHROOM_SOUP: case BREAD: case CARROT: - case CARROT_ITEM: + case LEGACY_CARROT_ITEM: case COOKIE: - case GRILLED_PORK: + case LEGACY_GRILLED_PORK: case POISONOUS_POTATO: case MUTTON: - case PORK: + case LEGACY_PORK: case POTATO: - case POTATO_ITEM: + case LEGACY_POTATO_ITEM: case POTION: case PUMPKIN_PIE: case RABBIT: case RABBIT_FOOT: case RABBIT_STEW: - case RAW_BEEF: - case RAW_FISH: - case RAW_CHICKEN: + case LEGACY_RAW_BEEF: + case LEGACY_RAW_FISH: + case LEGACY_RAW_CHICKEN: eventType = PlayerBlockEventType.EAT; break; case MINECART: - case STORAGE_MINECART: - case POWERED_MINECART: + case LEGACY_STORAGE_MINECART: + case LEGACY_POWERED_MINECART: case HOPPER_MINECART: - case EXPLOSIVE_MINECART: - case COMMAND_MINECART: - case BOAT: + case LEGACY_EXPLOSIVE_MINECART: + case LEGACY_COMMAND_MINECART: + case LEGACY_BOAT: eventType = PlayerBlockEventType.PLACE_VEHICLE; break; case PAINTING: @@ -1683,8 +1680,8 @@ public class PlayerEvents extends PlotListener implements Listener { return; } if (PlotSquared.get().worldedit != null && pp.getAttribute("worldedit")) { - if (player.getItemInHand().getTypeId() == PlotSquared.get().worldedit - .getConfiguration().wandItem) { + if (player.getInventory().getItemInMainHand().getType() == LegacyMappings.fromLegacyId(PlotSquared.get().worldedit + .getConfiguration().wandItem).getMaterial()) { return; } } @@ -1996,7 +1993,7 @@ public class PlayerEvents extends PlotListener implements Listener { Optional> use = plot.getFlag(Flags.USE); Block block = event.getBlockClicked(); if (use.isPresent() && use.get() - .contains(PlotBlock.get(block.getTypeId(), block.getData()))) { + .contains(PlotBlock.get(block.getType().name()))) { return; } if (Permissions.hasPermission(plotPlayer, C.PERMISSION_ADMIN_BUILD_OTHER)) { @@ -2520,7 +2517,7 @@ public class PlayerEvents extends PlotListener implements Listener { Set place = plot.getFlag(Flags.PLACE, null); if (place != null) { Block block = event.getBlock(); - if (place.contains(PlotBlock.get((short) block.getTypeId(), block.getData()))) { + if (place.contains(PlotBlock.get(block.getType().name()))) { return; } } diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents_1_8.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents_1_8.java index 791d862fa..ff1c3eb4b 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents_1_8.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/listeners/PlayerEvents_1_8.java @@ -73,8 +73,8 @@ public class PlayerEvents_1_8 extends PlotListener implements Listener { } if (!"[(+NBT)]".equals(newLore) || (current.equals(newItem) && newLore.equals(oldLore))) { switch (newItem.getType()) { - case BANNER: - case SKULL_ITEM: + case LEGACY_BANNER: + case PLAYER_HEAD: if (newMeta != null) break; default: @@ -92,12 +92,12 @@ public class PlayerEvents_1_8 extends PlotListener implements Listener { Material itemType = newItem.getType(); if (stateType != itemType) { switch (stateType) { - case STANDING_BANNER: - case WALL_BANNER: - if (itemType == Material.BANNER) + case LEGACY_STANDING_BANNER: + case LEGACY_WALL_BANNER: + if (itemType == Material.LEGACY_BANNER) break; - case SKULL: - if (itemType == Material.SKULL_ITEM) + case LEGACY_SKULL: + if (itemType == Material.LEGACY_SKULL_ITEM) break; default: return; diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitLazyBlock.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitLazyBlock.java index 8668ef387..0903e78d9 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitLazyBlock.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/object/BukkitLazyBlock.java @@ -2,135 +2,24 @@ package com.github.intellectualsites.plotsquared.bukkit.object; import com.github.intellectualsites.plotsquared.plot.object.LazyBlock; import com.github.intellectualsites.plotsquared.plot.object.PlotBlock; +import com.github.intellectualsites.plotsquared.plot.object.StringPlotBlock; import org.bukkit.block.Block; public class BukkitLazyBlock extends LazyBlock { - private int id; - private Block block; - private PlotBlock pb; + private StringPlotBlock pb; - public BukkitLazyBlock(int id, Block block) { - this.id = id; - this.block = block; + public BukkitLazyBlock(Block block) { + this.pb = (StringPlotBlock) PlotBlock.get(block.getType().toString()); } - public BukkitLazyBlock(PlotBlock pb) { - this.id = pb.id; + public BukkitLazyBlock(StringPlotBlock pb) { this.pb = pb; } - public BukkitLazyBlock(Block block) { - this.block = block; - } - - @Override public PlotBlock getPlotBlock() { - if (this.pb != null) { - return this.pb; - } - if (this.id == 0) { - this.id = this.block.getTypeId(); - } - byte data; - switch (this.id) { - case 0: - case 2: - case 4: - case 13: - case 14: - case 15: - case 20: - case 21: - case 22: - case 24: - case 25: - case 30: - case 32: - case 37: - case 39: - case 40: - case 41: - case 42: - case 45: - case 46: - case 47: - case 48: - case 49: - case 51: - case 52: - case 54: - case 55: - case 56: - case 57: - case 58: - case 60: - case 61: - case 62: - case 7: - case 8: - case 9: - case 10: - case 11: - case 73: - case 74: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 84: - case 85: - case 87: - case 88: - case 101: - case 102: - case 103: - case 110: - case 112: - case 113: - case 117: - case 121: - case 122: - case 123: - case 124: - case 129: - case 133: - case 138: - case 137: - case 140: - case 165: - case 166: - case 169: - case 170: - case 172: - case 173: - case 174: - case 176: - case 177: - case 181: - case 182: - case 188: - case 189: - case 190: - case 191: - case 192: - data = 0; - break; - default: - data = this.block.getData(); - break; - } - this.pb = PlotBlock.get((short) this.id, data); + public StringPlotBlock getPlotBlock() { return this.pb; - } - @Override public int getId() { - if (this.id == 0) { - this.id = this.block.getTypeId(); - } - return this.id; - } } diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChunkManager.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChunkManager.java index c2226e077..32d067e70 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChunkManager.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitChunkManager.java @@ -13,6 +13,7 @@ import com.github.intellectualsites.plotsquared.plot.util.block.ScopedLocalBlock import org.bukkit.*; import org.bukkit.block.*; import org.bukkit.block.banner.Pattern; +import org.bukkit.block.data.BlockData; import org.bukkit.entity.*; import org.bukkit.inventory.InventoryHolder; import org.bukkit.inventory.ItemStack; @@ -58,29 +59,35 @@ public class BukkitChunkManager extends ChunkManager { map.saveBlocks(world1, 256, sx, sz, relX, relZ, false); for (int y = 0; y < 256; y++) { Block block1 = world1.getBlockAt(x, y, z); - int id1 = block1.getTypeId(); - byte data1 = block1.getData(); + // int id1 = block1.getTypeId(); + Material id1 = block1.getType(); + BlockData data1 = block1.getBlockData(); + // byte data1 = block1.getData(); int xx = x + relX; int zz = z + relZ; Block block2 = world2.getBlockAt(xx, y, zz); - int id2 = block2.getTypeId(); - byte data2 = block2.getData(); - if (id1 == 0) { - if (id2 != 0) { - queue1.setBlock(x, y, z, (short) id2, data2); + // int id2 = block2.getTypeId(); + Material id2 = block2.getType(); + BlockData data2 = block2.getBlockData(); + // byte data2 = block2.getData(); + if (id1 == Material.AIR) { + if (id2 != Material.AIR) { + queue1.setBlock(x, y, z, id2.name()); queue2.setBlock(xx, y, zz, (short) 0, (byte) 0); } - } else if (id2 == 0) { + } else if (id2 == Material.AIR) { queue1.setBlock(x, y, z, (short) 0, (byte) 0); - queue2.setBlock(xx, y, zz, (short) id1, data1); + queue2.setBlock(xx, y, zz, id1.name()); } else if (id1 == id2) { if (data1 != data2) { - block1.setData(data2); - block2.setData(data1); + block1.setBlockData(data2); + block2.setBlockData(data1); } } else { - queue1.setBlock(x, y, z, (short) id2, data2); - queue2.setBlock(xx, y, zz, (short) id1, data1); + queue1.setBlock(x, y, z, id2.name()); + queue2.setBlock(xx, y, zz, id1.name()); + // queue1.setBlock(x, y, z, (short) id2, data2); + // queue2.setBlock(xx, y, zz, (short) id1, data1); } } } @@ -1092,7 +1099,7 @@ public class BukkitChunkManager extends ChunkManager { if (storeNormal) { int typeId = id.getId(); if (typeId == 0) { - ids[y] = PlotBlock.EVERYTHING; + ids[y] = StringPlotBlock.EVERYTHING; } else { ids[y] = PlotBlock.get((short) typeId, block.getData()); } @@ -1131,7 +1138,7 @@ public class BukkitChunkManager extends ChunkManager { this.brewingStandContents.put(bl, invBre); break; case FURNACE: - case BURNING_FURNACE: + case LEGACY_BURNING_FURNACE: Furnace furnace = (Furnace) inventoryHolder; short burn = furnace.getBurnTime(); short cook = furnace.getCookTime(); diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitInventoryUtil.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitInventoryUtil.java index 5fbf35066..6beebcd95 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitInventoryUtil.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitInventoryUtil.java @@ -7,6 +7,7 @@ import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer; import com.github.intellectualsites.plotsquared.plot.util.InventoryUtil; import org.bukkit.Bukkit; import org.bukkit.ChatColor; +import org.bukkit.Material; import org.bukkit.event.inventory.InventoryType; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.InventoryView; @@ -23,7 +24,7 @@ public class BukkitInventoryUtil extends InventoryUtil { if (item == null) { return null; } - ItemStack stack = new ItemStack(item.id, item.amount, item.data); + ItemStack stack = new ItemStack(BukkitUtil.getMaterial(item.getPlotBlock()), item.amount); ItemMeta meta = null; if (item.name != null) { meta = stack.getItemMeta(); @@ -82,7 +83,8 @@ public class BukkitInventoryUtil extends InventoryUtil { if (item == null) { return null; } - int id = item.getTypeId(); + // int id = item.getTypeId(); + Material id = item.getType(); short data = item.getDurability(); int amount = item.getAmount(); String name = null; @@ -97,7 +99,7 @@ public class BukkitInventoryUtil extends InventoryUtil { lore = itemLore.toArray(new String[itemLore.size()]); } } - return new PlotItemStack(id, data, amount, name, lore); + return new PlotItemStack(id.name(), amount, name, lore); } @Override public PlotItemStack[] getItems(PlotPlayer player) { diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSchematicHandler.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSchematicHandler.java index 665eb2ecd..1853f5a3f 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSchematicHandler.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitSchematicHandler.java @@ -140,7 +140,7 @@ public class BukkitSchematicHandler extends SchematicHandler { int rx = x - bx; int index = i2 + rx; Block block = worldObj.getBlockAt(x, y, z); - int id = block.getTypeId(); + int id = LegacyMappings.fromNewName(block.getType().name()).getNumericalId(); switch (id) { case 0: case 2: diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitUtil.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitUtil.java index f095821ce..8314cbda5 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitUtil.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/BukkitUtil.java @@ -60,6 +60,14 @@ import java.util.*; return getLocation(location).getPlot(); } + @Override public boolean isBlockSame(PlotBlock block1, PlotBlock block2) { + if (block1.equals(block2)) { + return true; + } + Material mat1 = getMaterial(block1), mat2 = getMaterial(block2); + return mat1 == mat2; + } + /** * Get a plot based on the player location. * @@ -248,7 +256,7 @@ import java.util.*; final Block block = world.getBlockAt(x, y, z); // block.setType(Material.AIR); final Material type = block.getType(); - if (type != Material.SIGN && type != Material.SIGN_POST) { + if (type != Material.SIGN && type != Material.WALL_SIGN) { int data = 2; if (world.getBlockAt(x, y, z + 1).getType().isSolid()) data = 2; @@ -258,7 +266,9 @@ import java.util.*; data = 3; else if (world.getBlockAt(x - 1, y, z).getType().isSolid()) data = 5; - block.setTypeIdAndData(Material.WALL_SIGN.getId(), (byte) data, false); + block.setType(Material.WALL_SIGN, false); + final Sign sign = (Sign) block.getBlockData(); + sign.setRawData((byte) data); } final BlockState blockstate = block.getState(); if (blockstate instanceof Sign) { @@ -322,8 +332,6 @@ import java.util.*; switch (type) { case WATER: case LAVA: - case STATIONARY_LAVA: - case STATIONARY_WATER: return y; } air++; @@ -363,7 +371,7 @@ import java.util.*; InventoryHolder holder = (InventoryHolder) state; Inventory inv = holder.getInventory(); for (int i = 0; i < items.id.length; i++) { - ItemStack item = new ItemStack(items.id[i], items.amount[i], items.data[i]); + ItemStack item = new ItemStack(LegacyMappings.fromLegacyId(items.id[i]).getMaterial(), items.amount[i], items.data[i]); inv.addItem(item); } state.update(true); @@ -372,9 +380,18 @@ import java.util.*; return false; } + public static Material getMaterial(@NonNull final PlotBlock plotBlock) { + if (plotBlock instanceof StringPlotBlock) { + return Material.getMaterial(((StringPlotBlock) plotBlock).getItemId().toUpperCase(Locale.ENGLISH)); + } else { + final LegacyPlotBlock legacyPlotBlock = (LegacyPlotBlock) plotBlock; + return LegacyMappings.fromLegacyId(legacyPlotBlock.getId()).getMaterial(); + } + } + @Override public boolean isBlockSolid(@NonNull final PlotBlock block) { try { - final Material material = Material.getMaterial(block.id); + final Material material = getMaterial(block); if (material.isBlock() && material.isSolid() && !material.hasGravity()) { Class data = material.getData(); if (data.equals(MaterialData.class) && !material.isTransparent() && material @@ -383,7 +400,7 @@ import java.util.*; .equals(WoodenStep.class)) { switch (material) { case NOTE_BLOCK: - case MOB_SPAWNER: + case SPAWNER: return false; default: return true; @@ -398,7 +415,7 @@ import java.util.*; @Override public String getClosestMatchingName(@NonNull final PlotBlock block) { try { - return Material.getMaterial(block.id).name(); + return getMaterial(block).name(); } catch (Exception ignored) { return null; } @@ -408,8 +425,8 @@ import java.util.*; public StringComparison.ComparisonResult getClosestBlock(String name) { try { final Material material = Material.valueOf(name.toUpperCase()); - return new StringComparison().new ComparisonResult(0, - PlotBlock.get((short) material.getId(), (byte) 0)); + return new StringComparison().new ComparisonResult(1, + PlotBlock.get(name)); } catch (IllegalArgumentException ignored) { } try { @@ -457,9 +474,9 @@ import java.util.*; final World world = getWorld(location.getWorld()); final Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ()); if (block == null) { - return PlotBlock.EVERYTHING; + return StringPlotBlock.EVERYTHING; } - return PlotBlock.get((short) block.getTypeId(), block.getData()); + return PlotBlock.get(block.getType().name()); } @Override public String getMainWorld() { diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/LegacyMappings.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/LegacyMappings.java new file mode 100644 index 000000000..f23752d5a --- /dev/null +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/LegacyMappings.java @@ -0,0 +1,905 @@ +package com.github.intellectualsites.plotsquared.bukkit.util; + +import lombok.*; +import org.bukkit.Material; + +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +/** + * Borrowed from https://github.com/Phoenix616/IDConverter/blob/master/mappings/src/main/java/de/themoep/idconverter/IdMappings.java + * Original License: + * + * Minecraft ID mappings + * Copyright (C) 2017 Max Lee (https://github.com/Phoenix616) + * + * 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 . + */ +public class LegacyMappings { + + private static final LegacyBlock[] BLOCKS = new LegacyBlock[] { + new LegacyBlock(0, "air"), + new LegacyBlock(1, "stone"), + new LegacyBlock(1, 1, "stone", "granite"), + new LegacyBlock(1, 2, "stone", "polished_granite"), + new LegacyBlock(1, 3, "stone", "diorite"), + new LegacyBlock(1, 4, "stone", "polished_diorite"), + new LegacyBlock(1, 5, "stone", "andesite"), + new LegacyBlock(1, 6, "stone", "polished_andesite"), + new LegacyBlock(2, "grass", "grass_block"), + new LegacyBlock(3, "dirt"), + new LegacyBlock(3, 1, "dirt", "coarse_dirt"), + new LegacyBlock(3, 2, "dirt", "podzol"), + new LegacyBlock(4, "cobblestone"), + new LegacyBlock(5, "wood", "oak_planks"), + new LegacyBlock(5, 1, "wood", "spruce_planks"), + new LegacyBlock(5, 2, "wood", "birch_planks"), + new LegacyBlock(5, 3, "wood", "jungle_planks"), + new LegacyBlock(5, 4, "wood", "acacia_planks"), + new LegacyBlock(5, 5, "wood", "dark_oak_planks"), + new LegacyBlock(6, "sapling", "oak_sapling"), + new LegacyBlock(6, 1, "sapling", "spruce_sapling"), + new LegacyBlock(6, 2, "sapling", "birch_sapling"), + new LegacyBlock(6, 3, "sapling", "jungle_sapling"), + new LegacyBlock(6, 4, "sapling", "acacia_sapling"), + new LegacyBlock(6, 5, "sapling", "dark_oak_sapling"), + new LegacyBlock(7, "bedrock"), + new LegacyBlock(8, "water", "flowing_water"), + new LegacyBlock(9, "stationary_water", "water"), + new LegacyBlock(10, "lava", "flowing_lava"), + new LegacyBlock(11, "stationary_lava", "lava"), + new LegacyBlock(12, "sand"), + new LegacyBlock(12, 1, "sand", "red_sand"), + new LegacyBlock(13, "gravel"), + new LegacyBlock(14, "gold_ore"), + new LegacyBlock(15, "iron_ore"), + new LegacyBlock(16, "coal_ore"), + new LegacyBlock(17, "log", "oak_log"), + new LegacyBlock(17, 1, "log", "oak_log"), + new LegacyBlock(17, 2, "log", "spruce_log"), + new LegacyBlock(17, 3, "log", "birch_log"), + new LegacyBlock(17, 4, "log", "jungle_log"), + new LegacyBlock(17, 5, "log", "oak_bark"), + new LegacyBlock(17, 6, "log", "spruce_bark"), + new LegacyBlock(17, 7, "log", "birch_bark"), + new LegacyBlock(17, 8, "log", "jungle_bark"), + new LegacyBlock(18, "leaves", "oak_leaves"), + new LegacyBlock(18, 1, "leaves", "spruce_leaves"), + new LegacyBlock(18, 2, "leaves", "birch_leaves"), + new LegacyBlock(18, 3, "leaves", "jungle_leaves"), + new LegacyBlock(19, "sponge"), + new LegacyBlock(19, 1, "sponge", "wet_sponge"), + new LegacyBlock(20, "glass"), + new LegacyBlock(21, "lapis_ore"), + new LegacyBlock(22, "lapis_block"), + new LegacyBlock(23, "dispenser"), + new LegacyBlock(24, "sandstone"), + new LegacyBlock(24, 1, "sandstone", "chisled_sandstone"), + new LegacyBlock(24, 2, "sandstone", "cut_sandstone"), + new LegacyBlock(25, "note_block"), + new LegacyBlock(26, "bed_block"), + new LegacyBlock(27, "powered_rail"), + new LegacyBlock(28, "detector_rail"), + new LegacyBlock(29, "piston_sticky_base", "sticky_piston"), + new LegacyBlock(30, "web", "cobweb"), + new LegacyBlock(31, "long_grass", "dead_bush"), + new LegacyBlock(31, 1, "long_grass", "grass"), + new LegacyBlock(31, 2, "long_grass", "fern"), + new LegacyBlock(32, "dead_bush"), + new LegacyBlock(33, "piston_base", "piston"), + new LegacyBlock(34, "piston_extension", "piston_head"), + new LegacyBlock(35, "wool", "white_wool"), + new LegacyBlock(35, 1, "wool", "orange_wool"), + new LegacyBlock(35, 2, "wool", "magenta_wool"), + new LegacyBlock(35, 3, "wool", "light_blue_wool"), + new LegacyBlock(35, 4, "wool", "yellow_wool"), + new LegacyBlock(35, 5, "wool", "lime_wool"), + new LegacyBlock(35, 6, "wool", "pink_wool"), + new LegacyBlock(35, 7, "wool", "gray_wool"), + new LegacyBlock(35, 8, "wool", "light_gray_wool"), + new LegacyBlock(35, 9, "wool", "cyan_wool"), + new LegacyBlock(35, 10, "wool", "purple_wool"), + new LegacyBlock(35, 11, "wool", "blue_wool"), + new LegacyBlock(35, 12, "wool", "brown_wool"), + new LegacyBlock(35, 13, "wool", "green_wool"), + new LegacyBlock(35, 14, "wool", "red_wool"), + new LegacyBlock(35, 15, "wool", "black_wool"), + new LegacyBlock(36, "piston_moving_piece", "moving_piston"), + new LegacyBlock(37, "yellow_flower", "dandelion"), + new LegacyBlock(38, "red_rose", "poppy"), + new LegacyBlock(38, 1, "red_rose", "blue_orchid"), + new LegacyBlock(38, 2, "red_rose", "allium"), + new LegacyBlock(38, 3, "red_rose", "azure_bluet"), + new LegacyBlock(38, 4, "red_rose", "red_tulip"), + new LegacyBlock(38, 5, "red_rose", "orange_tulip"), + new LegacyBlock(38, 6, "red_rose", "white_tulip"), + new LegacyBlock(38, 7, "red_rose", "pink_tulip"), + new LegacyBlock(38, 8, "red_rose", "oxeye_daisy"), + new LegacyBlock(39, "brown_mushroom"), + new LegacyBlock(40, "red_mushroom"), + new LegacyBlock(41, "gold_block"), + new LegacyBlock(42, "iron_block"), + new LegacyBlock(43, "double_step"), + new LegacyBlock(43, 6, "double_step", "smooth_quartz"), + new LegacyBlock(43, 8, "double_step", "smooth_stone"), + new LegacyBlock(43, 9, "double_step", "smooth_sandstone"), + new LegacyBlock(44, "step", "stone_slab"), + new LegacyBlock(44, 1, "step", "sandstone_slab"), + new LegacyBlock(44, 2, "step", "petrified_oak_slab"), + new LegacyBlock(44, 3, "step", "cobblestone_slab"), + new LegacyBlock(44, 4, "step", "brick_slab"), + new LegacyBlock(44, 5, "step", "stone_brick_slab"), + new LegacyBlock(44, 6, "step", "nether_brick_slab"), + new LegacyBlock(44, 7, "step", "quartz_slab"), + new LegacyBlock(45, "brick", "bricks"), + new LegacyBlock(46, "tnt"), + new LegacyBlock(47, "bookshelf"), + new LegacyBlock(48, "mossy_cobblestone"), + new LegacyBlock(49, "obsidian"), + new LegacyBlock(50, "torch"), + new LegacyBlock(50, 1, "torch", "wall_torch"), + new LegacyBlock(50, 2, "torch", "wall_torch"), + new LegacyBlock(50, 3, "torch", "wall_torch"), + new LegacyBlock(50, 4, "torch", "wall_torch"), + new LegacyBlock(50, 5, "torch"), + new LegacyBlock(51, "fire"), + new LegacyBlock(52, "mob_spawner"), + new LegacyBlock(53, "wood_stairs", "oak_stairs"), + new LegacyBlock(54, "chest", "chest"), + new LegacyBlock(55, "redstone_wire"), + new LegacyBlock(56, "diamond_ore"), + new LegacyBlock(57, "diamond_block"), + new LegacyBlock(58, "workbench", "crafting_table"), + new LegacyBlock(59, "crops", "wheat"), + new LegacyBlock(60, "soil", "farmland"), + new LegacyBlock(61, "furnace"), + new LegacyBlock(62, "burning_furnace"), + new LegacyBlock(63, "sign_post", "sign"), + new LegacyBlock(64, "wooden_door", "oak_door"), + new LegacyBlock(65, "ladder"), + new LegacyBlock(66, "rails", "rail"), + new LegacyBlock(67, "cobblestone_stairs"), + new LegacyBlock(68, "wall_sign"), + new LegacyBlock(69, "lever"), + new LegacyBlock(70, "stone_plate", "stone_pressure_plate"), + new LegacyBlock(71, "iron_door_block", "iron_door"), + new LegacyBlock(72, "wood_plate", "oak_pressure_plate"), + new LegacyBlock(73, "redstone_ore"), + new LegacyBlock(74, "glowing_redstone_ore"), + new LegacyBlock(75, "redstone_torch_off"), + new LegacyBlock(76, "redstone_torch_on", "redstone_torch"), + new LegacyBlock(76, 1, "redstone_torch_on", "redstone_wall_torch"), + new LegacyBlock(76, 2, "redstone_torch_on", "redstone_wall_torch"), + new LegacyBlock(76, 3, "redstone_torch_on", "redstone_wall_torch"), + new LegacyBlock(76, 4, "redstone_torch_on", "redstone_wall_torch"), + new LegacyBlock(76, 5, "redstone_torch_on", "redstone_torch"), + new LegacyBlock(77, "stone_button"), + new LegacyBlock(78, "snow"), + new LegacyBlock(79, "ice"), + new LegacyBlock(80, "snow_block"), + new LegacyBlock(81, "cactus"), + new LegacyBlock(82, "clay"), + new LegacyBlock(83, "sugar_cane_block", "sugar_cane"), + new LegacyBlock(84, "jukebox"), + new LegacyBlock(85, "fence", "oak_fence"), + new LegacyBlock(86, "pumpkin", "carved_pumpkin"), + new LegacyBlock(87, "netherrack"), + new LegacyBlock(88, "soul_sand"), + new LegacyBlock(89, "glowstone"), + new LegacyBlock(90, "portal"), + new LegacyBlock(91, "jack_o_lantern"), + new LegacyBlock(92, "cake_block", "cake"), + new LegacyBlock(93, "diode_block_off"), + new LegacyBlock(94, "diode_block_on", "repeater"), + new LegacyBlock(95, "stained_glass", "white_stained_glass"), + new LegacyBlock(95, 1, "stained_glass", "orange_stained_glass"), + new LegacyBlock(95, 2, "stained_glass", "magenta_stained_glass"), + new LegacyBlock(95, 3, "stained_glass", "light_blue_stained_glass"), + new LegacyBlock(95, 4, "stained_glass", "yellow_stained_glass"), + new LegacyBlock(95, 5, "stained_glass", "lime_stained_glass"), + new LegacyBlock(95, 6, "stained_glass", "pink_stained_glass"), + new LegacyBlock(95, 7, "stained_glass", "gray_stained_glass"), + new LegacyBlock(95, 8, "stained_glass", "light_gray_stained_glass"), + new LegacyBlock(95, 9, "stained_glass", "cyan_stained_glass"), + new LegacyBlock(95, 10, "stained_glass", "purple_stained_glass"), + new LegacyBlock(95, 11, "stained_glass", "blue_stained_glass"), + new LegacyBlock(95, 12, "stained_glass", "brown_stained_glass"), + new LegacyBlock(95, 13, "stained_glass", "green_stained_glass"), + new LegacyBlock(95, 14, "stained_glass", "red_stained_glass"), + new LegacyBlock(95, 15, "stained_glass", "black_stained_glass"), + new LegacyBlock(96, "trap_door", "oak_trapdoor"), + new LegacyBlock(97, "monster_eggs", "infested_stone"), + new LegacyBlock(97, 1, "monster_eggs", "infested_coblestone"), + new LegacyBlock(97, 2, "monster_eggs", "infested_stone_bricks"), + new LegacyBlock(97, 3, "monster_eggs", "infested_mossy_stone_bricks"), + new LegacyBlock(97, 4, "monster_eggs", "infested_crcked_stone_bricks"), + new LegacyBlock(97, 5, "monster_eggs", "infested_chiseled_stone_bricks"), + new LegacyBlock(98, "smooth_brick", "stone_bricks"), + new LegacyBlock(98, 1, "smooth_brick", "mossy_stone_bricks"), + new LegacyBlock(98, 2, "smooth_brick", "cracked_stone_bricks"), + new LegacyBlock(98, 3, "smooth_brick", "chiseled_bricks"), + new LegacyBlock(99, "huge_mushroom_1", "brown_mushroom_block"), + new LegacyBlock(99, 1, "huge_mushroom_1"), + new LegacyBlock(99, 2, "huge_mushroom_1"), + new LegacyBlock(99, 3, "huge_mushroom_1"), + new LegacyBlock(99, 4, "huge_mushroom_1"), + new LegacyBlock(99, 5, "huge_mushroom_1"), + new LegacyBlock(99, 6, "huge_mushroom_1"), + new LegacyBlock(99, 7, "huge_mushroom_1"), + new LegacyBlock(99, 8, "huge_mushroom_1"), + new LegacyBlock(99, 9, "huge_mushroom_1"), + new LegacyBlock(99, 10, "huge_mushroom_1", "mushroom_stem"), + new LegacyBlock(99, 14, "huge_mushroom_1"), + new LegacyBlock(99, 15, "huge_mushroom_1"), + new LegacyBlock(100, "huge_mushroom_2", "red_mushroom_block"), + new LegacyBlock(100, 1, "huge_mushroom_2"), + new LegacyBlock(100, 2, "huge_mushroom_2"), + new LegacyBlock(100, 3, "huge_mushroom_2"), + new LegacyBlock(100, 4, "huge_mushroom_2"), + new LegacyBlock(100, 5, "huge_mushroom_2"), + new LegacyBlock(100, 6, "huge_mushroom_2"), + new LegacyBlock(100, 7, "huge_mushroom_2"), + new LegacyBlock(100, 8, "huge_mushroom_2"), + new LegacyBlock(100, 9, "huge_mushroom_2"), + new LegacyBlock(100, 10, "huge_mushroom_2", "mushroom_stem"), + new LegacyBlock(100, 14, "huge_mushroom_2"), + new LegacyBlock(100, 15, "huge_mushroom_2"), + new LegacyBlock(101, "iron_fence", "ironbars"), + new LegacyBlock(102, "thin_glass", "glass_pane"), + new LegacyBlock(103, "melon_block"), + new LegacyBlock(104, "pumpkin_stem"), + new LegacyBlock(105, "melon_stem"), + new LegacyBlock(106, "vine"), + new LegacyBlock(107, "fence_gate", "oak_fence_gate"), + new LegacyBlock(108, "brick_stairs"), + new LegacyBlock(109, "smooth_stairs", "stone_brick_stairs"), + new LegacyBlock(110, "mycel", "mycelium"), + new LegacyBlock(111, "water_lily", "lily_pad"), + new LegacyBlock(112, "nether_brick", "nether_bricks"), + new LegacyBlock(113, "nether_fence", "nether_brick_fence"), + new LegacyBlock(114, "nether_brick_stairs"), + new LegacyBlock(115, "nether_warts", "nether_wart"), + new LegacyBlock(116, "enchantment_table", "enchanting_table"), + new LegacyBlock(117, "brewing_stand"), + new LegacyBlock(118, "cauldron"), + new LegacyBlock(119, "ender_portal", "end_portal"), + new LegacyBlock(120, "ender_portal_frame", "end_portal_frame"), + new LegacyBlock(121, "ender_stone", "end_stone"), + new LegacyBlock(122, "dragon_egg"), + new LegacyBlock(123, "redstone_lamp_off"), + new LegacyBlock(124, "redstone_lamp_on", "redstone_lamp"), + new LegacyBlock(125, "wood_double_step"), + new LegacyBlock(125, 1, "wood_double_step"), + new LegacyBlock(125, 2, "wood_double_step"), + new LegacyBlock(125, 3, "wood_double_step"), + new LegacyBlock(125, 4, "wood_double_step"), + new LegacyBlock(125, 5, "wood_double_step"), + new LegacyBlock(126, "wood_step", "oak_slab"), + new LegacyBlock(126, 1, "wood_step", "spruce_slab"), + new LegacyBlock(126, 2, "wood_step", "birch_slab"), + new LegacyBlock(126, 3, "wood_step", "jungle_slab"), + new LegacyBlock(126, 4, "wood_step", "acacia_slab"), + new LegacyBlock(126, 5, "wood_step", "dark_oak_slab"), + new LegacyBlock(127, "cocoa"), + new LegacyBlock(128, "sandstone_stairs"), + new LegacyBlock(129, "emerald_ore"), + new LegacyBlock(130, "ender_chest"), + new LegacyBlock(131, "tripwire_hook"), + new LegacyBlock(132, "tripwire"), + new LegacyBlock(133, "emerald_block"), + new LegacyBlock(134, "spruce_wood_stairs", "spruce_stairs"), + new LegacyBlock(135, "birch_wood_stairs", "birch_stairs"), + new LegacyBlock(136, "jungle_wood_stairs", "jungle_stairs"), + new LegacyBlock(137, "command", "command_block"), + new LegacyBlock(138, "beacon"), + new LegacyBlock(139, "cobble_wall", "cobblestone_wall"), + new LegacyBlock(139, 1, "cobble_wall", "mossy_cobblestone_wall"), + new LegacyBlock(140, "flower_pot"), + new LegacyBlock(141, "carrot", "carrots"), + new LegacyBlock(142, "potato", "potatoes"), + new LegacyBlock(143, "wood_button", "oak_button"), + new LegacyBlock(144, "skull", "skeleton_skull"), + new LegacyBlock(144, 1, "skull", "skeleton_wall_skull"), + new LegacyBlock(144, 2, "skull", "skeleton_wall_skull"), + new LegacyBlock(144, 3, "skull", "skeleton_wall_skull"), + new LegacyBlock(144, 4, "skull", "skeleton_wall_skull"), + new LegacyBlock(144, 5, "skull", "skeleton_wall_skull"), + new LegacyBlock(145, "anvil"), + new LegacyBlock(145, 1, "anvil", "chipped_anvil"), + new LegacyBlock(145, 2, "anvil", "damaged_anvil"), + new LegacyBlock(146, "trapped_chest"), + new LegacyBlock(147, "gold_plate", "light_weighted_pressure_plate"), + new LegacyBlock(148, "iron_plate", "heavy_weighted_pressure_plate"), + new LegacyBlock(149, "redstone_comparator_off"), + new LegacyBlock(150, "redstone_comparator_on", "comparator"), + new LegacyBlock(151, "daylight_detector"), + new LegacyBlock(152, "redstone_block"), + new LegacyBlock(153, "quartz_ore", "nether_quartz_ore"), + new LegacyBlock(154, "hopper"), + new LegacyBlock(155, "quartz_block"), + new LegacyBlock(156, "quartz_stairs"), + new LegacyBlock(157, "activator_rail"), + new LegacyBlock(158, "dropper"), + new LegacyBlock(159, "stained_clay", "white_terracotta"), + new LegacyBlock(159, 1, "stained_clay", "orange_terracotta"), + new LegacyBlock(159, 2, "stained_clay", "magenta_terracotta"), + new LegacyBlock(159, 3, "stained_clay", "light_blue_terracotta"), + new LegacyBlock(159, 4, "stained_clay", "yellow_terracotta"), + new LegacyBlock(159, 5, "stained_clay", "lime_terracotta"), + new LegacyBlock(159, 6, "stained_clay", "pink_terracotta"), + new LegacyBlock(159, 7, "stained_clay", "gray_terracotta"), + new LegacyBlock(159, 8, "stained_clay", "light_gray_terracotta"), + new LegacyBlock(159, 9, "stained_clay", "cyan_terracotta"), + new LegacyBlock(159, 10, "stained_clay", "purple_terracotta"), + new LegacyBlock(159, 11, "stained_clay", "blue_terracotta"), + new LegacyBlock(159, 12, "stained_clay", "brown_terracotta"), + new LegacyBlock(159, 13, "stained_clay", "green_terracotta"), + new LegacyBlock(159, 14, "stained_clay", "red_terracotta"), + new LegacyBlock(159, 15, "stained_clay", "black_terracotta"), + new LegacyBlock(160, "stained_glass_pane", "white_stained_glass_pane"), + new LegacyBlock(160, 1, "stained_glass_pane", "orange_stained_glass_pane"), + new LegacyBlock(160, 2, "stained_glass_pane", "magenta_stained_glass_pane"), + new LegacyBlock(160, 3, "stained_glass_pane", "light_blue_stained_glass_pane"), + new LegacyBlock(160, 4, "stained_glass_pane", "yellow_stained_glass_pane"), + new LegacyBlock(160, 5, "stained_glass_pane", "lime_stained_glass_pane"), + new LegacyBlock(160, 6, "stained_glass_pane", "pink_stained_glass_pane"), + new LegacyBlock(160, 7, "stained_glass_pane", "gray_stained_glass_pane"), + new LegacyBlock(160, 8, "stained_glass_pane", "light_gray_stained_glass_pane"), + new LegacyBlock(160, 9, "stained_glass_pane", "cyan_stained_glass_pane"), + new LegacyBlock(160, 10, "stained_glass_pane", "purple_stained_glass_pane"), + new LegacyBlock(160, 11, "stained_glass_pane", "blue_stained_glass_pane"), + new LegacyBlock(160, 12, "stained_glass_pane", "brown_stained_glass_pane"), + new LegacyBlock(160, 13, "stained_glass_pane", "green_stained_glass_pane"), + new LegacyBlock(160, 14, "stained_glass_pane", "red_stained_glass_pane"), + new LegacyBlock(160, 15, "stained_glass_pane", "black_stained_glass_pane"), + new LegacyBlock(161, "leaves_2", "acacia_leaves"), + new LegacyBlock(161, 1, "leaves_2", "dark_oak_leaves"), + new LegacyBlock(162, "log_2", "acacia_log"), + new LegacyBlock(162, 1, "log_2", "spruce_log"), + new LegacyBlock(162, 2, "log_2", "birch_log"), + new LegacyBlock(162, 3, "log_2", "jungle_log"), + new LegacyBlock(163, "acacia_stairs", "acacia_stairs"), + new LegacyBlock(164, "dark_oak_stairs", "dark_oak_stairs"), + new LegacyBlock(165, "slime_block", "slime_block"), + new LegacyBlock(166, "barrier", "barrier"), + new LegacyBlock(167, "iron_trapdoor", "iron_trapdoor"), + new LegacyBlock(168, "prismarine"), + new LegacyBlock(168, 1, "prismarine", "prismarine_bricks"), + new LegacyBlock(168, 2, "prismarine", "dark_prismarine"), + new LegacyBlock(169, "sea_lantern"), + new LegacyBlock(170, "hay_block"), + new LegacyBlock(171, "carpet", "white_carpet"), + new LegacyBlock(171, 1, "carpet", "orange_carpet"), + new LegacyBlock(171, 2, "carpet", "magenta_carpet"), + new LegacyBlock(171, 3, "carpet", "light_blue_carpet"), + new LegacyBlock(171, 4, "carpet", "yellow_carpet"), + new LegacyBlock(171, 5, "carpet", "lime_carpet"), + new LegacyBlock(171, 6, "carpet", "pink_carpet"), + new LegacyBlock(171, 7, "carpet", "gray_carpet"), + new LegacyBlock(171, 8, "carpet", "light_gray_carpet"), + new LegacyBlock(171, 9, "carpet", "cyan_carpet"), + new LegacyBlock(171, 10, "carpet", "purple_carpet"), + new LegacyBlock(171, 11, "carpet", "blue_carpet"), + new LegacyBlock(171, 12, "carpet", "brown_carpet"), + new LegacyBlock(171, 13, "carpet", "green_carpet"), + new LegacyBlock(171, 14, "carpet", "red_carpet"), + new LegacyBlock(171, 15, "carpet", "black_carpet"), + new LegacyBlock(172, "hard_clay", "terracotta"), + new LegacyBlock(173, "coal_block"), + new LegacyBlock(174, "packed_ice"), + new LegacyBlock(175, "double_plant", "sunflower"), + new LegacyBlock(175, 1, "double_plant", "lilac"), + new LegacyBlock(175, 2, "double_plant", "tall_grass"), + new LegacyBlock(175, 3, "double_plant", "large_fern"), + new LegacyBlock(175, 4, "double_plant", "rose_bush"), + new LegacyBlock(175, 5, "double_plant", "peony"), + new LegacyBlock(176, "standing_banner"), + new LegacyBlock(177, "wall_banner"), + new LegacyBlock(178, "daylight_detector_inverted"), + new LegacyBlock(179, "red_sandstone", "red_sandstone"), + new LegacyBlock(179, 1, "red_sandstone", "chiseled_red_sandstone"), + new LegacyBlock(179, 2, "red_sandstone", "cut_red_sandstone"), + new LegacyBlock(180, "red_sandstone_stairs"), + new LegacyBlock(181, "double_stone_slab2"), + new LegacyBlock(181, 8, "double_stone_slab2", "smooth_red_sandstone"), + new LegacyBlock(182, "stone_slab2", "red_sandstone_slab"), + new LegacyBlock(183, "spruce_fence_gate"), + new LegacyBlock(184, "birch_fence_gate"), + new LegacyBlock(185, "jungle_fence_gate"), + new LegacyBlock(186, "dark_oak_fence_gate"), + new LegacyBlock(187, "acacia_fence_gate"), + new LegacyBlock(188, "spruce_fence"), + new LegacyBlock(189, "birch_fence"), + new LegacyBlock(190, "jungle_fence"), + new LegacyBlock(191, "dark_oak_fence"), + new LegacyBlock(192, "acacia_fence"), + new LegacyBlock(193, "spruce_door"), + new LegacyBlock(194, "birch_door"), + new LegacyBlock(195, "jungle_door"), + new LegacyBlock(196, "acacia_door"), + new LegacyBlock(197, "dark_oak_door"), + new LegacyBlock(198, "end_rod"), + new LegacyBlock(199, "chorus_plant"), + new LegacyBlock(200, "chorus_flower"), + new LegacyBlock(201, "purpur_block"), + new LegacyBlock(202, "purpur_pillar"), + new LegacyBlock(203, "purpur_stairs"), + new LegacyBlock(204, "purpur_double_slab"), + new LegacyBlock(205, "purpur_slab"), + new LegacyBlock(206, "end_bricks", "end_stone_bricks"), + new LegacyBlock(207, "beetroot_block", "beetroots"), + new LegacyBlock(208, "grass_path"), + new LegacyBlock(209, "end_gateway"), + new LegacyBlock(210, "command_repeating", "repeating_command_block"), + new LegacyBlock(211, "command_chain", "chain_command_block"), + new LegacyBlock(212, "frosted_ice"), + new LegacyBlock(213, "magma", "magma_block"), + new LegacyBlock(214, "nether_wart_block"), + new LegacyBlock(215, "red_nether_brick", "red_nether_bricks"), + new LegacyBlock(216, "bone_block"), + new LegacyBlock(217, "structure_void"), + new LegacyBlock(218, "observer"), + new LegacyBlock(219, "white_shulker_box"), + new LegacyBlock(220, "orange_shulker_box"), + new LegacyBlock(221, "magenta_shulker_box"), + new LegacyBlock(222, "light_blue_shulker_box"), + new LegacyBlock(223, "yellow_shulker_box"), + new LegacyBlock(224, "lime_shulker_box"), + new LegacyBlock(225, "pink_shulker_box"), + new LegacyBlock(226, "gray_shulker_box"), + new LegacyBlock(227, "silver_shulker_box", "light_gray_shulker_box"), + new LegacyBlock(228, "cyan_shulker_box"), + new LegacyBlock(229, "purple_shulker_box"), + new LegacyBlock(230, "blue_shulker_box"), + new LegacyBlock(231, "brown_shulker_box"), + new LegacyBlock(232, "green_shulker_box"), + new LegacyBlock(233, "red_shulker_box"), + new LegacyBlock(234, "black_shulker_box"), + new LegacyBlock(235, "white_glazed_terracotta"), + new LegacyBlock(236, "orange_glazed_terracotta"), + new LegacyBlock(237, "magenta_glazed_terracotta"), + new LegacyBlock(238, "light_blue_glazed_terracotta"), + new LegacyBlock(239, "yellow_glazed_terracotta"), + new LegacyBlock(240, "lime_glazed_terracotta"), + new LegacyBlock(241, "pink_glazed_terracotta"), + new LegacyBlock(242, "gray_glazed_terracotta"), + new LegacyBlock(243, "silver_glazed_terracotta", "light_gray_glazed_terracotta"), + new LegacyBlock(244, "cyan_glazed_terracotta"), + new LegacyBlock(245, "purple_glazed_terracotta"), + new LegacyBlock(246, "blue_glazed_terracotta"), + new LegacyBlock(247, "brown_glazed_terracotta"), + new LegacyBlock(248, "green_glazed_terracotta"), + new LegacyBlock(249, "red_glazed_terracotta"), + new LegacyBlock(250, "black_glazed_terracotta"), + new LegacyBlock(251, "concrete", "white_concrete"), + new LegacyBlock(251, 1, "concrete", "orange_concrete"), + new LegacyBlock(251, 2, "concrete", "magenta_concrete"), + new LegacyBlock(251, 3, "concrete", "light_blue_concrete"), + new LegacyBlock(251, 4, "concrete", "yellow_concrete"), + new LegacyBlock(251, 5, "concrete", "lime_concrete"), + new LegacyBlock(251, 6, "concrete", "pink_concrete"), + new LegacyBlock(251, 7, "concrete", "gray_concrete"), + new LegacyBlock(251, 8, "concrete", "light_gray_concrete"), + new LegacyBlock(251, 9, "concrete", "cyan_concrete"), + new LegacyBlock(251, 10, "concrete", "purple_concrete"), + new LegacyBlock(251, 11, "concrete", "blue_concrete"), + new LegacyBlock(251, 12, "concrete", "brown_concrete"), + new LegacyBlock(251, 13, "concrete", "green_concrete"), + new LegacyBlock(251, 14, "concrete", "red_concrete"), + new LegacyBlock(251, 15, "concrete", "black_concrete"), + new LegacyBlock(252, "concrete_powder", "white_concrete_powder"), + new LegacyBlock(252, 1, "concrete_powder", "orange_concrete_powder"), + new LegacyBlock(252, 2, "concrete_powder", "magenta_concrete_powder"), + new LegacyBlock(252, 3, "concrete_powder", "light_blue_concrete_powder"), + new LegacyBlock(252, 4, "concrete_powder", "yellow_concrete_powder"), + new LegacyBlock(252, 5, "concrete_powder", "lime_concrete_powder"), + new LegacyBlock(252, 6, "concrete_powder", "pink_concrete_powder"), + new LegacyBlock(252, 7, "concrete_powder", "gray_concrete_powder"), + new LegacyBlock(252, 8, "concrete_powder", "light_gray_concrete_powder"), + new LegacyBlock(252, 9, "concrete_powder", "cyan_concrete_powder"), + new LegacyBlock(252, 10, "concrete_powder", "purple_concrete_powder"), + new LegacyBlock(252, 11, "concrete_powder", "blue_concrete_powder"), + new LegacyBlock(252, 12, "concrete_powder", "brown_concrete_powder"), + new LegacyBlock(252, 13, "concrete_powder", "green_concrete_powder"), + new LegacyBlock(252, 14, "concrete_powder", "red_concrete_powder"), + new LegacyBlock(252, 15, "concrete_powder", "black_concrete_powder"), + new LegacyBlock(255, "structure_block"), + new LegacyBlock(256, "iron_spade", "iron_shovel"), + new LegacyBlock(257, "iron_pickaxe"), + new LegacyBlock(258, "iron_axe"), + new LegacyBlock(259, "flint_and_steel"), + new LegacyBlock(260, "apple"), + new LegacyBlock(261, "bow"), + new LegacyBlock(262, "arrow"), + new LegacyBlock(263, "coal"), + new LegacyBlock(263, 1, "coal", "charcoal"), + new LegacyBlock(264, "diamond"), + new LegacyBlock(265, "iron_ingot"), + new LegacyBlock(266, "gold_ingot"), + new LegacyBlock(267, "iron_sword"), + new LegacyBlock(268, "wood_sword", "wooden_sword"), + new LegacyBlock(269, "wood_spade", "wooden_shovel"), + new LegacyBlock(270, "wood_pickaxe", "wooden_pickaxe"), + new LegacyBlock(271, "wood_axe", "wooden_axe"), + new LegacyBlock(272, "stone_sword"), + new LegacyBlock(273, "stone_spade", "stone_shovel"), + new LegacyBlock(274, "stone_pickaxe"), + new LegacyBlock(275, "stone_axe"), + new LegacyBlock(276, "diamond_sword"), + new LegacyBlock(277, "diamond_spade", "diamond_shovel"), + new LegacyBlock(278, "diamond_pickaxe"), + new LegacyBlock(279, "diamond_axe"), + new LegacyBlock(280, "stick"), + new LegacyBlock(281, "bowl"), + new LegacyBlock(282, "mushroom_soup", "mushroom_stew"), + new LegacyBlock(283, "gold_sword", "golden_sword"), + new LegacyBlock(284, "gold_spade", "golden_shovel"), + new LegacyBlock(285, "gold_pickaxe", "golden_pickaxe"), + new LegacyBlock(286, "gold_axe", "golden_axe"), + new LegacyBlock(287, "string"), + new LegacyBlock(288, "feather"), + new LegacyBlock(289, "sulphur", "gunpowder"), + new LegacyBlock(290, "wood_hoe", "wooden_hoe"), + new LegacyBlock(291, "stone_hoe"), + new LegacyBlock(292, "iron_hoe"), + new LegacyBlock(293, "diamond_hoe"), + new LegacyBlock(294, "gold_hoe", "golden_hoe"), + new LegacyBlock(295, "seeds", "wheat_seeds"), + new LegacyBlock(296, "wheat"), + new LegacyBlock(297, "bread"), + new LegacyBlock(298, "leather_helmet"), + new LegacyBlock(299, "leather_chestplate"), + new LegacyBlock(300, "leather_leggings"), + new LegacyBlock(301, "leather_boots"), + new LegacyBlock(302, "chainmail_helmet"), + new LegacyBlock(303, "chainmail_chestplate"), + new LegacyBlock(304, "chainmail_leggings"), + new LegacyBlock(305, "chainmail_boots"), + new LegacyBlock(306, "iron_helmet"), + new LegacyBlock(307, "iron_chestplate"), + new LegacyBlock(308, "iron_leggings"), + new LegacyBlock(309, "iron_boots"), + new LegacyBlock(310, "diamond_helmet"), + new LegacyBlock(311, "diamond_chestplate"), + new LegacyBlock(312, "diamond_leggings"), + new LegacyBlock(313, "diamond_boots"), + new LegacyBlock(314, "gold_helmet", "golden_helmet"), + new LegacyBlock(315, "gold_chestplate", "golden_chestplate"), + new LegacyBlock(316, "gold_leggings", "golden_leggings"), + new LegacyBlock(317, "gold_boots", "golden_boots"), + new LegacyBlock(318, "flint"), + new LegacyBlock(319, "pork", "porkchop"), + new LegacyBlock(320, "grilled_pork", "cooked_porkchop"), + new LegacyBlock(321, "painting"), + new LegacyBlock(322, "golden_apple", "golden_apple"), + new LegacyBlock(322, 1, "golden_apple", "enchanted_golden_apple"), + new LegacyBlock(323, "sign"), + new LegacyBlock(324, "wood_door", "oak_door"), + new LegacyBlock(325, "bucket"), + new LegacyBlock(326, "water_bucket"), + new LegacyBlock(327, "lava_bucket"), + new LegacyBlock(328, "minecart"), + new LegacyBlock(329, "saddle"), + new LegacyBlock(330, "iron_door"), + new LegacyBlock(331, "redstone"), + new LegacyBlock(332, "snow_ball", "snowball"), + new LegacyBlock(333, "boat", "oak_boat"), + new LegacyBlock(334, "leather"), + new LegacyBlock(335, "milk_bucket"), + new LegacyBlock(336, "clay_brick", "brick"), + new LegacyBlock(337, "clay_ball"), + new LegacyBlock(338, "sugar_cane"), + new LegacyBlock(339, "paper"), + new LegacyBlock(340, "book"), + new LegacyBlock(341, "slime_ball"), + new LegacyBlock(342, "storage_minecart", "chest_minecart"), + new LegacyBlock(343, "powered_minecart", "furnace_minecart"), + new LegacyBlock(344, "egg"), + new LegacyBlock(345, "compass"), + new LegacyBlock(346, "fishing_rod"), + new LegacyBlock(347, "watch", "clock"), + new LegacyBlock(348, "glowstone_dust"), + new LegacyBlock(349, "raw_fish", "cod"), + new LegacyBlock(349, 1, "raw_fish", "salmon"), + new LegacyBlock(349, 2, "raw_fish", "tropical_fish"), + new LegacyBlock(349, 3, "raw_fish", "pufferfish"), + new LegacyBlock(350, "cooked_fish", "cooked_cod"), + new LegacyBlock(350, 1, "cooked_fish", "cooked_salmon"), + new LegacyBlock(351, "ink_sack", "ink_sac"), + new LegacyBlock(351, 1, "ink_sack", "rose_red"), + new LegacyBlock(351, 2, "ink_sack", "cactus_green"), + new LegacyBlock(351, 3, "ink_sack", "cocoa_beans"), + new LegacyBlock(351, 4, "ink_sack", "lapis_lazuli"), + new LegacyBlock(351, 5, "ink_sack", "purple_dye"), + new LegacyBlock(351, 6, "ink_sack", "cyan_dye"), + new LegacyBlock(351, 7, "ink_sack", "light_gray_dye"), + new LegacyBlock(351, 8, "ink_sack", "gray_dye"), + new LegacyBlock(351, 9, "ink_sack", "pink_dye"), + new LegacyBlock(351, 10, "ink_sack", "lime_dye"), + new LegacyBlock(351, 11, "ink_sack", "dandelion_yellow"), + new LegacyBlock(351, 12, "ink_sack", "light_blue_dye"), + new LegacyBlock(351, 13, "ink_sack", "magenta_dye"), + new LegacyBlock(351, 14, "ink_sack", "orange_dye"), + new LegacyBlock(351, 15, "ink_sack", "bone_meal"), + new LegacyBlock(352, "bone"), + new LegacyBlock(353, "sugar", "sugar"), + new LegacyBlock(354, "cake", "cake"), + new LegacyBlock(355, "bed", "white_bed"), + new LegacyBlock(355, 1, "bed", "orange_bed"), + new LegacyBlock(355, 2, "bed", "magenta_bed"), + new LegacyBlock(355, 3, "bed", "light_blue_bed"), + new LegacyBlock(355, 4, "bed", "yellow_bed"), + new LegacyBlock(355, 5, "bed", "lime_bed"), + new LegacyBlock(355, 6, "bed", "pink_bed"), + new LegacyBlock(355, 7, "bed", "gray_bed"), + new LegacyBlock(355, 8, "bed", "light_gray_bed"), + new LegacyBlock(355, 9, "bed", "cyan_bed"), + new LegacyBlock(355, 10, "bed", "purple_bed"), + new LegacyBlock(355, 11, "bed", "blue_bed"), + new LegacyBlock(355, 12, "bed", "brown_bed"), + new LegacyBlock(355, 13, "bed", "green_bed"), + new LegacyBlock(355, 14, "bed", "red_bed"), + new LegacyBlock(355, 15, "bed", "black_bed"), + new LegacyBlock(356, "diode", "repeater"), + new LegacyBlock(357, "cookie", "cookie"), + new LegacyBlock(358, "map"), + new LegacyBlock(359, "shears"), + new LegacyBlock(360, "melon", "melon"), + new LegacyBlock(361, "pumpkin_seeds", "pumpkin_seeds"), + new LegacyBlock(362, "melon_seeds", "melon_seeds"), + new LegacyBlock(363, "raw_beef", "beef"), + new LegacyBlock(364, "cooked_beef"), + new LegacyBlock(365, "raw_chicken", "chicken"), + new LegacyBlock(366, "cooked_chicken"), + new LegacyBlock(367, "rotten_flesh"), + new LegacyBlock(368, "ender_pearl"), + new LegacyBlock(369, "blaze_rod"), + new LegacyBlock(370, "ghast_tear"), + new LegacyBlock(371, "gold_nugget"), + new LegacyBlock(372, "nether_stalk", "nether_wart"), + new LegacyBlock(373, "potion", "potion"), + new LegacyBlock(374, "glass_bottle"), + new LegacyBlock(375, "spider_eye"), + new LegacyBlock(376, "fermented_spider_eye"), + new LegacyBlock(377, "blaze_powder"), + new LegacyBlock(378, "magma_cream"), + new LegacyBlock(379, "brewing_stand_item", "brewing_stand"), + new LegacyBlock(380, "cauldron_item", "cauldron"), + new LegacyBlock(381, "eye_of_ender", "ender_eye"), + new LegacyBlock(382, "speckled_melon"), + new LegacyBlock(383, "monster_egg"), + new LegacyBlock(383, 4, "monster_egg", "elder_guardian_spawn_egg"), + new LegacyBlock(383, 5, "monster_egg", "wither_skeleton_spawn_egg"), + new LegacyBlock(383, 6, "monster_egg", "stray_spawn_egg"), + new LegacyBlock(383, 23, "monster_egg", "husk_spawn_egg"), + new LegacyBlock(383, 27, "monster_egg", "zombe_villager_spawn_egg"), + new LegacyBlock(383, 28, "monster_egg", "skeleton_horse_spawn_egg"), + new LegacyBlock(383, 29, "monster_egg", "zombie_horse_spawn_egg"), + new LegacyBlock(383, 31, "monster_egg", "donkey_spawn_egg"), + new LegacyBlock(383, 32, "monster_egg", "mule_spawn_egg"), + new LegacyBlock(383, 34, "monster_egg", "evocation_illager_spawn_egg"), + new LegacyBlock(383, 35, "monster_egg", "vex_spawn_egg"), + new LegacyBlock(383, 36, "monster_egg", "vindication_illager_spawn_egg"), + new LegacyBlock(383, 50, "monster_egg", "creeper_spawn_egg"), + new LegacyBlock(383, 51, "monster_egg", "skeleton_spawn_egg"), + new LegacyBlock(383, 52, "monster_egg", "spider_spawn_egg"), + new LegacyBlock(383, 54, "monster_egg", "zombie_spawn_egg"), + new LegacyBlock(383, 55, "monster_egg", "slime_spawn_egg"), + new LegacyBlock(383, 56, "monster_egg", "ghast_spawn_egg"), + new LegacyBlock(383, 57, "monster_egg", "zombie_pigman_spawn_egg"), + new LegacyBlock(383, 58, "monster_egg", "enderman_spawn_egg"), + new LegacyBlock(383, 59, "monster_egg", "cave_spider_spawn_egg"), + new LegacyBlock(383, 60, "monster_egg", "silverfish_spawn_egg"), + new LegacyBlock(383, 61, "monster_egg", "blaze_spawn_egg"), + new LegacyBlock(383, 62, "monster_egg", "magma_cube_spawn_egg"), + new LegacyBlock(383, 65, "monster_egg", "bat_spawn_egg"), + new LegacyBlock(383, 66, "monster_egg", "witch_spawn_egg"), + new LegacyBlock(383, 67, "monster_egg", "endermite_spawn_egg"), + new LegacyBlock(383, 68, "monster_egg", "guardian_spawn_egg"), + new LegacyBlock(383, 69, "monster_egg", "shulker_spawn_egg"), + new LegacyBlock(383, 90, "monster_egg", "pig_spawn_egg"), + new LegacyBlock(383, 91, "monster_egg", "sheep_spawn_egg"), + new LegacyBlock(383, 92, "monster_egg", "cow_spawn_egg"), + new LegacyBlock(383, 93, "monster_egg", "chicken_spawn_egg"), + new LegacyBlock(383, 94, "monster_egg", "squid_spawn_egg"), + new LegacyBlock(383, 95, "monster_egg", "wolf_spawn_egg"), + new LegacyBlock(383, 96, "monster_egg", "mooshroom_spawn_egg"), + new LegacyBlock(383, 98, "monster_egg", "ocelot_spawn_egg"), + new LegacyBlock(383, 100, "monster_egg", "horse_spawn_egg"), + new LegacyBlock(383, 101, "monster_egg", "rabbit_spawn_egg"), + new LegacyBlock(383, 102, "monster_egg", "polar_bear_spawn_egg"), + new LegacyBlock(383, 103, "monster_egg", "llama_spawn_egg"), + new LegacyBlock(383, 120, "monster_egg", "villager_spawn_egg"), + new LegacyBlock(384, "exp_bottle", "experience_bottle"), + new LegacyBlock(385, "fireball", "fire_charge"), + new LegacyBlock(386, "book_and_quill", "writable_book"), + new LegacyBlock(387, "written_book"), + new LegacyBlock(388, "emerald"), + new LegacyBlock(389, "item_frame"), + new LegacyBlock(390, "flower_pot_item", "flower_pot"), + new LegacyBlock(391, "carrot_item", "carrot"), + new LegacyBlock(392, "potato_item", "potato"), + new LegacyBlock(393, "baked_potato"), + new LegacyBlock(394, "poisonous_potato"), + new LegacyBlock(395, "empty_map", "map"), + new LegacyBlock(396, "golden_carrot"), + new LegacyBlock(397, "skull_item", "skeleton_skull"), + new LegacyBlock(397, 1, "skull_item", "wither_skeleton_skull"), + new LegacyBlock(397, 2, "skull_item", "zombie_head"), + new LegacyBlock(397, 3, "skull_item", "player_head"), + new LegacyBlock(397, 4, "skull_item", "creeper_head"), + new LegacyBlock(397, 5, "skull_item", "dragon_head"), + new LegacyBlock(398, "carrot_stick"), + new LegacyBlock(399, "nether_star"), + new LegacyBlock(400, "pumpkin_pie"), + new LegacyBlock(401, "firework", "firework_rocket"), + new LegacyBlock(402, "firework_charge", "firework_star"), + new LegacyBlock(403, "enchanted_book"), + new LegacyBlock(404, "redstone_comparator", "comparator"), + new LegacyBlock(405, "nether_brick_item", "nether_brick"), + new LegacyBlock(406, "quartz"), + new LegacyBlock(407, "explosive_minecart", "tnt_minecart"), + new LegacyBlock(408, "hopper_minecart"), + new LegacyBlock(409, "prismarine_shard"), + new LegacyBlock(410, "prismarine_crystals"), + new LegacyBlock(411, "rabbit"), + new LegacyBlock(412, "cooked_rabbit"), + new LegacyBlock(413, "rabbit_stew"), + new LegacyBlock(414, "rabbit_foot"), + new LegacyBlock(415, "rabbit_hide"), + new LegacyBlock(416, "armor_stand"), + new LegacyBlock(417, "iron_barding", "iron_horse_armor"), + new LegacyBlock(418, "gold_barding", "gold_horse_armor"), + new LegacyBlock(419, "diamond_barding", "diamond_horse_armor"), + new LegacyBlock(420, "leash", "lead"), + new LegacyBlock(421, "name_tag"), + new LegacyBlock(422, "command_minecart", "command_block_minecart"), + new LegacyBlock(423, "mutton"), + new LegacyBlock(424, "cooked_mutton"), + new LegacyBlock(425, "banner", "white_banner"), + new LegacyBlock(425, 1, "banner", "orange_banner"), + new LegacyBlock(425, 2, "banner", "magenta_banner"), + new LegacyBlock(425, 3, "banner", "light_blue_banner"), + new LegacyBlock(425, 4, "banner", "yellow_banner"), + new LegacyBlock(425, 5, "banner", "lime_banner"), + new LegacyBlock(425, 6, "banner", "pink_banner"), + new LegacyBlock(425, 7, "banner", "gray_banner"), + new LegacyBlock(425, 8, "banner", "light_gray_banner"), + new LegacyBlock(425, 9, "banner", "cyan_banner"), + new LegacyBlock(425, 10, "banner", "purple_banner"), + new LegacyBlock(425, 11, "banner", "blue_banner"), + new LegacyBlock(425, 12, "banner", "brown_banner"), + new LegacyBlock(425, 13, "banner", "green_banner"), + new LegacyBlock(425, 14, "banner", "red_banner"), + new LegacyBlock(425, 15, "banner", "black_banner"), + new LegacyBlock(426, "end_crystal"), + new LegacyBlock(427, "spruce_door_item", "spruce_door"), + new LegacyBlock(428, "birch_door_item", "birch_door"), + new LegacyBlock(429, "jungle_door_item", "jungle_door"), + new LegacyBlock(430, "acacia_door_item", "acacia_door"), + new LegacyBlock(431, "dark_oak_door_item", "dark_oak_door"), + new LegacyBlock(432, "chorus_fruit"), + new LegacyBlock(433, "chorus_fruit_popped"), + new LegacyBlock(434, "beetroot"), + new LegacyBlock(435, "beetroot_seeds"), + new LegacyBlock(436, "beetroot_soup"), + new LegacyBlock(437, "dragons_breath", "dragon_breath"), + new LegacyBlock(438, "splash_potion"), + new LegacyBlock(439, "spectral_arrow"), + new LegacyBlock(440, "tipped_arrow"), + new LegacyBlock(441, "lingering_potion"), + new LegacyBlock(442, "shield"), + new LegacyBlock(443, "elytra"), + new LegacyBlock(444, "boat_spruce", "spruce_boat"), + new LegacyBlock(445, "boat_birch", "birch_boat"), + new LegacyBlock(446, "boat_jungle", "jungle_boat"), + new LegacyBlock(447, "boat_acacia", "acacia_boat"), + new LegacyBlock(448, "boat_dark_oak", "dark_oak_boat"), + new LegacyBlock(449, "totem", "totem_of_undying"), + new LegacyBlock(450, "shulker_shell"), + new LegacyBlock(452, "iron_nugget"), + new LegacyBlock(453, "knowledge_book"), + new LegacyBlock(2256, "gold_record", "music_disc_13"), + new LegacyBlock(2257, "green_record", "music_disc_cat"), + new LegacyBlock(2258, "record_3", "music_disc_blocks"), + new LegacyBlock(2259, "record_4", "music_disc_chirp"), + new LegacyBlock(2260, "record_5", "music_disc_far"), + new LegacyBlock(2261, "record_6", "music_disc_mall"), + new LegacyBlock(2262, "record_7", "music_disc_mellohi"), + new LegacyBlock(2263, "record_8", "music_disc_stal"), + new LegacyBlock(2264, "record_9", "music_disc_strad"), + new LegacyBlock(2265, "record_10", "music_disc_ward"), + new LegacyBlock(2266, "record_11", "music_disc_11"), + new LegacyBlock(2267, "record_12", "music_disc_wait") + }; + + private static final Map NUMERICAL_MAP = new HashMap<>(); + private static final Map NUMERICAL_AND_DATA_MAP = new HashMap<>(); + private static final Map LEGACY_NAME_MAP = new HashMap<>(); + private static final Map NEW_NAME_MAP = new HashMap<>(); + + public static void initialize() { + for (final LegacyBlock legacyBlock : BLOCKS) { + NUMERICAL_MAP.put(legacyBlock.getNumericalId(), legacyBlock); + if (legacyBlock.getDataValue() != 0) { + NUMERICAL_AND_DATA_MAP.put(new IdDataPair(legacyBlock.getNumericalId(), legacyBlock.getDataValue()), legacyBlock); + } + LEGACY_NAME_MAP.put(legacyBlock.getLegacyName(), legacyBlock); + NEW_NAME_MAP.put(legacyBlock.getNewName(), legacyBlock); + Material material; + try { + material = Material.valueOf(legacyBlock.getNewName()); + } catch (final Exception e) + { + material = Material.getMaterial(legacyBlock.getLegacyName(), true); + } + legacyBlock.material = material; + } + } + + public static LegacyBlock fromLegacyId(final int id) { + return NUMERICAL_MAP.get(id); + } + + public static LegacyBlock fromIdAndData(final int id, final int data) { + if (data == 0) { + return fromLegacyId(id); + } + return NUMERICAL_AND_DATA_MAP.get(new IdDataPair(id, data)); + } + + public static LegacyBlock fromLegacyName(final String id) { + return LEGACY_NAME_MAP.get(id); + } + + public static LegacyBlock fromNewName(final String id) { + return NEW_NAME_MAP.get(id.toLowerCase(Locale.ENGLISH)); + } + + @Getter + @EqualsAndHashCode + @ToString + @RequiredArgsConstructor + private static final class IdDataPair { + private final int id; + private final int data; + } + + @Getter + @RequiredArgsConstructor(access = AccessLevel.PRIVATE) + public static final class LegacyBlock { + + private final int numericalId; + private final int dataValue; + private final String legacyName; + private final String newName; + + private Material material; + + LegacyBlock(final int numericalId, final int dataValue, @NonNull final String legacyName) { + this(numericalId, dataValue, legacyName, legacyName); + } + + LegacyBlock(final int numericalId, @NonNull final String legacyName, @NonNull final String newName) { + this(numericalId, 0, legacyName, newName); + } + + LegacyBlock(final int numericalId, @NonNull final String legacyName) { + this(numericalId, legacyName, legacyName); + } + + } + +} diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue.java index b0e75a946..4775fdc8e 100644 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue.java +++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue.java @@ -1,17 +1,23 @@ package com.github.intellectualsites.plotsquared.bukkit.util.block; +import com.github.intellectualsites.plotsquared.bukkit.util.LegacyMappings; +import com.github.intellectualsites.plotsquared.plot.object.LegacyPlotBlock; import com.github.intellectualsites.plotsquared.plot.object.PlotBlock; +import com.github.intellectualsites.plotsquared.plot.object.StringPlotBlock; import com.github.intellectualsites.plotsquared.plot.util.MainUtil; import com.github.intellectualsites.plotsquared.plot.util.StringMan; import com.github.intellectualsites.plotsquared.plot.util.block.BasicLocalBlockQueue; +import lombok.NonNull; import org.bukkit.Bukkit; import org.bukkit.Chunk; +import org.bukkit.Material; import org.bukkit.World; import org.bukkit.block.Biome; import org.bukkit.block.Block; import java.lang.reflect.Field; import java.lang.reflect.Method; +import java.util.Locale; public class BukkitLocalQueue extends BasicLocalBlockQueue { @@ -38,11 +44,12 @@ public class BukkitLocalQueue extends BasicLocalBlockQueue { if (block == null) { return PlotBlock.get(0, 0); } - int id = block.getTypeId(); - if (id == 0) { - return PlotBlock.get(0, 0); - } - return PlotBlock.get(id, block.getData()); + // int id = block.getTypeId(); + // if (id == 0) { + // return PlotBlock.get(0, 0); + // } + // return PlotBlock.get(id, block.getData()); + return PlotBlock.get(block.getType().toString()); } @Override public void refreshChunk(int x, int z) { @@ -86,22 +93,48 @@ public class BukkitLocalQueue extends BasicLocalBlockQueue { int y = MainUtil.y_loc[layer][j]; int z = MainUtil.z_loc[layer][j]; Block existing = chunk.getBlock(x, y, z); - int existingId = existing.getTypeId(); - if (existingId == block.id) { - if (existingId == 0) { - continue; - } - if (existing.getData() == block.data) { - continue; - } + // int existingId = existing.getTypeId(); + // if (existingId == block.id) { + // if (existingId == 0) { + // continue; + // } + // if (existing.getData() == block.data) { + // continue; + // } + //} + if (equals(block, existing)) { + continue; } - existing.setTypeIdAndData(block.id, block.data, false); + setMaterial(block, existing); } } } } } + private void setMaterial(@NonNull final PlotBlock plotBlock, @NonNull final Block block) { + if (plotBlock instanceof StringPlotBlock) { + final Material material = Material.getMaterial(((StringPlotBlock) plotBlock).getItemId().toLowerCase( + Locale.ENGLISH)); + if (material == null) { + throw new IllegalStateException(String.format("Could not find material that matches %s", block.toString())); + } + block.setType(material, false); + } else { + final LegacyPlotBlock legacyPlotBlock = (LegacyPlotBlock) plotBlock; + block.setType(LegacyMappings.fromIdAndData(legacyPlotBlock.getId(), legacyPlotBlock.getData()).getMaterial()); + // block.setTypeIdAndData(legacyPlotBlock.getId(), legacyPlotBlock.getData(), false); + } + } + + private boolean equals(@NonNull final PlotBlock plotBlock, @NonNull final Block block) { + if (plotBlock instanceof StringPlotBlock) { + return ((StringPlotBlock) plotBlock).idEquals(block.getType().name()); + } + final LegacyPlotBlock legacyPlotBlock = (LegacyPlotBlock) plotBlock; + return LegacyMappings.fromLegacyId(((LegacyPlotBlock) plotBlock).id).getMaterial() == block.getType() && (legacyPlotBlock.id == 0 || legacyPlotBlock.data == block.getData()); + } + public void setBiomes(LocalChunk lc) { if (lc.biomes != null) { World worldObj = Bukkit.getWorld(getWorld()); diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_7.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_7.java deleted file mode 100644 index a4fb27651..000000000 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_7.java +++ /dev/null @@ -1,129 +0,0 @@ -package com.github.intellectualsites.plotsquared.bukkit.util.block; - -import com.github.intellectualsites.plotsquared.bukkit.util.SendChunk; -import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper; -import com.github.intellectualsites.plotsquared.plot.object.PlotBlock; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils; -import com.github.intellectualsites.plotsquared.plot.util.TaskManager; -import org.bukkit.Bukkit; -import org.bukkit.Chunk; -import org.bukkit.World; - -import java.util.*; - -import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; - -public class BukkitLocalQueue_1_7 extends BukkitLocalQueue { - - private final ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block"); - private final ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk"); - private final ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World"); - private final ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld"); - private final ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk"); - private final ReflectionUtils.RefMethod methodGetHandle; - private final ReflectionUtils.RefMethod methodGetHandleChunk; - private final ReflectionUtils.RefMethod methodGetChunkAt; - private final ReflectionUtils.RefMethod methodA; - private final ReflectionUtils.RefMethod methodGetById; - private final ReflectionUtils.RefMethod methodInitLighting; - private final SendChunk sendChunk; - - private final HashMap toUpdate = new HashMap<>(); - - public BukkitLocalQueue_1_7(String world) - throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException { - super(world); - this.methodGetHandle = this.classCraftWorld.getMethod("getHandle"); - this.methodGetChunkAt = this.classWorld.getMethod("getChunkAt", int.class, int.class); - this.methodA = this.classChunk - .getMethod("a", int.class, int.class, int.class, this.classBlock, int.class); - this.methodGetById = this.classBlock.getMethod("getById", int.class); - this.methodGetHandleChunk = this.classCraftChunk.getMethod("getHandle"); - this.methodInitLighting = this.classChunk.getMethod("initLighting"); - this.sendChunk = new SendChunk(); - TaskManager.runTaskRepeat(new Runnable() { - @Override public void run() { - if (BukkitLocalQueue_1_7.this.toUpdate.isEmpty()) { - return; - } - int count = 0; - ArrayList chunks = new ArrayList<>(); - Iterator> i = - BukkitLocalQueue_1_7.this.toUpdate.entrySet().iterator(); - while (i.hasNext() && (count < 128)) { - chunks.add(i.next().getValue()); - i.remove(); - count++; - } - if (count == 0) { - return; - } - update(chunks); - } - }, 1); - MainUtil.initCache(); - } - - public void update(Collection chunks) { - if (chunks.isEmpty()) { - return; - } - if (!MainUtil.canSendChunk) { - for (Chunk chunk : chunks) { - chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ()); - chunk.unload(true, false); - chunk.load(); - } - return; - } - try { - this.sendChunk.sendChunk(chunks); - } catch (Throwable e) { - e.printStackTrace(); - MainUtil.canSendChunk = false; - } - } - - @Override public void fixChunkLighting(int x, int z) { - Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call(); - this.methodInitLighting.of(c).call(); - } - - @Override public void setBlocks(LocalChunk lc) { - Chunk chunk = getChunk(lc.getX(), lc.getZ()); - chunk.load(true); - World world = chunk.getWorld(); - ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ()); - if (!this.toUpdate.containsKey(wrapper)) { - this.toUpdate.put(wrapper, chunk); - } - Object w = this.methodGetHandle.of(world).call(); - Object c = this.methodGetChunkAt.of(w).call(lc.getX(), lc.getZ()); - for (int i = 0; i < lc.blocks.length; i++) { - PlotBlock[] result2 = lc.blocks[i]; - if (result2 == null) { - continue; - } - for (int j = 0; j < 4096; j++) { - int x = MainUtil.x_loc[i][j]; - int y = MainUtil.y_loc[i][j]; - int z = MainUtil.z_loc[i][j]; - PlotBlock newBlock = result2[j]; - if (newBlock != null) { - if (newBlock.id == -1) { - chunk.getBlock(x, y, z).setData(newBlock.data, false); - continue; - } - Object block = this.methodGetById.call(newBlock.id); - this.methodA.of(c).call(x, y, z, block, newBlock.data); - } - } - } - fixChunkLighting(lc.getX(), lc.getZ()); - } - - @Override public void refreshChunk(int x, int z) { - update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z))); - } -} diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8.java deleted file mode 100644 index c7e98f020..000000000 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8.java +++ /dev/null @@ -1,341 +0,0 @@ -package com.github.intellectualsites.plotsquared.bukkit.util.block; - -import com.github.intellectualsites.plotsquared.bukkit.util.SendChunk; -import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper; -import com.github.intellectualsites.plotsquared.plot.object.PlotBlock; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefClass; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.RefMethod; -import com.github.intellectualsites.plotsquared.plot.util.TaskManager; -import org.bukkit.Bukkit; -import org.bukkit.Chunk; -import org.bukkit.World; -import org.bukkit.block.Block; - -import java.util.*; - -import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; - -public class BukkitLocalQueue_1_8 extends BukkitLocalQueue { - - private final ReflectionUtils.RefMethod methodInitLighting; - private final ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block"); - private final ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition"); - private final ReflectionUtils.RefClass classIBlockData = getRefClass("{nms}.IBlockData"); - private final ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk"); - private final ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World"); - private final ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld"); - private final HashMap toUpdate = new HashMap<>(); - private final ReflectionUtils.RefMethod methodGetHandle; - private final ReflectionUtils.RefMethod methodGetChunkAt; - private final ReflectionUtils.RefMethod methodA; - private final ReflectionUtils.RefMethod methodGetByCombinedId; - private final ReflectionUtils.RefConstructor constructorBlockPosition; - private final SendChunk sendChunk; - private final RefMethod methodGetHandleChunk; - - public BukkitLocalQueue_1_8(String world) - throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException { - super(world); - this.methodInitLighting = this.classChunk.getMethod("initLighting"); - this.constructorBlockPosition = - this.classBlockPosition.getConstructor(int.class, int.class, int.class); - this.methodGetByCombinedId = this.classBlock.getMethod("getByCombinedId", int.class); - this.methodGetHandle = this.classCraftWorld.getMethod("getHandle"); - RefClass classCraftChunk = getRefClass("{cb}.CraftChunk"); - this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle"); - this.methodGetChunkAt = this.classWorld.getMethod("getChunkAt", int.class, int.class); - this.methodA = - this.classChunk.getMethod("a", this.classBlockPosition, this.classIBlockData); - this.sendChunk = new SendChunk(); - TaskManager.runTaskRepeat(new Runnable() { - @Override public void run() { - if (BukkitLocalQueue_1_8.this.toUpdate.isEmpty()) { - return; - } - int count = 0; - ArrayList chunks = new ArrayList<>(); - Iterator> i = - BukkitLocalQueue_1_8.this.toUpdate.entrySet().iterator(); - while (i.hasNext() && count < 128) { - chunks.add(i.next().getValue()); - i.remove(); - count++; - } - if (count == 0) { - return; - } - update(chunks); - } - }, 1); - MainUtil.initCache(); - } - - @Override public void fixChunkLighting(int x, int z) { - Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call(); - this.methodInitLighting.of(c).call(); - } - - @Override public void setBlocks(LocalChunk lc) { - Chunk chunk = getChunk(lc.getX(), lc.getZ()); - chunk.load(true); - World world = chunk.getWorld(); - ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ()); - if (!this.toUpdate.containsKey(wrapper)) { - this.toUpdate.put(wrapper, chunk); - } - Object w = this.methodGetHandle.of(world).call(); - Object c = this.methodGetChunkAt.of(w).call(lc.getX(), lc.getZ()); - for (int i = 0; i < lc.blocks.length; i++) { - PlotBlock[] result2 = lc.blocks[i]; - if (result2 == null) { - continue; - } - for (int j = 0; j < 4096; j++) { - int x = MainUtil.x_loc[i][j]; - int y = MainUtil.y_loc[i][j]; - int z = MainUtil.z_loc[i][j]; - PlotBlock newBlock = result2[j]; - if (newBlock == null) - continue; - - if (newBlock.id == -1) { - chunk.getBlock(x, y, z).setData(newBlock.data, false); - continue; - } - // Start blockstate workaround // - switch (newBlock.id) { - case 54: - case 130: - case 142: - case 132: - case 27: - case 137: - case 52: - case 154: - case 84: - case 25: - case 144: - case 138: - case 176: - case 177: - case 119: - case 63: - case 68: - case 323: - case 117: - case 116: - case 28: - case 66: - case 157: - case 61: - case 62: - case 140: - case 146: - case 149: - case 150: - case 158: - case 23: - case 123: - case 124: - case 29: - case 33: - case 151: - case 178: - Block block = world.getBlockAt(x, y, z); - if (block.getData() == newBlock.data) { - if (block.getTypeId() != newBlock.id) { - block.setTypeId(newBlock.id, false); - } - } else { - if (block.getTypeId() == newBlock.id) { - block.setData(newBlock.data, false); - } else { - block.setTypeIdAndData(newBlock.id, newBlock.data, false); - } - } - continue; - } - - // Start data value shortcut - Block block = world.getBlockAt(x, y, z); - int currentId = block.getTypeId(); - if (currentId == newBlock.id) { - switch (newBlock.id) { - case 0: - case 2: - case 4: - case 13: - case 14: - case 15: - case 20: - case 21: - case 22: - case 25: - case 30: - case 32: - case 37: - case 39: - case 40: - case 41: - case 42: - case 45: - case 46: - case 47: - case 48: - case 49: - case 51: - case 52: - case 54: - case 55: - case 56: - case 57: - case 58: - case 60: - case 61: - case 62: - case 7: - case 8: - case 9: - case 10: - case 11: - case 73: - case 74: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 84: - case 85: - case 87: - case 88: - case 101: - case 102: - case 103: - case 110: - case 112: - case 113: - case 117: - case 121: - case 122: - case 123: - case 124: - case 129: - case 133: - case 138: - case 137: - case 140: - case 165: - case 166: - case 169: - case 170: - case 172: - case 173: - case 174: - case 176: - case 177: - case 181: - case 182: - case 188: - case 189: - case 190: - case 191: - case 192: - continue; - } - if (block.getData() == newBlock.data) { - return; - } - block.setData(newBlock.data, false); - return; - } - // blockstate - switch (currentId) { - case 54: - case 130: - case 132: - case 142: - case 27: - case 137: - case 52: - case 154: - case 84: - case 25: - case 144: - case 138: - case 176: - case 177: - case 63: - case 68: - case 323: - case 117: - case 119: - case 116: - case 28: - case 66: - case 157: - case 61: - case 62: - case 140: - case 146: - case 149: - case 150: - case 158: - case 23: - case 123: - case 124: - case 29: - case 33: - case 151: - case 178: - if (block.getData() == newBlock.data) { - block.setTypeId(newBlock.id, false); - } else { - block.setTypeIdAndData(newBlock.id, newBlock.data, false); - } - continue; - } - // End blockstate workaround // - - // check sign - Object pos = null; - try { - pos = this.constructorBlockPosition.create(x, y, z); - } catch (ReflectiveOperationException e) { - e.printStackTrace(); - } - Object combined = - this.methodGetByCombinedId.call(newBlock.id + (newBlock.data << 12)); - this.methodA.of(c).call(pos, combined); - } - } - fixChunkLighting(lc.getX(), lc.getZ()); - } - - public void update(Collection chunks) { - if (chunks.isEmpty()) { - return; - } - if (!MainUtil.canSendChunk) { - for (Chunk chunk : chunks) { - chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ()); - chunk.unload(true, false); - chunk.load(); - } - return; - } - try { - this.sendChunk.sendChunk(chunks); - } catch (Throwable e) { - e.printStackTrace(); - MainUtil.canSendChunk = false; - } - } - - @Override public void refreshChunk(int x, int z) { - update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z))); - } -} diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8_3.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8_3.java deleted file mode 100644 index 2fd683e3c..000000000 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_8_3.java +++ /dev/null @@ -1,530 +0,0 @@ -package com.github.intellectualsites.plotsquared.bukkit.util.block; - -import com.github.intellectualsites.plotsquared.bukkit.util.SendChunk; -import com.github.intellectualsites.plotsquared.plot.object.ChunkLoc; -import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper; -import com.github.intellectualsites.plotsquared.plot.object.PseudoRandom; -import com.github.intellectualsites.plotsquared.plot.util.ChunkManager; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils; -import com.github.intellectualsites.plotsquared.plot.util.TaskManager; -import com.github.intellectualsites.plotsquared.plot.util.block.BasicLocalBlockQueue; -import org.bukkit.Bukkit; -import org.bukkit.Chunk; -import org.bukkit.Material; -import org.bukkit.World; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.*; - -import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; - -public class BukkitLocalQueue_1_8_3 extends BukkitLocalQueue { - - private final SendChunk sendChunk; - private final HashMap toUpdate = new HashMap<>(); - private final ReflectionUtils.RefMethod methodGetHandleChunk; - private final ReflectionUtils.RefMethod methodGetHandleWorld; - private final ReflectionUtils.RefMethod methodInitLighting; - private final ReflectionUtils.RefConstructor classBlockPositionConstructor; - private final ReflectionUtils.RefConstructor classChunkSectionConstructor; - private final ReflectionUtils.RefMethod methodX; - private final ReflectionUtils.RefMethod methodAreNeighborsLoaded; - private final ReflectionUtils.RefField fieldSections; - private final ReflectionUtils.RefField fieldWorld; - private final ReflectionUtils.RefMethod methodGetIdArray; - private final ReflectionUtils.RefMethod methodGetWorld; - private final ReflectionUtils.RefField tileEntityListTick; - - public BukkitLocalQueue_1_8_3(String world) - throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException { - super(world); - ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk"); - ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld"); - this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle"); - ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk"); - this.methodInitLighting = classChunk.getMethod("initLighting"); - ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition"); - this.classBlockPositionConstructor = - classBlockPosition.getConstructor(int.class, int.class, int.class); - ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World"); - this.methodX = classWorld.getMethod("x", classBlockPosition.getRealClass()); - this.fieldSections = classChunk.getField("sections"); - this.fieldWorld = classChunk.getField("world"); - ReflectionUtils.RefClass classChunkSection = getRefClass("{nms}.ChunkSection"); - this.methodGetIdArray = classChunkSection.getMethod("getIdArray"); - this.methodAreNeighborsLoaded = classChunk.getMethod("areNeighborsLoaded", int.class); - this.classChunkSectionConstructor = - classChunkSection.getConstructor(int.class, boolean.class, char[].class); - this.tileEntityListTick = classWorld.getField("tileEntityList"); - this.methodGetHandleWorld = classCraftWorld.getMethod("getHandle"); - this.methodGetWorld = classChunk.getMethod("getWorld"); - this.sendChunk = new SendChunk(); - TaskManager.runTaskRepeat(new Runnable() { - @Override public void run() { - if (BukkitLocalQueue_1_8_3.this.toUpdate.isEmpty()) { - return; - } - int count = 0; - ArrayList chunks = new ArrayList<>(); - Iterator> i = - BukkitLocalQueue_1_8_3.this.toUpdate.entrySet().iterator(); - while (i.hasNext() && count < 128) { - chunks.add(i.next().getValue()); - i.remove(); - count++; - } - if (count == 0) { - return; - } - update(chunks); - } - }, 1); - MainUtil.initCache(); - } - - @Override public LocalChunk getLocalChunk(int x, int z) { - return new CharLocalChunk_1_8_3(this, x, z); - } - - @Override public void setBlocks(LocalChunk lc) { - CharLocalChunk_1_8_3 fs = (CharLocalChunk_1_8_3) lc; - Chunk chunk = getChunk(lc.getX(), lc.getZ()); - chunk.load(true); - World world = chunk.getWorld(); - ChunkWrapper wrapper = new ChunkWrapper(getWorld(), lc.getX(), lc.getZ()); - if (!this.toUpdate.containsKey(wrapper)) { - this.toUpdate.put(wrapper, chunk); - } - try { - boolean flag = world.getEnvironment() == World.Environment.NORMAL; - - // Sections - Method getHandle = chunk.getClass().getDeclaredMethod("getHandle"); - Object c = getHandle.invoke(chunk); - Object w = this.methodGetWorld.of(c).call(); - Class clazz = c.getClass(); - Field sections1 = clazz.getDeclaredField("sections"); - sections1.setAccessible(true); - Field tileEntities = clazz.getDeclaredField("tileEntities"); - Field entitySlices = clazz.getDeclaredField("entitySlices"); - Object[] sections = (Object[]) sections1.get(c); - Map tiles = (Map) tileEntities.get(c); - Collection[] entities = (Collection[]) entitySlices.get(c); - - Method getX = null; - Method getY = null; - Method getZ = null; - - // Trim tiles - boolean removed = false; - Set> entrySet = (Set>) (Set) tiles.entrySet(); - Iterator> iterator = entrySet.iterator(); - while (iterator.hasNext()) { - Map.Entry tile = iterator.next(); - Object pos = tile.getKey(); - if (getX == null) { - Class clazz2 = pos.getClass().getSuperclass(); - getX = clazz2.getDeclaredMethod("getX"); - getY = clazz2.getDeclaredMethod("getY"); - getZ = clazz2.getDeclaredMethod("getZ"); - } - int lx = (int) getX.invoke(pos) & 15; - int ly = (int) getY.invoke(pos); - int lz = (int) getZ.invoke(pos) & 15; - int j = MainUtil.CACHE_I[ly][lx][lz]; - int k = MainUtil.CACHE_J[ly][lx][lz]; - char[] array = fs.getIdArray(j); - if (array == null) { - continue; - } - if (array[k] != 0) { - removed = true; - iterator.remove(); - } - } - if (removed) { - ((Collection) this.tileEntityListTick.of(w).get()).clear(); - } - - // Trim entities - for (int i = 0; i < 16; i++) { - if ((entities[i] != null) && (fs.getCount(i) >= 4096)) { - entities[i].clear(); - } - } - - // Efficiently merge sections - for (int j = 0; j < sections.length; j++) { - if (fs.getCount(j) == 0) { - continue; - } - char[] newArray = fs.getIdArray(j); - if (newArray == null) { - continue; - } - Object section = sections[j]; - if ((section == null) || (fs.getCount(j) >= 4096)) { - section = sections[j] = newChunkSection(j << 4, flag, newArray); - continue; - } - char[] currentArray = getIdArray(section); - boolean fill = true; - for (int k = 0; k < newArray.length; k++) { - char n = newArray[k]; - switch (n) { - case 0: - fill = false; - continue; - case 1: - fill = false; - currentArray[k] = 0; - continue; - default: - currentArray[k] = n; - continue; - } - } - if (fill) { - fs.setCount(j, Short.MAX_VALUE); - } - } - // Clear - } catch (IllegalArgumentException | SecurityException | ReflectiveOperationException e) { - e.printStackTrace(); - } - fixLighting(chunk, fs, true); - } - - public Object newChunkSection(int i, boolean flag, char[] ids) - throws ReflectiveOperationException { - return this.classChunkSectionConstructor.create(i, flag, ids); - } - - public char[] getIdArray(Object obj) { - return (char[]) this.methodGetIdArray.of(obj).call(); - } - - @Override public void fixChunkLighting(int x, int z) { - Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call(); - this.methodInitLighting.of(c).call(); - } - - public boolean fixLighting(Chunk chunk, CharLocalChunk_1_8_3 bc, boolean fixAll) { - try { - if (!chunk.isLoaded()) { - chunk.load(false); - } else { - chunk.unload(true, false); - chunk.load(false); - } - - // Initialize lighting - Object c = this.methodGetHandleChunk.of(chunk).call(); - - if (fixAll && !(boolean) this.methodAreNeighborsLoaded.of(c).call(1)) { - World world = chunk.getWorld(); - ChunkWrapper wrapper = new ChunkWrapper(getWorld(), chunk.getX(), chunk.getZ()); - for (int x = wrapper.x - 1; x <= wrapper.x + 1; x++) { - for (int z = wrapper.z - 1; z <= wrapper.z + 1; z++) { - if (x != 0 && z != 0) { - Chunk other = world.getChunkAt(x, z); - while (!other.isLoaded()) { - other.load(true); - } - ChunkManager.manager.loadChunk(wrapper.world, new ChunkLoc(x, z), true); - } - } - } - /* - if (!(boolean) methodAreNeighborsLoaded.of(c).call(1)) { - return false; - } - */ - } - - this.methodInitLighting.of(c).call(); - - if (bc.getTotalRelight() == 0 && !fixAll) { - return true; - } - - Object[] sections = (Object[]) this.fieldSections.of(c).get(); - Object w = this.fieldWorld.of(c).get(); - - int X = chunk.getX() << 4; - int Z = chunk.getZ() << 4; - - ReflectionUtils.RefMethod.RefExecutor relight = this.methodX.of(w); - for (int j = 0; j < sections.length; j++) { - Object section = sections[j]; - if (section == null) { - continue; - } - if ((bc.getRelight(j) == 0 && !fixAll) || bc.getCount(j) == 0 || ( - bc.getCount(j) >= 4096 && bc.getAir(j) == 0)) { - continue; - } - char[] array = getIdArray(section); - int l = PseudoRandom.random.random(2); - for (int k = 0; k < array.length; k++) { - int i = array[k]; - if (i < 16) { - continue; - } - short id = (short) (i >> 4); - switch (id) { // Lighting - default: - if (!fixAll) { - continue; - } - if ((k & 1) == l) { - l = 1 - l; - continue; - } - case 10: - case 11: - case 39: - case 40: - case 50: - case 51: - case 62: - case 74: - case 76: - case 89: - case 122: - case 124: - case 130: - case 138: - case 169: - int x = MainUtil.x_loc[j][k]; - int y = MainUtil.y_loc[j][k]; - int z = MainUtil.z_loc[j][k]; - if (isSurrounded(sections, x, y, z)) { - continue; - } - Object pos = this.classBlockPositionConstructor.create(X + x, y, Z + z); - relight.call(pos); - } - } - } - return true; - } catch (Throwable e) { - e.printStackTrace(); - } - return false; - } - - public boolean isSurrounded(Object[] sections, int x, int y, int z) { - return isSolid(getId(sections, x, y + 1, z)) && isSolid(getId(sections, x + 1, y - 1, z)) - && isSolid(getId(sections, x - 1, y, z)) && isSolid(getId(sections, x, y, z + 1)) - && isSolid(getId(sections, x, y, z - 1)); - } - - public boolean isSolid(int i) { - return i != 0 && Material.getMaterial(i).isOccluding(); - } - - public int getId(Object[] sections, int x, int y, int z) { - if (x < 0 || x > 15 || z < 0 || z > 15) { - return 1; - } - if (y < 0 || y > 255) { - return 1; - } - int i = MainUtil.CACHE_I[y][x][z]; - Object section = sections[i]; - if (section == null) { - return 0; - } - char[] array = getIdArray(section); - int j = MainUtil.CACHE_J[y][x][z]; - return array[j] >> 4; - } - - public void update(Collection chunks) { - if (chunks.isEmpty()) { - return; - } - if (!MainUtil.canSendChunk) { - for (Chunk chunk : chunks) { - chunk.getWorld().refreshChunk(chunk.getX(), chunk.getZ()); - chunk.unload(true, false); - chunk.load(); - } - return; - } - try { - this.sendChunk.sendChunk(chunks); - } catch (Throwable e) { - e.printStackTrace(); - MainUtil.canSendChunk = false; - } - } - - @Override public void refreshChunk(int x, int z) { - update(Arrays.asList(Bukkit.getWorld(getWorld()).getChunkAt(x, z))); - } - - - public class CharLocalChunk_1_8_3 extends CharLocalChunk { - public short[] count; - public short[] air; - public short[] relight; - - public CharLocalChunk_1_8_3(BasicLocalBlockQueue parent, int x, int z) { - super(parent, x, z); - this.count = new short[16]; - this.air = new short[16]; - this.relight = new short[16]; - } - - @Override public void setBlock(int x, int y, int z, int id, int data) { - int i = MainUtil.CACHE_I[y][x][z]; - int j = MainUtil.CACHE_J[y][x][z]; - char[] vs = this.blocks[i]; - if (vs == null) { - vs = this.blocks[i] = new char[4096]; - this.count[i]++; - } else if (vs[j] == 0) { - this.count[i]++; - } - switch (id) { - case 0: - this.air[i]++; - vs[j] = (char) 1; - return; - case 10: - case 11: - case 39: - case 40: - case 51: - case 74: - case 89: - case 122: - case 124: - case 138: - case 169: - this.relight[i]++; - case 2: - case 4: - case 13: - case 14: - case 15: - case 20: - case 21: - case 22: - case 30: - case 32: - case 37: - case 41: - case 42: - case 45: - case 46: - case 47: - case 48: - case 49: - case 55: - case 56: - case 57: - case 58: - case 60: - case 7: - case 8: - case 9: - case 73: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 85: - case 87: - case 88: - case 101: - case 102: - case 103: - case 110: - case 112: - case 113: - case 121: - case 129: - case 133: - case 165: - case 166: - case 170: - case 172: - case 173: - case 174: - case 181: - case 182: - case 188: - case 189: - case 190: - case 191: - case 192: - vs[j] = (char) (id << 4); - return; - case 130: - case 76: - case 62: - this.relight[i]++; - case 54: - case 146: - case 61: - case 65: - case 68: - case 50: - if (data < 2) { - data = 2; - } - default: - vs[j] = (char) ((id << 4) + data); - return; - } - } - - public char[] getIdArray(int i) { - return this.blocks[i]; - } - - public int getCount(int i) { - return this.count[i]; - } - - public int getAir(int i) { - return this.air[i]; - } - - public void setCount(int i, short value) { - this.count[i] = value; - } - - public int getRelight(int i) { - return this.relight[i]; - } - - public int getTotalCount() { - int total = 0; - for (int i = 0; i < 16; i++) { - total += this.count[i]; - } - return total; - } - - public int getTotalRelight() { - if (getTotalCount() == 0) { - Arrays.fill(this.count, (short) 1); - Arrays.fill(this.relight, Short.MAX_VALUE); - return Short.MAX_VALUE; - } - int total = 0; - for (int i = 0; i < 16; i++) { - total += this.relight[i]; - } - return total; - } - } -} diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_9.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_9.java deleted file mode 100644 index 2849f9082..000000000 --- a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/bukkit/util/block/BukkitLocalQueue_1_9.java +++ /dev/null @@ -1,494 +0,0 @@ -package com.github.intellectualsites.plotsquared.bukkit.util.block; - -import com.github.intellectualsites.plotsquared.plot.object.ChunkWrapper; -import com.github.intellectualsites.plotsquared.plot.object.PseudoRandom; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; -import com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils; -import com.github.intellectualsites.plotsquared.plot.util.block.BasicLocalBlockQueue; -import org.bukkit.Chunk; -import org.bukkit.Material; -import org.bukkit.World; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.*; - -import static com.github.intellectualsites.plotsquared.plot.util.ReflectionUtils.getRefClass; - -public class BukkitLocalQueue_1_9 extends BukkitLocalQueue { - - private final Object air; - // private final HashMap toUpdate = new HashMap<>(); - private final ReflectionUtils.RefMethod methodGetHandleChunk; - private final ReflectionUtils.RefMethod methodInitLighting; - private final ReflectionUtils.RefConstructor classBlockPositionConstructor; - private final ReflectionUtils.RefConstructor classChunkSectionConstructor; - private final ReflectionUtils.RefMethod methodW; - private final ReflectionUtils.RefMethod methodAreNeighborsLoaded; - private final ReflectionUtils.RefField fieldSections; - private final ReflectionUtils.RefField fieldWorld; - private final ReflectionUtils.RefMethod methodGetBlocks; - private final ReflectionUtils.RefMethod methodGetType; - private final ReflectionUtils.RefMethod methodSetType; - private final ReflectionUtils.RefMethod methodGetCombinedId; - private final ReflectionUtils.RefMethod methodGetByCombinedId; - private final ReflectionUtils.RefMethod methodGetWorld; - - private final ReflectionUtils.RefField tileEntityListTick; - - public BukkitLocalQueue_1_9(String world) - throws NoSuchMethodException, ClassNotFoundException, NoSuchFieldException { - super(world); - ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk"); - this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle"); - ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk"); - this.methodInitLighting = classChunk.getMethod("initLighting"); - ReflectionUtils.RefClass classBlockPosition = getRefClass("{nms}.BlockPosition"); - this.classBlockPositionConstructor = - classBlockPosition.getConstructor(int.class, int.class, int.class); - ReflectionUtils.RefClass classWorld = getRefClass("{nms}.World"); - this.tileEntityListTick = classWorld.getField("tileEntityListTick"); - this.methodGetWorld = classChunk.getMethod("getWorld"); - this.methodW = classWorld.getMethod("w", classBlockPosition.getRealClass()); - this.fieldSections = classChunk.getField("sections"); - this.fieldWorld = classChunk.getField("world"); - ReflectionUtils.RefClass classBlock = getRefClass("{nms}.Block"); - ReflectionUtils.RefClass classIBlockData = getRefClass("{nms}.IBlockData"); - this.methodGetCombinedId = - classBlock.getMethod("getCombinedId", classIBlockData.getRealClass()); - this.methodGetByCombinedId = classBlock.getMethod("getByCombinedId", int.class); - ReflectionUtils.RefClass classChunkSection = getRefClass("{nms}.ChunkSection"); - this.methodGetBlocks = classChunkSection.getMethod("getBlocks"); - this.methodGetType = - classChunkSection.getMethod("getType", int.class, int.class, int.class); - this.methodSetType = classChunkSection - .getMethod("setType", int.class, int.class, int.class, classIBlockData.getRealClass()); - this.methodAreNeighborsLoaded = classChunk.getMethod("areNeighborsLoaded", int.class); - this.classChunkSectionConstructor = - classChunkSection.getConstructor(int.class, boolean.class, char[].class); - this.air = this.methodGetByCombinedId.call(0); - MainUtil.initCache(); - } - - @Override public LocalChunk getLocalChunk(int x, int z) { - return new CharLocalChunk_1_8_3(this, x, z); - } - - @Override public void setBlocks(LocalChunk lc) { - CharLocalChunk_1_8_3 fs = (CharLocalChunk_1_8_3) lc; - Chunk chunk = getChunk(lc.getX(), lc.getZ()); - chunk.load(true); - World world = chunk.getWorld(); - try { - boolean flag = world.getEnvironment() == World.Environment.NORMAL; - - // Sections - Method getHandle = chunk.getClass().getDeclaredMethod("getHandle"); - Object c = getHandle.invoke(chunk); - Object w = this.methodGetWorld.of(c).call(); - Class clazz = c.getClass(); - Field sf = clazz.getDeclaredField("sections"); - sf.setAccessible(true); - Field tf = clazz.getDeclaredField("tileEntities"); - Field entitySlices = clazz.getDeclaredField("entitySlices"); - Object[] sections = (Object[]) sf.get(c); - Map tiles = (Map) tf.get(c); - Collection[] entities = (Collection[]) entitySlices.get(c); - - Method xm = null; - Method ym = null; - Method zm = null; - // Trim tiles - Collection tickList = ((Collection) this.tileEntityListTick.of(w).get()); - Set> entrySet = (Set>) (Set) tiles.entrySet(); - Iterator> iterator = entrySet.iterator(); - while (iterator.hasNext()) { - Map.Entry tile = iterator.next(); - Object pos = tile.getKey(); - if (xm == null) { - Class clazz2 = pos.getClass().getSuperclass(); - xm = clazz2.getDeclaredMethod("getX"); - ym = clazz2.getDeclaredMethod("getY"); - zm = clazz2.getDeclaredMethod("getZ"); - } - int lx = (int) xm.invoke(pos) & 15; - int ly = (int) ym.invoke(pos); - int lz = (int) zm.invoke(pos) & 15; - int j = MainUtil.CACHE_I[ly][lx][lz]; - int k = MainUtil.CACHE_J[ly][lx][lz]; - char[] array = fs.getIdArray(j); - if (array == null) { - continue; - } - if (array[k] != 0) { - tickList.remove(tile.getValue()); - iterator.remove(); - } - } - - // Trim entities - for (int i = 0; i < 16; i++) { - if (entities[i] != null && fs.getCount(i) >= 4096) { - entities[i].clear(); - } - } - - // Efficiently merge sections - for (int j = 0; j < sections.length; j++) { - if (fs.getCount(j) == 0) { - continue; - } - char[] newArray = fs.getIdArray(j); - if (newArray == null) { - continue; - } - Object section = sections[j]; - if (section == null || fs.getCount(j) >= 4096) { - section = sections[j] = newChunkSection(j << 4, flag, fs.getIdArray(j)); - continue; - } - Object currentArray = getBlocks(section); - ReflectionUtils.RefMethod.RefExecutor setType = this.methodSetType.of(section); - boolean fill = true; - for (int k = 0; k < newArray.length; k++) { - char n = newArray[k]; - switch (n) { - case 0: - fill = false; - continue; - case 1: { - fill = false; - int x = MainUtil.x_loc[j][k]; - int y = MainUtil.y_loc[j][k]; - int z = MainUtil.z_loc[j][k]; - setType.call(x, y & 15, z, this.air); - continue; - } - default: - int x = MainUtil.x_loc[j][k]; - int y = MainUtil.y_loc[j][k]; - int z = MainUtil.z_loc[j][k]; - int id = n >> 4; - int data = n & 15; - Object iBlock = - this.methodGetByCombinedId.call((int) (id & 0xFFF) + (data << 12)); - setType.call(x, y & 15, z, iBlock); - } - } - if (fill) { - fs.setCount(j, Short.MAX_VALUE); - } - } - // Clear - } catch (IllegalArgumentException | SecurityException | ReflectiveOperationException e) { - e.printStackTrace(); - } - fixLighting(chunk, fs, true); - refreshChunk(fs.getX(), fs.getZ()); - } - - public Object newChunkSection(int i, boolean flag, char[] ids) - throws ReflectiveOperationException { - return this.classChunkSectionConstructor.create(i, flag, ids); - } - - public Object getBlocks(Object obj) { - return this.methodGetBlocks.of(obj).call(); - } - - @Override public void fixChunkLighting(int x, int z) { - Object c = this.methodGetHandleChunk.of(getChunk(x, z)).call(); - this.methodInitLighting.of(c).call(); - } - - public boolean fixLighting(Chunk chunk, CharLocalChunk_1_8_3 bc, boolean fixAll) { - try { - if (!chunk.isLoaded()) { - chunk.load(false); - } else { - chunk.unload(true, false); - chunk.load(false); - } - - // Initialize lighting - Object c = this.methodGetHandleChunk.of(chunk).call(); - - ChunkWrapper wrapper = new ChunkWrapper(getWorld(), bc.getX(), bc.getZ()); - Object[] result = disableLighting(chunk); - enableLighting(result); - - this.methodInitLighting.of(c).call(); - - if (bc.getTotalRelight() != 0 || fixAll) { - Object[] sections = (Object[]) this.fieldSections.of(c).get(); - Object w = this.fieldWorld.of(c).get(); - - int X = chunk.getX() << 4; - int Z = chunk.getZ() << 4; - ReflectionUtils.RefMethod.RefExecutor relight = this.methodW.of(w); - for (int j = 0; j < sections.length; j++) { - Object section = sections[j]; - if (section == null) { - continue; - } - if (bc.getRelight(j) == 0 && !fixAll || bc.getCount(j) == 0 - || bc.getCount(j) >= 4096 && bc.getAir(j) == 0) { - continue; - } - char[] array = bc.getIdArray(j); - if (array != null) { - int l = PseudoRandom.random.random(2); - for (int k = 0; k < array.length; k++) { - int i = array[k]; - if (i < 16) { - continue; - } - short id = (short) (i >> 4); - switch (id) { // Lighting - default: - if (!fixAll) { - continue; - } - if ((k & 1) == l) { - l = 1 - l; - continue; - } - case 10: - case 11: - case 39: - case 40: - case 50: - case 51: - case 62: - case 74: - case 76: - case 89: - case 122: - case 124: - case 130: - case 138: - case 169: - int x = MainUtil.x_loc[j][k]; - int y = MainUtil.y_loc[j][k]; - int z = MainUtil.z_loc[j][k]; - if (isSurrounded(bc.blocks, x, y, z)) { - continue; - } - Object pos = - this.classBlockPositionConstructor.create(X + x, y, Z + z); - relight.call(pos); - } - } - } - } - } - resetLighting(result); - return true; - } catch (Throwable e) { - e.printStackTrace(); - } - return false; - } - - @Override public void refreshChunk(int x, int z) { - getBukkitWorld().refreshChunk(x, z); - } - - public boolean isSurrounded(char[][] sections, int x, int y, int z) { - return isSolid(getId(sections, x, y + 1, z)) && isSolid(getId(sections, x + 1, y - 1, z)) - && isSolid(getId(sections, x - 1, y, z)) && isSolid(getId(sections, x, y, z + 1)) - && isSolid(getId(sections, x, y, z - 1)); - } - - public boolean isSolid(int i) { - if (i != 0) { - Material material = Material.getMaterial(i); - return material != null && Material.getMaterial(i).isOccluding(); - } - return false; - } - - public int getId(char[] section, int x, int y, int z) { - if (section == null) { - return 0; - } - int j = MainUtil.CACHE_J[y][x][z]; - return section[j] >> 4; - } - - public int getId(char[][] sections, int x, int y, int z) { - if (x < 0 || x > 15 || z < 0 || z > 15) { - return 1; - } - if (y < 0 || y > 255) { - return 1; - } - int i = MainUtil.CACHE_I[y][x][z]; - char[] section = sections[i]; - if (section == null) { - return 0; - } - return getId(section, x, y, z); - } - - - public class CharLocalChunk_1_8_3 extends CharLocalChunk { - public short[] count; - public short[] air; - public short[] relight; - - public CharLocalChunk_1_8_3(BasicLocalBlockQueue parent, int x, int z) { - super(parent, x, z); - this.count = new short[16]; - this.air = new short[16]; - this.relight = new short[16]; - } - - @Override public void setBlock(int x, int y, int z, int id, int data) { - int i = MainUtil.CACHE_I[y][x][z]; - int j = MainUtil.CACHE_J[y][x][z]; - char[] vs = this.blocks[i]; - if (vs == null) { - vs = this.blocks[i] = new char[4096]; - this.count[i]++; - } else if (vs[j] == 0) { - this.count[i]++; - } - switch (id) { - case 0: - this.air[i]++; - vs[j] = (char) 1; - return; - case 10: - case 11: - case 39: - case 40: - case 51: - case 74: - case 89: - case 122: - case 124: - case 138: - case 169: - this.relight[i]++; - case 2: - case 4: - case 13: - case 14: - case 15: - case 20: - case 21: - case 22: - case 30: - case 32: - case 37: - case 41: - case 42: - case 45: - case 46: - case 47: - case 48: - case 49: - case 55: - case 56: - case 57: - case 58: - case 60: - case 7: - case 8: - case 9: - case 73: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 85: - case 87: - case 88: - case 101: - case 102: - case 103: - case 110: - case 112: - case 113: - case 121: - case 129: - case 133: - case 165: - case 166: - case 170: - case 172: - case 173: - case 174: - case 181: - case 182: - case 188: - case 189: - case 190: - case 191: - case 192: - vs[j] = (char) (id << 4); - return; - case 130: - case 76: - case 62: - this.relight[i]++; - case 54: - case 146: - case 61: - case 65: - case 68: - case 50: - if (data < 2) { - data = 2; - } - default: - vs[j] = (char) ((id << 4) + data); - return; - } - } - - public char[] getIdArray(int i) { - return this.blocks[i]; - } - - public int getCount(int i) { - return this.count[i]; - } - - public int getAir(int i) { - return this.air[i]; - } - - public void setCount(int i, short value) { - this.count[i] = value; - } - - public int getRelight(int i) { - return this.relight[i]; - } - - public int getTotalCount() { - int total = 0; - for (int i = 0; i < 16; i++) { - total += this.count[i]; - } - return total; - } - - public int getTotalRelight() { - if (getTotalCount() == 0) { - Arrays.fill(this.count, (short) 1); - Arrays.fill(this.relight, Short.MAX_VALUE); - return Short.MAX_VALUE; - } - int total = 0; - for (int i = 0; i < 16; i++) { - total += this.relight[i]; - } - return total; - } - } -} diff --git a/Bukkit/src/main/resources/plugin.yml b/Bukkit/src/main/resources/plugin.yml index fd2f4bd95..ae7d4ad57 100644 --- a/Bukkit/src/main/resources/plugin.yml +++ b/Bukkit/src/main/resources/plugin.yml @@ -1,5 +1,6 @@ name: ${name} main: com.github.intellectualsites.plotsquared.bukkit.BukkitMain +api-version: 1.13 version: ${version} load: STARTUP description: > diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/BO3.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/BO3.java deleted file mode 100644 index e2c634387..000000000 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/BO3.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.github.intellectualsites.plotsquared.plot.commands; - -import com.github.intellectualsites.plotsquared.commands.CommandDeclaration; -import com.github.intellectualsites.plotsquared.plot.config.C; -import com.github.intellectualsites.plotsquared.plot.object.Location; -import com.github.intellectualsites.plotsquared.plot.object.Plot; -import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer; -import com.github.intellectualsites.plotsquared.plot.util.BO3Handler; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; -import com.github.intellectualsites.plotsquared.plot.util.Permissions; - -@CommandDeclaration(command = "bo3", aliases = { - "bo2"}, description = "Mark a plot as done", permission = "plots.bo3", category = CommandCategory.SCHEMATIC, requiredType = RequiredType.NONE) -public class BO3 extends SubCommand { - - public void noArgs(PlotPlayer player) { - MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot bo3 export [category] [alias] [-r]"); - MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot bo3 import "); - } - - @Override public boolean onCommand(PlotPlayer player, String[] args) { - Location loc = player.getLocation(); - Plot plot = loc.getPlotAbs(); - if (plot == null || !plot.hasOwner()) { - return !sendMessage(player, C.NOT_IN_PLOT); - } - if (!plot.isOwner(player.getUUID()) && !Permissions - .hasPermission(player, C.PERMISSION_ADMIN_COMMAND_BO3)) { - MainUtil.sendMessage(player, C.NO_PLOT_PERMS); - return false; - } - if (args.length == 0) { - noArgs(player); - return false; - } - switch (args[0].toLowerCase()) { - case "output": - case "save": - case "export": - return BO3Handler.saveBO3(player, plot); - case "paste": - case "load": - case "import": - case "input": - // TODO NOT IMPLEMENTED YET - MainUtil.sendMessage(player, "NOT IMPLEMENTED YET!!!"); - return false; - default: - noArgs(player); - return false; - } - } -} diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Download.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Download.java index 650ff9d93..bf9b42aed 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Download.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Download.java @@ -65,27 +65,6 @@ public class Download extends SubCommand { }); } }); - } else if (args.length == 1 && StringMan - .isEqualIgnoreCaseToAny(args[0], "bo3", "bo2", "b03", "b02")) { - if (!Permissions.hasPermission(player, C.PERMISSION_DOWNLOAD_BO3)) { - C.NO_PERMISSION.send(player, C.PERMISSION_DOWNLOAD_BO3); - return false; - } - if (plot.getVolume() > 128d * 128d * 256) { - C.SCHEMATIC_TOO_LARGE.send(player); - return false; - } - plot.addRunning(); - BO3Handler.upload(plot, null, null, new RunnableVal() { - @Override public void run(URL url) { - plot.removeRunning(); - if (url == null) { - MainUtil.sendMessage(player, C.GENERATING_LINK_FAILED); - return; - } - MainUtil.sendMessage(player, url.toString()); - } - }); } else if (args.length == 1 && StringMan .isEqualIgnoreCaseToAny(args[0], "mcr", "world", "mca")) { if (!Permissions.hasPermission(player, C.PERMISSION_DOWNLOAD_WORLD)) { diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/MainCommand.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/MainCommand.java index d297219c8..cc74d3c6a 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/MainCommand.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/MainCommand.java @@ -88,7 +88,6 @@ import java.util.Arrays; new Trim(); new Done(); new Continue(); - new BO3(); new Middle(); new Grant(); // Set commands diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Music.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Music.java index 468b15b24..c889ba334 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Music.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Music.java @@ -25,11 +25,10 @@ public class Music extends SubCommand { if (item == null) { return true; } - int id = item.id == 7 ? 0 : item.id; - if (id == 0) { + if (item.getPlotBlock().equalsAny(7, "bedrock")) { plot.removeFlag(Flags.MUSIC); } else { - plot.setFlag(Flags.MUSIC, id); + plot.setFlag(Flags.MUSIC, item.getPlotBlock().getRawId()); } return false; } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Set.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Set.java index b73312854..b0acab576 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Set.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/commands/Set.java @@ -77,7 +77,7 @@ public class Set extends SubCommand { } } return false; - } else if (!allowUnsafe && (block.id != 0 && !WorldUtil.IMP + } else if (!allowUnsafe && (!block.isAir() && !WorldUtil.IMP .isBlockSolid(block))) { MainUtil .sendMessage(player, C.NOT_ALLOWED_BLOCK, block.toString()); @@ -86,7 +86,7 @@ public class Set extends SubCommand { } if (!allowUnsafe) { for (PlotBlock block : blocks) { - if (block.id != 0 && !WorldUtil.IMP.isBlockSolid(block)) { + if (!block.isAir() && !WorldUtil.IMP.isBlockSolid(block)) { MainUtil.sendMessage(player, C.NOT_ALLOWED_BLOCK, block.toString()); return false; diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotManager.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotManager.java index 846822fb0..847bf9fff 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotManager.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotManager.java @@ -46,7 +46,7 @@ public class ClassicPlotManager extends SquarePlotManager { @Override public boolean unclaimPlot(PlotArea plotArea, Plot plot, Runnable whenDone) { ClassicPlotWorld dpw = (ClassicPlotWorld) plotArea; setWallFilling(dpw, plot.getId(), new PlotBlock[] {dpw.WALL_FILLING}); - if (dpw.WALL_BLOCK.id != 0 || !dpw.WALL_BLOCK.equals(dpw.CLAIMED_WALL_BLOCK)) { + if (!dpw.WALL_BLOCK.isAir() || !dpw.WALL_BLOCK.equals(dpw.CLAIMED_WALL_BLOCK)) { setWall(dpw, plot.getId(), new PlotBlock[] {dpw.WALL_BLOCK}); } GlobalBlockQueue.IMP.addTask(whenDone); @@ -431,7 +431,7 @@ public class ClassicPlotManager extends SquarePlotManager { @Override public boolean finishPlotMerge(PlotArea plotArea, ArrayList plotIds) { PlotBlock block = ((ClassicPlotWorld) plotArea).CLAIMED_WALL_BLOCK; PlotBlock unclaim = ((ClassicPlotWorld) plotArea).WALL_BLOCK; - if (block.id != 0 || !block.equals(unclaim)) { + if (!block.isAir() || !block.equals(unclaim)) { for (PlotId id : plotIds) { setWall(plotArea, id, new PlotBlock[] {block}); } @@ -443,7 +443,7 @@ public class ClassicPlotManager extends SquarePlotManager { PlotBlock block = ((ClassicPlotWorld) plotArea).CLAIMED_WALL_BLOCK; PlotBlock unclaim = ((ClassicPlotWorld) plotArea).WALL_BLOCK; for (PlotId id : plotIds) { - if (block.id != 0 || !block.equals(unclaim)) { + if (block.isAir() || !block.equals(unclaim)) { setWall(plotArea, id, new PlotBlock[] {block}); } } @@ -461,7 +461,7 @@ public class ClassicPlotManager extends SquarePlotManager { @Override public boolean claimPlot(PlotArea plotArea, Plot plot) { PlotBlock unclaim = ((ClassicPlotWorld) plotArea).WALL_BLOCK; PlotBlock claim = ((ClassicPlotWorld) plotArea).CLAIMED_WALL_BLOCK; - if (claim.id != 0 || !claim.equals(unclaim)) { + if (!claim.isAir() || !claim.equals(unclaim)) { setWall(plotArea, plot.getId(), new PlotBlock[] {claim}); } return true; diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotWorld.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotWorld.java index 7f5d93cd1..b3e9ad30e 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotWorld.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/ClassicPlotWorld.java @@ -12,8 +12,8 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld { public int ROAD_HEIGHT = 64; public int PLOT_HEIGHT = 64; public int WALL_HEIGHT = 64; - public PlotBlock[] MAIN_BLOCK = new PlotBlock[] {PlotBlock.get((short) 1, (byte) 0)}; - public PlotBlock[] TOP_BLOCK = new PlotBlock[] {PlotBlock.get((short) 2, (byte) 0)}; + public PlotBlock[] MAIN_BLOCK = new PlotBlock[] {PlotBlock.get("stone")}; + public PlotBlock[] TOP_BLOCK = new PlotBlock[] {PlotBlock.get("grass")}; public PlotBlock WALL_BLOCK = PlotBlock.get((short) 44, (byte) 0); public PlotBlock CLAIMED_WALL_BLOCK = PlotBlock.get((short) 44, (byte) 1); public PlotBlock WALL_FILLING = PlotBlock.get((short) 1, (byte) 0); @@ -45,12 +45,14 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld { new ConfigurationNode("wall.block", this.WALL_BLOCK, "Top wall block", Configuration.BLOCK), new ConfigurationNode("wall.block_claimed", this.CLAIMED_WALL_BLOCK, - "Wall block (claimed)", Configuration.BLOCK), + "Wall block (claimed)", + Configuration.BLOCK), new ConfigurationNode("road.width", this.ROAD_WIDTH, "Road width", Configuration.INTEGER), new ConfigurationNode("road.height", this.ROAD_HEIGHT, "Road height", Configuration.INTEGER), - new ConfigurationNode("road.block", this.ROAD_BLOCK, "Road block", Configuration.BLOCK), + new ConfigurationNode("road.block", this.ROAD_BLOCK, "Road block", + Configuration.BLOCK), new ConfigurationNode("wall.filling", this.WALL_FILLING, "Wall filling block", Configuration.BLOCK), new ConfigurationNode("wall.height", this.WALL_HEIGHT, "Wall height", diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridPlotWorld.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridPlotWorld.java index dd509e559..ff5a9f247 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridPlotWorld.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridPlotWorld.java @@ -277,7 +277,7 @@ public class HybridPlotWorld extends ClassicPlotWorld { } this.ROAD_SCHEMATIC_ENABLED = true; // Do not populate road if using schematic population - this.ROAD_BLOCK = PlotBlock.get(this.ROAD_BLOCK.id, (byte) 0); + this.ROAD_BLOCK = PlotBlock.getEmptyData(this.ROAD_BLOCK); // PlotBlock.get(this.ROAD_BLOCK.id, (byte) 0); short[] ids1 = schematic1.getIds(); byte[] datas1 = schematic1.getDatas(); diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridUtils.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridUtils.java index 9bc4566bd..cad0e1685 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridUtils.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/generator/HybridUtils.java @@ -6,10 +6,7 @@ import com.github.intellectualsites.plotsquared.plot.config.C; import com.github.intellectualsites.plotsquared.plot.flag.FlagManager; import com.github.intellectualsites.plotsquared.plot.flag.Flags; import com.github.intellectualsites.plotsquared.plot.object.*; -import com.github.intellectualsites.plotsquared.plot.util.ChunkManager; -import com.github.intellectualsites.plotsquared.plot.util.MathMan; -import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler; -import com.github.intellectualsites.plotsquared.plot.util.TaskManager; +import com.github.intellectualsites.plotsquared.plot.util.*; import com.github.intellectualsites.plotsquared.plot.util.block.GlobalBlockQueue; import com.github.intellectualsites.plotsquared.plot.util.block.LocalBlockQueue; import com.github.intellectualsites.plotsquared.plot.util.expiry.PlotAnalysis; @@ -100,7 +97,7 @@ public abstract class HybridUtils { PlotBlock block = queue.getBlock(x, y, z); boolean same = false; for (PlotBlock p : blocks) { - if (block.id == p.id) { + if (WorldUtil.IMP.isBlockSame(block, p)) { same = true; break; } @@ -333,7 +330,7 @@ public abstract class HybridUtils { for (int y = sy; y <= pm.getWorldHeight(); y++) { if (y > ey) { PlotBlock block = queue.getBlock(x, y, z); - if (block.id != 0) { + if (!block.isAir()) { ey = y; } } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/BO3.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/BO3.java deleted file mode 100644 index e8bbd2585..000000000 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/BO3.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.github.intellectualsites.plotsquared.plot.object; - -import com.github.intellectualsites.plotsquared.plot.PlotSquared; -import com.github.intellectualsites.plotsquared.plot.config.Settings; -import com.github.intellectualsites.plotsquared.plot.util.MainUtil; - -import java.io.File; - -public class BO3 { - - private final ChunkLoc chunk; - private final String world; - private final StringBuilder blocks; - private final StringBuilder children; - private final String name; - - public BO3(String name, String world, ChunkLoc loc) { - this.world = world; - this.name = name; - this.chunk = loc; - this.blocks = new StringBuilder(); - this.children = new StringBuilder(); - } - - public void addChild(BO3 child) { - ChunkLoc childloc = child.getLoc(); - this.children.append("Branch(").append(childloc.x - this.chunk.x).append(",0,") - .append(childloc.z - this.chunk.z).append(',').append(this.name).append('_') - .append(childloc.x).append('_').append(childloc.z).append(",NORTH,100)\n"); - } - - public ChunkLoc getLoc() { - return this.chunk; - } - - public String getWorld() { - return this.world; - } - - public String getName() { - return this.name; - } - - public void addBlock(int x, int y, int z, PlotBlock block) { - if (block.data == 0) { - // Block(-3,1,-2,AIR) - this.blocks.append("Block(").append(x).append(',').append(y).append(',').append(z) - .append(',').append(block.id).append(")\n"); - } else { - this.blocks.append("Block(").append(x).append(',').append(y).append(',').append(z) - .append(',').append(block.id).append(':').append(block.data).append(")\n"); - } - } - - public String getBlocks() { - return this.blocks.toString(); - } - - public String getChildren() { - return this.children.toString(); - } - - public File getFile() { - return MainUtil.getFile(PlotSquared.get().IMP.getDirectory(), - Settings.Paths.BO3 + File.separator + getWorld() + File.separator + getFilename()); - } - - public String getFilename() { - if (this.chunk.x == 0 && this.chunk.z == 0) { - return this.name + ".bo3"; - } else { - return this.name + ("_" + this.chunk.x + '_' + this.chunk.z) + ".bo3"; - } - } -} diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LazyBlock.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LazyBlock.java index df61401aa..3413bd235 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LazyBlock.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LazyBlock.java @@ -2,9 +2,9 @@ package com.github.intellectualsites.plotsquared.plot.object; public abstract class LazyBlock { - public abstract PlotBlock getPlotBlock(); + public abstract StringPlotBlock getPlotBlock(); - public int getId() { - return getPlotBlock().id; + public String getId() { + return getPlotBlock().getItemId(); } } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LegacyPlotBlock.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LegacyPlotBlock.java new file mode 100644 index 000000000..b90995ddc --- /dev/null +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/LegacyPlotBlock.java @@ -0,0 +1,62 @@ +package com.github.intellectualsites.plotsquared.plot.object; + +import lombok.Getter; + +public class LegacyPlotBlock extends PlotBlock { + + public static final PlotBlock EVERYTHING = new LegacyPlotBlock((short) 0, (byte) 0); + public static final PlotBlock[] CACHE = new PlotBlock[65535]; + + static { + for (int i = 0; i < 65535; i++) { + short id = (short) (i >> 4); + byte data = (byte) (i & 15); + CACHE[i] = new LegacyPlotBlock(id, data); + } + } + + @Getter + public final short id; + @Getter + public final byte data; + + public LegacyPlotBlock(short id, byte data) { + this.id = id; + this.data = data; + } + + @Override public Object getRawId() { + return this.id; + } + + @Override public boolean isAir() { + return this.id == 0; + } + + @Override public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + LegacyPlotBlock other = (LegacyPlotBlock) obj; + return (this.id == other.id) && ((this.data == other.data) || (this.data == -1) || ( + other.data == -1)); + } + + @Override public int hashCode() { + return this.id; + } + + @Override public String toString() { + if (this.data == -1) { + return this.id + ""; + } + return this.id + ":" + this.data; + } + +} diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/Plot.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/Plot.java index 99af90eb7..99ac66073 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/Plot.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/Plot.java @@ -1203,7 +1203,7 @@ public class Plot { bot.getZ() + home.z, home.yaw, home.pitch); if (!isLoaded()) return loc; - if (WorldUtil.IMP.getBlock(loc).id != 0) { + if (!WorldUtil.IMP.getBlock(loc).isAir()) { loc.setY(Math.max( 1 + WorldUtil.IMP.getHighestBlock(this.getWorldName(), loc.getX(), loc.getZ()), bot.getY())); @@ -1848,22 +1848,6 @@ public class Plot { }); } - /** - * Export the plot as a BO3 object
- * - bedrock, floor and main block are ignored in their respective sections - * - air is ignored - * - The center is considered to be on top of the plot in the center - * - * @param whenDone value will be false if exporting fails - */ - public void exportBO3(RunnableVal whenDone) { - boolean result = BO3Handler.saveBO3(this); - if (whenDone != null) { - whenDone.value = result; - } - TaskManager.runTask(whenDone); - } - /** * Upload the plot as a schematic to the configured web interface. * @@ -1889,18 +1873,6 @@ public class Plot { WorldUtil.IMP.upload(this, null, null, whenDone); } - /** - * Upload this plot as a BO3
- * - May not work on non default generator
- * - BO3 includes flags/ignores plot main/floor block
- * - * @param whenDone - * @see BO3Handler - */ - public void uploadBO3(RunnableVal whenDone) { - BO3Handler.upload(this, null, null, whenDone); - } - @Override public boolean equals(Object obj) { if (this == obj) { return true; diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotBlock.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotBlock.java index ca4ef4ca6..17bbccc39 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotBlock.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotBlock.java @@ -1,26 +1,26 @@ package com.github.intellectualsites.plotsquared.plot.object; import com.github.intellectualsites.plotsquared.plot.config.Settings; +import lombok.NonNull; -public class PlotBlock { +import java.util.Collection; - public static final PlotBlock EVERYTHING = new PlotBlock((short) 0, (byte) 0); - private static final PlotBlock[] CACHE = new PlotBlock[65535]; +public abstract class PlotBlock { - static { - for (int i = 0; i < 65535; i++) { - short id = (short) (i >> 4); - byte data = (byte) (i & 15); - CACHE[i] = new PlotBlock(id, data); - } + public static boolean isEverything(@NonNull final PlotBlock block) { + return block.equals(LegacyPlotBlock.EVERYTHING) || block.equals(StringPlotBlock.EVERYTHING); } - public final short id; - public final byte data; + public static boolean containsEverything(@NonNull final Collection blocks) { + for (final PlotBlock block : blocks) { + if (isEverything(block)) { + return true; + } + } + return false; + } - public PlotBlock(short id, byte data) { - this.id = id; - this.data = data; + protected PlotBlock() { } public static PlotBlock get(char combinedId) { @@ -34,35 +34,43 @@ public class PlotBlock { } } + public abstract boolean isAir(); + + public static StringPlotBlock get(@NonNull final String itemId) { + if (Settings.Enabled_Components.BLOCK_CACHE) { + return StringPlotBlock.getOrAdd(itemId); + } + return new StringPlotBlock(itemId); + } + public static PlotBlock get(int id, int data) { return Settings.Enabled_Components.BLOCK_CACHE && data > 0 ? - CACHE[(id << 4) + data] : - new PlotBlock((short) id, (byte) data); + LegacyPlotBlock.CACHE[(id << 4) + data] : + new LegacyPlotBlock((short) id, (byte) data); } - @Override public boolean equals(Object obj) { - if (this == obj) { - return true; + public static PlotBlock getEmptyData(@NonNull final PlotBlock plotBlock) { + if (plotBlock instanceof StringPlotBlock) { + return plotBlock; } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - PlotBlock other = (PlotBlock) obj; - return (this.id == other.id) && ((this.data == other.data) || (this.data == -1) || ( - other.data == -1)); + return get(((LegacyPlotBlock) plotBlock).getId(), (byte) 0); } - @Override public int hashCode() { - return this.id; + public final boolean equalsAny(final int id, @NonNull final String stringId) { + if (this instanceof StringPlotBlock) { + final StringPlotBlock stringPlotBlock = (StringPlotBlock) this; + return stringPlotBlock.idEquals(stringId); + } + final LegacyPlotBlock legacyPlotBlock = (LegacyPlotBlock) this; + return legacyPlotBlock.id == id; } - @Override public String toString() { - if (this.data == -1) { - return this.id + ""; - } - return this.id + ":" + this.data; - } + @Override public abstract boolean equals(Object obj); + + @Override public abstract int hashCode(); + + @Override public abstract String toString(); + + public abstract Object getRawId(); + } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotItemStack.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotItemStack.java index e62b1cfee..e3dacc689 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotItemStack.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/PlotItemStack.java @@ -2,10 +2,13 @@ package com.github.intellectualsites.plotsquared.plot.object; import com.github.intellectualsites.plotsquared.plot.util.StringComparison; import com.github.intellectualsites.plotsquared.plot.util.WorldUtil; +import lombok.Getter; public class PlotItemStack { - public final int id; - public final short data; + // public final int id; + // public final short data; + @Getter + private final PlotBlock plotBlock; public final int amount; public final String name; public final String[] lore; @@ -13,19 +16,16 @@ public class PlotItemStack { @Deprecated public PlotItemStack(final int id, final short data, final int amount, final String name, final String... lore) { - this.id = id; - this.data = data; this.amount = amount; this.name = name; this.lore = lore; + this.plotBlock = PlotBlock.get(id, data); } public PlotItemStack(final String id, final int amount, final String name, final String... lore) { StringComparison.ComparisonResult match = WorldUtil.IMP.getClosestBlock(id); - final PlotBlock block = match.best; - this.id = block.id; - data = block.data; + this.plotBlock = match.best; this.amount = amount; this.name = name; this.lore = lore; diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/StringPlotBlock.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/StringPlotBlock.java new file mode 100644 index 000000000..72ce3eeae --- /dev/null +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/object/StringPlotBlock.java @@ -0,0 +1,91 @@ +package com.github.intellectualsites.plotsquared.plot.object; + +import lombok.Getter; +import lombok.NonNull; + +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +public class StringPlotBlock extends PlotBlock { + + public static final PlotBlock EVERYTHING = new StringPlotBlock(""); + private static final Map STRING_PLOT_BLOCK_CACHE = new HashMap<>(); + + public static StringPlotBlock getOrAdd(@NonNull final String itemId) { + // final String id = itemId.toLowerCase(Locale.ENGLISH); + + StringPlotBlock plotBlock = STRING_PLOT_BLOCK_CACHE.get(itemId); + if (plotBlock == null) { + plotBlock = new StringPlotBlock(itemId); + STRING_PLOT_BLOCK_CACHE.put(itemId, plotBlock); + } + + return plotBlock; + } + + @Getter + private final String nameSpace; + @Getter + private final String itemId; + private boolean isForeign = false; + + public StringPlotBlock(@NonNull final String nameSpace, @NonNull final String itemId) { + this.nameSpace = nameSpace.toLowerCase(Locale.ENGLISH); + this.itemId = itemId.toLowerCase(Locale.ENGLISH); + this.determineForeign(); + } + + public StringPlotBlock(@NonNull final String itemId) { + if (itemId.contains(":")) { + final String[] parts = itemId.split(":"); + if (parts.length < 2) { + throw new IllegalArgumentException(String.format("Cannot parse \"%s\"", itemId)); + } + this.nameSpace = parts[0].toLowerCase(Locale.ENGLISH); + this.itemId = parts[1].toLowerCase(Locale.ENGLISH); + } else { + this.nameSpace = "minecraft"; + this.itemId = itemId.toLowerCase(Locale.ENGLISH); + } + this.determineForeign(); + } + + private void determineForeign() { + this.isForeign = !this.nameSpace.equals("minecraft"); + } + + @Override public String toString() { + return this.isForeign ? String.format("%s:%s", nameSpace, itemId) : itemId; + } + + @Override public boolean isAir() { + return this.itemId.isEmpty() || this.itemId.equalsIgnoreCase("air"); + } + + @Override public int hashCode() { + return this.toString().hashCode(); + } + + public boolean idEquals(@NonNull final String id) { + return id.equalsIgnoreCase(this.itemId); + } + + @Override public Object getRawId() { + return this.getItemId(); + } + + @Override public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + StringPlotBlock other = (StringPlotBlock) obj; + return other.nameSpace.equals(this.nameSpace) && other.itemId.equals(this.itemId); + } +} diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/BO3Handler.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/BO3Handler.java deleted file mode 100644 index d51c429bc..000000000 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/BO3Handler.java +++ /dev/null @@ -1,297 +0,0 @@ -package com.github.intellectualsites.plotsquared.plot.util; - -import com.github.intellectualsites.plotsquared.plot.PlotSquared; -import com.github.intellectualsites.plotsquared.plot.config.Settings; -import com.github.intellectualsites.plotsquared.plot.flag.FlagManager; -import com.github.intellectualsites.plotsquared.plot.generator.ClassicPlotWorld; -import com.github.intellectualsites.plotsquared.plot.object.*; - -import java.io.*; -import java.net.URL; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; -import java.nio.file.StandardOpenOption; -import java.util.*; -import java.util.Map.Entry; -import java.util.zip.ZipEntry; -import java.util.zip.ZipOutputStream; - -public class BO3Handler { - - /** - * @param plot - * @return if successfully exported - * @see #saveBO3(PlotPlayer, Plot, RunnableVal) - */ - public static boolean saveBO3(Plot plot) { - return saveBO3(null, plot); - } - - public static boolean saveBO3(PlotPlayer player, final Plot plot) { - return saveBO3(player, plot, new RunnableVal() { - @Override public void run(BO3 bo3) { - save(plot, bo3); - } - }); - } - - public static boolean contains(PlotBlock[] blocks, PlotBlock block) { - for (PlotBlock item : blocks) { - if (item.equals(block)) { - return true; - } - } - return false; - } - - /** - * Save a plot as a BO3 file. - * - Use null for the player object if no player is applicable - * - * @param player - * @param plot - * @return - */ - public static boolean saveBO3(PlotPlayer player, Plot plot, RunnableVal saveTask) { - if (saveTask == null) { - throw new IllegalArgumentException("Save task cannot be null!"); - } - PlotArea plotworld = plot.getArea(); - if (!(plotworld instanceof ClassicPlotWorld) || plotworld.TYPE != 0) { - MainUtil.sendMessage(player, "BO3 exporting only supports type 0 classic generation."); - return false; - } - String alias = plot.toString(); - Location[] corners = plot.getCorners(); - Location bot = corners[0]; - Location top = corners[1]; - ClassicPlotWorld cpw = (ClassicPlotWorld) plotworld; - int height = cpw.PLOT_HEIGHT; - - int cx = MathMan.average(bot.getX(), top.getX()); - int cz = MathMan.average(bot.getZ(), top.getZ()); - - HashMap map = new HashMap<>(); - - HashSet regions = plot.getRegions(); - ArrayList chunks = new ArrayList<>(); - for (RegionWrapper region : regions) { - for (int x = region.minX >> 4; x <= region.maxX >> 4; x++) { - for (int z = region.minZ >> 4; z <= region.maxZ >> 4; z++) { - chunks.add(new ChunkLoc(x, z)); - } - } - } - for (ChunkLoc loc : chunks) { - ChunkManager.manager.loadChunk(plot.getWorldName(), loc, false); - } - - boolean content = false; - for (RegionWrapper region : regions) { - Location pos1 = - new Location(plotworld.worldname, region.minX, region.minY, region.minZ); - Location pos2 = - new Location(plotworld.worldname, region.maxX, region.maxY, region.maxZ); - for (int x = pos1.getX(); x <= pos2.getX(); x++) { - int X = x + 7 - cx >> 4; - int xx = (x - cx) % 16; - for (int z = pos1.getZ(); z <= pos2.getZ(); z++) { - int Z = z + 7 - cz >> 4; - int zz = (z - cz) % 16; - ChunkLoc loc = new ChunkLoc(X, Z); - BO3 bo3 = map.get(loc); - for (int y = 1; y < height; y++) { - PlotBlock block = - WorldUtil.IMP.getBlock(new Location(plot.getWorldName(), x, y, z)); - if (!contains(cpw.MAIN_BLOCK, block)) { - if (bo3 == null) { - bo3 = new BO3(alias, plotworld.worldname, loc); - map.put(loc, bo3); - content = true; - } - bo3.addBlock(xx, y - height - 1, zz, block); - } - } - PlotBlock floor = - WorldUtil.IMP.getBlock(new Location(plot.getWorldName(), x, height, z)); - if (!contains(cpw.TOP_BLOCK, floor)) { - if (bo3 == null) { - bo3 = new BO3(alias, plotworld.worldname, loc); - map.put(loc, bo3); - content = true; - } - bo3.addBlock(xx, -1, zz, floor); - } - for (int y = height + 1; y < 256; y++) { - PlotBlock block = - WorldUtil.IMP.getBlock(new Location(plot.getWorldName(), x, y, z)); - if (block.id != 0) { - if (bo3 == null) { - bo3 = new BO3(alias, plotworld.worldname, loc); - map.put(loc, bo3); - content = true; - } - bo3.addBlock(xx, y - height - 1, zz, block); - } - } - } - } - } - - if (!content) { - MainUtil.sendMessage(player, "No content found!"); - return false; - } - - for (Entry entry : map.entrySet()) { - ChunkLoc chunk = entry.getKey(); - BO3 bo3 = entry.getValue(); - if (chunk.x == 0 && chunk.z == 0) { - continue; - } - int x = chunk.x; - int z = chunk.z; - if (Math.abs(chunk.x) > Math.abs(chunk.z)) { - x += chunk.x > 0 ? -1 : 1; - } else { - z += chunk.z > 0 ? -1 : 1; - } - ChunkLoc parentLoc = new ChunkLoc(x, z); - if (!map.containsKey(parentLoc)) { - parentLoc = null; - for (Entry entry2 : map.entrySet()) { - ChunkLoc other = entry2.getKey(); - if (other.x == chunk.x - 1 && other.z == chunk.z - || other.z == chunk.z - 1 && other.x == chunk.x) { - parentLoc = other; - } - } - if (parentLoc == null) { - MainUtil.sendMessage(player, - "Exporting BO3 cancelled due to detached chunk: " + chunk - + " - Make sure you only have one object per plot"); - return false; - } - } - map.get(parentLoc).addChild(bo3); - } - - for (Entry entry : map.entrySet()) { - saveTask.run(entry.getValue()); - } - - MainUtil.sendMessage(player, "BO3 exporting was successful!"); - return true; - } - - - public static void upload(final Plot plot, UUID uuid, String file, RunnableVal whenDone) { - if (plot == null) { - throw new IllegalArgumentException("Arguments may not be null!"); - } - final ByteArrayOutputStream baos = new ByteArrayOutputStream(); - try (final ZipOutputStream zos = new ZipOutputStream(baos)) { - saveBO3(null, plot, new RunnableVal() { - @Override public void run(BO3 bo3) { - try { - ZipEntry ze = new ZipEntry(bo3.getFilename()); - zos.putNextEntry(ze); - write(zos, plot, bo3); - zos.flush(); - } catch (IOException e) { - e.printStackTrace(); - } - } - }); - } catch (IOException e) { - e.printStackTrace(); - whenDone.run(); - return; - } - MainUtil.upload(uuid, file, "zip", new RunnableVal() { - @Override public void run(OutputStream output) { - try { - output.write(baos.toByteArray()); - baos.flush(); - baos.close(); - } catch (IOException e) { - e.printStackTrace(); - } - } - }, whenDone); - } - - public static void write(OutputStream stream, Plot plot, BO3 bo3) throws IOException { - File base = getBaseFile(bo3.getWorld()); - List lines = Files.readAllLines(base.toPath(), StandardCharsets.UTF_8); - for (int i = 0; i < lines.size(); i++) { - String line = lines.get(i).trim(); - String result = StringMan - .replaceAll(line, "%owner%", MainUtil.getName(plot.owner), "%alias%", - plot.toString(), "%blocks%", bo3.getBlocks(), "%branches%", bo3.getChildren(), - "%flags%", StringMan.join(FlagManager.getPlotFlags(plot).values(), ",")); - if (!StringMan.isEqual(result, line)) { - lines.set(i, result); - } - } - stream.write(StringMan.join(lines, System.getProperty("line.separator")).getBytes()); - } - - public static boolean save(Plot plot, BO3 bo3) { - try { - File bo3File = bo3.getFile(); - File parent = bo3File.getParentFile(); - if (parent != null) { - parent.mkdirs(); - } - bo3File.createNewFile(); - bo3File.getParentFile().mkdirs(); - try (FileOutputStream fos = new FileOutputStream(bo3File)) { - write(fos, plot, bo3); - } - } catch (IOException e) { - e.printStackTrace(); - return false; - } - - File base = getBaseFile(plot.getWorldName()); - try { - List lines = Files.readAllLines(base.toPath(), StandardCharsets.UTF_8); - for (int i = 0; i < lines.size(); i++) { - String line = lines.get(i).trim(); - String result = StringMan - .replaceAll(line, "%owner%", MainUtil.getName(plot.owner), "%alias%", - plot.toString(), "%blocks%", bo3.getBlocks(), "%branches%", - bo3.getChildren(), "%flags%", - StringMan.join(FlagManager.getPlotFlags(plot).values(), ",")); - if (!StringMan.isEqual(result, line)) { - lines.set(i, result); - } - } - File bo3File; - if (bo3.getLoc().x == 0 && bo3.getLoc().z == 0) { - bo3File = MainUtil.getFile(base.getParentFile(), bo3.getName() + ".bo3"); - } else { - bo3File = MainUtil.getFile(base.getParentFile(), - bo3.getName() + '_' + bo3.getLoc().x + '_' + bo3.getLoc().z + ".bo3"); - } - bo3File.createNewFile(); - Files.write(bo3File.toPath(), - StringMan.join(lines, System.getProperty("line.separator")).getBytes(), - StandardOpenOption.WRITE); - return true; - } catch (IOException e) { - e.printStackTrace(); - return false; - } - } - - public static File getBaseFile(String category) { - File base = MainUtil.getFile(PlotSquared.get().IMP.getDirectory(), - Settings.Paths.BO3 + File.separator + category + File.separator + "base.yml"); - if (!base.exists()) { - PlotSquared.get().copyFile("base.yml", Settings.Paths.BO3 + File.separator + category); - } - return base; - } -} diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/EventUtil.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/EventUtil.java index f7799e5f2..16ce6a42c 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/EventUtil.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/EventUtil.java @@ -134,16 +134,14 @@ public abstract class EventUtil { Optional> use = plot.getFlag(Flags.USE); if (use.isPresent()) { HashSet value = use.get(); - if (value.contains(PlotBlock.EVERYTHING) || value - .contains(block.getPlotBlock())) { + if (PlotBlock.containsEverything(value) || value.contains(block.getPlotBlock())) { return true; } } Optional> destroy = plot.getFlag(Flags.BREAK); if (destroy.isPresent()) { HashSet value = destroy.get(); - if (value.contains(PlotBlock.EVERYTHING) || value - .contains(block.getPlotBlock())) { + if (PlotBlock.containsEverything(value) || value.contains(block.getPlotBlock())) { return true; } } @@ -220,7 +218,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { return Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false) || !( @@ -245,7 +243,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_BUILD_OTHER.s(), false)) { @@ -275,7 +273,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -305,7 +303,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -336,7 +334,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -367,7 +365,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -398,7 +396,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -431,7 +429,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { @@ -463,7 +461,7 @@ public abstract class EventUtil { } else { value = null; } - if (value == null || !value.contains(PlotBlock.EVERYTHING) && !value + if (value == null || !PlotBlock.containsEverything(value) && !value .contains(block.getPlotBlock())) { if (Permissions .hasPermission(player, C.PERMISSION_ADMIN_INTERACT_OTHER.s(), false)) { diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/WorldUtil.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/WorldUtil.java index 25907a43a..a322348fa 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/WorldUtil.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/WorldUtil.java @@ -142,4 +142,6 @@ public abstract class WorldUtil { } return null; } + + public abstract boolean isBlockSame(PlotBlock block1, PlotBlock block2); } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/BasicLocalBlockQueue.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/BasicLocalBlockQueue.java index cca60d40a..67adb0e1e 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/BasicLocalBlockQueue.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/BasicLocalBlockQueue.java @@ -5,6 +5,7 @@ import com.github.intellectualsites.plotsquared.plot.object.RunnableVal; import com.github.intellectualsites.plotsquared.plot.util.MainUtil; import com.github.intellectualsites.plotsquared.plot.util.MathMan; import com.github.intellectualsites.plotsquared.plot.util.TaskManager; +import lombok.NonNull; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentLinkedDeque; @@ -84,6 +85,33 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue { this.modified = modified; } + @Override public boolean setBlock(int x, int y, int z, String id) { + if ((y > 255) || (y < 0)) { + return false; + } + int cx = x >> 4; + int cz = z >> 4; + if (cx != lastX || cz != lastZ) { + lastX = cx; + lastZ = cz; + long pair = (long) (cx) << 32 | (cz) & 0xFFFFFFFFL; + lastWrappedChunk = this.blocks.get(pair); + if (lastWrappedChunk == null) { + lastWrappedChunk = this.getLocalChunk(x >> 4, z >> 4); + lastWrappedChunk.setBlock(x & 15, y, z & 15, id); + LocalChunk previous = this.blocks.put(pair, lastWrappedChunk); + if (previous == null) { + chunks.add(lastWrappedChunk); + return true; + } + this.blocks.put(pair, previous); + lastWrappedChunk = previous; + } + } + lastWrappedChunk.setBlock(x & 15, y, z & 15, id); + return true; + } + @Override public final boolean setBlock(int x, int y, int z, int id, int data) { if ((y > 255) || (y < 0)) { return false; @@ -211,6 +239,18 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue { } } + public void fillCuboid(int x1, int x2, int y1, int y2, int z1, int z2, String id) { + for (int x = x1; x <= x2; x++) { + for (int y = y1; y <= y2; y++) { + for (int z = z1; z <= z2; z++) { + setBlock(x, y, z, id); + } + } + } + } + + public abstract void setBlock(final int x, final int y, final int z, final String id); + public abstract void setBlock(final int x, final int y, final int z, final int id, final int data); @@ -241,20 +281,28 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue { blocks = new PlotBlock[16][]; } - public void setBlock(final int x, final int y, final int z, final int id, final int data) { - PlotBlock block = PlotBlock.get(id, data); - int i = MainUtil.CACHE_I[y][x][z]; - int j = MainUtil.CACHE_J[y][x][z]; + @Override public void setBlock(final int x, final int y, final int z, @NonNull final String id) { + final PlotBlock block = PlotBlock.get(id); + this.setInternal(x, y, z, block); + } + + private void setInternal(final int x, final int y, final int z, final PlotBlock plotBlock) { + final int i = MainUtil.CACHE_I[y][x][z]; + final int j = MainUtil.CACHE_J[y][x][z]; PlotBlock[] array = blocks[i]; if (array == null) { array = (blocks[i] = new PlotBlock[4096]); } - array[j] = block; + array[j] = plotBlock; + } + + public void setBlock(final int x, final int y, final int z, final int id, final int data) { + final PlotBlock block = PlotBlock.get(id, data); + this.setInternal(x, y, z, block); } } - - public class CharLocalChunk extends LocalChunk { + /* public class CharLocalChunk extends LocalChunk { public CharLocalChunk(BasicLocalBlockQueue parent, int x, int z) { super(parent, x, z); @@ -271,5 +319,5 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue { } array[j] = (char) ((block.id << 4) + block.data); } - } + } */ } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/DelegateLocalBlockQueue.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/DelegateLocalBlockQueue.java index a47c96f0f..f7da58954 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/DelegateLocalBlockQueue.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/DelegateLocalBlockQueue.java @@ -57,6 +57,10 @@ public class DelegateLocalBlockQueue extends LocalBlockQueue { } } + @Override public boolean setBlock(int x, int y, int z, String id) { + return parent.setBlock(x, y, z, id); + } + @Override public boolean setBlock(int x, int y, int z, int id, int data) { return parent.setBlock(x, y, z, id, data); } diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/LocalBlockQueue.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/LocalBlockQueue.java index 5459cf294..688b5bb14 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/LocalBlockQueue.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/LocalBlockQueue.java @@ -6,6 +6,7 @@ import com.github.intellectualsites.plotsquared.plot.util.SchematicHandler; import com.github.intellectualsites.plotsquared.plot.util.StringMan; import com.github.intellectualsites.plotsquared.plot.util.UUIDHandler; import com.github.intellectualsites.plotsquared.plot.util.WorldUtil; +import lombok.NonNull; import java.util.Map; @@ -43,8 +44,16 @@ public abstract class LocalBlockQueue { return setBlock(x, y, z, id, 0); } - public final boolean setBlock(int x, int y, int z, PlotBlock block) { - return setBlock(x, y, z, block.id, block.data); + public abstract boolean setBlock(final int x, final int y, final int z, final String id); + + public final boolean setBlock(int x, int y, int z, @NonNull final PlotBlock block) { + if (block instanceof LegacyPlotBlock) { + final LegacyPlotBlock legacyPlotBlock = (LegacyPlotBlock) block; + return this.setBlock(x, y, z, legacyPlotBlock.id, legacyPlotBlock.data); + } else { + final StringPlotBlock stringPlotBlock = (StringPlotBlock) block; + return this.setBlock(x, y, z, stringPlotBlock.getItemId()); + } } public boolean setTile(int x, int y, int z, CompoundTag tag) { diff --git a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/ScopedLocalBlockQueue.java b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/ScopedLocalBlockQueue.java index fc18edc3c..4e1e90eec 100644 --- a/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/ScopedLocalBlockQueue.java +++ b/Core/src/main/java/com/github/intellectualsites/plotsquared/plot/util/block/ScopedLocalBlockQueue.java @@ -44,6 +44,11 @@ public class ScopedLocalBlockQueue extends DelegateLocalBlockQueue { } } + @Override public boolean setBlock(int x, int y, int z, String id) { + return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && + super.setBlock(x + minX, y + minY, z + minZ, id); + } + @Override public boolean setBlock(int x, int y, int z, int id, int data) { return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super .setBlock(x + minX, y + minY, z + minZ, id, data); diff --git a/build.gradle b/build.gradle index 962bb0836..f2c3dea76 100644 --- a/build.gradle +++ b/build.gradle @@ -70,7 +70,6 @@ subprojects { } repositories { mavenCentral() - maven { url "http://empcraft.com/maven2" } maven { url "http://maven.sk89q.com/repo/" } maven { url "http://repo.maven.apache.org/maven2" } }