diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index faf9b7b14..1e16eb04a 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -19,8 +19,12 @@ package com.earth2me.essentials; import static com.earth2me.essentials.I18n._; import com.earth2me.essentials.api.*; +import com.earth2me.essentials.api.ISettings; +import com.earth2me.essentials.api.IUser; +import com.earth2me.essentials.api.IEssentials; import com.earth2me.essentials.craftbukkit.ItemDupeFix; import com.earth2me.essentials.listener.*; +import com.earth2me.essentials.listener.TNTExplodeListener; import com.earth2me.essentials.perm.PermissionsHandler; import com.earth2me.essentials.register.payment.Methods; import com.earth2me.essentials.settings.SettingsHolder; @@ -387,6 +391,7 @@ public class Essentials extends JavaPlugin implements IEssentials return this.getServer().getScheduler().scheduleSyncRepeatingTask(this, run, delay, period); } + @Override public TNTExplodeListener getTNTListener() { diff --git a/Essentials/src/com/earth2me/essentials/EssentialsCommandHandler.java b/Essentials/src/com/earth2me/essentials/EssentialsCommandHandler.java index 5c0fdbafa..71cd44501 100644 --- a/Essentials/src/com/earth2me/essentials/EssentialsCommandHandler.java +++ b/Essentials/src/com/earth2me/essentials/EssentialsCommandHandler.java @@ -2,6 +2,8 @@ package com.earth2me.essentials; import static com.earth2me.essentials.I18n._; import com.earth2me.essentials.api.*; +import com.earth2me.essentials.api.IEssentials; +import com.earth2me.essentials.api.IEssentialsModule; import com.earth2me.essentials.commands.EssentialsCommand; import com.earth2me.essentials.commands.IEssentialsCommand; import com.earth2me.essentials.commands.NoChargeException; diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandrealname.java b/Essentials/src/com/earth2me/essentials/commands/Commandrealname.java index 110453d8a..68478467b 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandrealname.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandrealname.java @@ -27,7 +27,7 @@ public class Commandrealname extends EssentialsCommand } final String displayName = Util.stripColor(u.getDisplayName()).toLowerCase(Locale.ENGLISH); if (!whois.equals(displayName) - && !displayName.equals(Util.stripColor(ess.getSettings().getNicknamePrefix()) + whois) + && !displayName.equals(Util.stripColor(ess.getSettings().getData().getChat().getNicknamePrefix()) + whois) && !whois.equalsIgnoreCase(u.getName())) { continue; diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandunlimited.java b/Essentials/src/com/earth2me/essentials/commands/Commandunlimited.java index 9beeda1a2..cea64131a 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandunlimited.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandunlimited.java @@ -5,6 +5,7 @@ import com.earth2me.essentials.api.IUser; import com.earth2me.essentials.craftbukkit.InventoryWorkaround; import java.util.List; import java.util.Locale; +import java.util.Set; import lombok.Cleanup; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; @@ -37,16 +38,11 @@ public class Commandunlimited extends EssentialsCommand else if (args[0].equalsIgnoreCase("clear")) { //TODO: Fix this, the clear should always work, even when the player does not have permission. - final List itemList = target.getData().getUnlimited(); - - int index = 0; - while (itemList.size() > index) + final Set itemList = target.getData().getUnlimited(); + for(Material mat : itemList) { - final Integer item = itemList.get(index); - if (toggleUnlimited(user, target, item.toString()) == false) - { - index++; - } + toggleUnlimited(user, target, mat.name()); + } } else @@ -60,19 +56,19 @@ public class Commandunlimited extends EssentialsCommand final StringBuilder output = new StringBuilder(); output.append(_("unlimitedItems")).append(" "); boolean first = true; - final List items = target.getUnlimited(); + final Set items = target.getData().getUnlimited(); if (items.isEmpty()) { output.append(_("none")); } - for (Integer integer : items) + for (Material mater : items) { if (!first) { output.append(", "); } first = false; - final String matname = Material.getMaterial(integer).toString().toLowerCase(Locale.ENGLISH).replace("_", ""); + final String matname = mater.name().toLowerCase(Locale.ENGLISH).replace("_", ""); output.append(matname); } @@ -93,7 +89,7 @@ public class Commandunlimited extends EssentialsCommand String message = "disableUnlimited"; Boolean enableUnlimited = false; - if (!target.hasUnlimited(stack)) + if (!target.getData().hasUnlimited(stack.getType())) { message = "enableUnlimited"; enableUnlimited = true; @@ -108,7 +104,7 @@ public class Commandunlimited extends EssentialsCommand user.sendMessage(_(message, itemname, target.getDisplayName())); } target.sendMessage(_(message, itemname, target.getDisplayName())); - target.setUnlimited(stack, enableUnlimited); + target.getData().setUnlimited(stack.getType(), enableUnlimited); return true; } diff --git a/Essentials/src/com/earth2me/essentials/user/User.java b/Essentials/src/com/earth2me/essentials/user/User.java index 6607792a0..0ac458a7f 100644 --- a/Essentials/src/com/earth2me/essentials/user/User.java +++ b/Essentials/src/com/earth2me/essentials/user/User.java @@ -7,21 +7,27 @@ import com.earth2me.essentials.Util; import com.earth2me.essentials.api.*; import com.earth2me.essentials.craftbukkit.InventoryWorkaround; import com.earth2me.essentials.register.payment.Method; -import java.util.Calendar; -import java.util.GregorianCalendar; -import java.util.List; -import java.util.Map; +import java.net.InetSocketAddress; +import java.util.*; import java.util.concurrent.atomic.AtomicBoolean; import java.util.logging.Logger; import lombok.Cleanup; import lombok.Getter; import lombok.Setter; -import org.bukkit.Bukkit; -import org.bukkit.Location; -import org.bukkit.OfflinePlayer; +import org.bukkit.*; +import org.bukkit.block.Block; import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; +import org.bukkit.entity.*; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; +import org.bukkit.map.MapView; +import org.bukkit.permissions.Permission; +import org.bukkit.permissions.PermissionAttachment; +import org.bukkit.permissions.PermissionAttachmentInfo; +import org.bukkit.plugin.Plugin; +import org.bukkit.util.Vector; public class User extends UserBase implements IUser @@ -88,12 +94,13 @@ public class User extends UserBase implements IUser //TODO: switch to Superperms only return ess.getPermissionsHandler().hasPermission(base, node); } - + + @Override public boolean isAuthorized(IPermission permission) { return isAuthorized(permission.getPermission()); } - + /*@Override public boolean isAuthorized(IEssentialsCommand cmd) { @@ -105,7 +112,8 @@ public class User extends UserBase implements IUser { return isAuthorized(permissionPrefix + (cmd.getName().equals("r") ? "msg" : cmd.getName())); }*/ - + + @Override public void checkCooldown(final UserData.TimestampType cooldownType, final double cooldown, final boolean set, final String bypassPermission) throws CooldownException { final Calendar now = new GregorianCalendar(); @@ -132,6 +140,7 @@ public class User extends UserBase implements IUser giveMoney(value, null); } + @Override public void giveMoney(final double value, final CommandSender initiator) { @@ -155,6 +164,7 @@ public class User extends UserBase implements IUser } } + @Override public void payUser(final IUser reciever, final double value) throws Exception { if (value == 0) @@ -180,6 +190,7 @@ public class User extends UserBase implements IUser takeMoney(value, null); } + @Override public void takeMoney(final double value, final CommandSender initiator) { if (value == 0) @@ -676,7 +687,7 @@ public class User extends UserBase implements IUser { @Cleanup final ISettings settings = ess.getSettings(); - settings.acquireReadLock(); + settings.acquireReadLock(); int oversizedStackSize = settings.getData().getGeneral().getOversizedStacksize(); overfilled = InventoryWorkaround.addItem(getInventory(), true, oversizedStackSize, itemStack); @@ -692,4 +703,823 @@ public class User extends UserBase implements IUser } return spew; } + + @Override + public void setDisplayName(String string) + { + base.setDisplayName(string); + } + + @Override + public String getPlayerListName() + { + return base.getPlayerListName(); + } + + @Override + public void setPlayerListName(String string) + { + base.setPlayerListName(string); + } + + @Override + public void setCompassTarget(Location lctn) + { + base.setCompassTarget(lctn); + } + + @Override + public Location getCompassTarget() + { + return base.getCompassTarget(); + } + + @Override + public InetSocketAddress getAddress() + { + return base.getAddress(); + } + + @Override + public void sendRawMessage(String string) + { + base.sendRawMessage(string); + } + + @Override + public void kickPlayer(String string) + { + base.kickPlayer(string); + } + + @Override + public void chat(String string) + { + base.chat(string); + } + + @Override + public boolean performCommand(String string) + { + return base.performCommand(string); + } + + @Override + public boolean isSneaking() + { + return base.isSneaking(); + } + + @Override + public void setSneaking(boolean bln) + { + base.setSneaking(bln); + } + + @Override + public boolean isSprinting() + { + return base.isSprinting(); + } + + @Override + public void setSprinting(boolean bln) + { + base.setSprinting(bln); + } + + @Override + public void saveData() + { + base.saveData(); + } + + @Override + public void loadData() + { + base.loadData(); + } + + @Override + public void setSleepingIgnored(boolean bln) + { + base.setSleepingIgnored(bln); + } + + @Override + public boolean isSleepingIgnored() + { + return base.isSleepingIgnored(); + } + + @Override + public void playNote(Location lctn, byte b, byte b1) + { + base.playNote(lctn, b, b1); + } + + @Override + public void playNote(Location lctn, Instrument i, Note note) + { + base.playNote(lctn, i, note); + } + + @Override + public void playEffect(Location lctn, Effect effect, int i) + { + base.playEffect(lctn, effect, i); + } + + @Override + public void sendBlockChange(Location lctn, Material mtrl, byte b) + { + base.sendBlockChange(lctn, mtrl, b); + } + + @Override + public boolean sendChunkChange(Location lctn, int i, int i1, int i2, byte[] bytes) + { + return base.sendChunkChange(lctn, i, i1, i2, bytes); + } + + @Override + public void sendBlockChange(Location lctn, int i, byte b) + { + base.sendBlockChange(lctn, i, b); + } + + @Override + public void sendMap(MapView mv) + { + base.sendMap(mv); + } + + @Override + public void updateInventory() + { + base.updateInventory(); + } + + @Override + public void awardAchievement(Achievement a) + { + base.awardAchievement(a); + } + + @Override + public void incrementStatistic(Statistic ststc) + { + base.incrementStatistic(ststc); + } + + @Override + public void incrementStatistic(Statistic ststc, int i) + { + base.incrementStatistic(ststc, i); + } + + @Override + public void incrementStatistic(Statistic ststc, Material mtrl) + { + base.incrementStatistic(ststc, mtrl); + } + + @Override + public void incrementStatistic(Statistic ststc, Material mtrl, int i) + { + base.incrementStatistic(ststc, mtrl, i); + } + + @Override + public void setPlayerTime(long l, boolean bln) + { + base.setPlayerTime(l, bln); + } + + @Override + public long getPlayerTime() + { + return base.getPlayerTime(); + } + + @Override + public long getPlayerTimeOffset() + { + return base.getPlayerTimeOffset(); + } + + @Override + public boolean isPlayerTimeRelative() + { + return base.isPlayerTimeRelative(); + } + + @Override + public void resetPlayerTime() + { + base.resetPlayerTime(); + } + + @Override + public void giveExp(int i) + { + base.giveExp(i); + } + + @Override + public float getExp() + { + return base.getExp(); + } + + @Override + public void setExp(float f) + { + base.setExp(f); + } + + @Deprecated + @Override + public int getExperience() + { + return base.getExperience(); + } + + @Deprecated + @Override + public void setExperience(int i) + { + base.setExperience(i); + } + + @Override + public int getLevel() + { + return base.getLevel(); + } + + @Override + public void setLevel(int i) + { + base.setLevel(i); + } + + @Override + public int getTotalExperience() + { + return base.getTotalExperience(); + } + + @Override + public void setTotalExperience(int i) + { + base.setTotalExperience(i); + } + + @Override + public float getExhaustion() + { + return base.getExhaustion(); + } + + @Override + public void setExhaustion(float f) + { + base.setExhaustion(f); + } + + @Override + public float getSaturation() + { + return base.getSaturation(); + } + + @Override + public void setSaturation(float f) + { + base.setSaturation(f); + } + + @Override + public int getFoodLevel() + { + return base.getFoodLevel(); + } + + @Override + public void setFoodLevel(int i) + { + base.setFoodLevel(i); + } + + @Override + public PlayerInventory getInventory() + { + return base.getInventory(); + } + + @Override + public ItemStack getItemInHand() + { + return base.getItemInHand(); + } + + @Override + public void setItemInHand(ItemStack is) + { + base.setItemInHand(is); + } + + @Override + public boolean isSleeping() + { + return base.isSleeping(); + } + + @Override + public int getSleepTicks() + { + return base.getSleepTicks(); + } + + @Override + public GameMode getGameMode() + { + return base.getGameMode(); + } + + @Override + public void setGameMode(GameMode gm) + { + base.setGameMode(gm); + } + + @Override + public int getHealth() + { + return base.getHealth(); + } + + @Override + public void setHealth(int i) + { + base.setHealth(i); + } + + @Override + public int getMaxHealth() + { + return base.getMaxHealth(); + } + + @Override + public double getEyeHeight() + { + return base.getEyeHeight(); + } + + @Override + public double getEyeHeight(boolean bln) + { + return base.getEyeHeight(bln); + } + + @Override + public Location getEyeLocation() + { + return base.getEyeLocation(); + } + + @Override + public List getLineOfSight(HashSet hs, int i) + { + return base.getLineOfSight(hs, i); + } + + @Override + public Block getTargetBlock(HashSet hs, int i) + { + return base.getTargetBlock(hs, i); + } + + @Override + public List getLastTwoTargetBlocks(HashSet hs, int i) + { + return base.getLastTwoTargetBlocks(hs, i); + } + + @Override + public Egg throwEgg() + { + return base.throwEgg(); + } + + @Override + public Snowball throwSnowball() + { + return base.throwSnowball(); + } + + @Override + public Arrow shootArrow() + { + return base.shootArrow(); + } + + @Override + public boolean isInsideVehicle() + { + return base.isInsideVehicle(); + } + + @Override + public boolean leaveVehicle() + { + return base.leaveVehicle(); + } + + @Override + public Vehicle getVehicle() + { + return base.getVehicle(); + } + + @Override + public int getRemainingAir() + { + return base.getRemainingAir(); + } + + @Override + public void setRemainingAir(int i) + { + base.setRemainingAir(i); + } + + @Override + public int getMaximumAir() + { + return base.getMaximumAir(); + } + + @Override + public void setMaximumAir(int i) + { + base.setMaximumAir(i); + } + + @Override + public void damage(int i) + { + base.damage(i); + } + + @Override + public void damage(int i, Entity entity) + { + base.damage(i, entity); + } + + @Override + public int getMaximumNoDamageTicks() + { + return base.getMaximumNoDamageTicks(); + } + + @Override + public void setMaximumNoDamageTicks(int i) + { + base.setMaximumNoDamageTicks(i); + } + + @Override + public int getLastDamage() + { + return base.getLastDamage(); + } + + @Override + public void setLastDamage(int i) + { + base.setLastDamage(i); + } + + @Override + public int getNoDamageTicks() + { + return base.getNoDamageTicks(); + } + + @Override + public void setNoDamageTicks(int i) + { + base.setNoDamageTicks(i); + } + + @Override + public Player getKiller() + { + return base.getKiller(); + } + + @Override + public Location getLocation() + { + return base.getLocation(); + } + + @Override + public void setVelocity(Vector vector) + { + base.setVelocity(vector); + } + + @Override + public Vector getVelocity() + { + return base.getVelocity(); + + } + + @Override + public World getWorld() + { + return base.getWorld(); + } + + @Override + public boolean teleport(Location lctn) + { + return base.teleport(lctn); + } + + @Override + public boolean teleport(Location lctn, TeleportCause tc) + { + return base.teleport(this, tc); + } + + @Override + public boolean teleport(Entity entity) + { + return base.teleport(entity); + } + + @Override + public boolean teleport(Entity entity, TeleportCause tc) + { + return base.teleport(entity, tc); + } + + @Override + public List getNearbyEntities(double d, double d1, double d2) + { + return base.getNearbyEntities(d, d1, d2); + } + + @Override + public int getEntityId() + { + return base.getEntityId(); + } + + @Override + public int getFireTicks() + { + return base.getFireTicks(); + } + + @Override + public int getMaxFireTicks() + { + return base.getMaxFireTicks(); + } + + @Override + public void setFireTicks(int i) + { + base.setFireTicks(i); + } + + @Override + public void remove() + { + base.remove(); + } + + @Override + public boolean isDead() + { + return base.isDead(); + } + + @Override + public Server getServer() + { + return base.getServer(); + } + + @Override + public Entity getPassenger() + { + return base.getPassenger(); + } + + @Override + public boolean setPassenger(Entity entity) + { + return base.setPassenger(entity); + } + + @Override + public boolean isEmpty() + { + return base.isEmpty(); + } + + @Override + public boolean eject() + { + return base.eject(); + } + + @Override + public float getFallDistance() + { + return base.getFallDistance(); + } + + @Override + public void setFallDistance(float f) + { + base.setFallDistance(f); + } + + @Override + public void setLastDamageCause(EntityDamageEvent ede) + { + base.setLastDamageCause(ede); + } + + @Override + public EntityDamageEvent getLastDamageCause() + { + return base.getLastDamageCause(); + } + + @Override + public UUID getUniqueId() + { + return base.getUniqueId(); + } + + @Override + public int getTicksLived() + { + return base.getTicksLived(); + } + + @Override + public void setTicksLived(int i) + { + base.setTicksLived(i); + } + + @Override + public boolean isPermissionSet(String string) + { + return base.isPermissionSet(string); + } + + @Override + public boolean isPermissionSet(Permission prmsn) + { + return base.isPermissionSet(prmsn); + } + + @Override + public boolean hasPermission(String string) + { + return base.hasPermission(string); + } + + @Override + public boolean hasPermission(Permission prmsn) + { + return base.hasPermission(prmsn); + } + + @Override + public PermissionAttachment addAttachment(Plugin plugin, String string, boolean bln) + { + return base.addAttachment(plugin, string, bln); + } + + @Override + public PermissionAttachment addAttachment(Plugin plugin) + { + return base.addAttachment(plugin); + } + + @Override + public PermissionAttachment addAttachment(Plugin plugin, String string, boolean bln, int i) + { + return base.addAttachment(plugin, string, bln, i); + } + + @Override + public PermissionAttachment addAttachment(Plugin plugin, int i) + { + return base.addAttachment(plugin, i); + } + + @Override + public void removeAttachment(PermissionAttachment pa) + { + base.removeAttachment(pa); + } + + @Override + public void recalculatePermissions() + { + base.recalculatePermissions(); + } + + @Override + public Set getEffectivePermissions() + { + return base.getEffectivePermissions(); + } + + @Override + public boolean isOp() + { + return base.isOp(); + } + + @Override + public void setOp(boolean bln) + { + base.setOp(bln); + } + + @Override + public void sendMessage(String string) + { + base.sendMessage(string); + } + + @Override + public boolean isOnline() + { + return base.isOnline(); + } + + @Override + public boolean isBanned() + { + return base.isBanned(); + } + + @Override + public boolean isWhitelisted() + { + return base.isWhitelisted(); + } + + @Override + public void setWhitelisted(boolean bln) + { + base.setWhitelisted(bln); + } + + @Override + public Player getPlayer() + { + return base.getPlayer(); + } + + @Override + public long getFirstPlayed() + { + return base.getFirstPlayed(); + } + + @Override + public long getLastPlayed() + { + return base.getLastPlayed(); + } + + @Override + public boolean hasPlayedBefore() + { + return base.hasPlayedBefore(); + } + + @Override + public Map serialize() + { + return base.serialize(); + } } diff --git a/Essentials/src/com/earth2me/essentials/user/UserData.java b/Essentials/src/com/earth2me/essentials/user/UserData.java index 1e81d85da..fd2eb99cc 100644 --- a/Essentials/src/com/earth2me/essentials/user/UserData.java +++ b/Essentials/src/com/earth2me/essentials/user/UserData.java @@ -9,6 +9,7 @@ import lombok.Data; import lombok.EqualsAndHashCode; import org.bukkit.Location; import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; @Data @@ -64,6 +65,18 @@ public class UserData implements StorageObject { return unlimited != null && unlimited.contains(mat); } + + public void setUnlimited(Material mat, boolean state) + { + if (unlimited.contains(mat)) + { + unlimited.remove(mat); + } + if (state) + { + unlimited.add(mat); + } + } public List getPowertool(Material mat) {