Upstream
/
bentobox
mirror of https://github.com/BentoBoxWorld/BentoBox.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #242 from BentoBoxWorld/develop 

Merging develop in master
This commit is contained in:
Florian CUNY 2018-08-25 22:59:20 +02:00 committed by GitHub
parent 5342a29c1c 45935a30a9
commit 1405a6a302
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 641 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -12,11 +12,11 @@ BentoBox
BentoBox is an expandable Minecraft Bukkit plugin for island-type games like ASkyBlock or AcidIsland.
Admins can assemble the game or games how they like with a variety of add-ons. These include:
BSkyBlock - the successor to the popular ASkyBlock. Don't fall!
AcidIsland - you are marooned in a sea of acid!
Level - an add-on to calculate your island level and show a top ten
Challenges - an add-on that gives you challenges to accomplish
Welcome WarpSigns - an add-on that enables players to plant a warp sign
* BSkyBlock - the successor to the popular ASkyBlock. Don't fall!
* AcidIsland - you are marooned in a sea of acid!
* Level - an add-on to calculate your island level and show a top ten
* Challenges - an add-on that gives you challenges to accomplish
* Welcome WarpSigns - an add-on that enables players to plant a warp sign
Bentobox represents a turning point on ASkyBlock's history : Tastybento and Poslovitch thought up and designed this complete rewrite in order to provide a whole new way to play Skyblock and other island-style games.

2
pom.xml
View File

@ -6,7 +6,7 @@
<groupId>world.bentobox</groupId>
<artifactId>bentobox</artifactId>
<version>FC-1</version>
<version>0.9.0-SNAPSHOT</version>
<name>BentoBox</name>
<description>BentoBox is an expandable Minecraft Spigot plugin for island-type games like ASkyBlock or AcidIsland.</description>

3
src/main/java/world/bentobox/bentobox/BentoBox.java
View File

@ -12,6 +12,7 @@ import world.bentobox.bentobox.api.user.Notifier;
import world.bentobox.bentobox.commands.BentoBoxCommand;
import world.bentobox.bentobox.listeners.BannedVisitorCommands;
import world.bentobox.bentobox.listeners.BlockEndDragon;
import world.bentobox.bentobox.listeners.DeathListener;
import world.bentobox.bentobox.listeners.JoinLeaveListener;
import world.bentobox.bentobox.listeners.NetherPortals;
import world.bentobox.bentobox.listeners.ObsidianToLava;
@ -156,6 +157,8 @@ public class BentoBox extends JavaPlugin {
manager.registerEvents(new BlockEndDragon(this), this);
// Banned visitor commands
manager.registerEvents(new BannedVisitorCommands(this), this);
// Death counter
manager.registerEvents(new DeathListener(this), this);
}
@Override

3
src/main/java/world/bentobox/bentobox/api/flags/clicklisteners/CycleClick.java
View File

@ -38,7 +38,8 @@ public class CycleClick implements PanelItem.ClickHandler {
return true;
}
String reqPerm = plugin.getIWM().getPermissionPrefix(Util.getWorld(user.getWorld())) + ".settings." + id;
if (!user.hasPermission(reqPerm)) {
String allPerms = plugin.getIWM().getPermissionPrefix(Util.getWorld(user.getWorld())) + ".settings.*";
if (!user.hasPermission(reqPerm) && !user.hasPermission(allPerms)) {
user.sendMessage("general.errors.no-permission", TextVariables.PERMISSION, reqPerm);
user.getPlayer().playSound(user.getLocation(), Sound.BLOCK_METAL_HIT, 1F, 1F);
return true;

33
src/main/java/world/bentobox/bentobox/listeners/DeathListener.java Normal file
View File

@ -0,0 +1,33 @@
/**
*
*/
package world.bentobox.bentobox.listeners;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import world.bentobox.bentobox.BentoBox;
/**
* Counts deaths in game worlds
* @author tastybento
*
*/
public class DeathListener implements Listener {
private BentoBox plugin;
public DeathListener(BentoBox plugin) {
super();
this.plugin = plugin;
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onPlayerDeathEvent(PlayerDeathEvent e) {
if (plugin.getIWM().inWorld(e.getEntity().getLocation())) {
plugin.getPlayers().addDeath(e.getEntity().getWorld(), e.getEntity().getUniqueId());
}
}
}

279
src/main/java/world/bentobox/bentobox/listeners/flags/BlockInteractionListener.java
View File

@ -1,8 +1,12 @@
package world.bentobox.bentobox.listeners.flags;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.event.Event;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import world.bentobox.bentobox.api.flags.AbstractFlagListener;
@ -23,136 +27,8 @@ public class BlockInteractionListener extends AbstractFlagListener {
if (!e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
return;
}
switch (e.getClickedBlock().getType()) {
case ANVIL:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.ANVIL);
break;
case BEACON:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.BEACON);
break;
case BLACK_BED:
case BLUE_BED:
case BROWN_BED:
case CYAN_BED:
case GRAY_BED:
case GREEN_BED:
case LIGHT_BLUE_BED:
case LIGHT_GRAY_BED:
case LIME_BED:
case MAGENTA_BED:
case ORANGE_BED:
case PINK_BED:
case PURPLE_BED:
case RED_BED:
case WHITE_BED:
case YELLOW_BED:
checkClickedBlock(e, e.getClickedBlock().getLocation(), e.getClickedBlock().getType());
checkIsland(e, e.getClickedBlock().getLocation(), Flags.BED);
break;
case BREWING_STAND:
case CAULDRON:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.BREWING);
break;
case CHEST:
case CHEST_MINECART:
case TRAPPED_CHEST:
case BLACK_SHULKER_BOX:
case BLUE_SHULKER_BOX:
case BROWN_SHULKER_BOX:
case CYAN_SHULKER_BOX:
case GRAY_SHULKER_BOX:
case GREEN_SHULKER_BOX:
case LIGHT_BLUE_SHULKER_BOX:
case LIME_SHULKER_BOX:
case PINK_SHULKER_BOX:
case MAGENTA_SHULKER_BOX:
case ORANGE_SHULKER_BOX:
case PURPLE_SHULKER_BOX:
case RED_SHULKER_BOX:
case LIGHT_GRAY_SHULKER_BOX:
case WHITE_SHULKER_BOX:
case YELLOW_SHULKER_BOX:
case DISPENSER:
case DROPPER:
case HOPPER:
case HOPPER_MINECART:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.CHEST);
break;
case ACACIA_DOOR:
case BIRCH_DOOR:
case DARK_OAK_DOOR:
case IRON_DOOR:
case JUNGLE_DOOR:
case SPRUCE_DOOR:
case OAK_DOOR:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.DOOR);
break;
case ACACIA_TRAPDOOR:
case BIRCH_TRAPDOOR:
case DARK_OAK_TRAPDOOR:
case OAK_TRAPDOOR:
case JUNGLE_TRAPDOOR:
case SPRUCE_TRAPDOOR:
case IRON_TRAPDOOR:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.TRAPDOOR);
break;
case ACACIA_FENCE_GATE:
case BIRCH_FENCE_GATE:
case DARK_OAK_FENCE_GATE:
case OAK_FENCE_GATE:
case JUNGLE_FENCE_GATE:
case SPRUCE_FENCE_GATE:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.GATE);
break;
case FURNACE:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.FURNACE);
break;
case ENCHANTING_TABLE:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.ENCHANTING);
break;
case ENDER_CHEST:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.ENDER_CHEST);
break;
case JUKEBOX:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.JUKEBOX);
break;
case NOTE_BLOCK:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.NOTE_BLOCK);
break;
case CRAFTING_TABLE:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.CRAFTING);
break;
case STONE_BUTTON:
case ACACIA_BUTTON:
case BIRCH_BUTTON:
case DARK_OAK_BUTTON:
case JUNGLE_BUTTON:
case OAK_BUTTON:
case SPRUCE_BUTTON:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.BUTTON);
break;
case LEVER:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.LEVER);
break;
case REPEATER:
case COMPARATOR:
case DAYLIGHT_DETECTOR:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.REDSTONE);
break;
case DRAGON_EGG:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.BREAK_BLOCKS);
break;
case END_PORTAL_FRAME:
checkIsland(e, e.getClickedBlock().getLocation(), Flags.PLACE_BLOCKS);
break;
default:
break;
}
// Now check for in-hand items
if (e.getItem() != null) {
switch (e.getItem().getType()) {
@ -218,4 +94,149 @@ public class BlockInteractionListener extends AbstractFlagListener {
}
}
}
/**
* Check if an action can occur on a clicked block
* @param e - event called
* @param loc - location of clicked block
* @param type - material type of clicked block
*/
private void checkClickedBlock(Event e, Location loc, Material type) {
switch (type) {
case ANVIL:
checkIsland(e, loc, Flags.ANVIL);
break;
case BEACON:
checkIsland(e, loc, Flags.BEACON);
break;
case BLACK_BED:
case BLUE_BED:
case BROWN_BED:
case CYAN_BED:
case GRAY_BED:
case GREEN_BED:
case LIGHT_BLUE_BED:
case LIGHT_GRAY_BED:
case LIME_BED:
case MAGENTA_BED:
case ORANGE_BED:
case PINK_BED:
case PURPLE_BED:
case RED_BED:
case WHITE_BED:
case YELLOW_BED:
checkIsland(e, loc, Flags.BED);
break;
case BREWING_STAND:
case CAULDRON:
checkIsland(e, loc, Flags.BREWING);
break;
case CHEST:
case CHEST_MINECART:
case TRAPPED_CHEST:
case BLACK_SHULKER_BOX:
case BLUE_SHULKER_BOX:
case BROWN_SHULKER_BOX:
case CYAN_SHULKER_BOX:
case GRAY_SHULKER_BOX:
case GREEN_SHULKER_BOX:
case LIGHT_BLUE_SHULKER_BOX:
case LIME_SHULKER_BOX:
case PINK_SHULKER_BOX:
case MAGENTA_SHULKER_BOX:
case ORANGE_SHULKER_BOX:
case PURPLE_SHULKER_BOX:
case RED_SHULKER_BOX:
case LIGHT_GRAY_SHULKER_BOX:
case WHITE_SHULKER_BOX:
case YELLOW_SHULKER_BOX:
case DISPENSER:
case DROPPER:
case HOPPER:
case HOPPER_MINECART:
checkIsland(e, loc, Flags.CHEST);
break;
case ACACIA_DOOR:
case BIRCH_DOOR:
case DARK_OAK_DOOR:
case IRON_DOOR:
case JUNGLE_DOOR:
case SPRUCE_DOOR:
case OAK_DOOR:
checkIsland(e, loc, Flags.DOOR);
break;
case ACACIA_TRAPDOOR:
case BIRCH_TRAPDOOR:
case DARK_OAK_TRAPDOOR:
case OAK_TRAPDOOR:
case JUNGLE_TRAPDOOR:
case SPRUCE_TRAPDOOR:
case IRON_TRAPDOOR:
checkIsland(e, loc, Flags.TRAPDOOR);
break;
case ACACIA_FENCE_GATE:
case BIRCH_FENCE_GATE:
case DARK_OAK_FENCE_GATE:
case OAK_FENCE_GATE:
case JUNGLE_FENCE_GATE:
case SPRUCE_FENCE_GATE:
checkIsland(e, loc, Flags.GATE);
break;
case FURNACE:
checkIsland(e, loc, Flags.FURNACE);
break;
case ENCHANTING_TABLE:
checkIsland(e, loc, Flags.ENCHANTING);
break;
case ENDER_CHEST:
checkIsland(e, loc, Flags.ENDER_CHEST);
break;
case JUKEBOX:
checkIsland(e, loc, Flags.JUKEBOX);
break;
case NOTE_BLOCK:
checkIsland(e, loc, Flags.NOTE_BLOCK);
break;
case CRAFTING_TABLE:
checkIsland(e, loc, Flags.CRAFTING);
break;
case STONE_BUTTON:
case ACACIA_BUTTON:
case BIRCH_BUTTON:
case DARK_OAK_BUTTON:
case JUNGLE_BUTTON:
case OAK_BUTTON:
case SPRUCE_BUTTON:
checkIsland(e, loc, Flags.BUTTON);
break;
case LEVER:
checkIsland(e, loc, Flags.LEVER);
break;
case REPEATER:
case COMPARATOR:
case DAYLIGHT_DETECTOR:
checkIsland(e, loc, Flags.REDSTONE);
break;
case DRAGON_EGG:
checkIsland(e, loc, Flags.BREAK_BLOCKS);
break;
case END_PORTAL_FRAME:
checkIsland(e, loc, Flags.PLACE_BLOCKS);
break;
default:
break;
}
}
/**
* Prevents blocks that are protected from being broken, which would bypass the protection
*
* @param e - event
*/
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onBlockBreak(final BlockBreakEvent e) {
checkClickedBlock(e, e.getBlock().getLocation(), e.getBlock().getType());
}
}

25
src/main/java/world/bentobox/bentobox/listeners/flags/EndermanListener.java
View File

@ -3,14 +3,10 @@
*/
package world.bentobox.bentobox.listeners.flags;
import org.bukkit.Material;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Enderman;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.inventory.ItemStack;
import world.bentobox.bentobox.api.flags.AbstractFlagListener;
import world.bentobox.bentobox.lists.Flags;
@ -36,25 +32,4 @@ public class EndermanListener extends AbstractFlagListener {
}
}
/**
* Drops the Enderman's block when he dies if he has one
*
* @param e - event
*/
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onEndermanDeath(final EntityDeathEvent e) {
if (!(e.getEntity() instanceof Enderman)
|| !getIWM().inWorld(e.getEntity().getLocation())
|| !Flags.ENDERMAN_DEATH_DROP.isSetForWorld(e.getEntity().getWorld())) {
return;
}
// Get the block the enderman is holding
Enderman ender = (Enderman) e.getEntity();
BlockData m = ender.getCarriedBlock();
if (m != null && !m.getMaterial().equals(Material.AIR)) {
// Drop the item
e.getEntity().getWorld().dropItemNaturally(e.getEntity().getLocation(), new ItemStack(m.getMaterial()));
}
}
}

4
src/main/java/world/bentobox/bentobox/lists/Flags.java
View File

@ -176,10 +176,6 @@ public class Flags {
.listener(new EndermanListener())
.build();
public static final Flag ENDERMAN_DEATH_DROP = new FlagBuilder().id("ENDERMAN_DEATH_DROP").icon(Material.END_ROD)
.allowedByDefault(true).type(Type.WORLD_SETTING)
.build();
public static final Flag ENTER_EXIT_MESSAGES = new FlagBuilder().id("ENTER_EXIT_MESSAGES").icon(Material.DIRT).allowedByDefault(true).type(Type.WORLD_SETTING)
.listener(new EnterExitListener())
.build();

6
src/main/java/world/bentobox/bentobox/managers/RanksManager.java
View File

@ -72,6 +72,9 @@ public class RanksManager {
*/
public boolean addRank(String reference, int value) {
if (reference.equalsIgnoreCase(OWNER_RANK_REF)
|| reference.equalsIgnoreCase(SUB_OWNER_RANK_REF)
|| reference.equalsIgnoreCase(TRUSTED_RANK_REF)
|| reference.equalsIgnoreCase(COOP_RANK_REF)
|| reference.equalsIgnoreCase(MEMBER_RANK_REF)
|| reference.equalsIgnoreCase(VISITOR_RANK_REF)
|| reference.equalsIgnoreCase(BANNED_RANK_REF)
@ -100,6 +103,9 @@ public class RanksManager {
*/
public boolean removeRank(String reference) {
return !reference.equalsIgnoreCase(OWNER_RANK_REF)
&& !reference.equalsIgnoreCase(SUB_OWNER_RANK_REF)
&& !reference.equalsIgnoreCase(TRUSTED_RANK_REF)
&& !reference.equalsIgnoreCase(COOP_RANK_REF)
&& !reference.equalsIgnoreCase(MEMBER_RANK_REF)
&& !reference.equalsIgnoreCase(VISITOR_RANK_REF)
&& !reference.equalsIgnoreCase(BANNED_RANK_REF)

5
src/main/java/world/bentobox/bentobox/managers/island/NewIsland.java
View File

@ -8,6 +8,7 @@ import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.util.Vector;
import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.events.IslandBaseEvent;
@ -141,6 +142,10 @@ public class NewIsland {
if (island.getSpawnPoint(Environment.NORMAL) != null) {
plugin.getPlayers().setHomeLocation(user, island.getSpawnPoint(Environment.NORMAL), 1);
}
// Stop the player from falling or moving if they are
user.getPlayer().setVelocity(new Vector(0,0,0));
user.getPlayer().setFallDistance(0F);
// Teleport player after this island is built
plugin.getIslands().homeTeleport(world, user.getPlayer(), true);
});

24
src/main/java/world/bentobox/bentobox/schems/Clipboard.java
View File

@ -186,7 +186,11 @@ public class Clipboard {
// Calculate location for pasting
Location loc = island.getCenter().toVector().subtract(off).toLocation(world);
// Paste
blockConfig.getConfigurationSection(BLOCK).getKeys(false).forEach(b -> pasteBlock(world, island, loc, blockConfig.getConfigurationSection(BLOCK + "." + b)));
if (blockConfig.contains(BLOCK)) {
blockConfig.getConfigurationSection(BLOCK).getKeys(false).forEach(b -> pasteBlock(world, island, loc, blockConfig.getConfigurationSection(BLOCK + "." + b)));
} else {
plugin.logError("Clipboard has no block data in it to paste!");
}
// Run follow on task if it exists
if (task != null) {
Bukkit.getScheduler().runTaskLater(plugin, task, 2L);
@ -198,8 +202,11 @@ public class Clipboard {
* @param location - location
*/
public void pasteClipboard(Location location) {
blockConfig.getConfigurationSection(BLOCK).getKeys(false).forEach(b -> pasteBlock(location.getWorld(), null, location, blockConfig.getConfigurationSection(BLOCK + "." + b)));
if (blockConfig.contains(BLOCK)) {
blockConfig.getConfigurationSection(BLOCK).getKeys(false).forEach(b -> pasteBlock(location.getWorld(), null, location, blockConfig.getConfigurationSection(BLOCK + "." + b)));
} else {
plugin.logError("Clipboard has no block data in it to paste!");
}
}
private void writeSign(Island island, Block block, List<String> lines) {
@ -238,10 +245,13 @@ public class Clipboard {
if (config.getBoolean(ATTACHED)) {
plugin.getServer().getScheduler().runTask(plugin, () -> setBlock(island, block, config, blockData));
} else {
setBlock(island, block, config, blockData);
}
}
// Entities
if (config.isConfigurationSection(ENTITY)) {
setEntity(island, block.getLocation(), config);
}
}
private void setBlock(Island island, Block block, ConfigurationSection config, String blockData) {
@ -249,10 +259,6 @@ public class Clipboard {
block.setBlockData(Bukkit.createBlockData(blockData));
// Set the block state for chests, signs and mob spawners
setBlockState(island, block, config);
// Set entities
if (config.isConfigurationSection(ENTITY)) {
setEntity(island, block.getLocation(), config);
}
}
/**
@ -266,7 +272,7 @@ public class Clipboard {
en.getKeys(false).forEach(k -> {
ConfigurationSection ent = en.getConfigurationSection(k);
Location center = location.add(new Vector(0.5, 0.0, 0.5));
LivingEntity e = (LivingEntity)island.getWorld().spawnEntity(center, EntityType.valueOf(ent.getString("type", "PIG")));
LivingEntity e = (LivingEntity)location.getWorld().spawnEntity(center, EntityType.valueOf(ent.getString("type", "PIG")));
if (e != null) {
e.setCustomName(ent.getString("name"));
}

68
src/test/java/world/bentobox/bentobox/listeners/DeathListenerTest.java Normal file
View File

@ -0,0 +1,68 @@
package world.bentobox.bentobox.listeners;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.managers.IslandWorldManager;
import world.bentobox.bentobox.managers.PlayersManager;
import world.bentobox.bentobox.util.Util;
@RunWith(PowerMockRunner.class)
@PrepareForTest({BentoBox.class, Util.class, Bukkit.class })
public class DeathListenerTest {
@Test
public void testDeathListener() {
assertNotNull(new DeathListener(mock(BentoBox.class)));
}
@Test
public void testOnPlayerDeathEvent() {
// Set up plugin
BentoBox plugin = mock(BentoBox.class);
Whitebox.setInternalState(BentoBox.class, "instance", plugin);
// Island World Manager
IslandWorldManager iwm = mock(IslandWorldManager.class);
when(iwm.inWorld(Mockito.any())).thenReturn(true);
when(iwm.getPermissionPrefix(Mockito.any())).thenReturn("bskyblock");
when(iwm.getVisitorBannedCommands(Mockito.any())).thenReturn(new ArrayList<>());
when(plugin.getIWM()).thenReturn(iwm);
// Player
Player player = mock(Player.class);
World world = mock(World.class);
when(player.getWorld()).thenReturn(world);
when(player.getLocation()).thenReturn(mock(Location.class));
UUID uuid = UUID.randomUUID();
when(player.getUniqueId()).thenReturn(uuid);
PlayersManager pm = mock(PlayersManager.class);
when(plugin.getPlayers()).thenReturn(pm);
// Test
DeathListener dl = new DeathListener(plugin);
PlayerDeathEvent e = new PlayerDeathEvent(player, new ArrayList<>(), 0, 0, 0, 0, "died");
dl.onPlayerDeathEvent(e);
Mockito.verify(pm).addDeath(world, uuid);
}
}

67
src/test/java/world/bentobox/bentobox/listeners/flags/EndermanListenerTest.java
View File

@ -9,7 +9,6 @@ import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@ -26,7 +25,6 @@ import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Enderman;
import org.bukkit.entity.Slime;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.inventory.ItemFactory;
import org.bukkit.inventory.meta.SkullMeta;
import org.bukkit.plugin.PluginManager;
@ -137,9 +135,6 @@ public class EndermanListenerTest {
when(Util.getWorld(Mockito.any())).thenReturn(mock(World.class));
// Not allowed to start
Flags.ENDERMAN_GRIEFING.setSetting(world, false);
// Allowed to start
Flags.ENDERMAN_DEATH_DROP.setSetting(world, true);
}
@ -197,66 +192,4 @@ public class EndermanListenerTest {
assertTrue(e.isCancelled());
}
/**
* Test method for {@link world.bentobox.bentobox.listeners.flags.EndermanListener#onEndermanDeath(org.bukkit.event.entity.EntityDeathEvent)}.
*/
@Test
public void testOnNotEndermanDeath() {
EndermanListener listener = new EndermanListener();
EntityDeathEvent e = new EntityDeathEvent(slime, new ArrayList<>());
listener.onEndermanDeath(e);
Mockito.verify(world, Mockito.never()).dropItemNaturally(Mockito.any(), Mockito.any());
}
/**
* Test method for {@link world.bentobox.bentobox.listeners.flags.EndermanListener#onEndermanDeath(org.bukkit.event.entity.EntityDeathEvent)}.
*/
@Test
public void testOnEndermanDeathCarryAir() {
when(bd.getMaterial()).thenReturn(Material.AIR);
EndermanListener listener = new EndermanListener();
EntityDeathEvent e = new EntityDeathEvent(enderman, new ArrayList<>());
listener.onEndermanDeath(e);
Mockito.verify(world, Mockito.never()).dropItemNaturally(Mockito.any(), Mockito.any());
}
/**
* Test method for {@link world.bentobox.bentobox.listeners.flags.EndermanListener#onEndermanDeath(org.bukkit.event.entity.EntityDeathEvent)}.
*/
@Test
public void testOnEndermanDeathNotInWorld() {
when(iwm.inWorld(Mockito.any())).thenReturn(false);
EndermanListener listener = new EndermanListener();
EntityDeathEvent e = new EntityDeathEvent(enderman, new ArrayList<>());
listener.onEndermanDeath(e);
Mockito.verify(world, Mockito.never()).dropItemNaturally(Mockito.any(), Mockito.any());
}
/**
* Test method for {@link world.bentobox.bentobox.listeners.flags.EndermanListener#onEndermanDeath(org.bukkit.event.entity.EntityDeathEvent)}.
*/
@Test
public void testOnEndermanDeathNoFlag() {
Flags.ENDERMAN_DEATH_DROP.setSetting(world, false);
EndermanListener listener = new EndermanListener();
EntityDeathEvent e = new EntityDeathEvent(enderman, new ArrayList<>());
listener.onEndermanDeath(e);
Mockito.verify(world, Mockito.never()).dropItemNaturally(Mockito.any(), Mockito.any());
}
/**
* Test method for {@link world.bentobox.bentobox.listeners.flags.EndermanListener#onEndermanDeath(org.bukkit.event.entity.EntityDeathEvent)}.
*/
@Test
public void testOnEndermanDeath() {
EndermanListener listener = new EndermanListener();
EntityDeathEvent e = new EntityDeathEvent(enderman, new ArrayList<>());
listener.onEndermanDeath(e);
Mockito.verify(world).dropItemNaturally(Mockito.any(), Mockito.any());
}
}

2
src/test/java/world/bentobox/bentobox/managers/RanksManagerTest.java
View File

@ -55,7 +55,7 @@ public class RanksManagerTest {
*/
@Test
public void testRemoveRank() {
ranksManager.addRank("test.rank.reference2", 650);
assertTrue(ranksManager.addRank("test.rank.reference2", 650));
assertTrue(ranksManager.removeRank("test.rank.reference2"));
// Second time should fail
assertFalse(ranksManager.removeRank("test.rank.reference2"));

352
src/test/java/world/bentobox/bentobox/schems/ClipboardTest.java Normal file
View File

@ -0,0 +1,352 @@
package world.bentobox.bentobox.schems;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.DyeColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.Chest;
import org.bukkit.block.CreatureSpawner;
import org.bukkit.block.Sign;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Cow;
import org.bukkit.entity.Creeper;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Horse;
import org.bukkit.entity.Horse.Color;
import org.bukkit.entity.Horse.Style;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Pig;
import org.bukkit.entity.Player;
import org.bukkit.entity.Sheep;
import org.bukkit.inventory.HorseInventory;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.util.Vector;
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 world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.localization.TextVariables;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.objects.Island;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Bukkit.class})
public class ClipboardTest {
private BentoBox plugin;
private File schemFolder;
private Location loc;
private User user;
private Location loc2;
private Sheep sheep;
private Horse horse;
private Block block;
private World world;
private BukkitScheduler sched;
@Before
public void setUp() throws Exception {
plugin = mock(BentoBox.class);
schemFolder = mock(File.class);
when(schemFolder.exists()).thenReturn(true);
loc = mock(Location.class);
world = mock(World.class);
block = mock(Block.class);
when(block.getType()).thenReturn(Material.GRASS);
when(block.getLocation()).thenReturn(loc);
BlockData bd = mock(BlockData.class);
when(bd.getAsString()).thenReturn("Block_data");
when(block.getBlockData()).thenReturn(bd);
when(world.getBlockAt(Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(block);
when(loc.getWorld()).thenReturn(world);
when(loc.getBlockX()).thenReturn(1);
when(loc.getBlockY()).thenReturn(2);
when(loc.getBlockZ()).thenReturn(3);
when(loc.getBlock()).thenReturn(block);
when(loc.toVector()).thenReturn(new Vector(1,2,3));
loc2 = mock(Location.class);
when(loc2.getWorld()).thenReturn(world);
when(loc2.getBlockX()).thenReturn(2);
when(loc2.getBlockY()).thenReturn(3);
when(loc2.getBlockZ()).thenReturn(4);
when(loc2.getBlock()).thenReturn(block);
// Living entities
List<LivingEntity> ents = new ArrayList<>();
Pig pig = mock(Pig.class);
Player player = mock(Player.class);
Cow cow = mock(Cow.class);
Creeper creeper = mock(Creeper.class);
sheep = mock(Sheep.class);
horse = mock(Horse.class);
when(pig.getLocation()).thenReturn(loc);
when(cow.getLocation()).thenReturn(loc);
when(creeper.getLocation()).thenReturn(loc);
when(player.getLocation()).thenReturn(loc);
when(sheep.getLocation()).thenReturn(loc);
when(horse.getLocation()).thenReturn(loc);
when(pig.getType()).thenReturn(EntityType.PIG);
when(player.getType()).thenReturn(EntityType.PLAYER);
when(cow.getType()).thenReturn(EntityType.COW);
when(creeper.getType()).thenReturn(EntityType.CREEPER);
when(sheep.getType()).thenReturn(EntityType.SHEEP);
when(sheep.getColor()).thenReturn(DyeColor.LIGHT_BLUE);
when(horse.getType()).thenReturn(EntityType.HORSE);
when(horse.getColor()).thenReturn(Color.CREAMY);
when(horse.getStyle()).thenReturn(Style.BLACK_DOTS);
HorseInventory inv = mock(HorseInventory.class);
when(horse.getInventory()).thenReturn(inv);
// UUIDs (I'm going to assume these will all be unique (prays to god of randomness)
when(creeper.getUniqueId()).thenReturn(UUID.randomUUID());
when(player.getUniqueId()).thenReturn(UUID.randomUUID());
when(cow.getUniqueId()).thenReturn(UUID.randomUUID());
when(pig.getUniqueId()).thenReturn(UUID.randomUUID());
when(sheep.getUniqueId()).thenReturn(UUID.randomUUID());
when(horse.getUniqueId()).thenReturn(UUID.randomUUID());
ents.add(creeper);
ents.add(player);
ents.add(cow);
ents.add(pig);
ents.add(sheep);
ents.add(horse);
when(world.getLivingEntities()).thenReturn(ents);
user = mock(User.class);
User.setPlugin(plugin);
when(user.getLocation()).thenReturn(loc);
// Scheduler
PowerMockito.mockStatic(Bukkit.class);
sched = mock(BukkitScheduler.class);
when(Bukkit.getScheduler()).thenReturn(sched);
}
@Test
public void testClipboard() {
when(schemFolder.exists()).thenReturn(false);
new Clipboard(plugin, schemFolder);
Mockito.verify(schemFolder).mkdirs();
}
@Test
public void testSetGetPos1() {
Clipboard cb = new Clipboard(plugin, schemFolder);
assertNull(cb.getPos1());
cb.setPos1(loc);
assertEquals(loc, cb.getPos1());
assertNull(cb.getOrigin());
}
@Test
public void testSetGetPos2() {
Clipboard cb = new Clipboard(plugin, schemFolder);
assertNull(cb.getPos2());
cb.setPos2(loc);
assertEquals(loc, cb.getPos2());
}
@Test
public void testSetGetOrigin() {
Clipboard cb = new Clipboard(plugin, schemFolder);
assertNull(cb.getOrigin());
cb.setOrigin(loc);
assertEquals(loc, cb.getOrigin());
}
@Test
public void testCopyNoPos1Pos2() {
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.copy(user, false);
Mockito.verify(user).sendMessage(Mockito.eq("commands.admin.schem.need-pos1-pos2"));
}
@Test
public void testCopyNoPos2() {
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.copy(user, false);
Mockito.verify(user).sendMessage(Mockito.eq("commands.admin.schem.need-pos1-pos2"));
}
@Test
public void testCopy() {
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "8");
}
@Test
public void testCopySigns() {
when(block.getType()).thenReturn(Material.SIGN);
Sign bs = mock(Sign.class);
String[] lines = {"line1", "line2", "line3", "line4"};
when(bs.getLines()).thenReturn(lines);
when(block.getState()).thenReturn(bs);
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "8");
// Every block is a sign, so this should be called 8 times
Mockito.verify(bs, Mockito.times(8)).getLines();
}
@Test
public void testCopyChests() {
when(block.getType()).thenReturn(Material.CHEST);
Chest bs = mock(Chest.class);
Inventory inv = mock(Inventory.class);
ItemStack[] contents = { new ItemStack(Material.ACACIA_BOAT, 1), new ItemStack(Material.GLASS, 23)};
when(inv.getContents()).thenReturn(contents);
when(bs.getInventory()).thenReturn(inv);
when(block.getState()).thenReturn(bs);
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "8");
// Every block is a sign, so this should be called 8 times
Mockito.verify(bs, Mockito.times(8)).getInventory();
}
@Test
public void testCopyCreatureSpawners() {
when(block.getType()).thenReturn(Material.SPAWNER);
CreatureSpawner bs = mock(CreatureSpawner.class);
when(bs.getSpawnedType()).thenReturn(EntityType.CAVE_SPIDER);
when(block.getState()).thenReturn(bs);
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "8");
// Every block is a sign, so this should be called 8 times
Mockito.verify(bs, Mockito.times(8)).getMaxNearbyEntities();
}
@Test
public void testCopyAir() {
// No entities
when(world.getLivingEntities()).thenReturn(new ArrayList<>());
when(block.getType()).thenReturn(Material.AIR);
BlockState bs = mock(BlockState.class);
when(block.getState()).thenReturn(bs);
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
// Do not copy air
cb.copy(user, false);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "0");
cb.copy(user, true);
Mockito.verify(user).sendMessage("commands.admin.schem.copied-blocks", TextVariables.NUMBER, "8");
}
@Test
public void testPasteIslandNoData() {
Clipboard cb = new Clipboard(plugin, schemFolder);
Island island = mock(Island.class);
when(island.getCenter()).thenReturn(loc);
cb.pasteIsland(world, island, () -> {});
Mockito.verify(plugin).logError(Mockito.eq("Clipboard has no block data in it to paste!"));
// Verify the task is run
Mockito.verify(sched).runTaskLater(Mockito.eq(plugin), Mockito.any(Runnable.class), Mockito.eq(2L));
}
@Test
public void testPasteIslandWithData() {
Clipboard cb = new Clipboard(plugin, schemFolder);
Island island = mock(Island.class);
when(island.getCenter()).thenReturn(loc);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
cb.pasteIsland(world, island, () -> {});
// This is set just once because the coords of the block are always the same
Mockito.verify(block).setBlockData(Mockito.any());
// Verify the entities are spawned
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.PIG));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.CREEPER));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.HORSE));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.SHEEP));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.COW));
// Player should NOT spawn!!
Mockito.verify(world, Mockito.never()).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.PLAYER));
// Verify the task is run
Mockito.verify(sched).runTaskLater(Mockito.eq(plugin), Mockito.any(Runnable.class), Mockito.eq(2L));
}
@Test
public void testPasteClipboardNoData() {
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.pasteClipboard(loc);
Mockito.verify(plugin).logError(Mockito.eq("Clipboard has no block data in it to paste!"));
}
@Test
public void testPasteClipboard() {
Clipboard cb = new Clipboard(plugin, schemFolder);
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
cb.pasteClipboard(loc);
// This is set just once because the coords of the block are always the same
Mockito.verify(block).setBlockData(Mockito.any());
// Verify the entities are spawned
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.PIG));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.CREEPER));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.HORSE));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.SHEEP));
Mockito.verify(world).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.COW));
// Player should NOT spawn!!
Mockito.verify(world, Mockito.never()).spawnEntity(Mockito.eq(null), Mockito.eq(EntityType.PLAYER));
}
@Test
public void testIsFull() {
Clipboard cb = new Clipboard(plugin, schemFolder);
assertFalse(cb.isFull());
cb.setPos1(loc);
cb.setPos2(loc2);
cb.copy(user, false);
assertTrue(cb.isFull());
}
/*
* Will not test the file system methods
*/
}