From 79e2bdb5870db343d34d45d98be63fdad6b43643 Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Mon, 3 Aug 2020 13:39:15 -0400 Subject: [PATCH] Standalones --- .../volmit/iris/gen/IrisChunkGenerator.java | 2 +- .../gen/standalone/StandaloneBiomeGrid.java | 40 + .../gen/standalone/StandaloneChunkData.java | 81 + .../iris/gen/standalone/StandaloneWorld.java | 1356 +++++++++++++++++ 4 files changed, 1478 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java diff --git a/src/main/java/com/volmit/iris/gen/IrisChunkGenerator.java b/src/main/java/com/volmit/iris/gen/IrisChunkGenerator.java index 0d4ea9bc2..498bf95e5 100644 --- a/src/main/java/com/volmit/iris/gen/IrisChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/IrisChunkGenerator.java @@ -77,7 +77,7 @@ public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisCon @Override protected void onTick(int ticks) { - + } @Override diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java new file mode 100644 index 000000000..32ec9860d --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java @@ -0,0 +1,40 @@ +package com.volmit.iris.gen.standalone; + +import org.bukkit.block.Biome; +import org.bukkit.generator.ChunkGenerator.BiomeGrid; + +import com.volmit.iris.util.BiomeStorage; + +public class StandaloneBiomeGrid implements BiomeGrid +{ + private final BiomeStorage storage; + + public StandaloneBiomeGrid() + { + storage = new BiomeStorage(); + } + + @Override + public Biome getBiome(int x, int z) + { + throw new UnsupportedOperationException("Use GetBiome x, y, z"); + } + + @Override + public Biome getBiome(int x, int y, int z) + { + return storage.getBiome(x, y, z); + } + + @Override + public void setBiome(int arg0, int arg1, Biome arg2) + { + throw new UnsupportedOperationException("Use SetBiome x, y, z, b"); + } + + @Override + public void setBiome(int x, int y, int z, Biome b) + { + storage.setBiome(x, y, z, b); + } +} diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java new file mode 100644 index 000000000..0a4e2a6ff --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java @@ -0,0 +1,81 @@ +package com.volmit.iris.gen.standalone; + +import org.bukkit.Material; +import org.bukkit.block.data.BlockData; +import org.bukkit.generator.ChunkGenerator.ChunkData; +import org.bukkit.material.MaterialData; + +import com.volmit.iris.gen.atomics.AtomicSliverMap; + +@SuppressWarnings("deprecation") +public class StandaloneChunkData extends AtomicSliverMap implements ChunkData +{ + @Override + public BlockData getBlockData(int x, int y, int z) + { + return getSliver(x, z).get(y); + } + + @Override + public byte getData(int x, int y, int z) + { + throw new UnsupportedOperationException("Use getBlockData"); + } + + @Override + public int getMaxHeight() + { + return 256; + } + + @Override + public Material getType(int x, int y, int z) + { + return getBlockData(x, y, z).getMaterial(); + } + + @Deprecated + @Override + public MaterialData getTypeAndData(int x, int y, int z) + { + throw new UnsupportedOperationException("Use GetBlockData"); + } + + @Override + public void setBlock(int x, int y, int z, Material arg3) + { + setBlock(x, y, z, arg3.createBlockData()); + } + + @Deprecated + @Override + public void setBlock(int arg0, int arg1, int arg2, MaterialData arg3) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Override + public void setBlock(int x, int y, int z, BlockData b) + { + getSliver(x, z).set(y, b); + } + + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, Material arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Deprecated + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, MaterialData arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, BlockData arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } +} diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java new file mode 100644 index 000000000..35e549b26 --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java @@ -0,0 +1,1356 @@ +package com.volmit.iris.gen.standalone; + +import java.io.File; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.function.Predicate; + +import org.bukkit.BlockChangeDelegate; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.Difficulty; +import org.bukkit.Effect; +import org.bukkit.FluidCollisionMode; +import org.bukkit.GameRule; +import org.bukkit.HeightMap; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Particle; +import org.bukkit.Raid; +import org.bukkit.Sound; +import org.bukkit.SoundCategory; +import org.bukkit.StructureType; +import org.bukkit.TreeType; +import org.bukkit.World; +import org.bukkit.WorldBorder; +import org.bukkit.WorldType; +import org.bukkit.block.Biome; +import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.bukkit.boss.DragonBattle; +import org.bukkit.entity.AbstractArrow; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.Entity; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.FallingBlock; +import org.bukkit.entity.Item; +import org.bukkit.entity.LightningStrike; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.generator.BlockPopulator; +import org.bukkit.generator.ChunkGenerator; +import org.bukkit.inventory.ItemStack; +import org.bukkit.material.MaterialData; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; +import org.bukkit.util.BoundingBox; +import org.bukkit.util.Consumer; +import org.bukkit.util.RayTraceResult; +import org.bukkit.util.Vector; + +@SuppressWarnings("deprecation") +public class StandaloneWorld implements World +{ + @Override + public Set getListeningPluginChannels() + { + throw new UnsupportedOperationException(); + } + + @Override + public void sendPluginMessage(Plugin arg0, String arg1, byte[] arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getMetadata(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean hasMetadata(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void removeMetadata(String arg0, Plugin arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setMetadata(String arg0, MetadataValue arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean addPluginChunkTicket(int arg0, int arg1, Plugin arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean canGenerateStructures() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2, boolean arg3, Entity arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4, boolean arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4, boolean arg5, Entity arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Item dropItem(Location arg0, ItemStack arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Item dropItemNaturally(Location arg0, ItemStack arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean generateTree(Location arg0, TreeType arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean generateTree(Location arg0, TreeType arg1, BlockChangeDelegate arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getAllowAnimals() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getAllowMonsters() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getAmbientSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getAnimalSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Biome getBiome(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Biome getBiome(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getBlockAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getBlockAt(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(Block arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Difficulty getDifficulty() + { + throw new UnsupportedOperationException(); + + } + + @Override + public ChunkSnapshot getEmptyChunkSnapshot(int arg0, int arg1, boolean arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public DragonBattle getEnderDragonBattle() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getEntities() + { + throw new UnsupportedOperationException(); + + } + + @SuppressWarnings("unchecked") + @Override + public Collection getEntitiesByClass(Class... arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getEntitiesByClass(Class arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getEntitiesByClasses(Class... arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Environment getEnvironment() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getForceLoadedChunks() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getFullTime() + { + throw new UnsupportedOperationException(); + + } + + @Override + public T getGameRuleDefault(GameRule arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public String getGameRuleValue(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T getGameRuleValue(GameRule arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public String[] getGameRules() + { + throw new UnsupportedOperationException(); + + } + + @Override + public ChunkGenerator getGenerator() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(Location arg0, HeightMap arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(int arg0, int arg1, HeightMap arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(Location arg0, HeightMap arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(int arg0, int arg1, HeightMap arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getHumidity(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getHumidity(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getKeepSpawnInMemory() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getLivingEntities() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk[] getLoadedChunks() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getMaxHeight() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getMonsterSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public String getName() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(BoundingBox arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(BoundingBox arg0, Predicate arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(Location arg0, double arg1, double arg2, double arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(Location arg0, double arg1, double arg2, double arg3, Predicate arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getPVP() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getPlayers() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Map> getPluginChunkTickets() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getPluginChunkTickets(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getPopulators() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getRaids() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getSeaLevel() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getSeed() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Location getSpawnLocation() + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getTemperature(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getTemperature(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getThunderDuration() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerAmbientSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerAnimalSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerMonsterSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerWaterAmbientSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerWaterSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTime() + { + throw new UnsupportedOperationException(); + + } + + @Override + public UUID getUID() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getViewDistance() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWaterAmbientSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWaterAnimalSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWeatherDuration() + { + throw new UnsupportedOperationException(); + + } + + @Override + public WorldBorder getWorldBorder() + { + throw new UnsupportedOperationException(); + + } + + @Override + public File getWorldFolder() + { + throw new UnsupportedOperationException(); + + } + + @Override + public WorldType getWorldType() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean hasStorm() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isAutoSave() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkForceLoaded(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkGenerated(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkInUse(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkLoaded(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkLoaded(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isGameRule(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isHardcore() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isThundering() + { + throw new UnsupportedOperationException(); + + } + + @Override + public void loadChunk(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void loadChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean loadChunk(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Raid locateNearestRaid(Location arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Location locateNearestStructure(Location arg0, StructureType arg1, int arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, T arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, int arg2, int arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, T arg2, int arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, Sound arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, String arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, Sound arg1, SoundCategory arg2, float arg3, float arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, String arg1, SoundCategory arg2, float arg3, float arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTrace(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3, boolean arg4, double arg5, Predicate arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3, boolean arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, double arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, Predicate arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, double arg3, Predicate arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean refreshChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean regenerateChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean removePluginChunkTicket(int arg0, int arg1, Plugin arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void removePluginChunkTickets(Plugin arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void save() + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAmbientSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAnimalSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAutoSave(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setBiome(int arg0, int arg1, Biome arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setBiome(int arg0, int arg1, int arg2, Biome arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setChunkForceLoaded(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setDifficulty(Difficulty arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setFullTime(long arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setGameRule(GameRule arg0, T arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setGameRuleValue(String arg0, String arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setHardcore(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setKeepSpawnInMemory(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setMonsterSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setPVP(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setSpawnFlags(boolean arg0, boolean arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setSpawnLocation(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setSpawnLocation(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setStorm(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setThunderDuration(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setThundering(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerAmbientSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerAnimalSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerMonsterSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerWaterAmbientSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerWaterSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTime(long arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWaterAmbientSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWaterAnimalSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWeatherDuration(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawn(Location arg0, Class arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawn(Location arg0, Class arg1, Consumer arg2) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public Arrow spawnArrow(Location arg0, Vector arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawnArrow(Location arg0, Vector arg1, float arg2, float arg3, Class arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Entity spawnEntity(Location arg0, EntityType arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, MaterialData arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, BlockData arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, Material arg1, byte arg2) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, T arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, T arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, T arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6, T arg7) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, T arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6, T arg7, boolean arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8, T arg9) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8, T arg9, boolean arg10) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Spigot spigot() + { + throw new UnsupportedOperationException(); + + } + + @Override + public LightningStrike strikeLightning(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public LightningStrike strikeLightningEffect(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean unloadChunk(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean unloadChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + } + + @Override + public boolean unloadChunk(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + } + + @Override + public boolean unloadChunkRequest(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + } + +}