From 0f1eb9b4f910b4f61f4c89fbad14b6485c372756 Mon Sep 17 00:00:00 2001 From: snowleo Date: Wed, 14 Dec 2011 16:04:15 +0100 Subject: Moved signs code to a new module --- .../earth2me/essentials/signs/EssentialsSign.java | 517 +++++++++++++++++++++ .../essentials/signs/EssentialsSignsPlugin.java | 55 +++ .../com/earth2me/essentials/signs/SignBalance.java | 21 + .../essentials/signs/SignBlockListener.java | 252 ++++++++++ .../src/com/earth2me/essentials/signs/SignBuy.java | 38 ++ .../earth2me/essentials/signs/SignDisposal.java | 21 + .../com/earth2me/essentials/signs/SignEnchant.java | 121 +++++ .../essentials/signs/SignEntityListener.java | 73 +++ .../earth2me/essentials/signs/SignException.java | 15 + .../com/earth2me/essentials/signs/SignFree.java | 40 ++ .../earth2me/essentials/signs/SignGameMode.java | 37 ++ .../com/earth2me/essentials/signs/SignHeal.java | 36 ++ .../src/com/earth2me/essentials/signs/SignKit.java | 75 +++ .../com/earth2me/essentials/signs/SignMail.java | 41 ++ .../essentials/signs/SignPlayerListener.java | 68 +++ .../earth2me/essentials/signs/SignProtection.java | 350 ++++++++++++++ .../com/earth2me/essentials/signs/SignSell.java | 35 ++ .../earth2me/essentials/signs/SignSpawnmob.java | 47 ++ .../com/earth2me/essentials/signs/SignTime.java | 57 +++ .../com/earth2me/essentials/signs/SignTrade.java | 356 ++++++++++++++ .../com/earth2me/essentials/signs/SignWarp.java | 70 +++ .../com/earth2me/essentials/signs/SignWeather.java | 55 +++ .../src/com/earth2me/essentials/signs/Signs.java | 33 ++ 23 files changed, 2413 insertions(+) create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSign.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSignsPlugin.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignBalance.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignBlockListener.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignBuy.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignDisposal.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignEnchant.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignEntityListener.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignException.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignFree.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignGameMode.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignHeal.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignKit.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignMail.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignPlayerListener.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignProtection.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignSell.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignSpawnmob.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignTime.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignTrade.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignWarp.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/SignWeather.java create mode 100644 EssentialsSigns/src/com/earth2me/essentials/signs/Signs.java (limited to 'EssentialsSigns/src/com/earth2me') diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSign.java b/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSign.java new file mode 100644 index 000000000..a6057f6ab --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSign.java @@ -0,0 +1,517 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.*; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.block.Sign; +import org.bukkit.entity.Player; +import org.bukkit.event.block.SignChangeEvent; +import org.bukkit.inventory.ItemStack; + + +public class EssentialsSign +{ + private static final Set EMPTY_SET = new HashSet(); + protected transient final String signName; + + public EssentialsSign(final String signName) + { + this.signName = signName; + } + + public final boolean onSignCreate(final SignChangeEvent event, final IEssentials ess) + { + final ISign sign = new EventSign(event); + final IUser user = ess.getUser(event.getPlayer()); + if (!(user.isAuthorized("essentials.signs." + signName.toLowerCase(Locale.ENGLISH) + ".create") + || user.isAuthorized("essentials.signs.create." + signName.toLowerCase(Locale.ENGLISH)))) + { + // Return true, so other plugins can use the same sign title, just hope + // they won't change it to §1[Signname] + return true; + } + sign.setLine(0, _("signFormatFail", this.signName)); + try + { + final boolean ret = onSignCreate(sign, user, getUsername(user), ess); + if (ret) + { + sign.setLine(0, getSuccessName()); + } + return ret; + } + catch (ChargeException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + // Return true, so the player sees the wrong sign. + return true; + } + + public String getSuccessName() + { + return _("signFormatSuccess", this.signName); + } + + public String getTemplateName() + { + return _("signFormatTemplate", this.signName); + } + + private String getUsername(final IUser user) + { + return user.getName().substring(0, user.getName().length() > 13 ? 13 : user.getName().length()); + } + + public final boolean onSignInteract(final Block block, final Player player, final IEssentials ess) + { + final ISign sign = new BlockSign(block); + final IUser user = ess.getUser(player); + try + { + return (user.isAuthorized("essentials.signs." + signName.toLowerCase(Locale.ENGLISH) + ".use") + || user.isAuthorized("essentials.signs.use." + signName.toLowerCase(Locale.ENGLISH))) + && onSignInteract(sign, user, getUsername(user), ess); + } + catch (ChargeException ex) + { + ess.getCommandHandler().showCommandError(user,signName, ex); + return false; + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + return false; + } + } + + public final boolean onSignBreak(final Block block, final Player player, final IEssentials ess) + { + final ISign sign = new BlockSign(block); + final IUser user = ess.getUser(player); + try + { + return (user.isAuthorized("essentials.signs." + signName.toLowerCase(Locale.ENGLISH) + ".break") + || user.isAuthorized("essentials.signs.break." + signName.toLowerCase(Locale.ENGLISH))) + && onSignBreak(sign, user, getUsername(user), ess); + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + return false; + } + } + + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + return true; + } + + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + return true; + } + + protected boolean onSignBreak(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + return true; + } + + public final boolean onBlockPlace(final Block block, final Player player, final IEssentials ess) + { + IUser user = ess.getUser(player); + try + { + return onBlockPlace(block, user, getUsername(user), ess); + } + catch (ChargeException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + return false; + } + + public final boolean onBlockInteract(final Block block, final Player player, final IEssentials ess) + { + IUser user = ess.getUser(player); + try + { + return onBlockInteract(block, user, getUsername(user), ess); + } + catch (ChargeException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + return false; + } + + public final boolean onBlockBreak(final Block block, final Player player, final IEssentials ess) + { + IUser user = ess.getUser(player); + try + { + return onBlockBreak(block, user, getUsername(user), ess); + } + catch (SignException ex) + { + ess.getCommandHandler().showCommandError(user, signName, ex); + } + return false; + } + + public boolean onBlockBreak(final Block block, final IEssentials ess) + { + return true; + } + + public boolean onBlockExplode(final Block block, final IEssentials ess) + { + return true; + } + + public boolean onBlockBurn(final Block block, final IEssentials ess) + { + return true; + } + + public boolean onBlockIgnite(final Block block, final IEssentials ess) + { + return true; + } + + public boolean onBlockPush(final Block block, final IEssentials ess) + { + return true; + } + + public static boolean checkIfBlockBreaksSigns(final Block block) + { + final Block sign = block.getRelative(BlockFace.UP); + if (sign.getType() == Material.SIGN_POST && isValidSign(new BlockSign(sign))) + { + return true; + } + final BlockFace[] directions = new BlockFace[] + { + BlockFace.NORTH, + BlockFace.EAST, + BlockFace.SOUTH, + BlockFace.WEST + }; + for (BlockFace blockFace : directions) + { + final Block signblock = block.getRelative(blockFace); + if (signblock.getType() == Material.WALL_SIGN) + { + final org.bukkit.material.Sign signMat = (org.bukkit.material.Sign)signblock.getState().getData(); + if (signMat != null && signMat.getFacing() == blockFace && isValidSign(new BlockSign(signblock))) + { + return true; + } + } + } + return false; + } + + public static boolean isValidSign(final ISign sign) + { + return sign.getLine(0).matches("§1\\[.*\\]"); + } + + protected boolean onBlockPlace(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + return true; + } + + protected boolean onBlockInteract(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + return true; + } + + protected boolean onBlockBreak(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException + { + return true; + } + + public Set getBlocks() + { + return EMPTY_SET; + } + + protected final void validateTrade(final ISign sign, final int index, final IEssentials ess) throws SignException + { + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + return; + } + final Trade trade = getTrade(sign, index, 0, ess); + final Double money = trade.getMoney(); + if (money != null) + { + sign.setLine(index, Util.formatCurrency(money, ess)); + } + } + + protected final void validateTrade(final ISign sign, final int amountIndex, final int itemIndex, + final IUser player, final IEssentials ess) throws SignException + { + if (sign.getLine(itemIndex).equalsIgnoreCase("exp") || sign.getLine(itemIndex).equalsIgnoreCase("xp")) + { + int amount = getIntegerPositive(sign.getLine(amountIndex)); + sign.setLine(amountIndex, Integer.toString(amount)); + sign.setLine(itemIndex, "exp"); + return; + } + final Trade trade = getTrade(sign, amountIndex, itemIndex, player, ess); + final ItemStack item = trade.getItemStack(); + sign.setLine(amountIndex, Integer.toString(item.getAmount())); + sign.setLine(itemIndex, sign.getLine(itemIndex).trim()); + } + + protected final Trade getTrade(final ISign sign, final int amountIndex, final int itemIndex, + final IUser player, final IEssentials ess) throws SignException + { + if (sign.getLine(itemIndex).equalsIgnoreCase("exp") || sign.getLine(itemIndex).equalsIgnoreCase("xp")) + { + final int amount = getIntegerPositive(sign.getLine(amountIndex)); + return new Trade(amount, ess); + } + final ItemStack item = getItemStack(sign.getLine(itemIndex), 1, ess); + final int amount = Math.min(getIntegerPositive(sign.getLine(amountIndex)), item.getType().getMaxStackSize() * player.getInventory().getSize()); + if (item.getTypeId() == 0 || amount < 1) + { + throw new SignException(_("moreThanZero")); + } + item.setAmount(amount); + return new Trade(item, ess); + } + + protected final void validateInteger(final ISign sign, final int index) throws SignException + { + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + throw new SignException("Empty line " + index); + } + final int quantity = getIntegerPositive(line); + sign.setLine(index, Integer.toString(quantity)); + } + + protected final int getIntegerPositive(final String line) throws SignException + { + final int quantity = getInteger(line); + if (quantity < 1) + { + throw new SignException(_("moreThanZero")); + } + return quantity; + } + + protected final int getInteger(final String line) throws SignException + { + try + { + final int quantity = Integer.parseInt(line); + + return quantity; + } + catch (NumberFormatException ex) + { + throw new SignException("Invalid sign", ex); + } + } + + protected final ItemStack getItemStack(final String itemName, final int quantity, final IEssentials ess) throws SignException + { + try + { + final ItemStack item = ess.getItemDb().get(itemName); + item.setAmount(quantity); + return item; + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + } + + protected final Double getMoney(final String line) throws SignException + { + final boolean isMoney = line.matches("^[^0-9-\\.][\\.0-9]+$"); + return isMoney ? getDoublePositive(line.substring(1)) : null; + } + + protected final Double getDoublePositive(final String line) throws SignException + { + final double quantity = getDouble(line); + if (Math.round(quantity * 100.0) < 1.0) + { + throw new SignException(_("moreThanZero")); + } + return quantity; + } + + protected final Double getDouble(final String line) throws SignException + { + try + { + return Double.parseDouble(line); + } + catch (NumberFormatException ex) + { + throw new SignException(ex.getMessage(), ex); + } + } + + protected final Trade getTrade(final ISign sign, final int index, final IEssentials ess) throws SignException + { + return getTrade(sign, index, 1, ess); + } + + protected final Trade getTrade(final ISign sign, final int index, final int decrement, final IEssentials ess) throws SignException + { + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + return new Trade(signName.toLowerCase(Locale.ENGLISH) + "sign", ess); + } + + final Double money = getMoney(line); + if (money == null) + { + final String[] split = line.split("[ :]+", 2); + if (split.length != 2) + { + throw new SignException(_("invalidCharge")); + } + final int quantity = getIntegerPositive(split[0]); + + final String item = split[1].toLowerCase(Locale.ENGLISH); + if (item.equalsIgnoreCase("times")) + { + sign.setLine(index, (quantity - decrement) + " times"); + return new Trade(signName.toLowerCase(Locale.ENGLISH) + "sign", ess); + } + else if (item.equalsIgnoreCase("exp") || item.equalsIgnoreCase("xp")) + { + sign.setLine(index, quantity + " exp"); + return new Trade(quantity, ess); + } + else + { + final ItemStack stack = getItemStack(item, quantity, ess); + sign.setLine(index, quantity + " " + item); + return new Trade(stack, ess); + } + } + else + { + return new Trade(money, ess); + } + } + + + static class EventSign implements ISign + { + private final transient SignChangeEvent event; + private final transient Block block; + + public EventSign(final SignChangeEvent event) + { + this.event = event; + this.block = event.getBlock(); + } + + @Override + public final String getLine(final int index) + { + return event.getLine(index); + } + + @Override + public final void setLine(final int index, final String text) + { + event.setLine(index, text); + } + + @Override + public Block getBlock() + { + return block; + } + + @Override + public void updateSign() + { + } + } + + + static class BlockSign implements ISign + { + private final transient Sign sign; + private final transient Block block; + + public BlockSign(final Block block) + { + this.block = block; + this.sign = (Sign)block.getState(); + } + + @Override + public final String getLine(final int index) + { + return sign.getLine(index); + } + + @Override + public final void setLine(final int index, final String text) + { + sign.setLine(index, text); + } + + @Override + public final Block getBlock() + { + return block; + } + + @Override + public final void updateSign() + { + sign.update(); + } + } + + + public interface ISign + { + String getLine(final int index); + + void setLine(final int index, final String text); + + public Block getBlock(); + + void updateSign(); + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSignsPlugin.java b/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSignsPlugin.java new file mode 100644 index 000000000..fd14eba0e --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/EssentialsSignsPlugin.java @@ -0,0 +1,55 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.bukkit.Bukkit; +import org.bukkit.event.Event; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; + + +public class EssentialsSignsPlugin extends JavaPlugin +{ + private static final transient Logger LOGGER = Bukkit.getLogger(); + private transient IEssentials ess; + + public void onEnable() + { + final PluginManager pluginManager = getServer().getPluginManager(); + ess = (IEssentials)pluginManager.getPlugin("Essentials"); + if (!this.getDescription().getVersion().equals(ess.getDescription().getVersion())) + { + LOGGER.log(Level.WARNING, _("versionMismatchAll")); + } + if (!ess.isEnabled()) + { + this.setEnabled(false); + return; + } + + final SignBlockListener signBlockListener = new SignBlockListener(ess); + pluginManager.registerEvent(Event.Type.SIGN_CHANGE, signBlockListener, Event.Priority.Highest, this); + pluginManager.registerEvent(Event.Type.BLOCK_PLACE, signBlockListener, Event.Priority.Low, this); + pluginManager.registerEvent(Event.Type.BLOCK_BREAK, signBlockListener, Event.Priority.Highest, this); + pluginManager.registerEvent(Event.Type.BLOCK_IGNITE, signBlockListener, Event.Priority.Low, this); + pluginManager.registerEvent(Event.Type.BLOCK_BURN, signBlockListener, Event.Priority.Low, this); + pluginManager.registerEvent(Event.Type.BLOCK_PISTON_EXTEND, signBlockListener, Event.Priority.Low, this); + pluginManager.registerEvent(Event.Type.BLOCK_PISTON_RETRACT, signBlockListener, Event.Priority.Low, this); + + final SignPlayerListener signPlayerListener = new SignPlayerListener(ess); + pluginManager.registerEvent(Event.Type.PLAYER_INTERACT, signPlayerListener, Event.Priority.Low, this); + + final SignEntityListener signEntityListener = new SignEntityListener(ess); + pluginManager.registerEvent(Event.Type.ENTITY_EXPLODE, signEntityListener, Event.Priority.Low, this); + pluginManager.registerEvent(Event.Type.ENDERMAN_PICKUP, signEntityListener, Event.Priority.Low, this); + + + LOGGER.info(_("loadinfo", this.getDescription().getName(), this.getDescription().getVersion(), "essentials team")); + } + + public void onDisable() + { + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignBalance.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBalance.java new file mode 100644 index 000000000..2ef64003a --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBalance.java @@ -0,0 +1,21 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; + + +public class SignBalance extends EssentialsSign +{ + public SignBalance() + { + super("Balance"); + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + player.sendMessage(_("balance", player.getMoney())); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignBlockListener.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBlockListener.java new file mode 100644 index 000000000..7cc461782 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBlockListener.java @@ -0,0 +1,252 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.Sign; +import org.bukkit.entity.Player; +import org.bukkit.event.block.*; + + +public class SignBlockListener extends BlockListener +{ + private final transient IEssentials ess; + private final static Logger LOGGER = Logger.getLogger("Minecraft"); + + public SignBlockListener(final IEssentials ess) + { + this.ess = ess; + } + + @Override + public void onBlockBreak(final BlockBreakEvent event) + { + if (event.isCancelled()) + { + return; + } + + if (protectSignsAndBlocks(event.getBlock(), event.getPlayer())) + { + event.setCancelled(true); + } + } + + public boolean protectSignsAndBlocks(final Block block, final Player player) + { + final int mat = block.getTypeId(); + if (mat == Material.SIGN_POST.getId() || mat == Material.WALL_SIGN.getId()) + { + final Sign csign = (Sign)block.getState(); + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (csign.getLine(0).equalsIgnoreCase(sign.getSuccessName()) + && !sign.onSignBreak(block, player, ess)) + { + return true; + } + } + } + else + { + // prevent any signs be broken by destroying the block they are attached to + if (EssentialsSign.checkIfBlockBreaksSigns(block)) + { + LOGGER.log(Level.INFO, "Prevented that a block was broken next to a sign."); + return true; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockBreak(block, player, ess)) + { + LOGGER.log(Level.INFO, "A block was protected by a sign."); + return true; + } + } + } + return false; + } + + @Override + public void onSignChange(final SignChangeEvent event) + { + if (event.isCancelled()) + { + return; + } + IUser user = ess.getUser(event.getPlayer()); + if (user.isAuthorized("essentials.signs.color")) + { + for (int i = 0; i < 4; i++) + { + event.setLine(i, event.getLine(i).replaceAll("&([0-9a-f])", "§$1")); + } + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (event.getLine(0).equalsIgnoreCase(sign.getSuccessName())) + { + event.setCancelled(true); + return; + } + if (event.getLine(0).equalsIgnoreCase(sign.getTemplateName()) + && !sign.onSignCreate(event, ess)) + { + event.setCancelled(true); + return; + } + } + } + + @Override + public void onBlockPlace(final BlockPlaceEvent event) + { + if (event.isCancelled()) + { + return; + } + + final Block against = event.getBlockAgainst(); + if ((against.getType() == Material.WALL_SIGN + || against.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(against))) + { + event.setCancelled(true); + return; + } + final Block block = event.getBlock(); + if (block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + { + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockPlace(block, event.getPlayer(), ess)) + { + event.setCancelled(true); + return; + } + } + } + + @Override + public void onBlockBurn(final BlockBurnEvent event) + { + if (event.isCancelled()) + { + return; + } + + final Block block = event.getBlock(); + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockBurn(block, ess)) + { + event.setCancelled(true); + return; + } + } + } + + @Override + public void onBlockIgnite(final BlockIgniteEvent event) + { + if (event.isCancelled()) + { + return; + } + + final Block block = event.getBlock(); + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockIgnite(block, ess)) + { + event.setCancelled(true); + return; + } + } + } + + @Override + public void onBlockPistonExtend(final BlockPistonExtendEvent event) + { + for (Block block : event.getBlocks()) + { + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockPush(block, ess)) + { + event.setCancelled(true); + return; + } + } + } + } + + @Override + public void onBlockPistonRetract(final BlockPistonRetractEvent event) + { + if (event.isSticky()) + { + final Block block = event.getBlock(); + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockPush(block, ess)) + { + event.setCancelled(true); + return; + } + } + } + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignBuy.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBuy.java new file mode 100644 index 000000000..fd84bd0f3 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignBuy.java @@ -0,0 +1,38 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; + + +public class SignBuy extends EssentialsSign +{ + public SignBuy() + { + super("Buy"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 1, 2, player, ess); + validateTrade(sign, 3, ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade items = getTrade(sign, 1, 2, player, ess); + final Trade charge = getTrade(sign, 3, ess); + charge.isAffordableFor(player); + if (!items.pay(player, false)) + { + throw new ChargeException("Inventory full"); + } + charge.charge(player); + Trade.log("Sign", "Buy", "Interact", username, charge, username, items, sign.getBlock().getLocation(), ess); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignDisposal.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignDisposal.java new file mode 100644 index 000000000..a6c64ca0b --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignDisposal.java @@ -0,0 +1,21 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import com.earth2me.essentials.craftbukkit.ShowInventory; + + +public class SignDisposal extends EssentialsSign +{ + public SignDisposal() + { + super("Disposal"); + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) + { + ShowInventory.showEmptyInventory(player.getBase()); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignEnchant.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignEnchant.java new file mode 100644 index 000000000..9d640c735 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignEnchant.java @@ -0,0 +1,121 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import com.earth2me.essentials.Enchantments; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.craftbukkit.InventoryWorkaround; +import java.util.Locale; +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.inventory.ItemStack; + + +public class SignEnchant extends EssentialsSign +{ + public SignEnchant() + { + super("Enchant"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final ItemStack stack = sign.getLine(1).equals("*") || sign.getLine(1).equalsIgnoreCase("any") ? null : getItemStack(sign.getLine(1), 1, ess); + final String[] enchantLevel = sign.getLine(2).split(":"); + if (enchantLevel.length != 2) + { + throw new SignException(_("invalidSignLine", 3)); + } + final Enchantment enchantment = Enchantments.getByName(enchantLevel[0]); + if (enchantment == null) + { + throw new SignException(_("enchantmentNotFound")); + } + int level; + try + { + level = Integer.parseInt(enchantLevel[1]); + } + catch (NumberFormatException ex) + { + throw new SignException(ex.getMessage()); + } + if (level < 1 || level > enchantment.getMaxLevel()) + { + level = enchantment.getMaxLevel(); + sign.setLine(2, enchantLevel[0] + ":" + level); + } + try + { + if (stack != null) + { + stack.addEnchantment(enchantment, level); + } + } + catch (Throwable ex) + { + throw new SignException(ex.getMessage()); + } + getTrade(sign, 3, ess); + return true; + } + + @Override + protected boolean onSignInteract(ISign sign, IUser player, String username, IEssentials ess) throws SignException, ChargeException + { + final ItemStack search = sign.getLine(1).equals("*") || sign.getLine(1).equalsIgnoreCase("any") ? null : getItemStack(sign.getLine(1), 1, ess); + int slot = -1; + final Trade charge = getTrade(sign, 3, ess); + charge.isAffordableFor(player); + final String[] enchantLevel = sign.getLine(2).split(":"); + if (enchantLevel.length != 2) + { + throw new SignException(_("invalidSignLine", 3)); + } + final Enchantment enchantment = Enchantments.getByName(enchantLevel[0]); + if (enchantment == null) + { + throw new SignException(_("enchantmentNotFound")); + } + int level; + try + { + level = Integer.parseInt(enchantLevel[1]); + } + catch (NumberFormatException ex) + { + level = enchantment.getMaxLevel(); + } + + final ItemStack playerHand = player.getItemInHand(); + if (playerHand == null + || playerHand.getAmount() != 1 + || (playerHand.containsEnchantment(enchantment) + && playerHand.getEnchantmentLevel(enchantment) == level)) + { + throw new SignException(_("missingItems", 1, sign.getLine(1))); + } + if (search != null && playerHand.getType() != search.getType()) + { + throw new SignException(_("missingItems", 1, search.getType().toString().toLowerCase(Locale.ENGLISH).replace('_', ' '))); + } + + final ItemStack toEnchant = playerHand; + try + { + toEnchant.addEnchantment(enchantment, level); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + + charge.charge(player); + Trade.log("Sign", "Enchant", "Interact", username, charge, username, charge, sign.getBlock().getLocation(), ess); + player.updateInventory(); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignEntityListener.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignEntityListener.java new file mode 100644 index 000000000..12a2fc2f8 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignEntityListener.java @@ -0,0 +1,73 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.api.IEssentials; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.event.entity.EndermanPickupEvent; +import org.bukkit.event.entity.EntityExplodeEvent; +import org.bukkit.event.entity.EntityListener; + + +public class SignEntityListener extends EntityListener +{ + private final transient IEssentials ess; + + public SignEntityListener(final IEssentials ess) + { + this.ess = ess; + } + + @Override + public void onEntityExplode(final EntityExplodeEvent event) + { + for (Block block : event.blockList()) + { + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType())) + { + event.setCancelled(!sign.onBlockExplode(block, ess)); + return; + } + } + } + } + + @Override + public void onEndermanPickup(EndermanPickupEvent event) + { + if (event.isCancelled()) + { + return; + } + + final Block block = event.getBlock(); + if (((block.getType() == Material.WALL_SIGN + || block.getType() == Material.SIGN_POST) + && EssentialsSign.isValidSign(new EssentialsSign.BlockSign(block))) + || EssentialsSign.checkIfBlockBreaksSigns(block)) + { + event.setCancelled(true); + return; + } + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockBreak(block, ess)) + { + event.setCancelled(true); + return; + } + } + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignException.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignException.java new file mode 100644 index 000000000..9c9ab44a2 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignException.java @@ -0,0 +1,15 @@ +package com.earth2me.essentials.signs; + + +public class SignException extends Exception +{ + public SignException(final String message) + { + super(message); + } + + public SignException(final String message, final Throwable throwable) + { + super(message, throwable); + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignFree.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignFree.java new file mode 100644 index 000000000..0dad2b100 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignFree.java @@ -0,0 +1,40 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; +import com.earth2me.essentials.craftbukkit.ShowInventory; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + + +public class SignFree extends EssentialsSign +{ + public SignFree() + { + super("Free"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + getItemStack(sign.getLine(1), 1, ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + final ItemStack item = getItemStack(sign.getLine(1), 1, ess); + if (item.getType() == Material.AIR) + { + throw new SignException(_("cantSpawnItem", "Air")); + } + + item.setAmount(item.getType().getMaxStackSize() * 9 * 4); + ShowInventory.showFilledInventory(player.getBase(), item); + Trade.log("Sign", "Free", "Interact", username, null, username, new Trade(item, ess), sign.getBlock().getLocation(), ess); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignGameMode.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignGameMode.java new file mode 100644 index 000000000..05fb7c17f --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignGameMode.java @@ -0,0 +1,37 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; +import java.util.Locale; +import org.bukkit.GameMode; + + +public class SignGameMode extends EssentialsSign +{ + public SignGameMode() + { + super("GameMode"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 1, ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 1, ess); + charge.isAffordableFor(player); + + player.setGameMode(player.getGameMode() == GameMode.SURVIVAL ? GameMode.CREATIVE : GameMode.SURVIVAL); + player.sendMessage(_("gameMode", _(player.getGameMode().toString().toLowerCase(Locale.ENGLISH)), player.getDisplayName())); + charge.charge(player); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignHeal.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignHeal.java new file mode 100644 index 000000000..3f412f5b4 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignHeal.java @@ -0,0 +1,36 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; + + +public class SignHeal extends EssentialsSign +{ + public SignHeal() + { + super("Heal"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 1, ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 1, ess); + charge.isAffordableFor(player); + player.setHealth(20); + player.setFoodLevel(20); + player.setFireTicks(0); + player.sendMessage(_("youAreHealed")); + charge.charge(player); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignKit.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignKit.java new file mode 100644 index 000000000..16f314d5f --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignKit.java @@ -0,0 +1,75 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.*; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import java.util.List; +import java.util.Locale; +import java.util.Map; + + +public class SignKit extends EssentialsSign +{ + public SignKit() + { + super("Kit"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 3, ess); + + final String kitName = sign.getLine(1).toLowerCase(Locale.ENGLISH); + + if (kitName.isEmpty()) + { + sign.setLine(1, "§dKit name!"); + return false; + } + else + { + try + { + ess.getSettings().getKit(kitName); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + final String group = sign.getLine(2); + if ("Everyone".equalsIgnoreCase(group) || "Everybody".equalsIgnoreCase(group)) + { + sign.setLine(2, "§2Everyone"); + } + return true; + } + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final String kitName = sign.getLine(1).toLowerCase(Locale.ENGLISH); + final String group = sign.getLine(2); + if ((!group.isEmpty() && ("§2Everyone".equals(group) || player.inGroup(group))) + || (group.isEmpty() && (player.isAuthorized("essentials.kit." + kitName)))) + { + final Trade charge = getTrade(sign, 3, ess); + charge.isAffordableFor(player); + try + { + final Object kit = ess.getSettings().getKit(kitName); + final Map els = (Map)kit; + final List items = Kit.getItems(player, els); + Kit.expandItems(ess, player, items); + charge.charge(player); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + return true; + } + return false; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignMail.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignMail.java new file mode 100644 index 000000000..7845c86a6 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignMail.java @@ -0,0 +1,41 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import java.util.List; + + +public class SignMail extends EssentialsSign +{ + public SignMail() + { + super("Mail"); + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + final List mail; + player.acquireReadLock(); + try + { + mail = player.getData().getMails(); + } + finally + { + player.unlock(); + } + if (mail == null || mail.isEmpty()) + { + player.sendMessage(_("noNewMail")); + return false; + } + for (String s : mail) + { + player.sendMessage(s); + } + player.sendMessage(_("markMailAsRead")); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignPlayerListener.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignPlayerListener.java new file mode 100644 index 000000000..9f1a22896 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignPlayerListener.java @@ -0,0 +1,68 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.api.IEssentials; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.Sign; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerListener; + + +public class SignPlayerListener extends PlayerListener +{ + private final transient IEssentials ess; + + public SignPlayerListener(IEssentials ess) + { + this.ess = ess; + } + + @Override + public void onPlayerInteract(PlayerInteractEvent event) + { + if (event.isCancelled()) + { + return; + } + + final Block block = event.getClickedBlock(); + if (block == null) + { + return; + } + final int mat = block.getTypeId(); + if (mat == Material.SIGN_POST.getId() || mat == Material.WALL_SIGN.getId()) + { + if (event.getAction() != Action.RIGHT_CLICK_BLOCK) + { + return; + } + final Sign csign = (Sign)block.getState(); + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (csign.getLine(0).equalsIgnoreCase(sign.getSuccessName())) + { + sign.onSignInteract(block, event.getPlayer(), ess); + event.setCancelled(true); + return; + } + } + } + else + { + for (Signs signs : Signs.values()) + { + final EssentialsSign sign = signs.getSign(); + if (sign.getBlocks().contains(block.getType()) + && !sign.onBlockInteract(block, event.getPlayer(), ess)) + { + event.setCancelled(true); + return; + + } + } + } + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignProtection.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignProtection.java new file mode 100644 index 000000000..1ec05ec2d --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignProtection.java @@ -0,0 +1,350 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; +import com.earth2me.essentials.Util; +import java.util.*; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.block.Sign; +import org.bukkit.inventory.ItemStack; + + +public class SignProtection extends EssentialsSign +{ + private final transient Set protectedBlocks = EnumSet.noneOf(Material.class); + + public SignProtection() + { + super("Protection"); + protectedBlocks.add(Material.CHEST); + protectedBlocks.add(Material.BURNING_FURNACE); + protectedBlocks.add(Material.FURNACE); + protectedBlocks.add(Material.DISPENSER); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + sign.setLine(3, "§4" + username); + if (hasAdjacentBlock(sign.getBlock())) + { + final SignProtectionState state = isBlockProtected(sign.getBlock(), player, username, true); + if (state == SignProtectionState.NOSIGN || state == SignProtectionState.OWNER + || player.isAuthorized("essentials.signs.protection.override")) + { + sign.setLine(3, "§1" + username); + return true; + } + } + player.sendMessage(_("signProtectInvalidLocation")); + return false; + } + + @Override + protected boolean onSignBreak(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + final SignProtectionState state = checkProtectionSign(sign, player, username); + return state == SignProtectionState.OWNER; + } + + public boolean hasAdjacentBlock(final Block block, final Block... ignoredBlocks) + { + final Block[] faces = getAdjacentBlocks(block); + for (Block b : faces) + { + for (Block ignoredBlock : ignoredBlocks) + { + if (b.getLocation().equals(ignoredBlock.getLocation())) + { + continue; + } + } + if (protectedBlocks.contains(b.getType())) + { + return true; + } + } + return false; + } + + private void checkIfSignsAreBroken(final Block block, final IUser player, final String username, final IEssentials ess) + { + final Map signs = getConnectedSigns(block, player, username, false); + for (Map.Entry entry : signs.entrySet()) + { + if (entry.getValue() != SignProtectionState.NOSIGN) + { + final Block sign = entry.getKey().getBlock(); + if (!hasAdjacentBlock(sign, block)) + { + block.setType(Material.AIR); + final Trade trade = new Trade(new ItemStack(Material.SIGN, 1), ess); + trade.pay(player); + } + } + } + } + + private Map getConnectedSigns(final Block block, final IUser user, final String username, boolean secure) + { + final Map signs = new HashMap(); + getConnectedSigns(block, signs, user, username, secure ? 4 : 2); + return signs; + } + + private void getConnectedSigns(final Block block, final Map signs, final IUser user, final String username, final int depth) + { + final Block[] faces = getAdjacentBlocks(block); + for (Block b : faces) + { + final Location loc = b.getLocation(); + if (signs.containsKey(loc)) + { + continue; + } + final SignProtectionState check = checkProtectionSign(b, user, username); + signs.put(loc, check); + + if (protectedBlocks.contains(b.getType()) && depth > 0) + { + getConnectedSigns(b, signs, user, username, depth - 1); + } + } + } + + + public enum SignProtectionState + { + NOT_ALLOWED, ALLOWED, NOSIGN, OWNER + } + + private SignProtectionState checkProtectionSign(final Block block, final IUser user, final String username) + { + if (block.getType() == Material.SIGN_POST || block.getType() == Material.WALL_SIGN) + { + final BlockSign sign = new BlockSign(block); + if (sign.getLine(0).equalsIgnoreCase(this.getSuccessName())) + { + return checkProtectionSign(sign, user, username); + } + } + return SignProtectionState.NOSIGN; + } + + private SignProtectionState checkProtectionSign(final ISign sign, final IUser user, final String username) + { + if (user == null || username == null) + { + return SignProtectionState.NOT_ALLOWED; + } + if (user.isAuthorized("essentials.signs.protection.override")) + { + return SignProtectionState.OWNER; + } + if (Util.stripColor(sign.getLine(3)).equalsIgnoreCase(username)) + { + return SignProtectionState.OWNER; + } + for (int i = 1; i <= 2; i++) + { + final String line = sign.getLine(i); + if (line.startsWith("(") && line.endsWith(")") && user.inGroup(line.substring(1, line.length() - 1))) + { + return SignProtectionState.ALLOWED; + } + else if (line.equalsIgnoreCase(username)) + { + return SignProtectionState.ALLOWED; + } + } + return SignProtectionState.NOT_ALLOWED; + } + + private Block[] getAdjacentBlocks(final Block block) + { + return new Block[] + { + block.getRelative(BlockFace.NORTH), + block.getRelative(BlockFace.SOUTH), + block.getRelative(BlockFace.EAST), + block.getRelative(BlockFace.WEST), + block.getRelative(BlockFace.DOWN), + block.getRelative(BlockFace.UP) + }; + } + + public SignProtectionState isBlockProtected(final Block block, final IUser user, final String username, boolean secure) + { + final Map signs = getConnectedSigns(block, user, username, secure); + SignProtectionState retstate = SignProtectionState.NOSIGN; + for (SignProtectionState state : signs.values()) + { + if (state == SignProtectionState.ALLOWED) + { + retstate = state; + } + else if (state == SignProtectionState.NOT_ALLOWED && retstate != SignProtectionState.ALLOWED) + { + retstate = state; + } + } + if (!secure || retstate == SignProtectionState.NOSIGN) + { + for (SignProtectionState state : signs.values()) + { + if (state == SignProtectionState.OWNER) + { + return state; + } + } + } + return retstate; + } + + public boolean isBlockProtected(final Block block) + { + final Block[] faces = getAdjacentBlocks(block); + for (Block b : faces) + { + if (b.getType() == Material.SIGN_POST || b.getType() == Material.WALL_SIGN) + { + final Sign sign = (Sign)b.getState(); + if (sign.getLine(0).equalsIgnoreCase("§1[Protection]")) + { + return true; + } + } + if (protectedBlocks.contains(b.getType())) + { + final Block[] faceChest = getAdjacentBlocks(b); + + for (Block a : faceChest) + { + if (a.getType() == Material.SIGN_POST || a.getType() == Material.WALL_SIGN) + { + final Sign sign = (Sign)a.getState(); + if (sign.getLine(0).equalsIgnoreCase("§1[Protection]")) + { + return true; + } + } + } + } + } + return false; + } + + @Override + public Set getBlocks() + { + return protectedBlocks; + } + + @Override + protected boolean onBlockPlace(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException + { + for (Block adjBlock : getAdjacentBlocks(block)) + { + final SignProtectionState state = isBlockProtected(adjBlock, player, username, true); + + if ((state == SignProtectionState.ALLOWED || state == SignProtectionState.NOT_ALLOWED) + && !player.isAuthorized("essentials.signs.protection.override")) + { + player.sendMessage(_("noPlacePermission", block.getType().toString().toLowerCase(Locale.ENGLISH))); + return false; + } + } + return true; + + } + + @Override + protected boolean onBlockInteract(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException + { + final SignProtectionState state = isBlockProtected(block, player, username, false); + + if (state == SignProtectionState.OWNER || state == SignProtectionState.NOSIGN || state == SignProtectionState.ALLOWED) + { + return true; + } + + if (state == SignProtectionState.NOT_ALLOWED + && player.isAuthorized("essentials.signs.protection.override")) + { + return true; + } + + + player.sendMessage(_("noAccessPermission", block.getType().toString().toLowerCase(Locale.ENGLISH))); + return false; + } + + @Override + protected boolean onBlockBreak(final Block block, final IUser player, final String username, final IEssentials ess) throws SignException + { + final SignProtectionState state = isBlockProtected(block, player, username, false); + + if (state == SignProtectionState.OWNER || state == SignProtectionState.NOSIGN) + { + checkIfSignsAreBroken(block, player, username, ess); + return true; + } + + if ((state == SignProtectionState.ALLOWED || state == SignProtectionState.NOT_ALLOWED) + && player.isAuthorized("essentials.signs.protection.override")) + { + checkIfSignsAreBroken(block, player, username, ess); + return true; + } + + + player.sendMessage(_("noDestroyPermission", block.getType().toString().toLowerCase(Locale.ENGLISH))); + return false; + } + + @Override + public boolean onBlockBreak(final Block block, final IEssentials ess) + { + final SignProtectionState state = isBlockProtected(block, null, null, false); + + return state == SignProtectionState.NOSIGN; + } + + @Override + public boolean onBlockExplode(final Block block, final IEssentials ess) + { + final SignProtectionState state = isBlockProtected(block, null, null, false); + + return state == SignProtectionState.NOSIGN; + } + + @Override + public boolean onBlockBurn(final Block block, final IEssentials ess) + { + final SignProtectionState state = isBlockProtected(block, null, null, false); + + return state == SignProtectionState.NOSIGN; + } + + @Override + public boolean onBlockIgnite(final Block block, final IEssentials ess) + { + final SignProtectionState state = isBlockProtected(block, null, null, false); + + return state == SignProtectionState.NOSIGN; + } + + @Override + public boolean onBlockPush(final Block block, final IEssentials ess) + { + final SignProtectionState state = isBlockProtected(block, null, null, false); + + return state == SignProtectionState.NOSIGN; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignSell.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignSell.java new file mode 100644 index 000000000..7a5f4969b --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignSell.java @@ -0,0 +1,35 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; + + +public class SignSell extends EssentialsSign +{ + public SignSell() + { + super("Sell"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 1, 2, player, ess); + validateTrade(sign, 3, ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 1, 2, player, ess); + final Trade money = getTrade(sign, 3, ess); + charge.isAffordableFor(player); + money.pay(player); + charge.charge(player); + Trade.log("Sign", "Sell", "Interact", username, charge, username, money, sign.getBlock().getLocation(), ess); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignSpawnmob.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignSpawnmob.java new file mode 100644 index 000000000..f21d937b3 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignSpawnmob.java @@ -0,0 +1,47 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; +import com.earth2me.essentials.commands.Commandspawnmob; + + +public class SignSpawnmob extends EssentialsSign +{ + public SignSpawnmob() + { + super("Spawnmob"); + } + + @Override + protected boolean onSignCreate(ISign sign, IUser player, String username, IEssentials ess) throws SignException, ChargeException + { + validateInteger(sign, 1); + validateTrade(sign, 3, ess); + return true; + } + + @Override + protected boolean onSignInteract(ISign sign, IUser player, String username, IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 3, ess); + charge.isAffordableFor(player); + Commandspawnmob command = new Commandspawnmob(); + command.setEssentials(ess); + String[] args = new String[] + { + sign.getLine(2), sign.getLine(1) + }; + try + { + command.run(ess.getServer(), player, "spawnmob", args); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + charge.charge(player); + return true; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignTime.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignTime.java new file mode 100644 index 000000000..2d1ab2a87 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignTime.java @@ -0,0 +1,57 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; + + +public class SignTime extends EssentialsSign +{ + public SignTime() + { + super("Time"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 2, ess); + final String timeString = sign.getLine(1); + if ("Day".equalsIgnoreCase(timeString)) + { + sign.setLine(1, "§2Day"); + return true; + } + if ("Night".equalsIgnoreCase(timeString)) + { + sign.setLine(1, "§2Night"); + return true; + } + throw new SignException(_("onlyDayNight")); + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 2, ess); + charge.isAffordableFor(player); + final String timeString = sign.getLine(1); + long time = player.getWorld().getTime(); + time -= time % 24000; + if ("§2Day".equalsIgnoreCase(timeString)) + { + player.getWorld().setTime(time + 24000); + charge.charge(player); + return true; + } + if ("§2Night".equalsIgnoreCase(timeString)) + { + player.getWorld().setTime(time + 37700); + charge.charge(player); + return true; + } + throw new SignException(_("onlyDayNight")); + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignTrade.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignTrade.java new file mode 100644 index 000000000..04db5511c --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignTrade.java @@ -0,0 +1,356 @@ +package com.earth2me.essentials.signs; + +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.*; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IUser; +import org.bukkit.inventory.ItemStack; + +//TODO: Sell Enchantment on Trade signs? +public class SignTrade extends EssentialsSign +{ + + public SignTrade() + { + super("Trade"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + validateTrade(sign, 1, false, ess); + validateTrade(sign, 2, true, ess); + final Trade charge = getTrade(sign, 2, true, true, ess); + charge.isAffordableFor(player); + sign.setLine(3, "§8" + username); + charge.charge(player); + Trade.log("Sign", "Trade", "Create", username, charge, username, null, sign.getBlock().getLocation(), ess); + return true; + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + if (sign.getLine(3).substring(2).equalsIgnoreCase(username)) + { + final Trade store = rechargeSign(sign, ess, player); + Trade stored = null; + try + { + stored = getTrade(sign, 1, true, true, ess); + substractAmount(sign, 1, stored, ess); + stored.pay(player); + } + catch (SignException e) + { + if (store == null) + { + throw new SignException(_("tradeSignEmptyOwner"), e); + } + } + Trade.log("Sign", "Trade", "OwnerInteract", username, store, username, stored, sign.getBlock().getLocation(), ess); + } + else + { + final Trade charge = getTrade(sign, 1, false, false, ess); + final Trade trade = getTrade(sign, 2, false, true, ess); + charge.isAffordableFor(player); + if (!trade.pay(player, false)) + { + throw new ChargeException("Full inventory"); + } + substractAmount(sign, 2, trade, ess); + addAmount(sign, 1, charge, ess); + charge.charge(player); + Trade.log("Sign", "Trade", "Interact", sign.getLine(3), charge, username, trade, sign.getBlock().getLocation(), ess); + } + sign.updateSign(); + return true; + } + + private Trade rechargeSign(final ISign sign, final IEssentials ess, final IUser player) throws SignException, ChargeException + { + final Trade trade = getTrade(sign, 2, false, false, ess); + if (trade.getItemStack() != null && player.getItemInHand() != null + && trade.getItemStack().getTypeId() == player.getItemInHand().getTypeId() + && trade.getItemStack().getDurability() == player.getItemInHand().getDurability() + && trade.getItemStack().getEnchantments().equals(player.getItemInHand().getEnchantments())) + { + int amount = player.getItemInHand().getAmount(); + amount -= amount % trade.getItemStack().getAmount(); + if (amount > 0) + { + final ItemStack stack = player.getItemInHand().clone(); + stack.setAmount(amount); + final Trade store = new Trade(stack, ess); + addAmount(sign, 2, store, ess); + store.charge(player); + return store; + } + } + return null; + } + + @Override + protected boolean onSignBreak(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + if ((sign.getLine(3).length() > 3 && sign.getLine(3).substring(2).equalsIgnoreCase(username)) + || player.isAuthorized("essentials.signs.trade.override")) + { + try + { + final Trade stored1 = getTrade(sign, 1, true, false, ess); + final Trade stored2 = getTrade(sign, 2, true, false, ess); + stored1.pay(player); + stored2.pay(player); + Trade.log("Sign", "Trade", "Break", username, stored2, username, stored1, sign.getBlock().getLocation(), ess); + } + catch (SignException e) + { + if (player.isAuthorized("essentials.signs.trade.override")) + { + return true; + } + throw e; + } + return true; + } + else + { + return false; + } + } + + protected final void validateTrade(final ISign sign, final int index, final boolean amountNeeded, final IEssentials ess) throws SignException + { + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + throw new SignException("Empty line"); + } + final String[] split = line.split("[ :]+"); + + if (split.length == 1 && !amountNeeded) + { + final Double money = getMoney(split[0]); + if (money != null) + { + if (Util.formatCurrency(money, ess).length() * 2 > 15) + { + throw new SignException("Line can be too long!"); + } + sign.setLine(index, Util.formatCurrency(money, ess) + ":0"); + return; + } + } + + if (split.length == 2 && amountNeeded) + { + final Double money = getMoney(split[0]); + Double amount = getDoublePositive(split[1]); + if (money != null && amount != null) + { + amount -= amount % money; + if (amount < 0.01 || money < 0.01) + { + throw new SignException(_("moreThanZero")); + } + sign.setLine(index, Util.formatCurrency(money, ess) + ":" + Util.formatCurrency(amount, ess).substring(1)); + return; + } + } + + if (split.length == 2 && !amountNeeded) + { + final int amount = getIntegerPositive(split[0]); + + if (amount < 1) + { + throw new SignException(_("moreThanZero")); + } + if (!(split[1].equalsIgnoreCase("exp") || split[1].equalsIgnoreCase("xp")) + && getItemStack(split[1], amount, ess).getTypeId() == 0) + { + throw new SignException(_("moreThanZero")); + } + String newline = amount + " " + split[1] + ":0"; + if ((newline + amount).length() > 15) + { + throw new SignException("Line can be too long!"); + } + sign.setLine(index, newline); + return; + } + + if (split.length == 3 && amountNeeded) + { + final int stackamount = getIntegerPositive(split[0]); + int amount = getIntegerPositive(split[2]); + amount -= amount % stackamount; + if (amount < 1 || stackamount < 1) + { + throw new SignException(_("moreThanZero")); + } + if (!(split[1].equalsIgnoreCase("exp") || split[1].equalsIgnoreCase("xp")) + && getItemStack(split[1], stackamount, ess).getTypeId() == 0) + { + throw new SignException(_("moreThanZero")); + } + sign.setLine(index, stackamount + " " + split[1] + ":" + amount); + return; + } + throw new SignException(_("invalidSignLine", index + 1)); + } + + protected final Trade getTrade(final ISign sign, final int index, final boolean fullAmount, final boolean notEmpty, final IEssentials ess) throws SignException + { + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + throw new SignException("Empty line"); + } + final String[] split = line.split("[ :]+"); + + if (split.length == 2) + { + try + { + final Double money = getMoney(split[0]); + final Double amount = notEmpty ? getDoublePositive(split[1]) : getDouble(split[1]); + if (money != null && amount != null) + { + return new Trade(fullAmount ? amount : money, ess); + } + } + catch (SignException e) + { + throw new SignException(_("tradeSignEmpty")); + } + } + + if (split.length == 3) + { + if (split[1].equalsIgnoreCase("exp") || split[1].equalsIgnoreCase("xp")) + { + final int stackamount = getIntegerPositive(split[0]); + int amount = getInteger(split[2]); + amount -= amount % stackamount; + if (notEmpty && (amount < 1 || stackamount < 1)) + { + throw new SignException(_("tradeSignEmpty")); + } + return new Trade(fullAmount ? amount : stackamount, ess); + } + else + { + final int stackamount = getIntegerPositive(split[0]); + final ItemStack item = getItemStack(split[1], stackamount, ess); + int amount = getInteger(split[2]); + amount -= amount % stackamount; + if (notEmpty && (amount < 1 || stackamount < 1 || item.getTypeId() == 0)) + { + throw new SignException(_("tradeSignEmpty")); + } + item.setAmount(fullAmount ? amount : stackamount); + return new Trade(item, ess); + } + } + throw new SignException(_("invalidSignLine", index + 1)); + } + + protected final void substractAmount(final ISign sign, final int index, final Trade trade, final IEssentials ess) throws SignException + { + final Double money = trade.getMoney(); + if (money != null) + { + changeAmount(sign, index, -money, ess); + } + final ItemStack item = trade.getItemStack(); + if (item != null) + { + changeAmount(sign, index, -item.getAmount(), ess); + } + final Integer exp = trade.getExperience(); + if (exp != null) + { + changeAmount(sign, index, -exp.intValue(), ess); + } + } + + protected final void addAmount(final ISign sign, final int index, final Trade trade, final IEssentials ess) throws SignException + { + final Double money = trade.getMoney(); + if (money != null) + { + changeAmount(sign, index, money, ess); + } + final ItemStack item = trade.getItemStack(); + if (item != null) + { + changeAmount(sign, index, item.getAmount(), ess); + } + final Integer exp = trade.getExperience(); + if (exp != null) + { + changeAmount(sign, index, exp.intValue(), ess); + } + } + + private void changeAmount(final ISign sign, final int index, final double value, final IEssentials ess) throws SignException + { + + final String line = sign.getLine(index).trim(); + if (line.isEmpty()) + { + throw new SignException("Empty line"); + } + final String[] split = line.split("[ :]+"); + + if (split.length == 2) + { + final Double money = getMoney(split[0]); + final Double amount = getDouble(split[1]); + if (money != null && amount != null) + { + final String newline = Util.formatCurrency(money, ess) + ":" + Util.formatCurrency(amount + value, ess).substring(1); + if (newline.length() > 15) + { + throw new SignException("Line too long!"); + } + sign.setLine(index, newline); + return; + } + } + + if (split.length == 3) + { + if (split[1].equalsIgnoreCase("exp") || split[1].equalsIgnoreCase("xp")) + { + final int stackamount = getIntegerPositive(split[0]); + final int amount = getInteger(split[2]); + final String newline = stackamount + " " + split[1] + ":" + (amount + Math.round(value)); + if (newline.length() > 15) + { + throw new SignException("Line too long!"); + } + sign.setLine(index, newline); + return; + } + else + { + final int stackamount = getIntegerPositive(split[0]); + //TODO: Unused local variable + final ItemStack item = getItemStack(split[1], stackamount, ess); + final int amount = getInteger(split[2]); + final String newline = stackamount + " " + split[1] + ":" + (amount + Math.round(value)); + if (newline.length() > 15) + { + throw new SignException("Line too long!"); + } + sign.setLine(index, newline); + return; + } + } + throw new SignException(_("invalidSignLine", index + 1)); + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignWarp.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignWarp.java new file mode 100644 index 000000000..3ab254705 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignWarp.java @@ -0,0 +1,70 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; +import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; + + +public class SignWarp extends EssentialsSign +{ + public SignWarp() + { + super("Warp"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 3, ess); + final String warpName = sign.getLine(1); + + if (warpName.isEmpty()) + { + sign.setLine(1, "§dWarp name!"); + return false; + } + else + { + try + { + ess.getWarps().getWarp(warpName); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + final String group = sign.getLine(2); + if ("Everyone".equalsIgnoreCase(group) || "Everybody".equalsIgnoreCase(group)) + { + sign.setLine(2, "§2Everyone"); + } + return true; + } + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final String warpName = sign.getLine(1); + final String group = sign.getLine(2); + if ((!group.isEmpty() + && ("§2Everyone".equals(group) + || player.inGroup(group))) + || (group.isEmpty() && (!ess.getSettings().getPerWarpPermission() || player.isAuthorized("essentials.warp." + warpName)))) + { + final Trade charge = getTrade(sign, 3, ess); + try + { + player.getTeleport().warp(warpName, charge, TeleportCause.PLUGIN); + } + catch (Exception ex) + { + throw new SignException(ex.getMessage(), ex); + } + return true; + } + return false; + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/SignWeather.java b/EssentialsSigns/src/com/earth2me/essentials/signs/SignWeather.java new file mode 100644 index 000000000..c674e04a9 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/SignWeather.java @@ -0,0 +1,55 @@ +package com.earth2me.essentials.signs; + +import com.earth2me.essentials.ChargeException; +import static com.earth2me.essentials.I18n._; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.Trade; +import com.earth2me.essentials.api.IUser; + + +public class SignWeather extends EssentialsSign +{ + public SignWeather() + { + super("Weather"); + } + + @Override + protected boolean onSignCreate(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException + { + validateTrade(sign, 2, ess); + final String timeString = sign.getLine(1); + if ("Sun".equalsIgnoreCase(timeString)) + { + sign.setLine(1, "§2Sun"); + return true; + } + if ("Storm".equalsIgnoreCase(timeString)) + { + sign.setLine(1, "§2Storm"); + return true; + } + throw new SignException(_("onlySunStorm")); + } + + @Override + protected boolean onSignInteract(final ISign sign, final IUser player, final String username, final IEssentials ess) throws SignException, ChargeException + { + final Trade charge = getTrade(sign, 2, ess); + charge.isAffordableFor(player); + final String weatherString = sign.getLine(1); + if ("§2Sun".equalsIgnoreCase(weatherString)) + { + player.getWorld().setStorm(false); + charge.charge(player); + return true; + } + if ("§2Storm".equalsIgnoreCase(weatherString)) + { + player.getWorld().setStorm(true); + charge.charge(player); + return true; + } + throw new SignException(_("onlySunStorm")); + } +} diff --git a/EssentialsSigns/src/com/earth2me/essentials/signs/Signs.java b/EssentialsSigns/src/com/earth2me/essentials/signs/Signs.java new file mode 100644 index 000000000..e29d45ad4 --- /dev/null +++ b/EssentialsSigns/src/com/earth2me/essentials/signs/Signs.java @@ -0,0 +1,33 @@ +package com.earth2me.essentials.signs; + + +public enum Signs +{ + BALANCE(new SignBalance()), + BUY(new SignBuy()), + DISPOSAL(new SignDisposal()), + ENCHANT(new SignEnchant()), + FREE(new SignFree()), + GAMEMODE(new SignGameMode()), + HEAL(new SignHeal()), + KIT(new SignKit()), + MAIL(new SignMail()), + PROTECTION(new SignProtection()), + SELL(new SignSell()), + SPAWNMOB(new SignSpawnmob()), + TIME(new SignTime()), + TRADE(new SignTrade()), + WARP(new SignWarp()), + WEATHER(new SignWeather()); + private final EssentialsSign sign; + + private Signs(final EssentialsSign sign) + { + this.sign = sign; + } + + public EssentialsSign getSign() + { + return sign; + } +} -- cgit v1.2.3