Upstream/bentobox
1
0
Fork 0
mirror of https://github.com/BentoBoxWorld/BentoBox.git synced 2024-12-21 16:47:39 +01:00
Code Issues Projects Releases Wiki Activity

Added clean super-flat world setting and test

Browse Source
This commit is contained in:
tastybento 2018-07-12 21:25:07 -07:00
parent 4f9a68bd03
commit 451756bc81
5 changed files with 259 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
locales/en-US.yml
View File

@ -320,6 +320,12 @@ protection:
description: "Toggle teleportation"
name: "Chorus fruits"
hint: "No teleporting"
CLEAN_SUPER_FLAT:
description: |
Enable to clean any
super-flat chunks in
island worlds
name: "Clean Super Flat"
COLLECT_LAVA:
description: |
Toggle collecting lava

27
src/main/java/us/tastybento/bskyblock/BSkyBlock.java
View File

@ -62,8 +62,12 @@ public class BSkyBlock extends JavaPlugin {
private HeadGetter headGetter;
private boolean isLoaded;
@Override
public void onEnable(){
// Not loaded
setLoaded(false);
// Store the current millis time so we can tell how many ms it took for BSB to fully load.
final long startMillis = System.currentTimeMillis();
@ -142,6 +146,7 @@ public class BSkyBlock extends JavaPlugin {
instance.log("Thanks for using our plugin !");
instance.log("- Tastybento and Poslovitch, 2017-2018");
instance.log("#############################################");
instance.setLoaded(true);
});
});
}
@ -182,7 +187,9 @@ public class BSkyBlock extends JavaPlugin {
islandsManager.shutdown();
}
// Save settings
new BSBConfig<>(this, Settings.class).saveConfigObject(settings);
if (isEnabled()) {
new BSBConfig<>(this, Settings.class).saveConfigObject(settings);
}
}
private void registerCustomCharts(){
@ -339,4 +346,22 @@ public class BSkyBlock extends JavaPlugin {
}
/**
* @return the isLoaded
*/
public boolean isLoaded() {
return isLoaded;
}
/**
* @param isLoaded the isLoaded to set
*/
public void setLoaded(boolean isLoaded) {
this.isLoaded = isLoaded;
}
}

42
src/main/java/us/tastybento/bskyblock/listeners/flags/CleanSuperFlatListener.java Normal file
View File

@ -0,0 +1,42 @@
/**
*
*/
package us.tastybento.bskyblock.listeners.flags;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.world.ChunkLoadEvent;
import us.tastybento.bskyblock.BSkyBlock;
import us.tastybento.bskyblock.api.flags.AbstractFlagListener;
import us.tastybento.bskyblock.lists.Flags;
/**
* Cleans super-flat world chunks or normal nether chunks if they generate accidentally
* due to lack of a generator being loaded
* @author tastybento
*
*/
public class CleanSuperFlatListener extends AbstractFlagListener {
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onChunkLoad(ChunkLoadEvent e) {
BSkyBlock plugin = BSkyBlock.getInstance();
if (!plugin.isLoaded()) {
return;
}
World world = e.getWorld();
if (!e.getChunk().getBlock(0, 0, 0).getType().equals(Material.BEDROCK)
|| !Flags.CLEAN_SUPER_FLAT.isSetForWorld(world)
|| (world.getEnvironment().equals(Environment.NETHER) && (!plugin.getIWM().isNetherGenerate(world) || !plugin.getIWM().isNetherIslands(world)))
|| (world.getEnvironment().equals(Environment.THE_END) && (!plugin.getIWM().isEndGenerate(world) || !plugin.getIWM().isEndIslands(world)))) {
return;
}
world.regenerateChunk(e.getChunk().getX(), e.getChunk().getZ());
plugin.logWarning("Regenerating superflat chunk at " + (e.getChunk().getX() * 16) + "," + (e.getChunk().getZ() * 16));
}
}

6
src/main/java/us/tastybento/bskyblock/lists/Flags.java
View File

@ -16,6 +16,7 @@ import us.tastybento.bskyblock.listeners.flags.BlockInteractionListener;
import us.tastybento.bskyblock.listeners.flags.BreakBlocksListener;
import us.tastybento.bskyblock.listeners.flags.BreedingListener;
import us.tastybento.bskyblock.listeners.flags.BucketListener;
import us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener;
import us.tastybento.bskyblock.listeners.flags.EggListener;
import us.tastybento.bskyblock.listeners.flags.EnderChestListener;
import us.tastybento.bskyblock.listeners.flags.EnterExitListener;
@ -52,7 +53,7 @@ public class Flags {
// TODO: add KEEP_INVENTORY - is it needed?
public static final Flag BREAK_BLOCKS = new FlagBuilder().id("BREAK_BLOCKS").icon(Material.STONE).listener(new BreakBlocksListener()).build();
public static final Flag PLACE_BLOCKS = new FlagBuilder().id("PLACE_BLOCKS").icon(Material.BEDROCK).listener(new PlaceBlocksListener()).build();
public static final Flag PLACE_BLOCKS = new FlagBuilder().id("PLACE_BLOCKS").icon(Material.GRASS).listener(new PlaceBlocksListener()).build();
// Block interactions - all use BlockInteractionListener()
public static final Flag ANVIL = new FlagBuilder().id("ANVIL").icon(Material.ANVIL).listener(new BlockInteractionListener()).build();
@ -180,7 +181,8 @@ public class Flags {
.listener(new IslandRespawnListener()).allowedByDefault(true).onClick(new WorldToggleClickListener("ISLAND_RESPAWN")).build();
public static final Flag OFFLINE_REDSTONE = new FlagBuilder().id("OFFLINE_REDSTONE").icon(Material.REDSTONE_COMPARATOR).type(Type.WORLD_SETTING)
.listener(new OfflineRedstoneListener()).allowedByDefault(true).onClick(new WorldToggleClickListener("OFFLINE_REDSTONE")).build();
public static final Flag CLEAN_SUPER_FLAT = new FlagBuilder().id("CLEAN_SUPER_FLAT").icon(Material.BEDROCK).type(Type.WORLD_SETTING)
.listener(new CleanSuperFlatListener()).allowedByDefault(false).onClick(new WorldToggleClickListener("CLEAN_SUPER_FLAT")).build();
/**
* @return List of all the flags in this class
*/

181
src/test/java/us/tastybento/bskyblock/listeners/flags/CleanSuperFlatListenerTest.java Normal file
View File

@ -0,0 +1,181 @@
/**
*
*/
package us.tastybento.bskyblock.listeners.flags;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.inventory.ItemFactory;
import org.bukkit.inventory.meta.ItemMeta;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import us.tastybento.bskyblock.BSkyBlock;
import us.tastybento.bskyblock.api.configuration.WorldSettings;
import us.tastybento.bskyblock.lists.Flags;
import us.tastybento.bskyblock.managers.IslandWorldManager;
import us.tastybento.bskyblock.util.Util;
/**
* @author tastybento
*
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({Bukkit.class, BSkyBlock.class, Util.class })
public class CleanSuperFlatListenerTest {
private World world;
private Block block;
private Chunk chunk;
private IslandWorldManager iwm;
private BSkyBlock plugin;
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
// Set up plugin
plugin = mock(BSkyBlock.class);
Whitebox.setInternalState(BSkyBlock.class, "instance", plugin);
when(plugin.isLoaded()).thenReturn(true);
// World
world = mock(World.class);
when(world.getEnvironment()).thenReturn(World.Environment.NORMAL);
PowerMockito.mockStatic(Util.class);
when(Util.getWorld(Mockito.any())).thenReturn(world);
// World Settings
iwm = mock(IslandWorldManager.class);
when(plugin.getIWM()).thenReturn(iwm);
WorldSettings ws = mock(WorldSettings.class);
when(iwm.getWorldSettings(Mockito.any())).thenReturn(ws);
Map<String, Boolean> worldFlags = new HashMap<>();
when(ws.getWorldFlags()).thenReturn(worldFlags);
when(iwm.isNetherGenerate(Mockito.any())).thenReturn(true);
when(iwm.isEndGenerate(Mockito.any())).thenReturn(true);
when(iwm.isNetherIslands(Mockito.any())).thenReturn(true);
when(iwm.isEndIslands(Mockito.any())).thenReturn(true);
PowerMockito.mockStatic(Bukkit.class);
ItemFactory itemF = mock(ItemFactory.class);
ItemMeta im = mock(ItemMeta.class);
when(itemF.getItemMeta(Mockito.any())).thenReturn(im);
when(Bukkit.getItemFactory()).thenReturn(itemF);
Flags.CLEAN_SUPER_FLAT.setSetting(world, true);
chunk = mock(Chunk.class);
when(chunk.getWorld()).thenReturn(world);
block = mock(Block.class);
when(block.getType()).thenReturn(Material.BEDROCK);
when(chunk.getBlock(Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(block);
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadNotBedrockNoFlsg() {
when(block.getType()).thenReturn(Material.AIR);
Flags.CLEAN_SUPER_FLAT.setSetting(world, false);
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world, Mockito.never()).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadNotLoaded() {
when(plugin.isLoaded()).thenReturn(false);
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world, Mockito.never()).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadBedrock() {
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadBedrockNoClean() {
Flags.CLEAN_SUPER_FLAT.setSetting(world, false);
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world, Mockito.never()).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadBedrockNether() {
when(world.getEnvironment()).thenReturn(World.Environment.NETHER);
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
when(iwm.isNetherGenerate(Mockito.any())).thenReturn(false);
when(iwm.isNetherIslands(Mockito.any())).thenReturn(true);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt()); // No more than once
when(iwm.isNetherGenerate(Mockito.any())).thenReturn(true);
when(iwm.isNetherIslands(Mockito.any())).thenReturn(false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt()); // No more than once
}
/**
* Test method for {@link us.tastybento.bskyblock.listeners.flags.CleanSuperFlatListener#onChunkLoad(org.bukkit.event.world.ChunkLoadEvent)}.
*/
@Test
public void testOnChunkLoadBedrockEnd() {
when(world.getEnvironment()).thenReturn(World.Environment.THE_END);
ChunkLoadEvent e = new ChunkLoadEvent(chunk, false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt());
when(iwm.isEndGenerate(Mockito.any())).thenReturn(false);
when(iwm.isEndIslands(Mockito.any())).thenReturn(true);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt()); // No more than once
when(iwm.isEndGenerate(Mockito.any())).thenReturn(true);
when(iwm.isEndIslands(Mockito.any())).thenReturn(false);
new CleanSuperFlatListener().onChunkLoad(e);
Mockito.verify(world).regenerateChunk(Mockito.anyInt(), Mockito.anyInt()); // No more than once
}
}