diff --git a/.gitignore b/.gitignore
index eda2b5917a..9251ca7e61 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,42 +1,47 @@
-.DS_Store
-/BuildAll/nbproject/private/
-/EssentialsProtect/nbproject/private/
-/EssentialsChat/nbproject/private/
-/EssentialsGroupBridge/nbproject/private/
-/EssentialsGeoIP/nbproject/private/
-/EssentialsSpawn/nbproject/private/
-/EssentialsXMPP/nbproject/private/
-/EssentialsGroupManager/nbproject/private/
-/BuildAll/build/
-/EssentialsGroupBridge/dist/
-/EssentialsGroupBridge/build/
-/EssentialsGeoIP/dist/
-/EssentialsGeoIP/build/
-/EssentialsGroupManager/build/
-/EssentialsGroupManager/dist/
-/BuildAll/dist/
-/EssentialsChat/build/
-/EssentialsChat/dist/
-/EssentialsSpawn/build/
-/EssentialsSpawn/dist/
-/EssentialsXMPP/dist/
-/EssentialsXMPP/build/
-/EssentialsProtect/dist/
-/EssentialsProtect/build/
-/EssentialsPermissionsCommands/nbproject/private/
-/EssentialsPermissionsCommands/build/
-/EssentialsPermissionsCommands/dist/
-/Essentials/nbproject/private/
-/Essentials/dist/
-/Essentials/build/
-/YamlAnnotations/
-/EssentialsUpdate/nbproject/private/
-/EssentialsRelease/
-/EssentialsUpdate/dist/
-/EssentialsUpdate/build/
-/WebPush/apikey.php
-/WebPush/nbproject/private
-/.idea
+.DS_Store
+/BuildAll/nbproject/private/
+/EssentialsProtect/nbproject/private/
+/EssentialsChat/nbproject/private/
+/EssentialsGroupBridge/nbproject/private/
+/EssentialsGeoIP/nbproject/private/
+/EssentialsSpawn/nbproject/private/
+/EssentialsXMPP/nbproject/private/
+/EssentialsGroupManager/nbproject/private/
+/BuildAll/build/
+/EssentialsGroupBridge/dist/
+/EssentialsGroupBridge/build/
+/EssentialsGeoIP/dist/
+/EssentialsGeoIP/build/
+/EssentialsGroupManager/build/
+/EssentialsGroupManager/dist/
+/BuildAll/dist/
+/EssentialsChat/build/
+/EssentialsChat/dist/
+/EssentialsSpawn/build/
+/EssentialsSpawn/dist/
+/EssentialsXMPP/dist/
+/EssentialsXMPP/build/
+/EssentialsProtect/dist/
+/EssentialsProtect/build/
+/EssentialsPermissionsCommands/nbproject/private/
+/EssentialsPermissionsCommands/build/
+/EssentialsPermissionsCommands/dist/
+/Essentials/nbproject/private/
+/Essentials/dist/
+/Essentials/build/
+/YamlAnnotations/
+/EssentialsUpdate/nbproject/private/
+/EssentialsRelease/
+/EssentialsUpdate/dist/
+/EssentialsUpdate/build/
+/WebPush/apikey.php
+/WebPush/nbproject/private
+/.idea
*.iml
/EssentialsGroupManager/bin
-/EssentialsGroupManager/.externalToolBuilders
\ No newline at end of file
+/EssentialsGroupManager/.externalToolBuilders
+/EssentialsAntiBuild/nbproject/private/
+/EssentialsAntiBuild/dist/
+/EssentialsAntiBuild/build/
+/jars
+/out
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000000..b68a6c4952
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,17 @@
+language: java
+jdk:
+ - oraclejdk7
+ - openjdk7
+ - openjdk6
+script: ant collect
+notifications:
+ irc:
+ channels:
+ - "irc.esper.net#lain"
+ on_success: change
+ on_failure: always
+ email:
+ recipients:
+ - "khobbits@ess3.net"
+ on_success: change
+ on_failure: always
\ No newline at end of file
diff --git a/BuildAll/nbproject/build-impl.xml b/BuildAll/nbproject/build-impl.xml
index 1f8bcbaaea..3c7d317da7 100644
--- a/BuildAll/nbproject/build-impl.xml
+++ b/BuildAll/nbproject/build-impl.xml
@@ -12,9 +12,9 @@ is divided into following sections:
- execution
- debugging
- javadoc
- - junit compilation
- - junit execution
- - junit debugging
+ - test compilation
+ - test execution
+ - test debugging
- applet
- cleanup
@@ -181,6 +181,7 @@ is divided into following sections:
+
@@ -225,6 +226,27 @@ is divided into following sections:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -357,11 +379,52 @@ is divided into following sections:
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -370,32 +433,270 @@ is divided into following sections:
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ No tests executed.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
-
+
@@ -427,10 +728,13 @@ is divided into following sections:
-
+
Must set JVM to use for profiling in profiler.info.jvm
Must set profiler agent JVM arguments in profiler.info.jvmargs.agent
+
@@ -488,6 +792,7 @@ is divided into following sections:
+
@@ -504,6 +809,7 @@ is divided into following sections:
+
@@ -511,6 +817,7 @@ is divided into following sections:
+
@@ -537,6 +844,9 @@ is divided into following sections:
+
+
+
@@ -582,7 +892,7 @@ is divided into following sections:
-
+
-
+
+
+ This target only works when run from inside the NetBeans IDE.
@@ -862,8 +1176,9 @@ is divided into following sections:
-
+
Must select one file in the IDE or set profile.class
+ This target only works when run from inside the NetBeans IDE.
@@ -871,12 +1186,8 @@ is divided into following sections:
-
-
+
+ This target only works when run from inside the NetBeans IDE.
@@ -888,12 +1199,8 @@ is divided into following sections:
-
-
+
+ This target only works when run from inside the NetBeans IDE.
@@ -915,6 +1222,42 @@ is divided into following sections:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+
+ Must select some files in the IDE or set test.includes
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
@@ -1001,14 +1344,14 @@ is divided into following sections:
-
+
Some tests failed; see details above.
@@ -1021,39 +1364,40 @@ is divided into following sections:
Must select some files in the IDE or set test.includes
-
+
Some tests failed; see details above.
+
+ Must select some files in the IDE or set test.class
+ Must select some method in the IDE or set test.method
+
+
+
+ Some tests failed; see details above.
+
+
-
+
Must select one file in the IDE or set test.class
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+ Must select one file in the IDE or set test.class
+ Must select some method in the IDE or set test.method
+
+
@@ -1128,15 +1472,15 @@ is divided into following sections:
-
-
+
+
-
-
+
+
@@ -1174,9 +1518,12 @@ is divided into following sections:
-
-
-
+
+
+
+
+
+
diff --git a/BuildAll/nbproject/genfiles.properties b/BuildAll/nbproject/genfiles.properties
index 8068c7fc04..b95cd73c29 100644
--- a/BuildAll/nbproject/genfiles.properties
+++ b/BuildAll/nbproject/genfiles.properties
@@ -1,8 +1,8 @@
-build.xml.data.CRC32=51b33957
+build.xml.data.CRC32=cab45985
build.xml.script.CRC32=7a797370
-build.xml.stylesheet.CRC32=28e38971@1.44.1.45
+build.xml.stylesheet.CRC32=28e38971@1.50.3.46
# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
-nbproject/build-impl.xml.data.CRC32=51b33957
-nbproject/build-impl.xml.script.CRC32=c5170bed
-nbproject/build-impl.xml.stylesheet.CRC32=fcddb364@1.50.1.46
+nbproject/build-impl.xml.data.CRC32=b4df970c
+nbproject/build-impl.xml.script.CRC32=8905537e
+nbproject/build-impl.xml.stylesheet.CRC32=6ddba6b6@1.53.1.46
diff --git a/BuildAll/nbproject/project.properties b/BuildAll/nbproject/project.properties
index 246ea1240f..a18e718e52 100644
--- a/BuildAll/nbproject/project.properties
+++ b/BuildAll/nbproject/project.properties
@@ -66,10 +66,10 @@ jar.compress=true
javac.classpath=\
${reference.Essentials.jar}:\
${reference.EssentialsChat.jar}:\
+ ${reference.EssentialsAntiBuild.jar}:\
${reference.EssentialsProtect.jar}:\
${reference.EssentialsSpawn.jar}:\
${reference.EssentialsGeoIP.jar}:\
- ${reference.EssentialsGroupBridge.jar}:\
${reference.EssentialsXMPP.jar}:\
${reference.EssentialsGroupManager.jar}
# Space-separated list of extra javac options
@@ -101,16 +101,16 @@ platform.active=default_platform
project.Essentials=../Essentials
project.EssentialsChat=../EssentialsChat
project.EssentialsGeoIP=../EssentialsGeoIP
-project.EssentialsGroupBridge=../EssentialsGroupBridge
project.EssentialsGroupManager=../EssentialsGroupManager
+project.EssentialsAntiBuild=../EssentialsAntiBuild
project.EssentialsProtect=../EssentialsProtect
project.EssentialsSpawn=../EssentialsSpawn
project.EssentialsXMPP=../EssentialsXMPP
reference.Essentials.jar=${project.Essentials}/dist/Essentials.jar
reference.EssentialsChat.jar=${project.EssentialsChat}/dist/EssentialsChat.jar
reference.EssentialsGeoIP.jar=${project.EssentialsGeoIP}/dist/EssentialsGeoIP.jar
-reference.EssentialsGroupBridge.jar=${project.EssentialsGroupBridge}/dist/EssentialsGroupBridge.jar
reference.EssentialsGroupManager.jar=${project.EssentialsGroupManager}/dist/EssentialsGroupManager.jar
+reference.EssentialsAntiBuild.jar=${project.EssentialsAntiBuild}/dist/EssentialsAntiBuild.jar
reference.EssentialsProtect.jar=${project.EssentialsProtect}/dist/EssentialsProtect.jar
reference.EssentialsSpawn.jar=${project.EssentialsSpawn}/dist/EssentialsSpawn.jar
reference.EssentialsXMPP.jar=${project.EssentialsXMPP}/dist/EssentialsXMPP.jar
diff --git a/BuildAll/nbproject/project.xml b/BuildAll/nbproject/project.xml
index 420233ac92..a7afa7da68 100644
--- a/BuildAll/nbproject/project.xml
+++ b/BuildAll/nbproject/project.xml
@@ -40,7 +40,7 @@
jar
- EssentialsGroupBridge
+ EssentialsGroupManager
jar
jar
@@ -48,7 +48,7 @@
jar
- EssentialsGroupManager
+ EssentialsAntiBuild
jar
jar
diff --git a/Essentials/nbproject/build-impl.xml b/Essentials/nbproject/build-impl.xml
index f79ca7e26d..7a011527b1 100644
--- a/Essentials/nbproject/build-impl.xml
+++ b/Essentials/nbproject/build-impl.xml
@@ -12,9 +12,9 @@ is divided into following sections:
- execution
- debugging
- javadoc
- - junit compilation
- - junit execution
- - junit debugging
+ - test compilation
+ - test execution
+ - test debugging
- applet
- cleanup
@@ -181,6 +181,7 @@ is divided into following sections:
+
@@ -225,6 +226,27 @@ is divided into following sections:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -357,11 +379,57 @@ is divided into following sections:
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -369,33 +437,277 @@ is divided into following sections:
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ No tests executed.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
-
+
@@ -427,10 +739,13 @@ is divided into following sections:
-
+
Must set JVM to use for profiling in profiler.info.jvm
Must set profiler agent JVM arguments in profiler.info.jvmargs.agent
+
@@ -488,6 +803,7 @@ is divided into following sections:
+
@@ -504,6 +820,7 @@ is divided into following sections:
+
@@ -511,6 +828,7 @@ is divided into following sections:
+
@@ -537,6 +855,9 @@ is divided into following sections:
+
+
+
@@ -582,7 +903,7 @@ is divided into following sections:
-
+
-
+
+
+ This target only works when run from inside the NetBeans IDE.
@@ -813,8 +1138,9 @@ is divided into following sections:
-
+
Must select one file in the IDE or set profile.class
+ This target only works when run from inside the NetBeans IDE.
@@ -822,12 +1148,8 @@ is divided into following sections:
-
-
+
+ This target only works when run from inside the NetBeans IDE.
@@ -839,12 +1161,8 @@ is divided into following sections:
-
-
+
+ This target only works when run from inside the NetBeans IDE.
@@ -866,6 +1184,42 @@ is divided into following sections:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+
+ Must select some files in the IDE or set test.includes
+
+
+
+
+ Must select one file in the IDE or set run.class
+
+
+
+
+ Must select one file in the IDE or set applet.url
+
+
+
@@ -952,14 +1306,14 @@ is divided into following sections:
-
+
Some tests failed; see details above.
@@ -972,39 +1326,40 @@ is divided into following sections:
Must select some files in the IDE or set test.includes
-
+
Some tests failed; see details above.
+
+ Must select some files in the IDE or set test.class
+ Must select some method in the IDE or set test.method
+
+
+
+ Some tests failed; see details above.
+
+
-
+
Must select one file in the IDE or set test.class
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+ Must select one file in the IDE or set test.class
+ Must select some method in the IDE or set test.method
+
+
@@ -1076,9 +1431,12 @@ is divided into following sections:
-
-
-
+
+
+
+
+
+
diff --git a/Essentials/nbproject/genfiles.properties b/Essentials/nbproject/genfiles.properties
index 8d631fddf4..8b1c292649 100644
--- a/Essentials/nbproject/genfiles.properties
+++ b/Essentials/nbproject/genfiles.properties
@@ -4,8 +4,8 @@ build.xml.stylesheet.CRC32=28e38971@1.38.2.45
# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
nbproject/build-impl.xml.data.CRC32=a830bc14
-nbproject/build-impl.xml.script.CRC32=a9f8842a
-nbproject/build-impl.xml.stylesheet.CRC32=fcddb364@1.50.1.46
+nbproject/build-impl.xml.script.CRC32=21ffdddf
+nbproject/build-impl.xml.stylesheet.CRC32=c6d2a60f@1.56.1.46
nbproject/profiler-build-impl.xml.data.CRC32=ab78ce15
nbproject/profiler-build-impl.xml.script.CRC32=abda56ed
nbproject/profiler-build-impl.xml.stylesheet.CRC32=f10cf54c@1.11.1
diff --git a/Essentials/nbproject/project.properties b/Essentials/nbproject/project.properties
index 7a5ffe7bbb..f749b85535 100644
--- a/Essentials/nbproject/project.properties
+++ b/Essentials/nbproject/project.properties
@@ -1,5 +1,5 @@
annotation.processing.enabled=true
-annotation.processing.enabled.in.editor=false
+annotation.processing.enabled.in.editor=true
annotation.processing.processors.list=lombok.core.AnnotationProcessor
annotation.processing.run.all.processors=false
annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output
@@ -68,7 +68,6 @@ file.reference.BOSEconomy7.jar=../lib/BOSEconomy7.jar
file.reference.bPermissions.jar=../lib/bPermissions.jar
file.reference.bpermissions2.jar=../lib/bpermissions2.jar
file.reference.bukkit.jar=../lib/bukkit.jar
-file.reference.craftbukkit.jar=../lib/craftbukkit.jar
file.reference.iCo4.jar=../lib/iCo4.jar
file.reference.iCo5.jar=../lib/iCo5.jar
file.reference.iCo6.jar=../lib/iCo6.jar
@@ -79,6 +78,7 @@ file.reference.PermissionsBukkit-1.2.jar=../lib/PermissionsBukkit-1.2.jar
file.reference.PermissionsEx.jar=../lib/PermissionsEx.jar
file.reference.Privileges.jar=..\\lib\\Privileges.jar
file.reference.Vault.jar=../lib/Vault.jar
+file.reference.SimplyPerms.jar=../lib/SimplyPerms.jar
includes=**
jar.archive.disabled=${jnlp.enabled}
jar.compress=true
@@ -96,12 +96,12 @@ javac.classpath=\
${file.reference.lombok.jar}:\
${reference.EssentialsGroupManager.jar}:\
${file.reference.bukkit.jar}:\
- ${file.reference.craftbukkit.jar}:\
${file.reference.Vault.jar}:\
${file.reference.Privileges.jar}:\
- ${file.reference.bpermissions2.jar}
+ ${file.reference.bpermissions2.jar}:\
+ ${file.reference.SimplyPerms.jar}
# Space-separated list of extra javac options
-javac.compilerargs=
+javac.compilerargs=-Xlint:unchecked
javac.deprecation=false
javac.processorpath=\
${javac.classpath}
diff --git a/Essentials/src/book.txt b/Essentials/src/book.txt
new file mode 100644
index 0000000000..164910fb7e
--- /dev/null
+++ b/Essentials/src/book.txt
@@ -0,0 +1,18 @@
+This is the book file.
+
+This file format works similar to the info.txt, motd.txt and rules.txt
+
+Place content in here that you would like to be used by books ingame.
+
+You can use this content by using the book: meta option in kits or item spawning.
+
+#Colors
+Minecraft colors:
+&0 &&0 &1 &&1 &2 &&2 &3 &&3
+&4 &&4 &5 &&5 &6 &&6 &7 &&7
+&8 &&8 &9 &&9 &a &&a &b &&b
+&c &&c &d &&d &e &&e &f &&f
+&0
+&&k &kMagic&r &&l &lBold
+&&m &mStrike&r &&n &nUline
+&&o &oItalic&r &&r &rReset
\ No newline at end of file
diff --git a/Essentials/src/com/earth2me/essentials/AlternativeCommandsHandler.java b/Essentials/src/com/earth2me/essentials/AlternativeCommandsHandler.java
index e75644ad53..e9cb6fe193 100644
--- a/Essentials/src/com/earth2me/essentials/AlternativeCommandsHandler.java
+++ b/Essentials/src/com/earth2me/essentials/AlternativeCommandsHandler.java
@@ -121,13 +121,14 @@ public PluginCommand getAlternative(final String label)
return commands.get(0);
}
- public void executed(final String label, final String otherLabel)
+ public void executed(final String label, final PluginCommand pc)
{
+ final String altString = pc.getPlugin().getName() + ":" + pc.getLabel();
if (ess.getSettings().isDebug())
{
- LOGGER.log(Level.INFO, "Essentials: Alternative command " + label + " found, using " + otherLabel);
+ LOGGER.log(Level.INFO, "Essentials: Alternative command " + label + " found, using " + altString);
}
- disabledList.put(label, otherLabel);
+ disabledList.put(label, altString);
}
public Map disabledCommands()
diff --git a/Essentials/src/com/earth2me/essentials/Backup.java b/Essentials/src/com/earth2me/essentials/Backup.java
index baa90e561e..3b7d9297c1 100644
--- a/Essentials/src/com/earth2me/essentials/Backup.java
+++ b/Essentials/src/com/earth2me/essentials/Backup.java
@@ -25,16 +25,33 @@ public Backup(final IEssentials ess)
server = ess.getServer();
if (server.getOnlinePlayers().length > 0)
{
- startTask();
+ ess.runTaskAsynchronously(new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ startTask();
+ }
+ });
}
}
- void onPlayerJoin()
+ public void onPlayerJoin()
{
startTask();
}
- private void startTask()
+ public synchronized void stopTask()
+ {
+ running = false;
+ if (taskId != -1)
+ {
+ server.getScheduler().cancelTask(taskId);
+ }
+ taskId = -1;
+ }
+
+ private synchronized void startTask()
{
if (!running)
{
@@ -61,7 +78,8 @@ public void run()
{
return;
}
- if ("save-all".equalsIgnoreCase(command)) {
+ if ("save-all".equalsIgnoreCase(command))
+ {
final CommandSender cs = server.getConsoleSender();
server.dispatchCommand(cs, "save-all");
active = false;
@@ -72,7 +90,7 @@ public void run()
server.dispatchCommand(cs, "save-all");
server.dispatchCommand(cs, "save-off");
- ess.scheduleAsyncDelayedTask(
+ ess.runTaskAsynchronously(
new Runnable()
{
@Override
@@ -123,11 +141,7 @@ public void run()
server.dispatchCommand(cs, "save-on");
if (server.getOnlinePlayers().length == 0)
{
- running = false;
- if (taskId != -1)
- {
- server.getScheduler().cancelTask(taskId);
- }
+ stopTask();
}
active = false;
LOGGER.log(Level.INFO, _("backupFinished"));
diff --git a/Essentials/src/com/earth2me/essentials/DescParseTickFormat.java b/Essentials/src/com/earth2me/essentials/DescParseTickFormat.java
index 9c40acacc7..91efe3c0ad 100644
--- a/Essentials/src/com/earth2me/essentials/DescParseTickFormat.java
+++ b/Essentials/src/com/earth2me/essentials/DescParseTickFormat.java
@@ -269,11 +269,11 @@ public static Date ticksToDate(long ticks)
// How many ingame days have passed since the server start?
final long days = ticks / ticksPerDay;
- ticks = ticks - days * ticksPerDay;
+ ticks -= days * ticksPerDay;
// How many hours on the last day?
final long hours = ticks / ticksPerHour;
- ticks = ticks - hours * ticksPerHour;
+ ticks -= hours * ticksPerHour;
// How many minutes on the last day?
final long minutes = (long)Math.floor(ticks / ticksPerMinute);
diff --git a/Essentials/src/com/earth2me/essentials/Enchantments.java b/Essentials/src/com/earth2me/essentials/Enchantments.java
index 060dfd2c1e..e30bff1c1f 100644
--- a/Essentials/src/com/earth2me/essentials/Enchantments.java
+++ b/Essentials/src/com/earth2me/essentials/Enchantments.java
@@ -5,112 +5,144 @@
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import java.util.regex.Pattern;
import org.bukkit.enchantments.Enchantment;
public class Enchantments
{
- private static final transient Pattern NUMPATTERN = Pattern.compile("\\d+");
private static final Map ENCHANTMENTS = new HashMap();
+ private static final Map ALIASENCHANTMENTS = new HashMap();
static
{
ENCHANTMENTS.put("alldamage", Enchantment.DAMAGE_ALL);
- ENCHANTMENTS.put("alldmg", Enchantment.DAMAGE_ALL);
+ ALIASENCHANTMENTS.put("alldmg", Enchantment.DAMAGE_ALL);
ENCHANTMENTS.put("sharpness", Enchantment.DAMAGE_ALL);
- ENCHANTMENTS.put("sharp", Enchantment.DAMAGE_ALL);
-
- ENCHANTMENTS.put("arthropodsdamage", Enchantment.DAMAGE_ARTHROPODS);
+ ALIASENCHANTMENTS.put("sharp", Enchantment.DAMAGE_ALL);
+ ALIASENCHANTMENTS.put("dal", Enchantment.DAMAGE_ALL);
+
ENCHANTMENTS.put("ardmg", Enchantment.DAMAGE_ARTHROPODS);
ENCHANTMENTS.put("baneofarthropods", Enchantment.DAMAGE_ARTHROPODS);
- ENCHANTMENTS.put("baneofarthropod", Enchantment.DAMAGE_ARTHROPODS);
- ENCHANTMENTS.put("arthropod", Enchantment.DAMAGE_ARTHROPODS);
+ ALIASENCHANTMENTS.put("baneofarthropod", Enchantment.DAMAGE_ARTHROPODS);
+ ALIASENCHANTMENTS.put("arthropod", Enchantment.DAMAGE_ARTHROPODS);
+ ALIASENCHANTMENTS.put("dar", Enchantment.DAMAGE_ARTHROPODS);
ENCHANTMENTS.put("undeaddamage", Enchantment.DAMAGE_UNDEAD);
ENCHANTMENTS.put("smite", Enchantment.DAMAGE_UNDEAD);
+ ALIASENCHANTMENTS.put("du", Enchantment.DAMAGE_UNDEAD);
ENCHANTMENTS.put("digspeed", Enchantment.DIG_SPEED);
ENCHANTMENTS.put("efficiency", Enchantment.DIG_SPEED);
- ENCHANTMENTS.put("minespeed", Enchantment.DIG_SPEED);
- ENCHANTMENTS.put("cutspeed", Enchantment.DIG_SPEED);
+ ALIASENCHANTMENTS.put("minespeed", Enchantment.DIG_SPEED);
+ ALIASENCHANTMENTS.put("cutspeed", Enchantment.DIG_SPEED);
+ ALIASENCHANTMENTS.put("ds", Enchantment.DIG_SPEED);
+ ALIASENCHANTMENTS.put("eff", Enchantment.DIG_SPEED);
ENCHANTMENTS.put("durability", Enchantment.DURABILITY);
- ENCHANTMENTS.put("dura", Enchantment.DURABILITY);
+ ALIASENCHANTMENTS.put("dura", Enchantment.DURABILITY);
ENCHANTMENTS.put("unbreaking", Enchantment.DURABILITY);
+ ALIASENCHANTMENTS.put("d", Enchantment.DURABILITY);
+
+ ENCHANTMENTS.put("thorns", Enchantment.THORNS);
+ ENCHANTMENTS.put("highcrit", Enchantment.THORNS);
+ ALIASENCHANTMENTS.put("thorn", Enchantment.THORNS);
+ ALIASENCHANTMENTS.put("highercrit", Enchantment.THORNS);
+ ALIASENCHANTMENTS.put("t", Enchantment.THORNS);
ENCHANTMENTS.put("fireaspect", Enchantment.FIRE_ASPECT);
ENCHANTMENTS.put("fire", Enchantment.FIRE_ASPECT);
- ENCHANTMENTS.put("meleefire", Enchantment.FIRE_ASPECT);
- ENCHANTMENTS.put("meleeflame", Enchantment.FIRE_ASPECT);
+ ALIASENCHANTMENTS.put("meleefire", Enchantment.FIRE_ASPECT);
+ ALIASENCHANTMENTS.put("meleeflame", Enchantment.FIRE_ASPECT);
+ ALIASENCHANTMENTS.put("fa", Enchantment.FIRE_ASPECT);
ENCHANTMENTS.put("knockback", Enchantment.KNOCKBACK);
+ ALIASENCHANTMENTS.put("kback", Enchantment.KNOCKBACK);
+ ALIASENCHANTMENTS.put("kb", Enchantment.KNOCKBACK);
+ ALIASENCHANTMENTS.put("k", Enchantment.KNOCKBACK);
- ENCHANTMENTS.put("blockslootbonus", Enchantment.LOOT_BONUS_BLOCKS);
+ ALIASENCHANTMENTS.put("blockslootbonus", Enchantment.LOOT_BONUS_BLOCKS);
ENCHANTMENTS.put("fortune", Enchantment.LOOT_BONUS_BLOCKS);
+ ALIASENCHANTMENTS.put("fort", Enchantment.LOOT_BONUS_BLOCKS);
+ ALIASENCHANTMENTS.put("lbb", Enchantment.LOOT_BONUS_BLOCKS);
- ENCHANTMENTS.put("mobslootbonus", Enchantment.LOOT_BONUS_MOBS);
+ ALIASENCHANTMENTS.put("mobslootbonus", Enchantment.LOOT_BONUS_MOBS);
ENCHANTMENTS.put("mobloot", Enchantment.LOOT_BONUS_MOBS);
ENCHANTMENTS.put("looting", Enchantment.LOOT_BONUS_MOBS);
+ ALIASENCHANTMENTS.put("lbm", Enchantment.LOOT_BONUS_MOBS);
- ENCHANTMENTS.put("oxygen", Enchantment.OXYGEN);
+ ALIASENCHANTMENTS.put("oxygen", Enchantment.OXYGEN);
ENCHANTMENTS.put("respiration", Enchantment.OXYGEN);
- ENCHANTMENTS.put("breathing", Enchantment.OXYGEN);
+ ALIASENCHANTMENTS.put("breathing", Enchantment.OXYGEN);
ENCHANTMENTS.put("breath", Enchantment.OXYGEN);
+ ALIASENCHANTMENTS.put("o", Enchantment.OXYGEN);
ENCHANTMENTS.put("protection", Enchantment.PROTECTION_ENVIRONMENTAL);
- ENCHANTMENTS.put("prot", Enchantment.PROTECTION_ENVIRONMENTAL);
+ ALIASENCHANTMENTS.put("prot", Enchantment.PROTECTION_ENVIRONMENTAL);
ENCHANTMENTS.put("protect", Enchantment.PROTECTION_ENVIRONMENTAL);
+ ALIASENCHANTMENTS.put("p", Enchantment.PROTECTION_ENVIRONMENTAL);
- ENCHANTMENTS.put("explosionsprotection", Enchantment.PROTECTION_EXPLOSIONS);
- ENCHANTMENTS.put("explosionprotection", Enchantment.PROTECTION_EXPLOSIONS);
- ENCHANTMENTS.put("expprot", Enchantment.PROTECTION_EXPLOSIONS);
- ENCHANTMENTS.put("blastprotection", Enchantment.PROTECTION_EXPLOSIONS);
+ ALIASENCHANTMENTS.put("explosionsprotection", Enchantment.PROTECTION_EXPLOSIONS);
+ ALIASENCHANTMENTS.put("explosionprotection", Enchantment.PROTECTION_EXPLOSIONS);
+ ALIASENCHANTMENTS.put("expprot", Enchantment.PROTECTION_EXPLOSIONS);
+ ALIASENCHANTMENTS.put("blastprotection", Enchantment.PROTECTION_EXPLOSIONS);
ENCHANTMENTS.put("blastprotect", Enchantment.PROTECTION_EXPLOSIONS);
+ ALIASENCHANTMENTS.put("pe", Enchantment.PROTECTION_EXPLOSIONS);
- ENCHANTMENTS.put("fallprotection", Enchantment.PROTECTION_FALL);
+ ALIASENCHANTMENTS.put("fallprotection", Enchantment.PROTECTION_FALL);
ENCHANTMENTS.put("fallprot", Enchantment.PROTECTION_FALL);
ENCHANTMENTS.put("featherfall", Enchantment.PROTECTION_FALL);
- ENCHANTMENTS.put("featherfalling", Enchantment.PROTECTION_FALL);
+ ALIASENCHANTMENTS.put("featherfalling", Enchantment.PROTECTION_FALL);
+ ALIASENCHANTMENTS.put("pfa", Enchantment.PROTECTION_FALL);
- ENCHANTMENTS.put("fireprotection", Enchantment.PROTECTION_FIRE);
- ENCHANTMENTS.put("flameprotection", Enchantment.PROTECTION_FIRE);
+ ALIASENCHANTMENTS.put("fireprotection", Enchantment.PROTECTION_FIRE);
+ ALIASENCHANTMENTS.put("flameprotection", Enchantment.PROTECTION_FIRE);
ENCHANTMENTS.put("fireprotect", Enchantment.PROTECTION_FIRE);
- ENCHANTMENTS.put("flameprotect", Enchantment.PROTECTION_FIRE);
+ ALIASENCHANTMENTS.put("flameprotect", Enchantment.PROTECTION_FIRE);
+ ENCHANTMENTS.put("fireprot", Enchantment.PROTECTION_FIRE);
+ ALIASENCHANTMENTS.put("flameprot", Enchantment.PROTECTION_FIRE);
+ ALIASENCHANTMENTS.put("pf", Enchantment.PROTECTION_FIRE);
ENCHANTMENTS.put("projectileprotection", Enchantment.PROTECTION_PROJECTILE);
ENCHANTMENTS.put("projprot", Enchantment.PROTECTION_PROJECTILE);
+ ALIASENCHANTMENTS.put("pp", Enchantment.PROTECTION_PROJECTILE);
ENCHANTMENTS.put("silktouch", Enchantment.SILK_TOUCH);
- ENCHANTMENTS.put("softtouch", Enchantment.SILK_TOUCH);
+ ALIASENCHANTMENTS.put("softtouch", Enchantment.SILK_TOUCH);
+ ALIASENCHANTMENTS.put("st", Enchantment.SILK_TOUCH);
ENCHANTMENTS.put("waterworker", Enchantment.WATER_WORKER);
ENCHANTMENTS.put("aquaaffinity", Enchantment.WATER_WORKER);
+ ALIASENCHANTMENTS.put("watermine", Enchantment.WATER_WORKER);
+ ALIASENCHANTMENTS.put("ww", Enchantment.WATER_WORKER);
- ENCHANTMENTS.put("firearrow", Enchantment.ARROW_FIRE);
+ ALIASENCHANTMENTS.put("firearrow", Enchantment.ARROW_FIRE);
ENCHANTMENTS.put("flame", Enchantment.ARROW_FIRE);
ENCHANTMENTS.put("flamearrow", Enchantment.ARROW_FIRE);
+ ALIASENCHANTMENTS.put("af", Enchantment.ARROW_FIRE);
ENCHANTMENTS.put("arrowdamage", Enchantment.ARROW_DAMAGE);
ENCHANTMENTS.put("power", Enchantment.ARROW_DAMAGE);
- ENCHANTMENTS.put("arrowpower", Enchantment.ARROW_DAMAGE);
+ ALIASENCHANTMENTS.put("arrowpower", Enchantment.ARROW_DAMAGE);
+ ALIASENCHANTMENTS.put("ad", Enchantment.ARROW_DAMAGE);
ENCHANTMENTS.put("arrowknockback", Enchantment.ARROW_KNOCKBACK);
- ENCHANTMENTS.put("arrowkb", Enchantment.ARROW_KNOCKBACK);
+ ALIASENCHANTMENTS.put("arrowkb", Enchantment.ARROW_KNOCKBACK);
ENCHANTMENTS.put("punch", Enchantment.ARROW_KNOCKBACK);
- ENCHANTMENTS.put("arrowpunch", Enchantment.ARROW_KNOCKBACK);
+ ALIASENCHANTMENTS.put("arrowpunch", Enchantment.ARROW_KNOCKBACK);
+ ALIASENCHANTMENTS.put("ak", Enchantment.ARROW_KNOCKBACK);
- ENCHANTMENTS.put("infinitearrows", Enchantment.ARROW_INFINITE);
+ ALIASENCHANTMENTS.put("infinitearrows", Enchantment.ARROW_INFINITE);
ENCHANTMENTS.put("infarrows", Enchantment.ARROW_INFINITE);
ENCHANTMENTS.put("infinity", Enchantment.ARROW_INFINITE);
- ENCHANTMENTS.put("infinite", Enchantment.ARROW_INFINITE);
- ENCHANTMENTS.put("unlimited", Enchantment.ARROW_INFINITE);
- ENCHANTMENTS.put("unlimitedarrows", Enchantment.ARROW_INFINITE);
+ ALIASENCHANTMENTS.put("infinite", Enchantment.ARROW_INFINITE);
+ ALIASENCHANTMENTS.put("unlimited", Enchantment.ARROW_INFINITE);
+ ALIASENCHANTMENTS.put("unlimitedarrows", Enchantment.ARROW_INFINITE);
+ ALIASENCHANTMENTS.put("ai", Enchantment.ARROW_INFINITE);
}
public static Enchantment getByName(String name) {
Enchantment enchantment;
- if (NUMPATTERN.matcher(name).matches()) {
+ if (Util.isInt(name)) {
enchantment = Enchantment.getById(Integer.parseInt(name));
} else {
enchantment = Enchantment.getByName(name.toUpperCase(Locale.ENGLISH));
@@ -119,6 +151,10 @@ public static Enchantment getByName(String name) {
{
enchantment = ENCHANTMENTS.get(name.toLowerCase(Locale.ENGLISH));
}
+ if (enchantment == null)
+ {
+ enchantment = ALIASENCHANTMENTS.get(name.toLowerCase(Locale.ENGLISH));
+ }
return enchantment;
}
diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java
index 8790e70223..d9b1af096f 100644
--- a/Essentials/src/com/earth2me/essentials/Essentials.java
+++ b/Essentials/src/com/earth2me/essentials/Essentials.java
@@ -20,7 +20,6 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.api.Economy;
import com.earth2me.essentials.api.IJails;
-import com.earth2me.essentials.commands.EssentialsCommand;
import com.earth2me.essentials.commands.IEssentialsCommand;
import com.earth2me.essentials.commands.NoChargeException;
import com.earth2me.essentials.commands.NotEnoughArgumentsException;
@@ -36,7 +35,6 @@
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -49,9 +47,12 @@
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginCommand;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.command.defaults.VanillaCommand;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.world.WorldLoadEvent;
@@ -62,12 +63,13 @@
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitTask;
import org.yaml.snakeyaml.error.YAMLException;
public class Essentials extends JavaPlugin implements IEssentials
{
- public static final int BUKKIT_VERSION = 2149;
+ public static final int BUKKIT_VERSION = 2754;
private static final Logger LOGGER = Logger.getLogger("Minecraft");
private transient ISettings settings;
private final transient TNTExplodeListener tntListener = new TNTExplodeListener(this);
@@ -86,6 +88,7 @@ public class Essentials extends JavaPlugin implements IEssentials
private transient Metrics metrics;
private transient EssentialsTimer timer;
private transient List vanishedPlayers = new ArrayList();
+ private transient SimpleCommandMap scm;
@Override
public ISettings getSettings()
@@ -124,6 +127,7 @@ public void onEnable()
i18n = new I18n(this);
i18n.onEnable();
execTimer.mark("I18n1");
+ scm = new SimpleCommandMap(this.getServer());
final PluginManager pm = getServer().getPluginManager();
for (Plugin plugin : pm.getPlugins())
{
@@ -178,6 +182,8 @@ public void onEnable()
itemDb = new ItemDb(this);
confList.add(itemDb);
execTimer.mark("Init(Worth/ItemDB)");
+ jails = new Jails(this);
+ confList.add(jails);
reload();
}
catch (YAMLException exception)
@@ -209,6 +215,40 @@ public void onPlayerJoin(final PlayerJoinEvent event)
backup = new Backup(this);
permissionsHandler = new PermissionsHandler(this, settings.useBukkitPermissions());
alternativeCommandsHandler = new AlternativeCommandsHandler(this);
+
+ timer = new EssentialsTimer(this);
+ scheduleSyncRepeatingTask(timer, 1000, 50);
+
+ Economy.setEss(this);
+ execTimer.mark("RegHandler");
+
+ final MetricsStarter metricsStarter = new MetricsStarter(this);
+ if (metricsStarter.getStart() != null && metricsStarter.getStart() == true)
+ {
+ runTaskLaterAsynchronously(metricsStarter, 1);
+ }
+ else if (metricsStarter.getStart() != null && metricsStarter.getStart() == false)
+ {
+ final MetricsListener metricsListener = new MetricsListener(this, metricsStarter);
+ pm.registerEvents(metricsListener, this);
+ }
+
+ final String timeroutput = execTimer.end();
+ if (getSettings().isDebug())
+ {
+ LOGGER.log(Level.INFO, "Essentials load " + timeroutput);
+ }
+ }
+
+ private void registerListeners(PluginManager pm)
+ {
+ HandlerList.unregisterAll(this);
+
+ if (getSettings().isDebug())
+ {
+ LOGGER.log(Level.INFO, "Registering Listeners");
+ }
+
final EssentialsPluginListener serverListener = new EssentialsPluginListener(this);
pm.registerEvents(serverListener, this);
confList.add(serverListener);
@@ -234,34 +274,9 @@ public void onPlayerJoin(final PlayerJoinEvent event)
final EssentialsWorldListener worldListener = new EssentialsWorldListener(this);
pm.registerEvents(worldListener, this);
- //TODO: Check if this should be here, and not above before reload()
- jails = new Jails(this);
- confList.add(jails);
-
pm.registerEvents(tntListener, this);
- timer = new EssentialsTimer(this);
- getScheduler().scheduleSyncRepeatingTask(this, timer, 100, 100);
-
- Economy.setEss(this);
- execTimer.mark("RegListeners");
-
- final MetricsStarter metricsStarter = new MetricsStarter(this);
- if (metricsStarter.getStart() != null && metricsStarter.getStart() == true)
- {
- getScheduler().scheduleAsyncDelayedTask(this, metricsStarter, 1);
- }
- else if (metricsStarter.getStart() != null && metricsStarter.getStart() == false)
- {
- final MetricsListener metricsListener = new MetricsListener(this, metricsStarter);
- pm.registerEvents(metricsListener, this);
- }
-
- final String timeroutput = execTimer.end();
- if (getSettings().isDebug())
- {
- LOGGER.log(Level.INFO, "Essentials load " + timeroutput);
- }
+ jails.resetListener();
}
@Override
@@ -276,7 +291,9 @@ public void onDisable()
p.sendMessage(_("unvanishedReload"));
}
}
+ cleanupOpenInventories();
i18n.onDisable();
+ backup.stopTask();
Economy.setEss(null);
Trade.closeLog();
}
@@ -293,6 +310,9 @@ public void reload()
}
i18n.updateLocale(settings.getLocale());
+
+ final PluginManager pm = getServer().getPluginManager();
+ registerListeners(pm);
}
@Override
@@ -310,7 +330,7 @@ public boolean onCommandEssentials(final CommandSender sender, final Command com
final PluginCommand pc = alternativeCommandsHandler.getAlternative(commandLabel);
if (pc != null)
{
- alternativeCommandsHandler.executed(commandLabel, pc.getLabel());
+ alternativeCommandsHandler.executed(commandLabel, pc);
try
{
return pc.execute(sender, commandLabel, args);
@@ -330,11 +350,10 @@ public boolean onCommandEssentials(final CommandSender sender, final Command com
if (sender instanceof Player)
{
user = getUser(sender);
- LOGGER.log(Level.INFO, String.format("[PLAYER_COMMAND] %s: /%s %s ", ((Player)sender).getName(), commandLabel, EssentialsCommand.getFinalArg(args, 0)));
}
// New mail notification
- if (user != null && !getSettings().isCommandDisabled("mail") && !commandLabel.equals("mail") && user.isAuthorized("essentials.mail"))
+ if (user != null && !getSettings().isCommandDisabled("mail") && !command.getName().equals("mail") && user.isAuthorized("essentials.mail"))
{
final List mail = user.getMails();
if (mail != null && !mail.isEmpty())
@@ -343,9 +362,26 @@ public boolean onCommandEssentials(final CommandSender sender, final Command com
}
}
+ //Print version even if admin command is not available
+ if (commandLabel.equalsIgnoreCase("essversion"))
+ {
+ sender.sendMessage("This server is running Essentials " + getDescription().getVersion());
+ return true;
+ }
+
// Check for disabled commands
if (getSettings().isCommandDisabled(commandLabel))
{
+ if (scm != null)
+ {
+ for (VanillaCommand cmd : scm.getFallbackCommands())
+ {
+ if (cmd.matches(commandLabel))
+ {
+ cmd.execute(sender, commandLabel, args);
+ }
+ }
+ }
return true;
}
@@ -371,6 +407,19 @@ public boolean onCommandEssentials(final CommandSender sender, final Command com
return true;
}
+ if (user != null && user.isJailed() && !user.isAuthorized(cmd, "essentials.jail.allow."))
+ {
+ if (user.getJailTimeout() > 0)
+ {
+ user.sendMessage(_("playerJailedFor", user.getName(), Util.formatDateDiff(user.getJailTimeout())));
+ }
+ else
+ {
+ user.sendMessage(_("jailMessage"));
+ }
+ return true;
+ }
+
// Run the command
try
{
@@ -411,6 +460,26 @@ public boolean onCommandEssentials(final CommandSender sender, final Command com
}
}
+ public void cleanupOpenInventories()
+ {
+ for (Player player : getServer().getOnlinePlayers())
+ {
+ User user = getUser(player);
+ if (user.isRecipeSee())
+ {
+ user.getPlayer().getOpenInventory().getTopInventory().clear();
+ user.getPlayer().getOpenInventory().close();
+ user.setRecipeSee(false);
+ }
+ if (user.isInvSee() || user.isEnderSee())
+ {
+ user.getPlayer().getOpenInventory().close();
+ user.setInvSee(false);
+ user.setEnderSee(false);
+ }
+ }
+ }
+
@Override
public void showError(final CommandSender sender, final Throwable exception, final String commandLabel)
{
@@ -470,16 +539,22 @@ public User getUser(final Object base)
}
if (base instanceof String)
{
- final User user = userMap.getUser((String)base);
- if (user != null && user.getBase() instanceof OfflinePlayer)
- {
- ((OfflinePlayer)user.getBase()).setName((String)base);
- }
- return user;
+ return getOfflineUser((String)base);
}
return null;
}
+ @Override
+ public User getOfflineUser(final String name)
+ {
+ final User user = userMap.getUser(name);
+ if (user != null && user.getBase() instanceof OfflinePlayer)
+ {
+ ((OfflinePlayer)user.getBase()).setName(name);
+ }
+ return user;
+ }
+
private User getUser(final T base)
{
if (base == null)
@@ -491,6 +566,13 @@ private User getUser(final T base)
{
return (User)base;
}
+
+ if (userMap == null)
+ {
+ LOGGER.log(Level.WARNING, "Essentials userMap not initialized");
+ return null;
+ }
+
User user = userMap.getUser(base.getName());
if (user == null)
@@ -504,17 +586,6 @@ private User getUser(final T base)
return user;
}
- @Override
- public User getOfflineUser(final String name)
- {
- final User user = userMap.getUser(name);
- if (user != null && user.getBase() instanceof OfflinePlayer)
- {
- ((OfflinePlayer)user.getBase()).setName(name);
- }
- return user;
- }
-
@Override
public World getWorld(final String name)
{
@@ -567,9 +638,15 @@ public int broadcastMessage(final IUser sender, final String message)
}
@Override
- public int scheduleAsyncDelayedTask(final Runnable run)
+ public BukkitTask runTaskAsynchronously(final Runnable run)
+ {
+ return this.getScheduler().runTaskAsynchronously(this, run);
+ }
+
+ @Override
+ public BukkitTask runTaskLaterAsynchronously(final Runnable run, final long delay)
{
- return this.getScheduler().scheduleAsyncDelayedTask(this, run);
+ return this.getScheduler().runTaskLaterAsynchronously(this, run, delay);
}
@Override
@@ -638,6 +715,7 @@ public List getVanishedPlayers()
return vanishedPlayers;
}
+
private static class EssentialsWorldListener implements Listener, Runnable
{
private transient final IEssentials ess;
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsBlockListener.java b/Essentials/src/com/earth2me/essentials/EssentialsBlockListener.java
index 0c6bec0fee..c5c35d9018 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsBlockListener.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsBlockListener.java
@@ -28,8 +28,7 @@ public void onBlockPlace(final BlockPlaceEvent event)
return;
}
final User user = ess.getUser(event.getPlayer());
- final boolean unlimitedForUser = user.hasUnlimited(is);
- if (unlimitedForUser && user.getGameMode() == GameMode.SURVIVAL)
+ if (user.hasUnlimited(is) && user.getGameMode() == GameMode.SURVIVAL)
{
ess.scheduleSyncDelayedTask(
new Runnable()
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsConf.java b/Essentials/src/com/earth2me/essentials/EssentialsConf.java
index b2cb1fd125..26f9d1c9da 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsConf.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsConf.java
@@ -5,43 +5,51 @@
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
-import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.World;
+import org.bukkit.*;
+import org.bukkit.OfflinePlayer;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
public class EssentialsConf extends YamlConfiguration
{
private static final Logger LOGGER = Logger.getLogger("Minecraft");
- private transient File configFile;
- private transient String templateName = null;
- private transient Class resourceClass = EssentialsConf.class;
+ private final File configFile;
+ private String templateName = null;
+ private Class resourceClass = EssentialsConf.class;
private static final Charset UTF8 = Charset.forName("UTF-8");
+ private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor();
+ private final AtomicInteger pendingDiskWrites = new AtomicInteger(0);
public EssentialsConf(final File configFile)
{
super();
- this.configFile = configFile;
+ this.configFile = configFile.getAbsoluteFile();
}
+ private final byte[] bytebuffer = new byte[1024];
public synchronized void load()
{
- configFile = configFile.getAbsoluteFile();
+ if (pendingDiskWrites.get() != 0)
+ {
+ LOGGER.log(Level.INFO, "File " + configFile + " not read, because it's not yet written to disk.");
+ return;
+ }
if (!configFile.getParentFile().exists())
{
if (!configFile.getParentFile().mkdirs())
@@ -94,18 +102,7 @@ public synchronized void load()
}
else
{
- try
- {
- LOGGER.log(Level.INFO, _("creatingEmptyConfig", configFile.toString()));
- if (!configFile.createNewFile())
- {
- LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
- }
- }
- catch (IOException ex)
- {
- LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()), ex);
- }
+ return;
}
}
@@ -115,9 +112,12 @@ public synchronized void load()
final FileInputStream inputStream = new FileInputStream(configFile);
try
{
- final FileChannel channel = inputStream.getChannel();
final ByteBuffer buffer = ByteBuffer.allocate((int)configFile.length());
- channel.read(buffer);
+ int length;
+ while ((length = inputStream.read(bytebuffer)) != -1)
+ {
+ buffer.put(bytebuffer, 0, length);
+ }
buffer.rewind();
final CharBuffer data = CharBuffer.allocate((int)configFile.length());
CharsetDecoder decoder = UTF8.newDecoder();
@@ -232,6 +232,148 @@ public void setTemplateName(final String templateName, final Class resClass)
this.resourceClass = resClass;
}
+ public void save()
+ {
+ try
+ {
+ save(configFile);
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+
+ public void saveWithError() throws IOException
+ {
+ save(configFile);
+ }
+
+ @Override
+ public synchronized void save(final File file) throws IOException
+ {
+ delayedSave(file);
+ }
+
+ public synchronized void forceSave()
+ {
+ try
+ {
+ Future future = delayedSave(configFile);
+ if (future != null)
+ {
+ future.get();
+ }
+ }
+ catch (InterruptedException ex)
+ {
+ LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ catch (ExecutionException ex)
+ {
+ LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+
+ private Future delayedSave(final File file)
+ {
+ //long startTime = System.nanoTime();
+ if (file == null)
+ {
+ throw new IllegalArgumentException("File cannot be null");
+ }
+
+ final String data = saveToString();
+
+ if (data.length() == 0)
+ {
+ return null;
+ }
+
+ pendingDiskWrites.incrementAndGet();
+
+ Future future = EXECUTOR_SERVICE.submit(new WriteRunner(configFile, data, pendingDiskWrites));
+
+ //LOGGER.log(Level.INFO, configFile + " prepared for writing in " + (System.nanoTime() - startTime) + " nsec.");
+
+ return future;
+ }
+
+
+ private static class WriteRunner implements Runnable
+ {
+ private final File configFile;
+ private final String data;
+ private final AtomicInteger pendingDiskWrites;
+
+ private WriteRunner(final File configFile, final String data, final AtomicInteger pendingDiskWrites)
+ {
+ this.configFile = configFile;
+ this.data = data;
+ this.pendingDiskWrites = pendingDiskWrites;
+ }
+
+ @Override
+ public void run()
+ {
+ //long startTime = System.nanoTime();
+ synchronized (configFile)
+ {
+ if (pendingDiskWrites.get() > 1)
+ {
+ // Writes can be skipped, because they are stored in a queue (in the executor).
+ // Only the last is actually written.
+ pendingDiskWrites.decrementAndGet();
+ //LOGGER.log(Level.INFO, configFile + " skipped writing in " + (System.nanoTime() - startTime) + " nsec.");
+ return;
+ }
+ try
+ {
+ Files.createParentDirs(configFile);
+
+ if (!configFile.exists())
+ {
+ try
+ {
+ LOGGER.log(Level.INFO, _("creatingEmptyConfig", configFile.toString()));
+ if (!configFile.createNewFile())
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
+ return;
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()), ex);
+ return;
+ }
+ }
+
+
+ final OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(configFile), UTF8);
+
+ try
+ {
+ writer.write(data);
+ }
+ finally
+ {
+ writer.close();
+ }
+ }
+ catch (IOException e)
+ {
+ LOGGER.log(Level.SEVERE, e.getMessage(), e);
+ }
+ finally
+ {
+ //LOGGER.log(Level.INFO, configFile + " written to disk in " + (System.nanoTime() - startTime) + " nsec.");
+ pendingDiskWrites.decrementAndGet();
+ }
+ }
+ }
+ }
+
public boolean hasProperty(final String path)
{
return isSet(path);
@@ -316,81 +458,297 @@ public void setProperty(final String path, final ItemStack stack)
set(path, map);
}
- public long getLong(final String path, final long def)
+ public void setProperty(String path, List object)
{
- try
- {
- final Number num = (Number)get(path);
- return num == null ? def : num.longValue();
- }
- catch (ClassCastException ex)
- {
- return def;
- }
+ set(path, new ArrayList(object));
+ }
+
+ public void setProperty(String path, Map object)
+ {
+ set(path, new LinkedHashMap(object));
+ }
+
+ public Object getProperty(String path)
+ {
+ return get(path);
+ }
+
+ public void setProperty(String path, Object object)
+ {
+ set(path, object);
+ }
+
+ public void removeProperty(String path)
+ {
+ set(path, null);
}
@Override
- public double getDouble(final String path, final double def)
+ public synchronized Object get(String path)
{
- try
- {
- Number num = (Number)get(path);
- return num == null ? def : num.doubleValue();
- }
- catch (ClassCastException ex)
- {
- return def;
- }
+ return super.get(path);
}
- public void save()
+ @Override
+ public synchronized Object get(String path, Object def)
{
- try
- {
- save(configFile);
- }
- catch (IOException ex)
- {
- LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
- }
+ return super.get(path, def);
}
@Override
- public synchronized void save(final File file) throws IOException
+ public synchronized boolean getBoolean(String path)
{
- if (file == null)
- {
- throw new IllegalArgumentException("File cannot be null");
- }
+ return super.getBoolean(path);
+ }
- Files.createParentDirs(file);
+ @Override
+ public synchronized boolean getBoolean(String path, boolean def)
+ {
+ return super.getBoolean(path, def);
+ }
- final String data = saveToString();
+ @Override
+ public synchronized List getBooleanList(String path)
+ {
+ return super.getBooleanList(path);
+ }
- final OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), UTF8);
+ @Override
+ public synchronized List getByteList(String path)
+ {
+ return super.getByteList(path);
+ }
- try
- {
- writer.write(data);
- }
- finally
- {
- writer.close();
- }
+ @Override
+ public synchronized List getCharacterList(String path)
+ {
+ return super.getCharacterList(path);
}
- public Object getProperty(String path)
+ @Override
+ public synchronized ConfigurationSection getConfigurationSection(String path)
{
- return get(path);
+ return super.getConfigurationSection(path);
}
- public void setProperty(String path, Object object)
+ @Override
+ public synchronized double getDouble(String path)
{
- set(path, object);
+ return super.getDouble(path);
}
- public void removeProperty(String path)
+ @Override
+ public synchronized double getDouble(final String path, final double def)
{
- set(path, null);
+ return super.getDouble(path, def);
+ }
+
+ @Override
+ public synchronized List getDoubleList(String path)
+ {
+ return super.getDoubleList(path);
+ }
+
+ @Override
+ public synchronized List getFloatList(String path)
+ {
+ return super.getFloatList(path);
+ }
+
+ @Override
+ public synchronized int getInt(String path)
+ {
+ return super.getInt(path);
+ }
+
+ @Override
+ public synchronized int getInt(String path, int def)
+ {
+ return super.getInt(path, def);
+ }
+
+ @Override
+ public synchronized List getIntegerList(String path)
+ {
+ return super.getIntegerList(path);
+ }
+
+ @Override
+ public synchronized ItemStack getItemStack(String path, ItemStack def)
+ {
+ return super.getItemStack(path, def);
+ }
+
+ @Override
+ public synchronized Set getKeys(boolean deep)
+ {
+ return super.getKeys(deep);
+ }
+
+ @Override
+ public synchronized List getList(String path)
+ {
+ return super.getList(path);
+ }
+
+ @Override
+ public synchronized List getList(String path, List def)
+ {
+ return super.getList(path, def);
+ }
+
+ @Override
+ public synchronized long getLong(String path)
+ {
+ return super.getLong(path);
+ }
+
+ @Override
+ public synchronized long getLong(final String path, final long def)
+ {
+ return super.getLong(path, def);
+ }
+
+ @Override
+ public synchronized List getLongList(String path)
+ {
+ return super.getLongList(path);
+ }
+
+ public synchronized Map getMap()
+ {
+ return map;
+ }
+
+ @Override
+ public synchronized List> getMapList(String path)
+ {
+ return super.getMapList(path);
+ }
+
+ @Override
+ public synchronized OfflinePlayer getOfflinePlayer(String path)
+ {
+ return super.getOfflinePlayer(path);
+ }
+
+ @Override
+ public synchronized OfflinePlayer getOfflinePlayer(String path, OfflinePlayer def)
+ {
+ return super.getOfflinePlayer(path, def);
+ }
+
+ @Override
+ public synchronized List getShortList(String path)
+ {
+ return super.getShortList(path);
+ }
+
+ @Override
+ public synchronized String getString(String path)
+ {
+ return super.getString(path);
+ }
+
+ @Override
+ public synchronized String getString(String path, String def)
+ {
+ return super.getString(path, def);
+ }
+
+ @Override
+ public synchronized List getStringList(String path)
+ {
+ return super.getStringList(path);
+ }
+
+ @Override
+ public synchronized Map getValues(boolean deep)
+ {
+ return super.getValues(deep);
+ }
+
+ @Override
+ public synchronized Vector getVector(String path)
+ {
+ return super.getVector(path);
+ }
+
+ @Override
+ public synchronized Vector getVector(String path, Vector def)
+ {
+ return super.getVector(path, def);
+ }
+
+ @Override
+ public synchronized boolean isBoolean(String path)
+ {
+ return super.isBoolean(path);
+ }
+
+ @Override
+ public synchronized boolean isConfigurationSection(String path)
+ {
+ return super.isConfigurationSection(path);
+ }
+
+ @Override
+ public synchronized boolean isDouble(String path)
+ {
+ return super.isDouble(path);
+ }
+
+ @Override
+ public synchronized boolean isInt(String path)
+ {
+ return super.isInt(path);
+ }
+
+ @Override
+ public synchronized boolean isItemStack(String path)
+ {
+ return super.isItemStack(path);
+ }
+
+ @Override
+ public synchronized boolean isList(String path)
+ {
+ return super.isList(path);
+ }
+
+ @Override
+ public synchronized boolean isLong(String path)
+ {
+ return super.isLong(path);
+ }
+
+ @Override
+ public synchronized boolean isOfflinePlayer(String path)
+ {
+ return super.isOfflinePlayer(path);
+ }
+
+ @Override
+ public synchronized boolean isSet(String path)
+ {
+ return super.isSet(path);
+ }
+
+ @Override
+ public synchronized boolean isString(String path)
+ {
+ return super.isString(path);
+ }
+
+ @Override
+ public synchronized boolean isVector(String path)
+ {
+ return super.isVector(path);
+ }
+
+ @Override
+ public synchronized void set(String path, Object value)
+ {
+ super.set(path, value);
}
}
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsEntityListener.java b/Essentials/src/com/earth2me/essentials/EssentialsEntityListener.java
index 19cfde0f4c..bb58067bc2 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsEntityListener.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsEntityListener.java
@@ -2,10 +2,11 @@
import static com.earth2me.essentials.I18n._;
import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
import org.bukkit.Material;
-import org.bukkit.entity.Ageable;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
+import org.bukkit.entity.*;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@@ -16,69 +17,105 @@
public class EssentialsEntityListener implements Listener
{
+ private static final Logger LOGGER = Logger.getLogger("Minecraft");
private final IEssentials ess;
+ private static final transient Pattern powertoolPlayer = Pattern.compile("\\{player\\}");
public EssentialsEntityListener(IEssentials ess)
{
this.ess = ess;
}
+ // This method does something undocumented reguarding certain bucket types #EasterEgg
@EventHandler(priority = EventPriority.LOW)
public void onEntityDamage(final EntityDamageByEntityEvent event)
{
final Entity eAttack = event.getDamager();
final Entity eDefend = event.getEntity();
- if (eDefend instanceof Player && eAttack instanceof Player)
+ if (eAttack instanceof Player)
{
- final User defender = ess.getUser(eDefend);
final User attacker = ess.getUser(eAttack);
-
- if (ess.getSettings().getLoginAttackDelay() > 0 && !attacker.isAuthorized("essentials.pvpdelay.exempt")
- && (System.currentTimeMillis() < (attacker.getLastLogin() + ess.getSettings().getLoginAttackDelay())))
+ if (eDefend instanceof Player)
{
- event.setCancelled(true);
+ onPlayerVsPlayerDamage(event, (Player)eDefend, attacker);
}
-
- if (attacker.hasInvulnerabilityAfterTeleport() || defender.hasInvulnerabilityAfterTeleport())
+ else if (eDefend instanceof Ageable)
{
- event.setCancelled(true);
+ final ItemStack hand = attacker.getItemInHand();
+ if (hand != null && hand.getType() == Material.MILK_BUCKET)
+ {
+ ((Ageable)eDefend).setBaby();
+ hand.setType(Material.BUCKET);
+ attacker.setItemInHand(hand);
+ attacker.updateInventory();
+ event.setCancelled(true);
+ }
}
-
attacker.updateActivity(true);
- final List commandList = attacker.getPowertool(attacker.getItemInHand());
- if (commandList != null && !commandList.isEmpty())
+ }
+ else if (eAttack instanceof Projectile && eDefend instanceof Player)
+ {
+ Entity shooter = ((Projectile)event.getDamager()).getShooter();
+ if (shooter instanceof Player)
{
- for (final String command : commandList)
- {
- if (command != null && !command.isEmpty())
- {
- ess.scheduleSyncDelayedTask(
- new Runnable()
- {
- @Override
- public void run()
- {
- attacker.getServer().dispatchCommand(attacker.getBase(), command.replaceAll("\\{player\\}", defender.getName()));
- }
- });
-
- event.setCancelled(true);
- return;
- }
- }
+ final User attacker = ess.getUser(shooter);
+ onPlayerVsPlayerDamage(event, (Player)eDefend, attacker);
+ attacker.updateActivity(true);
}
}
- else if (eDefend instanceof Ageable && eAttack instanceof Player)
+ }
+
+ private void onPlayerVsPlayerDamage(final EntityDamageByEntityEvent event, final Player defender, final User attacker)
+ {
+ if (ess.getSettings().getLoginAttackDelay() > 0
+ && (System.currentTimeMillis() < (attacker.getLastLogin() + ess.getSettings().getLoginAttackDelay()))
+ && !attacker.isAuthorized("essentials.pvpdelay.exempt"))
+ {
+ event.setCancelled(true);
+ }
+
+ if (!defender.equals(attacker.getBase()) && (attacker.hasInvulnerabilityAfterTeleport() || ess.getUser(defender).hasInvulnerabilityAfterTeleport()))
+ {
+ event.setCancelled(true);
+ }
+
+ if (attacker.isGodModeEnabled() && !attacker.isAuthorized("essentials.god.pvp"))
{
- final Player player = (Player)eAttack;
- final ItemStack hand = player.getItemInHand();
- if (hand != null && hand.getType() == Material.MILK_BUCKET)
+ event.setCancelled(true);
+ }
+
+ if (attacker.isHidden() && !attacker.isAuthorized("essentials.vanish.pvp"))
+ {
+ event.setCancelled(true);
+ }
+
+ onPlayerVsPlayerPowertool(event, defender, attacker);
+ }
+
+ private void onPlayerVsPlayerPowertool(final EntityDamageByEntityEvent event, final Player defender, final User attacker)
+ {
+ final List commandList = attacker.getPowertool(attacker.getItemInHand());
+ if (commandList != null && !commandList.isEmpty())
+ {
+ for (final String tempCommand : commandList)
{
- ((Ageable)eDefend).setBaby();
- hand.setType(Material.BUCKET);
- player.setItemInHand(hand);
- player.updateInventory();
- event.setCancelled(true);
+ final String command = powertoolPlayer.matcher(tempCommand).replaceAll(defender.getName());
+ if (command != null && !command.isEmpty() && !command.equals(tempCommand))
+ {
+ ess.scheduleSyncDelayedTask(
+ new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ attacker.getServer().dispatchCommand(attacker.getBase(), command);
+ LOGGER.log(Level.INFO, String.format("[PT] %s issued server command: /%s", attacker.getName(), command));
+ }
+ });
+
+ event.setCancelled(true);
+ return;
+ }
}
}
}
@@ -119,11 +156,25 @@ public void onPlayerDeathEvent(final PlayerDeathEvent event)
}
}
+ @EventHandler(priority = EventPriority.LOW)
+ public void onPlayerDeathExpEvent(final PlayerDeathEvent event)
+ {
+ final User user = ess.getUser(event.getEntity());
+ if (user.isAuthorized("essentials.keepxp"))
+ {
+ event.setKeepLevel(true);
+ event.setDroppedExp(0);
+ }
+ }
+
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onFoodLevelChange(final FoodLevelChangeEvent event)
{
if (event.getEntity() instanceof Player && ess.getUser(event.getEntity()).isGodModeEnabled())
{
+ final Player player = (Player)event.getEntity();
+ player.setFoodLevel(20);
+ player.setSaturation(10);
event.setCancelled(true);
}
}
@@ -137,4 +188,28 @@ public void onEntityRegainHealth(final EntityRegainHealthEvent event)
event.setCancelled(true);
}
}
+
+ @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+ public void onPotionSplashEvent(final PotionSplashEvent event)
+ {
+ for (LivingEntity entity : event.getAffectedEntities())
+ {
+ if (entity instanceof Player && ess.getUser(entity).isGodModeEnabled())
+ {
+ event.setIntensity(entity, 0d);
+ }
+ }
+ }
+ @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+ public void onEntityShootBow (EntityShootBowEvent event)
+ {
+ if (event.getEntity() instanceof Player)
+ {
+ final User user = ess.getUser(event.getEntity());
+ if (user.isAfk())
+ {
+ user.updateActivity(true);
+ }
+ }
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsPlayerListener.java b/Essentials/src/com/earth2me/essentials/EssentialsPlayerListener.java
index 369eb38085..ca90182527 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsPlayerListener.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsPlayerListener.java
@@ -6,14 +6,15 @@
import com.earth2me.essentials.textreader.TextInput;
import com.earth2me.essentials.textreader.TextPager;
import java.io.IOException;
-import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
import java.util.logging.Logger;
+import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
+import org.bukkit.World;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@@ -25,6 +26,7 @@
import org.bukkit.event.player.PlayerLoginEvent.Result;
import org.bukkit.event.player.*;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
@@ -50,7 +52,7 @@ public void onPlayerRespawn(final PlayerRespawnEvent event)
}
@EventHandler(priority = EventPriority.LOWEST)
- public void onPlayerChat(final PlayerChatEvent event)
+ public void onPlayerChat(final AsyncPlayerChatEvent event)
{
final User user = ess.getUser(event.getPlayer());
if (user.isMuted())
@@ -75,10 +77,20 @@ public void onPlayerChat(final PlayerChatEvent event)
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onPlayerMove(final PlayerMoveEvent event)
{
- if ((!ess.getSettings().cancelAfkOnMove() && !ess.getSettings().getFreezeAfkPlayers())
- || event.getFrom().getBlockX() == event.getTo().getBlockX()
- && event.getFrom().getBlockZ() == event.getTo().getBlockZ()
- && event.getFrom().getBlockY() == event.getTo().getBlockY())
+ if (!ess.getSettings().cancelAfkOnMove() && !ess.getSettings().getFreezeAfkPlayers())
+ {
+ event.getHandlers().unregister(this);
+
+ if (ess.getSettings().isDebug())
+ {
+ LOGGER.log(Level.INFO, "Unregistering move listener");
+ }
+
+ return;
+ }
+ if (event.getFrom().getBlockX() == event.getTo().getBlockX()
+ && event.getFrom().getBlockZ() == event.getTo().getBlockZ()
+ && event.getFrom().getBlockY() == event.getTo().getBlockY())
{
return;
}
@@ -87,7 +99,13 @@ public void onPlayerMove(final PlayerMoveEvent event)
if (user.isAfk() && ess.getSettings().getFreezeAfkPlayers())
{
final Location from = event.getFrom();
- final Location to = event.getTo().clone();
+ final Location origTo = event.getTo();
+ final Location to = origTo.clone();
+ if (ess.getSettings().cancelAfkOnMove() && origTo.getY() >= from.getBlockY() + 1)
+ {
+ user.updateActivity(true);
+ return;
+ }
to.setX(from.getX());
to.setY(from.getY());
to.setZ(from.getZ());
@@ -120,7 +138,11 @@ public void onPlayerQuit(final PlayerQuitEvent event)
{
user.toggleVanished();
}
- user.setLastLocation();
+ user.setLogoutLocation();
+ if (user.isRecipeSee())
+ {
+ user.getPlayer().getOpenInventory().getTopInventory().clear();
+ }
user.updateActivity(false);
user.dispose();
}
@@ -128,7 +150,7 @@ public void onPlayerQuit(final PlayerQuitEvent event)
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerJoin(final PlayerJoinEvent event)
{
- ess.scheduleAsyncDelayedTask(new Runnable()
+ ess.runTaskAsynchronously(new Runnable()
{
@Override
public void run()
@@ -144,62 +166,115 @@ public void delayedJoin(final Player player)
{
return;
}
+
ess.getBackup().onPlayerJoin();
final User user = ess.getUser(player);
- user.setDisplayNick();
- updateCompass(user);
- user.setLastLogin(System.currentTimeMillis());
- user.updateActivity(false);
- for (String p : ess.getVanishedPlayers())
+ if (user.isNPC())
{
- if (!user.isAuthorized("essentials.vanish.see"))
- {
- user.hidePlayer(ess.getUser(p).getBase());
- }
+ user.setNPC(false);
}
- if (user.isAuthorized("essentials.sleepingignored"))
- {
- user.setSleepingIgnored(true);
- }
+ final long currentTime = System.currentTimeMillis();
+ user.checkMuteTimeout(currentTime);
+ user.updateActivity(false);
- if (!ess.getSettings().isCommandDisabled("motd") && user.isAuthorized("essentials.motd"))
+ ess.scheduleSyncDelayedTask(new Runnable()
{
- try
- {
- final IText input = new TextInput(user, "motd", true, ess);
- final IText output = new KeywordReplacer(input, user, ess);
- final TextPager pager = new TextPager(output, true);
- pager.showPage("1", null, "motd", user);
- }
- catch (IOException ex)
+ @Override
+ public void run()
{
- if (ess.getSettings().isDebug())
+ if (!user.isOnline())
{
- LOGGER.log(Level.WARNING, ex.getMessage(), ex);
+ return;
}
- else
+
+ user.setLastLogin(currentTime);
+ user.setDisplayNick();
+ updateCompass(user);
+
+ if (!ess.getVanishedPlayers().isEmpty() && !user.isAuthorized("essentials.vanish.see"))
{
- LOGGER.log(Level.WARNING, ex.getMessage());
+ for (String p : ess.getVanishedPlayers())
+ {
+ Player toVanish = ess.getServer().getPlayerExact(p);
+ if (toVanish != null && toVanish.isOnline())
+ {
+ user.hidePlayer(toVanish);
+ }
+ }
}
- }
- }
- if (!ess.getSettings().isCommandDisabled("mail") && user.isAuthorized("essentials.mail"))
- {
- final List mail = user.getMails();
- if (mail.isEmpty())
- {
- user.sendMessage(_("noNewMail"));
- }
- else
- {
- user.sendMessage(_("youHaveNewMail", mail.size()));
+ if (user.isAuthorized("essentials.sleepingignored"))
+ {
+ user.setSleepingIgnored(true);
+ }
+
+ if (!ess.getSettings().isCommandDisabled("motd") && user.isAuthorized("essentials.motd"))
+ {
+ try
+ {
+ final IText input = new TextInput(user, "motd", true, ess);
+ final IText output = new KeywordReplacer(input, user, ess);
+ final TextPager pager = new TextPager(output, true);
+ pager.showPage("1", null, "motd", user);
+ }
+ catch (IOException ex)
+ {
+ if (ess.getSettings().isDebug())
+ {
+ LOGGER.log(Level.WARNING, ex.getMessage(), ex);
+ }
+ else
+ {
+ LOGGER.log(Level.WARNING, ex.getMessage());
+ }
+ }
+ }
+
+ if (!ess.getSettings().isCommandDisabled("mail") && user.isAuthorized("essentials.mail"))
+ {
+ final List mail = user.getMails();
+ if (mail.isEmpty())
+ {
+ final String msg = _("noNewMail");
+ if (!msg.isEmpty())
+ {
+ user.sendMessage(msg);
+ }
+ }
+ else
+ {
+ user.sendMessage(_("youHaveNewMail", mail.size()));
+ }
+ }
+
+ if (user.isAuthorized("essentials.fly.safelogin"))
+ {
+ final World world = user.getLocation().getWorld();
+ final int x = user.getLocation().getBlockX();
+ int y = user.getLocation().getBlockY();
+ final int z = user.getLocation().getBlockZ();
+ while (Util.isBlockUnsafe(world, x, y, z) && y > -1)
+ {
+ y--;
+ }
+
+ if (user.getLocation().getBlockY() - y > 1 || y < 0)
+ {
+ user.setAllowFlight(true);
+ user.setFlying(true);
+ user.sendMessage(_("flyMode", _("enabled"), user.getDisplayName()));
+ }
+ }
+ user.setFlySpeed(0.1f);
+ user.setWalkSpeed(0.2f);
+
}
- }
+ });
}
+ // Makes the compass item ingame always point to the first essentials home. #EasterEgg
private void updateCompass(final User user)
{
Location loc = user.getHome(user.getLocation());
@@ -210,14 +285,7 @@ private void updateCompass(final User user)
if (loc != null)
{
final Location updateLoc = loc;
- ess.scheduleSyncDelayedTask(new Runnable()
- {
- @Override
- public void run()
- {
- user.setCompassTarget(updateLoc);
- }
- });
+ user.setCompassTarget(updateLoc);
}
}
@@ -226,7 +294,6 @@ public void onPlayerLogin(final PlayerLoginEvent event)
{
switch (event.getResult())
{
- case ALLOWED:
case KICK_FULL:
case KICK_BANNED:
break;
@@ -235,21 +302,25 @@ public void onPlayerLogin(final PlayerLoginEvent event)
}
final User user = ess.getUser(event.getPlayer());
- if (user.isNPC())
- {
- user.setNPC(false);
- }
-
- final long currentTime = System.currentTimeMillis();
- final boolean banExpired = user.checkBanTimeout(currentTime);
- user.checkMuteTimeout(currentTime);
- user.checkJailTimeout(currentTime);
- if (!banExpired && (user.isBanned() || event.getResult() == Result.KICK_BANNED))
+ if (event.getResult() == Result.KICK_BANNED || user.isBanned())
{
- final String banReason = user.getBanReason();
- event.disallow(Result.KICK_BANNED, banReason != null && !banReason.isEmpty() && !banReason.equalsIgnoreCase("ban") ? banReason : _("defaultBanReason"));
- return;
+ final boolean banExpired = user.checkBanTimeout(System.currentTimeMillis());
+ if (!banExpired)
+ {
+ String banReason = user.getBanReason();
+ if (banReason == null || banReason.isEmpty() || banReason.equalsIgnoreCase("ban"))
+ {
+ banReason = _("defaultBanReason");
+ }
+ if (user.getBanTimeout() > 0)
+ {
+ //TODO: TL This
+ banReason += "\n\n" + "Expires in " + Util.formatDateDiff(user.getBanTimeout());
+ }
+ event.disallow(Result.KICK_BANNED, banReason);
+ return;
+ }
}
if (event.getResult() == Result.KICK_FULL && !user.isAuthorized("essentials.joinfullserver"))
@@ -309,14 +380,13 @@ public void run()
});
}
}
- private final static List COMMANDS = Arrays.asList("msg", "r", "mail", "m", "t", "whisper", "emsg", "tell", "er", "reply", "ereply", "email");
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event)
{
final Player player = event.getPlayer();
final String cmd = event.getMessage().toLowerCase(Locale.ENGLISH).split(" ")[0].replace("/", "").toLowerCase(Locale.ENGLISH);
- if (COMMANDS.contains(cmd))
+ if (ess.getSettings().getSocialSpyCommands().contains(cmd))
{
for (Player onlinePlayer : ess.getServer().getOnlinePlayers())
{
@@ -334,6 +404,18 @@ else if (!cmd.equalsIgnoreCase("afk"))
}
}
+ @EventHandler(priority = EventPriority.NORMAL)
+ public void onPlayerChangedWorldFlyReset(final PlayerChangedWorldEvent event)
+ {
+ final User user = ess.getUser(event.getPlayer());
+ if (user.getGameMode() != GameMode.CREATIVE && !user.isAuthorized("essentials.fly"))
+ {
+ user.setAllowFlight(false);
+ }
+ user.setFlySpeed(0.1f);
+ user.setWalkSpeed(0.2f);
+ }
+
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerChangedWorld(final PlayerChangedWorldEvent event)
{
@@ -346,10 +428,14 @@ public void onPlayerChangedWorld(final PlayerChangedWorldEvent event)
user.sendMessage(_("noGodWorldWarning"));
}
- if (!event.getPlayer().getWorld().getName().equals(newWorld))
+ if (!user.getWorld().getName().equals(newWorld))
{
user.sendMessage(_("currentWorld", newWorld));
}
+ if (user.isVanished())
+ {
+ user.setVanished(user.isAuthorized("essentials.vanish"));
+ }
}
@EventHandler(priority = EventPriority.NORMAL)
@@ -360,16 +446,29 @@ public void onPlayerInteract(final PlayerInteractEvent event)
case RIGHT_CLICK_BLOCK:
if (!event.isCancelled() && event.getClickedBlock().getTypeId() == BED && ess.getSettings().getUpdateBedAtDaytime())
{
- Player player = event.getPlayer();
- player.setBedSpawnLocation(event.getClickedBlock().getLocation());
- player.sendMessage(_("homeSet", player.getLocation().getWorld().getName(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()));
+ User player = ess.getUser(event.getPlayer());
+ if (player.isAuthorized("essentials.sethome.bed"))
+ {
+ player.setBedSpawnLocation(event.getClickedBlock().getLocation());
+ player.sendMessage(_("bedSet", player.getLocation().getWorld().getName(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()));
+ }
}
break;
case LEFT_CLICK_AIR:
+ if (event.getPlayer().isFlying())
+ {
+ final User user = ess.getUser(event.getPlayer());
+ if (user.isFlyClickJump())
+ {
+ useFlyClickJump(user);
+ return;
+ }
+ }
case LEFT_CLICK_BLOCK:
if (event.getItem() != null && event.getItem().getTypeId() != AIR)
{
final User user = ess.getUser(event.getPlayer());
+ user.updateActivity(true);
if (user.hasPowerTools() && user.arePowerToolsEnabled() && usePowertools(user, event.getItem().getTypeId()))
{
event.setCancelled(true);
@@ -381,6 +480,39 @@ public void onPlayerInteract(final PlayerInteractEvent event)
}
}
+ // This method allows the /jump lock feature to work, allows teleporting while flying #EasterEgg
+ private void useFlyClickJump(final User user)
+ {
+ try
+ {
+ final Location otarget = Util.getTarget(user);
+
+ ess.scheduleSyncDelayedTask(
+ new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ Location loc = user.getLocation();
+ loc.setX(otarget.getX());
+ loc.setZ(otarget.getZ());
+ while (Util.isBlockDamaging(loc.getWorld(), loc.getBlockX(), loc.getBlockY() - 1, loc.getBlockZ()))
+ {
+ loc.setY(loc.getY() + 1d);
+ }
+ user.getBase().teleport(loc, TeleportCause.PLUGIN);
+ }
+ });
+ }
+ catch (Exception ex)
+ {
+ if (ess.getSettings().isDebug())
+ {
+ LOGGER.log(Level.WARNING, ex.getMessage(), ex);
+ }
+ }
+ }
+
private boolean usePowertools(final User user, final int id)
{
final List commandList = user.getPowertool(id);
@@ -411,6 +543,7 @@ else if (command.startsWith("c:"))
public void run()
{
user.getServer().dispatchCommand(user.getBase(), command);
+ LOGGER.log(Level.INFO, String.format("[PT] %s issued server command: /%s", user.getName(), command));
}
});
}
@@ -430,13 +563,16 @@ public void onPlayerPickupItem(final PlayerPickupItemEvent event)
}
}
- @EventHandler(priority = EventPriority.LOWEST)
+ @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onInventoryClickEvent(final InventoryClickEvent event)
{
- if (event.getView().getTopInventory().getType() == InventoryType.PLAYER)
+ final Inventory top = event.getView().getTopInventory();
+ final InventoryType type = top.getType();
+
+ if (type == InventoryType.PLAYER)
{
final User user = ess.getUser(event.getWhoClicked());
- final InventoryHolder invHolder = event.getView().getTopInventory().getHolder();
+ final InventoryHolder invHolder = top.getHolder();
if (invHolder != null && invHolder instanceof HumanEntity)
{
final User invOwner = ess.getUser((HumanEntity)invHolder);
@@ -445,18 +581,76 @@ public void onInventoryClickEvent(final InventoryClickEvent event)
|| !invOwner.isOnline()))
{
event.setCancelled(true);
+ user.updateInventory();
}
}
}
+ else if (type == InventoryType.ENDER_CHEST)
+ {
+ final User user = ess.getUser(event.getWhoClicked());
+ if (user.isEnderSee() && (!user.isAuthorized("essentials.enderchest.modify")))
+ {
+ event.setCancelled(true);
+ }
+ }
+ else if (type == InventoryType.WORKBENCH)
+ {
+ User user = ess.getUser(event.getWhoClicked());
+ if (user.isRecipeSee())
+ {
+ event.setCancelled(true);
+ }
+ }
+ else if (type == InventoryType.CHEST && top.getSize() == 9)
+ {
+ final User user = ess.getUser(event.getWhoClicked());
+ final InventoryHolder invHolder = top.getHolder();
+ if (invHolder != null && invHolder instanceof HumanEntity && user.isInvSee())
+ {
+ event.setCancelled(true);
+ }
+ }
}
@EventHandler(priority = EventPriority.MONITOR)
public void onInventoryCloseEvent(final InventoryCloseEvent event)
{
- if (event.getView().getTopInventory().getType() == InventoryType.PLAYER)
+ final Inventory top = event.getView().getTopInventory();
+ final InventoryType type = top.getType();
+ if (type == InventoryType.PLAYER)
{
final User user = ess.getUser(event.getPlayer());
user.setInvSee(false);
}
+ else if (type == InventoryType.ENDER_CHEST)
+ {
+ final User user = ess.getUser(event.getPlayer());
+ user.setEnderSee(false);
+ }
+ else if (type == InventoryType.WORKBENCH)
+ {
+ final User user = ess.getUser(event.getPlayer());
+ if (user.isRecipeSee())
+ {
+ user.setRecipeSee(false);
+ event.getView().getTopInventory().clear();
+ }
+ }
+ else if (type == InventoryType.CHEST && top.getSize() == 9)
+ {
+ final InventoryHolder invHolder = top.getHolder();
+ if (invHolder != null && invHolder instanceof HumanEntity)
+ {
+ final User user = ess.getUser(event.getPlayer());
+ user.setInvSee(false);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+ public void onPlayerFishEvent(final PlayerFishEvent event)
+ {
+ final User user = ess.getUser(event.getPlayer());
+ user.updateActivity(true);
}
}
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsPluginListener.java b/Essentials/src/com/earth2me/essentials/EssentialsPluginListener.java
index 2ec8538ca1..c25233bcc4 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsPluginListener.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsPluginListener.java
@@ -1,6 +1,7 @@
package com.earth2me.essentials;
import java.util.logging.Level;
+import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@@ -11,7 +12,7 @@
public class EssentialsPluginListener implements Listener, IConf
{
private final transient IEssentials ess;
-
+
public EssentialsPluginListener(final IEssentials ess)
{
this.ess = ess;
@@ -20,17 +21,25 @@ public EssentialsPluginListener(final IEssentials ess)
@EventHandler(priority = EventPriority.MONITOR)
public void onPluginEnable(final PluginEnableEvent event)
{
+ if (event.getPlugin().getName().equals("EssentialsChat"))
+ {
+ ess.getSettings().setEssentialsChatActive(true);
+ }
ess.getPermissionsHandler().checkPermissions();
ess.getAlternativeCommandsHandler().addPlugin(event.getPlugin());
if (!ess.getPaymentMethod().hasMethod() && ess.getPaymentMethod().setMethod(ess.getServer().getPluginManager()))
{
ess.getLogger().log(Level.INFO, "Payment method found (" + ess.getPaymentMethod().getMethod().getLongName() + " version: " + ess.getPaymentMethod().getMethod().getVersion() + ")");
}
- }
+ }
@EventHandler(priority = EventPriority.MONITOR)
public void onPluginDisable(final PluginDisableEvent event)
{
+ if (event.getPlugin().getName().equals("EssentialsChat"))
+ {
+ ess.getSettings().setEssentialsChatActive(false);
+ }
ess.getPermissionsHandler().checkPermissions();
ess.getAlternativeCommandsHandler().removePlugin(event.getPlugin());
// Check to see if the plugin thats being disabled is the one we are using
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsTimer.java b/Essentials/src/com/earth2me/essentials/EssentialsTimer.java
index 95cf77521d..38c42e9184 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsTimer.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsTimer.java
@@ -12,8 +12,12 @@ public class EssentialsTimer implements Runnable
{
private final transient IEssentials ess;
private final transient Set onlineUsers = new HashSet();
- private transient long lastPoll = System.currentTimeMillis();
- private final transient LinkedList history = new LinkedList();
+ private transient long lastPoll = System.nanoTime();
+ private final LinkedList history = new LinkedList();
+ private int skip1 = 0;
+ private int skip2 = 0;
+ private final long maxTime = 10 * 1000000;
+ private final long tickInterval = 50;
EssentialsTimer(final IEssentials ess)
{
@@ -23,8 +27,9 @@ public class EssentialsTimer implements Runnable
@Override
public void run()
{
+ final long startTime = System.nanoTime();
final long currentTime = System.currentTimeMillis();
- long timeSpent = (currentTime - lastPoll) / 1000;
+ long timeSpent = (startTime - lastPoll) / 1000;
if (timeSpent == 0)
{
timeSpent = 1;
@@ -33,14 +38,29 @@ public void run()
{
history.remove();
}
- float tps = 100f / timeSpent;
+ double tps = tickInterval * 1000000.0 / timeSpent;
if (tps <= 20)
{
history.add(tps);
}
- lastPoll = currentTime;
+ lastPoll = startTime;
+ int count = 0;
for (Player player : ess.getServer().getOnlinePlayers())
{
+ count++;
+ if (skip1 > 0)
+ {
+ skip1--;
+ continue;
+ }
+ if (count % 10 == 0)
+ {
+ if (System.nanoTime() - startTime > maxTime / 2)
+ {
+ skip1 = count - 1;
+ break;
+ }
+ }
try
{
final User user = ess.getUser(player);
@@ -54,9 +74,24 @@ public void run()
}
}
+ count = 0;
final Iterator iterator = onlineUsers.iterator();
while (iterator.hasNext())
{
+ count++;
+ if (skip2 > 0)
+ {
+ skip2--;
+ continue;
+ }
+ if (count % 10 == 0)
+ {
+ if (System.nanoTime() - startTime > maxTime)
+ {
+ skip2 = count - 1;
+ break;
+ }
+ }
final User user = iterator.next();
if (user.getLastOnlineActivity() < currentTime && user.getLastOnlineActivity() > user.getLastLogout())
{
@@ -70,10 +105,10 @@ public void run()
}
}
- public float getAverageTPS()
+ public double getAverageTPS()
{
- float avg = 0;
- for (Float f : history)
+ double avg = 0;
+ for (Double f : history)
{
if (f != null)
{
diff --git a/Essentials/src/com/earth2me/essentials/EssentialsUpgrade.java b/Essentials/src/com/earth2me/essentials/EssentialsUpgrade.java
index bc0de9fa40..60b23a8c87 100644
--- a/Essentials/src/com/earth2me/essentials/EssentialsUpgrade.java
+++ b/Essentials/src/com/earth2me/essentials/EssentialsUpgrade.java
@@ -1,9 +1,9 @@
package com.earth2me.essentials;
+import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.craftbukkit.FakeWorld;
import com.earth2me.essentials.settings.Spawns;
import com.earth2me.essentials.storage.YamlStorageWriter;
-import static com.earth2me.essentials.I18n._;
import java.io.*;
import java.math.BigInteger;
import java.security.DigestInputStream;
@@ -230,7 +230,7 @@ private void updateUsersToNewDefaultHome()
config.removeProperty("home");
config.setProperty("home.default", worldName);
config.setProperty("home.worlds." + worldName, loc);
- config.save();
+ config.forceSave();
}
}
}
@@ -285,7 +285,7 @@ private void updateUsersPowerToolsFormat()
((Map)powertools).put(entry.getKey(), temp);
}
}
- config.save();
+ config.forceSave();
}
}
catch (RuntimeException ex)
@@ -358,7 +358,7 @@ private void updateUsersHomesFormat()
}
}
config.removeProperty("home");
- config.save();
+ config.forceSave();
}
}
diff --git a/Essentials/src/com/earth2me/essentials/I18n.java b/Essentials/src/com/earth2me/essentials/I18n.java
index 97d500a6a9..b2ae6a73a7 100644
--- a/Essentials/src/com/earth2me/essentials/I18n.java
+++ b/Essentials/src/com/earth2me/essentials/I18n.java
@@ -43,6 +43,7 @@ public void onDisable()
instance = null;
}
+ @Override
public Locale getCurrentLocale()
{
return currentLocale;
@@ -70,7 +71,8 @@ public String translate(final String string)
public static String _(final String string, final Object... objects)
{
- if (instance == null) {
+ if (instance == null)
+ {
return "";
}
if (objects.length == 0)
@@ -85,11 +87,20 @@ public static String _(final String string, final Object... objects)
public String format(final String string, final Object... objects)
{
- final String format = translate(string);
+ String format = translate(string);
MessageFormat messageFormat = messageFormatCache.get(format);
if (messageFormat == null)
{
- messageFormat = new MessageFormat(format);
+ try
+ {
+ messageFormat = new MessageFormat(format);
+ }
+ catch (IllegalArgumentException e)
+ {
+ ess.getLogger().log(Level.SEVERE, "Invalid Translation key for '" + string + "': " + e.getMessage());
+ format = format.replaceAll("\\{(\\D*?)\\}", "\\[$1\\]");
+ messageFormat = new MessageFormat(format);
+ }
messageFormatCache.put(format, messageFormat);
}
return messageFormat.format(objects);
@@ -133,7 +144,7 @@ private static class FileResClassLoader extends ClassLoader
{
private final transient File dataFolder;
- public FileResClassLoader(final ClassLoader classLoader, final IEssentials ess)
+ FileResClassLoader(final ClassLoader classLoader, final IEssentials ess)
{
super(classLoader);
this.dataFolder = ess.getDataFolder();
diff --git a/Essentials/src/com/earth2me/essentials/IConf.java b/Essentials/src/com/earth2me/essentials/IConf.java
index 580e6232f5..600c7ed48a 100644
--- a/Essentials/src/com/earth2me/essentials/IConf.java
+++ b/Essentials/src/com/earth2me/essentials/IConf.java
@@ -1,9 +1,6 @@
package com.earth2me.essentials;
-/**
- * @deprecated New interface will be IReload in api package
- */
-@Deprecated
-public interface IConf {
+public interface IConf
+{
public void reloadConfig();
}
diff --git a/Essentials/src/com/earth2me/essentials/IEssentials.java b/Essentials/src/com/earth2me/essentials/IEssentials.java
index f12798db36..35efd61932 100644
--- a/Essentials/src/com/earth2me/essentials/IEssentials.java
+++ b/Essentials/src/com/earth2me/essentials/IEssentials.java
@@ -10,12 +10,9 @@
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitTask;
-/**
- * @deprecated This will be moved to the api package soon
- */
-@Deprecated
public interface IEssentials extends Plugin
{
void addReloadListener(IConf listener);
@@ -48,7 +45,9 @@ public interface IEssentials extends Plugin
Methods getPaymentMethod();
- int scheduleAsyncDelayedTask(Runnable run);
+ BukkitTask runTaskAsynchronously(Runnable run);
+
+ BukkitTask runTaskLaterAsynchronously(Runnable run, long delay);
int scheduleSyncDelayedTask(Runnable run);
diff --git a/Essentials/src/com/earth2me/essentials/IReplyTo.java b/Essentials/src/com/earth2me/essentials/IReplyTo.java
index 5bef5fced4..429fd75840 100644
--- a/Essentials/src/com/earth2me/essentials/IReplyTo.java
+++ b/Essentials/src/com/earth2me/essentials/IReplyTo.java
@@ -2,8 +2,17 @@
import org.bukkit.command.CommandSender;
-public interface IReplyTo {
+public interface IReplyTo
+{
+ /**
+ * Sets the user to reply to
+ * @param user
+ */
public void setReplyTo(CommandSender user);
+ /**
+ * Gets the user the sender should reply to
+ * @return
+ */
public CommandSender getReplyTo();
}
diff --git a/Essentials/src/com/earth2me/essentials/ISettings.java b/Essentials/src/com/earth2me/essentials/ISettings.java
index 71fc7f5dd8..be75ef50d5 100644
--- a/Essentials/src/com/earth2me/essentials/ISettings.java
+++ b/Essentials/src/com/earth2me/essentials/ISettings.java
@@ -42,6 +42,8 @@ public interface ISettings extends IConf
double getHealCooldown();
+ Set getSocialSpyCommands();
+
Map getKit(String name);
ConfigurationSection getKits();
@@ -74,8 +76,6 @@ public interface ISettings extends IConf
int getHomeLimit(User user);
- boolean getSortListByGroups();
-
int getSpawnMobLimit();
int getStartingBalance();
@@ -92,10 +92,6 @@ public interface ISettings extends IConf
boolean isCommandOverridden(String name);
- boolean isCommandRestricted(IEssentialsCommand cmd);
-
- boolean isCommandRestricted(String label);
-
boolean isDebug();
boolean isEcoDisabled();
@@ -110,8 +106,6 @@ public interface ISettings extends IConf
boolean showNonEssCommandsInHelp();
- boolean spawnIfNoHome();
-
boolean warnOnBuildDisallow();
boolean warnOnSmite();
@@ -147,6 +141,8 @@ public interface ISettings extends IConf
boolean getFreezeAfkPlayers();
boolean cancelAfkOnMove();
+
+ boolean cancelAfkOnInteract();
boolean areDeathMessagesEnabled();
@@ -155,11 +151,13 @@ public interface ISettings extends IConf
Set getNoGodWorlds();
boolean getUpdateBedAtDaytime();
+
+ boolean allowUnsafeEnchantments();
boolean getRepairEnchanted();
boolean isWorldTeleportPermissions();
-
+
boolean isWorldHomePermissions();
boolean registerBackInListener();
@@ -177,8 +175,20 @@ public interface ISettings extends IConf
long getTeleportInvulnerability();
boolean isTeleportInvulnerability();
-
+
long getLoginAttackDelay();
-
+
int getSignUsePerSecond();
+
+ double getMaxFlySpeed();
+
+ double getMaxWalkSpeed();
+
+ public int getMailsPerMinute();
+
+ public void setEssentialsChatActive(boolean b);
+
+ long getMaxTempban();
+
+ public Map getListGroupConfig();
}
diff --git a/Essentials/src/com/earth2me/essentials/IUser.java b/Essentials/src/com/earth2me/essentials/IUser.java
index bfa9ed146e..00c4f328f8 100644
--- a/Essentials/src/com/earth2me/essentials/IUser.java
+++ b/Essentials/src/com/earth2me/essentials/IUser.java
@@ -1,14 +1,12 @@
package com.earth2me.essentials;
import com.earth2me.essentials.commands.IEssentialsCommand;
+import java.util.Map;
+import java.util.Set;
import org.bukkit.Location;
import org.bukkit.entity.Player;
-/**
- * @deprecated This will be moved to the api package soon
- */
-@Deprecated
public interface IUser extends Player
{
long getLastTeleportTimestamp();
@@ -46,4 +44,22 @@ public interface IUser extends Player
Teleport getTeleport();
void setJail(String jail);
+
+ boolean isIgnoreExempt();
+
+ boolean isAfk();
+
+ void setAfk(final boolean set);
+
+ void setLogoutLocation();
+
+ Location getLogoutLocation();
+
+ void setConfigProperty(String node, Object object);
+
+ Set getConfigKeys();
+
+ Map getConfigMap();
+
+ Map getConfigMap(String node);
}
diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java
index e3df50bab3..a79685bb51 100644
--- a/Essentials/src/com/earth2me/essentials/ItemDb.java
+++ b/Essentials/src/com/earth2me/essentials/ItemDb.java
@@ -1,11 +1,9 @@
package com.earth2me.essentials;
-import com.earth2me.essentials.api.IItemDb;
import static com.earth2me.essentials.I18n._;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
+import com.earth2me.essentials.api.IItemDb;
+import java.util.*;
+import java.util.regex.Pattern;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
@@ -20,8 +18,10 @@ public ItemDb(final IEssentials ess)
file = new ManagedFile("items.csv", ess);
}
private final transient Map items = new HashMap();
+ private final transient Map> names = new HashMap>();
private final transient Map durabilities = new HashMap();
private final transient ManagedFile file;
+ private final transient Pattern splitPattern = Pattern.compile("[:+',;.]");
@Override
public void reloadConfig()
@@ -35,6 +35,7 @@ public void reloadConfig()
durabilities.clear();
items.clear();
+ names.clear();
for (String line : lines)
{
@@ -51,9 +52,25 @@ public void reloadConfig()
}
final int numeric = Integer.parseInt(parts[1]);
+ final short data = parts.length > 2 && !parts[2].equals("0") ? Short.parseShort(parts[2]) : 0;
+ String itemName = parts[0].toLowerCase(Locale.ENGLISH);
- durabilities.put(parts[0].toLowerCase(Locale.ENGLISH), parts.length > 2 && !parts[2].equals("0") ? Short.parseShort(parts[2]) : 0);
- items.put(parts[0].toLowerCase(Locale.ENGLISH), numeric);
+ durabilities.put(itemName, data);
+ items.put(itemName, numeric);
+
+ ItemData itemData = new ItemData(numeric, data);
+ if (names.containsKey(itemData))
+ {
+ List nameList = names.get(itemData);
+ nameList.add(itemName);
+ Collections.sort(nameList, new LengthCompare());
+ }
+ else
+ {
+ List nameList = new ArrayList();
+ nameList.add(itemName);
+ names.put(itemData, nameList);
+ }
}
}
@@ -69,19 +86,20 @@ public ItemStack get(final String id) throws Exception
int itemid = 0;
String itemname = null;
short metaData = 0;
+ String[] parts = splitPattern.split(id);;
if (id.matches("^\\d+[:+',;.]\\d+$"))
{
- itemid = Integer.parseInt(id.split("[:+',;.]")[0]);
- metaData = Short.parseShort(id.split("[:+',;.]")[1]);
+ itemid = Integer.parseInt(parts[0]);
+ metaData = Short.parseShort(parts[1]);
}
- else if (id.matches("^\\d+$"))
+ else if (Util.isInt(id))
{
itemid = Integer.parseInt(id);
}
else if (id.matches("^[^:+',;.]+[:+',;.]\\d+$"))
{
- itemname = id.split("[:+',;.]")[0].toLowerCase(Locale.ENGLISH);
- metaData = Short.parseShort(id.split("[:+',;.]")[1]);
+ itemname = parts[0].toLowerCase(Locale.ENGLISH);
+ metaData = Short.parseShort(parts[1]);
}
else
{
@@ -98,9 +116,9 @@ else if (id.matches("^\\d+$"))
metaData = durabilities.get(itemname);
}
}
- else if (Material.getMaterial(itemname) != null)
+ else if (Material.getMaterial(itemname.toUpperCase(Locale.ENGLISH)) != null)
{
- itemid = Material.getMaterial(itemname).getId();
+ itemid = Material.getMaterial(itemname.toUpperCase(Locale.ENGLISH)).getId();
metaData = 0;
}
else
@@ -119,4 +137,85 @@ else if (Material.getMaterial(itemname) != null)
retval.setDurability(metaData);
return retval;
}
+
+ public String names(ItemStack item)
+ {
+ ItemData itemData = new ItemData(item.getTypeId(), item.getDurability());
+ List nameList = names.get(itemData);
+ if (nameList == null)
+ {
+ itemData = new ItemData(item.getTypeId(), (short)0);
+ nameList = names.get(itemData);
+ if (nameList == null)
+ {
+ return null;
+ }
+ }
+
+ if (nameList.size() > 15)
+ {
+ nameList = nameList.subList(0, 14);
+ }
+ return Util.joinList(", ", nameList);
+ }
+
+
+ class ItemData
+ {
+ final private int itemNo;
+ final private short itemData;
+
+ ItemData(final int itemNo, final short itemData)
+ {
+ this.itemNo = itemNo;
+ this.itemData = itemData;
+ }
+
+ public int getItemNo()
+ {
+ return itemNo;
+ }
+
+ public short getItemData()
+ {
+ return itemData;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return (31 * itemNo) ^ itemData;
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ if (o == null)
+ {
+ return false;
+ }
+ if (!(o instanceof ItemData))
+ {
+ return false;
+ }
+ ItemData pairo = (ItemData)o;
+ return this.itemNo == pairo.getItemNo()
+ && this.itemData == pairo.getItemData();
+ }
+ }
+
+
+ class LengthCompare implements java.util.Comparator
+ {
+ public LengthCompare()
+ {
+ super();
+ }
+
+ @Override
+ public int compare(String s1, String s2)
+ {
+ return s1.length() - s2.length();
+ }
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/Jails.java b/Essentials/src/com/earth2me/essentials/Jails.java
index 0aa90e08cf..4cffb125b8 100644
--- a/Essentials/src/com/earth2me/essentials/Jails.java
+++ b/Essentials/src/com/earth2me/essentials/Jails.java
@@ -44,6 +44,10 @@ private void registerListeners()
final PluginManager pluginManager = ess.getServer().getPluginManager();
final JailListener blockListener = new JailListener();
pluginManager.registerEvents(blockListener, ess);
+ if (ess.getSettings().isDebug())
+ {
+ LOGGER.log(Level.INFO, "Registering Jail listener");
+ }
}
@Override
@@ -55,16 +59,24 @@ public File getStorageFile()
@Override
public void finishRead()
{
- if (enabled == false && getCount() > 0)
- {
- registerListeners();
- }
+ checkRegister();
}
@Override
public void finishWrite()
{
- if (enabled == false)
+ checkRegister();
+ }
+
+ public void resetListener()
+ {
+ enabled = false;
+ checkRegister();
+ }
+
+ private void checkRegister()
+ {
+ if (enabled == false && getCount() > 0)
{
registerListeners();
}
@@ -298,6 +310,8 @@ public void onPlayerTeleport(final PlayerTeleportEvent event)
public void onPlayerJoin(final PlayerJoinEvent event)
{
final User user = ess.getUser(event.getPlayer());
+ final long currentTime = System.currentTimeMillis();
+ user.checkJailTimeout(currentTime);
if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty())
{
return;
diff --git a/Essentials/src/com/earth2me/essentials/Kit.java b/Essentials/src/com/earth2me/essentials/Kit.java
index 5a907beb3a..571787384b 100644
--- a/Essentials/src/com/earth2me/essentials/Kit.java
+++ b/Essentials/src/com/earth2me/essentials/Kit.java
@@ -4,11 +4,12 @@
import static com.earth2me.essentials.I18n.capitalCase;
import com.earth2me.essentials.commands.NoChargeException;
import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.textreader.IText;
+import com.earth2me.essentials.textreader.KeywordReplacer;
+import com.earth2me.essentials.textreader.SimpleTextInput;
import java.util.*;
import java.util.logging.Level;
-import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
@@ -23,7 +24,7 @@ public static String listKits(final IEssentials ess, final User user) throws Exc
final StringBuilder list = new StringBuilder();
for (String kiteItem : kits.getKeys(false))
{
- if (user == null || user.isAuthorized("essentials.kit." + kiteItem.toLowerCase(Locale.ENGLISH)))
+ if (user == null || user.isAuthorized("essentials.kits." + kiteItem.toLowerCase(Locale.ENGLISH)))
{
list.append(" ").append(capitalCase(kiteItem));
}
@@ -37,12 +38,17 @@ public static String listKits(final IEssentials ess, final User user) throws Exc
}
- public static void checkTime(final User user, final String kitName, final Map els) throws NoChargeException
+ public static void checkTime(final User user, final String kitName, final Map els) throws Exception
{
+ if (user.isAuthorized("essentials.kit.exemptdelay"))
+ {
+ return;
+ }
+
final Calendar time = new GregorianCalendar();
// Take the current time, and remove the delay from it.
- final double delay = els.containsKey("delay") ? ((Number)els.get("delay")).doubleValue() : 0L;
+ final double delay = els.containsKey("delay") ? ((Number)els.get("delay")).doubleValue() : 0.0d;
final Calendar earliestTime = new GregorianCalendar();
earliestTime.add(Calendar.SECOND, -(int)delay);
earliestTime.add(Calendar.MILLISECOND, -(int)((delay * 1000.0) % 1000.0));
@@ -50,9 +56,9 @@ public static void checkTime(final User user, final String kitName, final Map time.getTimeInMillis())
// If this happens, let's give the user the benifit of the doubt.
user.setKitTimestamp(kitName, time.getTimeInMillis());
}
+ else if (earliestLong < 0L)
+ {
+ user.sendMessage(_("kitOnce"));
+ throw new NoChargeException();
+ }
else
{
time.setTimeInMillis(lastTime);
@@ -76,7 +87,7 @@ public static List getItems(final User user, final Map k
{
if (kit == null)
{
- throw new Exception(_("kitError2"));
+ throw new Exception(_("kitNotFound"));
}
try
@@ -94,58 +105,39 @@ public static void expandItems(final IEssentials ess, final User user, final Lis
{
try
{
+ IText input = new SimpleTextInput(items);
+ IText output = new KeywordReplacer(input, user, ess);
+
boolean spew = false;
- for (String d : items)
+ final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments();
+ for (String kitItem : output.getLines())
{
- final String[] parts = d.split(" ");
- final String[] item = parts[0].split("[:+',;.]", 2);
- final int id = Material.getMaterial(Integer.parseInt(item[0])).getId();
- final short data = item.length > 1 ? Short.parseShort(item[1]) : 0;
- final int amount = parts.length > 1 ? Integer.parseInt(parts[1]) : 1;
+ if (kitItem.startsWith(ess.getSettings().getCurrencySymbol()))
+ {
+ Double value = Double.parseDouble(kitItem.substring(ess.getSettings().getCurrencySymbol().length()).trim());
+ Trade t = new Trade(value, ess);
+ t.pay(user);
+ continue;
+ }
+
+ final String[] parts = kitItem.split(" ");
+ final ItemStack parseStack = ess.getItemDb().get(parts[0], parts.length > 1 ? Integer.parseInt(parts[1]) : 1);
+ final MetaItemStack metaStack = new MetaItemStack(parseStack);
- final ItemStack stack = new ItemStack(id, amount, data);
if (parts.length > 2)
{
- for (int i = 2; i < parts.length; i++)
- {
- final String[] split = parts[i].split("[:+',;.]", 2);
- if (split.length < 1)
- {
- continue;
- }
- final Enchantment enchantment = Enchantments.getByName(split[0]);
- if (enchantment == null)
- {
- throw new Exception("Enchantment not found: " + split[0]);
- }
- int level;
- if (split.length > 1)
- {
- level = Integer.parseInt(split[1]);
- }
- else
- {
- level = enchantment.getMaxLevel();
- }
- try
- {
- stack.addEnchantment(enchantment, level);
- }
- catch (Exception ex)
- {
- throw new Exception("Enchantment " + enchantment.getName() + ": " + ex.getMessage(), ex);
- }
- }
+ // We pass a null sender here because kits should not do perm checks
+ metaStack.parseStringMeta(null, allowUnsafe, parts, 2, ess);
}
final Map overfilled;
if (user.isAuthorized("essentials.oversizedstacks"))
{
- overfilled = InventoryWorkaround.addItem(user.getInventory(), true, ess.getSettings().getOversizedStackSize(), stack);
+ overfilled = InventoryWorkaround.addOversizedItems(user.getInventory(), ess.getSettings().getOversizedStackSize(), metaStack.getItemStack());
}
else
{
- overfilled = InventoryWorkaround.addItem(user.getInventory(), true, 0, stack);
+ overfilled = InventoryWorkaround.addItems(user.getInventory(), metaStack.getItemStack());
}
for (ItemStack itemStack : overfilled.values())
{
diff --git a/Essentials/src/com/earth2me/essentials/MetaItemStack.java b/Essentials/src/com/earth2me/essentials/MetaItemStack.java
new file mode 100644
index 0000000000..f7ea6dbcc8
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/MetaItemStack.java
@@ -0,0 +1,519 @@
+package com.earth2me.essentials;
+
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.textreader.BookInput;
+import com.earth2me.essentials.textreader.BookPager;
+import com.earth2me.essentials.textreader.IText;
+import java.util.*;
+import java.util.regex.Pattern;
+import org.bukkit.Color;
+import org.bukkit.DyeColor;
+import org.bukkit.FireworkEffect;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.*;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+
+public class MetaItemStack
+{
+ private final transient Pattern splitPattern = Pattern.compile("[:+',;.]");
+ private final ItemStack stack;
+ private final static Map colorMap = new HashMap();
+ private final static Map fireworkShape = new HashMap();
+ private FireworkEffect.Builder builder = FireworkEffect.builder();
+ private PotionEffectType pEffectType;
+ private PotionEffect pEffect;
+ private boolean validFirework = false;
+ private boolean validPotionEffect = false;
+ private boolean validPotionDuration = false;
+ private boolean validPotionPower = false;
+ private boolean completePotion = false;
+ private int power = 1;
+ private int duration = 120;
+
+ static
+ {
+ for (DyeColor color : DyeColor.values())
+ {
+ colorMap.put(color.name(), color);
+ }
+ for (FireworkEffect.Type type : FireworkEffect.Type.values())
+ {
+ fireworkShape.put(type.name(), type);
+ }
+ }
+
+ public MetaItemStack(final ItemStack stack)
+ {
+ this.stack = stack.clone();
+ }
+
+ public ItemStack getItemStack()
+ {
+ return stack;
+ }
+
+ public boolean isValidFirework()
+ {
+ return validFirework;
+ }
+
+ public boolean isValidPotion()
+ {
+ return validPotionEffect && validPotionDuration && validPotionPower;
+ }
+
+ public FireworkEffect.Builder getFireworkBuilder()
+ {
+ return builder;
+ }
+
+ public PotionEffect getPotionEffect()
+ {
+ return pEffect;
+ }
+
+ public boolean completePotion()
+ {
+ return completePotion;
+ }
+
+ private void resetPotionMeta()
+ {
+ pEffect = null;
+ pEffectType = null;
+ validPotionEffect = false;
+ validPotionDuration = false;
+ validPotionPower = false;
+ completePotion = true;
+ }
+
+ public void parseStringMeta(final CommandSender sender, final boolean allowUnsafe, String[] string, int fromArg, final IEssentials ess) throws Exception
+ {
+
+ for (int i = fromArg; i < string.length; i++)
+ {
+ addStringMeta(sender, allowUnsafe, string[i], ess);
+ }
+ if (validFirework)
+ {
+ if (!hasMetaPermission(sender, "firework", true, true, ess))
+ {
+ throw new Exception(_("noMetaFirework"));
+ }
+ FireworkEffect effect = builder.build();
+ FireworkMeta fmeta = (FireworkMeta)stack.getItemMeta();
+ fmeta.addEffect(effect);
+ if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess))
+ {
+ throw new Exception(_("multipleCharges"));
+ }
+ stack.setItemMeta(fmeta);
+ }
+ }
+
+ private void addStringMeta(final CommandSender sender, final boolean allowUnsafe, final String string, final IEssentials ess) throws Exception
+ {
+ final String[] split = splitPattern.split(string, 2);
+ if (split.length < 1)
+ {
+ return;
+ }
+
+ if (split.length > 1 && split[0].equalsIgnoreCase("name") && hasMetaPermission(sender, "name", false, true, ess))
+ {
+ final String displayName = Util.replaceFormat(split[1].replace('_', ' '));
+ final ItemMeta meta = stack.getItemMeta();
+ meta.setDisplayName(displayName);
+ stack.setItemMeta(meta);
+ }
+ else if (split.length > 1 && (split[0].equalsIgnoreCase("lore") || split[0].equalsIgnoreCase("desc")) && hasMetaPermission(sender, "lore", false, true, ess))
+ {
+ final List lore = new ArrayList();
+ for (String line : split[1].split("\\|"))
+ {
+ lore.add(Util.replaceFormat(line.replace('_', ' ')));
+ }
+ final ItemMeta meta = stack.getItemMeta();
+ meta.setLore(lore);
+ stack.setItemMeta(meta);
+ }
+ else if (split.length > 1 && (split[0].equalsIgnoreCase("player") || split[0].equalsIgnoreCase("owner")) && stack.getType() == Material.SKULL_ITEM && hasMetaPermission(sender, "head", false, true, ess))
+ {
+ if (stack.getDurability() == 3)
+ {
+ final String owner = split[1];
+ final SkullMeta meta = (SkullMeta)stack.getItemMeta();
+ boolean result = meta.setOwner(owner);
+ stack.setItemMeta(meta);
+ }
+ else
+ {
+ throw new Exception(_("onlyPlayerSkulls"));
+ }
+ }
+ else if (split.length > 1 && split[0].equalsIgnoreCase("book") && stack.getType() == Material.WRITTEN_BOOK
+ && (hasMetaPermission(sender, "book", true, true, ess) || hasMetaPermission(sender, "chapter-" + split[1].toLowerCase(Locale.ENGLISH), true, true, ess)))
+ {
+ final BookMeta meta = (BookMeta)stack.getItemMeta();
+ final IText input = new BookInput("book", true, ess);
+ final BookPager pager = new BookPager(input);
+
+ List pages = pager.getPages(split[1]);
+ meta.setPages(pages);
+ stack.setItemMeta(meta);
+ }
+ else if (split.length > 1 && split[0].equalsIgnoreCase("author") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "author", false, true, ess))
+ {
+ final String author = split[1];
+ final BookMeta meta = (BookMeta)stack.getItemMeta();
+ meta.setAuthor(author);
+ stack.setItemMeta(meta);
+ }
+ else if (split.length > 1 && split[0].equalsIgnoreCase("title") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "title", false, true, ess))
+ {
+ final String title = Util.replaceFormat(split[1].replace('_', ' '));
+ final BookMeta meta = (BookMeta)stack.getItemMeta();
+ meta.setTitle(title);
+ stack.setItemMeta(meta);
+ }
+ else if (split.length > 1 && split[0].equalsIgnoreCase("power") && stack.getType() == Material.FIREWORK && hasMetaPermission(sender, "firework-power", false, true, ess))
+ {
+ final int power = Util.isInt(split[1]) ? Integer.parseInt(split[1]) : 0;
+ final FireworkMeta meta = (FireworkMeta)stack.getItemMeta();
+ meta.setPower(power > 3 ? 4 : power);
+ stack.setItemMeta(meta);
+ }
+ else if (stack.getType() == Material.FIREWORK) //WARNING - Meta for fireworks will be ignored after this point.
+ {
+ addFireworkMeta(sender, false, string, ess);
+ }
+ else if (stack.getType() == Material.POTION) //WARNING - Meta for potions will be ignored after this point.
+ {
+ addPotionMeta(sender, false, string, ess);
+ }
+ else if (split.length > 1 && (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour"))
+ && (stack.getType() == Material.LEATHER_BOOTS
+ || stack.getType() == Material.LEATHER_CHESTPLATE
+ || stack.getType() == Material.LEATHER_HELMET
+ || stack.getType() == Material.LEATHER_LEGGINGS))
+ {
+ final String[] color = split[1].split("(\\||,)");
+ if (color.length == 3)
+ {
+ final int red = Util.isInt(color[0]) ? Integer.parseInt(color[0]) : 0;
+ final int green = Util.isInt(color[1]) ? Integer.parseInt(color[1]) : 0;
+ final int blue = Util.isInt(color[2]) ? Integer.parseInt(color[2]) : 0;
+ final LeatherArmorMeta meta = (LeatherArmorMeta)stack.getItemMeta();
+ meta.setColor(Color.fromRGB(red, green, blue));
+ stack.setItemMeta(meta);
+ }
+ else
+ {
+ throw new Exception(_("leatherSyntax"));
+ }
+ }
+ else
+ {
+ parseEnchantmentStrings(sender, allowUnsafe, split, ess);
+ }
+ }
+
+ public void addFireworkMeta(final CommandSender sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception
+ {
+ if (stack.getType() == Material.FIREWORK)
+ {
+ final String[] split = splitPattern.split(string, 2);
+
+ if (split.length < 2)
+ {
+ return;
+ }
+
+ if (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour") || (allowShortName && split[0].equalsIgnoreCase("c")))
+ {
+ if (validFirework)
+ {
+ if (!hasMetaPermission(sender, "firework", true, true, ess))
+ {
+ throw new Exception(_("noMetaFirework"));
+ }
+ FireworkEffect effect = builder.build();
+ FireworkMeta fmeta = (FireworkMeta)stack.getItemMeta();
+ fmeta.addEffect(effect);
+ if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess))
+ {
+ throw new Exception(_("multipleCharges"));
+ }
+ stack.setItemMeta(fmeta);
+ builder = FireworkEffect.builder();
+ }
+
+ List primaryColors = new ArrayList();
+ String[] colors = split[1].split(",");
+ for (String color : colors)
+ {
+ if (colorMap.containsKey(color.toUpperCase()))
+ {
+ validFirework = true;
+ primaryColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
+ }
+ else
+ {
+ throw new Exception(_("invalidFireworkFormat", split[1], split[0]));
+ }
+ }
+ builder.withColor(primaryColors);
+ }
+ else if (split[0].equalsIgnoreCase("shape") || split[0].equalsIgnoreCase("type") || (allowShortName && (split[0].equalsIgnoreCase("s") || split[0].equalsIgnoreCase("t"))))
+ {
+ FireworkEffect.Type finalEffect = null;
+ split[1] = (split[1].equalsIgnoreCase("large") ? "BALL_LARGE" : split[1]);
+ if (fireworkShape.containsKey(split[1].toUpperCase()))
+ {
+ finalEffect = fireworkShape.get(split[1].toUpperCase());
+ }
+ else
+ {
+ throw new Exception(_("invalidFireworkFormat", split[1], split[0]));
+ }
+ if (finalEffect != null)
+ {
+ builder.with(finalEffect);
+ }
+ }
+ else if (split[0].equalsIgnoreCase("fade") || (allowShortName && split[0].equalsIgnoreCase("f")))
+ {
+ List fadeColors = new ArrayList();
+ String[] colors = split[1].split(",");
+ for (String color : colors)
+ {
+ if (colorMap.containsKey(color.toUpperCase()))
+ {
+ fadeColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
+ }
+ else
+ {
+ throw new Exception(_("invalidFireworkFormat", split[1], split[0]));
+ }
+ }
+ if (!fadeColors.isEmpty())
+ {
+ builder.withFade(fadeColors);
+ }
+ }
+ else if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e")))
+ {
+ String[] effects = split[1].split(",");
+ for (String effect : effects)
+ {
+ if (effect.equalsIgnoreCase("twinkle"))
+ {
+ builder.flicker(true);
+ }
+ else if (effect.equalsIgnoreCase("trail"))
+ {
+ builder.trail(true);
+ }
+ else
+ {
+ throw new Exception(_("invalidFireworkFormat", split[1], split[0]));
+ }
+ }
+ }
+ }
+ }
+
+ public void addPotionMeta(final CommandSender sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception
+ {
+ if (stack.getType() == Material.POTION)
+ {
+ final String[] split = splitPattern.split(string, 2);
+
+ if (split.length < 2)
+ {
+ return;
+ }
+
+ if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e")))
+ {
+ pEffectType = Potions.getByName(split[1]);
+ if (pEffectType != null && pEffectType.getName() != null)
+ {
+ if (hasMetaPermission(sender, "potions." + pEffectType.getName().toLowerCase(Locale.ENGLISH), true, false, ess))
+ {
+ validPotionEffect = true;
+ }
+ else
+ {
+ throw new Exception(_("noPotionEffectPerm", pEffectType.getName().toLowerCase(Locale.ENGLISH)));
+ }
+ }
+ else
+ {
+ throw new Exception(_("invalidPotionMeta", split[1]));
+ }
+ }
+ else if (split[0].equalsIgnoreCase("power") || (allowShortName && split[0].equalsIgnoreCase("p")))
+ {
+ if (Util.isInt(split[1]))
+ {
+ validPotionPower = true;
+ power = Integer.parseInt(split[1]);
+ if (power > 0 && power < 4)
+ {
+ power -= 1;
+ }
+ }
+ else
+ {
+ throw new Exception(_("invalidPotionMeta", split[1]));
+ }
+ }
+ else if (split[0].equalsIgnoreCase("duration") || (allowShortName && split[0].equalsIgnoreCase("d")))
+ {
+ if (Util.isInt(split[1]))
+ {
+ validPotionDuration = true;
+ duration = Integer.parseInt(split[1]) * 20; //Duration is in ticks by default, converted to seconds
+ }
+ else
+ {
+ throw new Exception(_("invalidPotionMeta", split[1]));
+ }
+ }
+
+ if (isValidPotion())
+ {
+ PotionMeta pmeta = (PotionMeta)stack.getItemMeta();
+ pEffect = pEffectType.createEffect(duration, power);
+ if (pmeta.getCustomEffects().size() > 1 && !hasMetaPermission(sender, "potions.multiple", true, false, ess))
+ {
+ throw new Exception(_("multiplePotionEffects"));
+ }
+ pmeta.addCustomEffect(pEffect, true);
+ stack.setItemMeta(pmeta);
+ resetPotionMeta();
+ }
+ }
+ }
+
+ private void parseEnchantmentStrings(final CommandSender sender, final boolean allowUnsafe, final String[] split, final IEssentials ess) throws Exception
+ {
+ final Enchantment enchantment = Enchantments.getByName(split[0]);
+ if (enchantment == null || !hasMetaPermission(sender, "enchantments." + enchantment.getName().toLowerCase(Locale.ENGLISH), false, false, ess))
+ {
+ return;
+ }
+
+ int level = -1;
+ if (split.length > 1)
+ {
+ try
+ {
+ level = Integer.parseInt(split[1]);
+ }
+ catch (NumberFormatException ex)
+ {
+ level = -1;
+ }
+ }
+
+ if (level < 0 || (!allowUnsafe && level > enchantment.getMaxLevel()))
+ {
+ level = enchantment.getMaxLevel();
+ }
+ addEnchantment(sender, allowUnsafe, enchantment, level);
+ }
+
+ public void addEnchantment(final CommandSender sender, final boolean allowUnsafe, final Enchantment enchantment, final int level) throws Exception
+ {
+ if (enchantment == null)
+ {
+ throw new Exception(_("enchantmentNotFound"));
+ }
+ try
+ {
+ if (stack.getType().equals(Material.ENCHANTED_BOOK))
+ {
+ EnchantmentStorageMeta meta = (EnchantmentStorageMeta)stack.getItemMeta();
+ if (level == 0)
+ {
+ meta.removeStoredEnchant(enchantment);
+ }
+ else
+ {
+ meta.addStoredEnchant(enchantment, level, allowUnsafe);
+ }
+ stack.setItemMeta(meta);
+ }
+ else // all other material types besides ENCHANTED_BOOK
+ {
+ if (level == 0)
+ {
+ stack.removeEnchantment(enchantment);
+ }
+ else
+ {
+ if (allowUnsafe)
+ {
+ stack.addUnsafeEnchantment(enchantment, level);
+ }
+ else
+ {
+ stack.addEnchantment(enchantment, level);
+ }
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ throw new Exception("Enchantment " + enchantment.getName() + ": " + ex.getMessage(), ex);
+ }
+ }
+
+ public Enchantment getEnchantment(final User user, final String name) throws Exception
+ {
+ final Enchantment enchantment = Enchantments.getByName(name);
+ if (enchantment == null)
+ {
+ return null;
+ }
+
+ final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);
+
+ if (!hasMetaPermission(user, "enchantments." + enchantmentName, true, false))
+ {
+ throw new Exception(_("enchantmentPerm", enchantmentName));
+ }
+ return enchantment;
+ }
+
+ private boolean hasMetaPermission(final CommandSender sender, final String metaPerm, final boolean graceful, final boolean includeBase, final IEssentials ess) throws Exception
+ {
+ final User user = ess.getUser(sender);
+ return hasMetaPermission(user, metaPerm, graceful, includeBase);
+ }
+
+ private boolean hasMetaPermission(final User user, final String metaPerm, final boolean graceful, final boolean includeBase) throws Exception
+ {
+ final String permBase = includeBase ? "essentials.itemspawn.meta-" : "essentials.";
+ if (user == null || user.isAuthorized(permBase + metaPerm))
+ {
+ return true;
+ }
+
+ if (graceful)
+ {
+ return false;
+ }
+ else
+ {
+ throw new Exception(_("noMetaPerm", metaPerm));
+ }
+ }
+}
diff --git a/Essentials/src/com/earth2me/essentials/Mob.java b/Essentials/src/com/earth2me/essentials/Mob.java
index 38c11a81a4..b08281df46 100644
--- a/Essentials/src/com/earth2me/essentials/Mob.java
+++ b/Essentials/src/com/earth2me/essentials/Mob.java
@@ -1,20 +1,19 @@
package com.earth2me.essentials;
import static com.earth2me.essentials.I18n._;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.Location;
import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
-import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
+// Suffixes can be appended on the end of a mob name to make it plural
+// Entities without a suffix, will default to 's'
public enum Mob
{
CHICKEN("Chicken", Enemies.FRIENDLY, EntityType.CHICKEN),
@@ -41,8 +40,18 @@ public enum Mob
MAGMACUBE("MagmaCube", Enemies.ENEMY, EntityType.MAGMA_CUBE),
SNOWMAN("Snowman", Enemies.FRIENDLY, "", EntityType.SNOWMAN),
OCELOT("Ocelot", Enemies.NEUTRAL, EntityType.OCELOT),
- IRONGOLEM("IronGolem", Enemies.NEUTRAL, EntityType.IRON_GOLEM);
-
+ IRONGOLEM("IronGolem", Enemies.NEUTRAL, EntityType.IRON_GOLEM),
+ WITHER("Wither", Enemies.ENEMY, EntityType.WITHER),
+ BAT("Bat", Enemies.FRIENDLY, EntityType.BAT),
+ WITCH("Witch", Enemies.ENEMY, EntityType.WITCH),
+ BOAT("Boat", Enemies.NEUTRAL, EntityType.BOAT),
+ MINECART("Minecart", Enemies.NEUTRAL, EntityType.MINECART),
+ MINECART_CHEST("ChestMinecart", Enemies.NEUTRAL, EntityType.MINECART_CHEST),
+ MINECART_FURNACE("FurnaceMinecart", Enemies.NEUTRAL, EntityType.MINECART_FURNACE),
+ MINECART_TNT("TNTMinecart", Enemies.NEUTRAL, EntityType.MINECART_TNT),
+ MINECART_HOPPER("HopperMinecart", Enemies.NEUTRAL, EntityType.MINECART_HOPPER),
+ ENDERCRYSTAL("EnderCrystal", Enemies.NEUTRAL, EntityType.ENDER_CRYSTAL),
+ EXPERIENCEORB("ExperienceOrb", Enemies.NEUTRAL, EntityType.EXPERIENCE_ORB);
public static final Logger logger = Logger.getLogger("Minecraft");
private Mob(String n, Enemies en, String s, EntityType type)
@@ -72,14 +81,20 @@ private Mob(String n, Enemies en, EntityType type)
hashMap.put(mob.name.toLowerCase(Locale.ENGLISH), mob);
}
}
-
- public static Set getMobList() {
+
+ public static Set getMobList()
+ {
return Collections.unmodifiableSet(hashMap.keySet());
}
- public LivingEntity spawn(final Player player, final Server server, final Location loc) throws MobException
+ public Entity spawn(final Player player, final Server server, final Location loc) throws MobException
+ {
+ return spawn(player.getWorld(), server, loc);
+ }
+
+ public Entity spawn(final World world, final Server server, final Location loc) throws MobException
{
- final LivingEntity entity = player.getWorld().spawn(loc, (Class)this.bukkitType.getEntityClass());
+ final Entity entity = world.spawn(loc, (Class)this.bukkitType.getEntityClass());
if (entity == null)
{
logger.log(Level.WARNING, _("unableToSpawnMob"));
diff --git a/Essentials/src/com/earth2me/essentials/OfflinePlayer.java b/Essentials/src/com/earth2me/essentials/OfflinePlayer.java
index c6230f5e02..d78ff71462 100644
--- a/Essentials/src/com/earth2me/essentials/OfflinePlayer.java
+++ b/Essentials/src/com/earth2me/essentials/OfflinePlayer.java
@@ -11,11 +11,8 @@
import org.bukkit.entity.*;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.*;
import org.bukkit.inventory.InventoryView.Property;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
import org.bukkit.map.MapView;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.permissions.Permission;
@@ -24,6 +21,7 @@
import org.bukkit.plugin.Plugin;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.util.Vector;
public class OfflinePlayer implements Player
@@ -841,6 +839,12 @@ public void setBedSpawnLocation(Location lctn)
throw new UnsupportedOperationException("Not supported yet.");
}
+ @Override
+ public void setBedSpawnLocation(Location lctn, boolean force)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
@Override
public void playEffect(EntityEffect ee)
{
@@ -1051,4 +1055,178 @@ public void setFlying(boolean arg0)
{
throw new UnsupportedOperationException("Not supported yet.");
}
+
+ @Override
+ public int getExpToLevel()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean hasLineOfSight(Entity entity)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isValid()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFlySpeed(float value) throws IllegalArgumentException
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setWalkSpeed(float value) throws IllegalArgumentException
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFlySpeed()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getWalkSpeed()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Inventory getEnderChest()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void playSound(Location arg0, Sound arg1, float arg2, float arg3)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void giveExpLevels(int i)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getRemoveWhenFarAway()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRemoveWhenFarAway(boolean bln)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public EntityEquipment getEquipment()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCanPickupItems(boolean bln)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getCanPickupItems()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Location getLocation(Location lctn)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTexturePack(String string)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxHealth(int i)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void resetMaxHealth()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCustomName(String string)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCustomName()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCustomNameVisible(boolean bln)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isCustomNameVisible()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPlayerWeather(WeatherType arg0)
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public WeatherType getPlayerWeather()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void resetPlayerWeather()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isOnGround()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Scoreboard getScoreboard()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setScoreboard(Scoreboard scrbrd) throws IllegalArgumentException, IllegalStateException
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/Potions.java b/Essentials/src/com/earth2me/essentials/Potions.java
new file mode 100644
index 0000000000..cba132bdad
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/Potions.java
@@ -0,0 +1,130 @@
+package com.earth2me.essentials;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.potion.PotionEffectType;
+
+
+public class Potions
+{
+ private static final Map POTIONS = new HashMap();
+ private static final Map ALIASPOTIONS = new HashMap();
+
+ static
+ {
+
+ POTIONS.put("speed", PotionEffectType.SPEED);
+ ALIASPOTIONS.put("fast", PotionEffectType.SPEED);
+ ALIASPOTIONS.put("runfast", PotionEffectType.SPEED);
+ ALIASPOTIONS.put("sprint", PotionEffectType.SPEED);
+ ALIASPOTIONS.put("swift", PotionEffectType.SPEED);
+
+ POTIONS.put("slowness", PotionEffectType.SLOW);
+ ALIASPOTIONS.put("slow", PotionEffectType.SLOW);
+ ALIASPOTIONS.put("sluggish", PotionEffectType.SLOW);
+
+ POTIONS.put("haste", PotionEffectType.FAST_DIGGING);
+ ALIASPOTIONS.put("superpick", PotionEffectType.FAST_DIGGING);
+ ALIASPOTIONS.put("quickmine", PotionEffectType.FAST_DIGGING);
+ ALIASPOTIONS.put("digspeed", PotionEffectType.FAST_DIGGING);
+ ALIASPOTIONS.put("digfast", PotionEffectType.FAST_DIGGING);
+ ALIASPOTIONS.put("sharp", PotionEffectType.FAST_DIGGING);
+
+ POTIONS.put("fatigue", PotionEffectType.SLOW_DIGGING);
+ ALIASPOTIONS.put("slow", PotionEffectType.SLOW_DIGGING);
+ ALIASPOTIONS.put("dull", PotionEffectType.SLOW_DIGGING);
+
+ POTIONS.put("strength", PotionEffectType.INCREASE_DAMAGE);
+ ALIASPOTIONS.put("strong", PotionEffectType.INCREASE_DAMAGE);
+ ALIASPOTIONS.put("bull", PotionEffectType.INCREASE_DAMAGE);
+ ALIASPOTIONS.put("attack", PotionEffectType.INCREASE_DAMAGE);
+
+ POTIONS.put("heal", PotionEffectType.HEAL);
+ ALIASPOTIONS.put("healthy", PotionEffectType.HEAL);
+ ALIASPOTIONS.put("instaheal", PotionEffectType.HEAL);
+
+ POTIONS.put("harm", PotionEffectType.HARM);
+ ALIASPOTIONS.put("harming", PotionEffectType.HARM);
+ ALIASPOTIONS.put("injure", PotionEffectType.HARM);
+ ALIASPOTIONS.put("damage", PotionEffectType.HARM);
+ ALIASPOTIONS.put("inflict", PotionEffectType.HARM);
+
+ POTIONS.put("jump", PotionEffectType.JUMP);
+ ALIASPOTIONS.put("leap", PotionEffectType.JUMP);
+
+ POTIONS.put("nausea", PotionEffectType.CONFUSION);
+ ALIASPOTIONS.put("sick", PotionEffectType.CONFUSION);
+ ALIASPOTIONS.put("sickness", PotionEffectType.CONFUSION);
+ ALIASPOTIONS.put("confusion", PotionEffectType.CONFUSION);
+
+ POTIONS.put("regeneration", PotionEffectType.REGENERATION);
+ ALIASPOTIONS.put("regen", PotionEffectType.REGENERATION);
+
+ POTIONS.put("resistance", PotionEffectType.DAMAGE_RESISTANCE);
+ ALIASPOTIONS.put("dmgresist", PotionEffectType.DAMAGE_RESISTANCE);
+ ALIASPOTIONS.put("armor", PotionEffectType.DAMAGE_RESISTANCE);
+ ALIASPOTIONS.put("dmgresist", PotionEffectType.DAMAGE_RESISTANCE);
+
+ POTIONS.put("fireresist", PotionEffectType.FIRE_RESISTANCE);
+ ALIASPOTIONS.put("fireresistance", PotionEffectType.FIRE_RESISTANCE);
+ ALIASPOTIONS.put("resistfire", PotionEffectType.FIRE_RESISTANCE);
+
+ POTIONS.put("waterbreath", PotionEffectType.WATER_BREATHING);
+ ALIASPOTIONS.put("waterbreathing", PotionEffectType.WATER_BREATHING);
+
+ POTIONS.put("invisibility", PotionEffectType.INVISIBILITY);
+ ALIASPOTIONS.put("invisible", PotionEffectType.INVISIBILITY);
+ ALIASPOTIONS.put("invis", PotionEffectType.INVISIBILITY);
+ ALIASPOTIONS.put("vanish", PotionEffectType.INVISIBILITY);
+ ALIASPOTIONS.put("disappear", PotionEffectType.INVISIBILITY);
+
+ POTIONS.put("blindness", PotionEffectType.BLINDNESS);
+ ALIASPOTIONS.put("blind", PotionEffectType.BLINDNESS);
+
+ POTIONS.put("nightvision", PotionEffectType.NIGHT_VISION);
+ ALIASPOTIONS.put("vision", PotionEffectType.NIGHT_VISION);
+
+ POTIONS.put("hunger", PotionEffectType.HUNGER);
+ ALIASPOTIONS.put("hungry", PotionEffectType.HUNGER);
+ ALIASPOTIONS.put("starve", PotionEffectType.HUNGER);
+
+ POTIONS.put("weakness", PotionEffectType.WEAKNESS);
+ ALIASPOTIONS.put("weak", PotionEffectType.WEAKNESS);
+
+ POTIONS.put("poison", PotionEffectType.POISON);
+ ALIASPOTIONS.put("venom", PotionEffectType.POISON);
+
+ POTIONS.put("wither", PotionEffectType.WITHER);
+ ALIASPOTIONS.put("decay", PotionEffectType.WITHER);
+ }
+
+ public static PotionEffectType getByName(String name)
+ {
+ PotionEffectType peffect;
+ if (Util.isInt(name))
+ {
+ peffect = PotionEffectType.getById(Integer.parseInt(name));
+ }
+ else
+ {
+ peffect = PotionEffectType.getByName(name.toUpperCase(Locale.ENGLISH));
+ }
+ if (peffect == null)
+ {
+ peffect = POTIONS.get(name.toLowerCase(Locale.ENGLISH));
+ }
+ if (peffect == null)
+ {
+ peffect = ALIASPOTIONS.get(name.toLowerCase(Locale.ENGLISH));
+ }
+ return peffect;
+ }
+
+ public static Set> entrySet()
+ {
+ return POTIONS.entrySet();
+ }
+}
\ No newline at end of file
diff --git a/Essentials/src/com/earth2me/essentials/Settings.java b/Essentials/src/com/earth2me/essentials/Settings.java
index ec317dbfd5..3327849c17 100644
--- a/Essentials/src/com/earth2me/essentials/Settings.java
+++ b/Essentials/src/com/earth2me/essentials/Settings.java
@@ -12,6 +12,7 @@
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.ChatColor;
+import org.bukkit.command.PluginCommand;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.MemoryConfiguration;
import org.bukkit.event.EventPriority;
@@ -54,19 +55,21 @@ public Set getMultipleHomes()
@Override
public int getHomeLimit(final User user)
{
- final Set homeList = getMultipleHomes();
- if (homeList == null)
+ int limit = 1;
+ if (user.isAuthorized("essentials.sethome.multiple"))
{
- //TODO: Replace this code to remove backwards compat, after settings are automatically updated
- // return getHomeLimit("default");
- return config.getInt("multiple-homes", 5);
+ limit = getHomeLimit("default");
}
- int limit = getHomeLimit("default");
- for (String set : homeList)
+
+ final Set homeList = getMultipleHomes();
+ if (homeList != null)
{
- if (user.isAuthorized("essentials.sethome.multiple." + set) && (limit < getHomeLimit(set)))
+ for (String set : homeList)
{
- limit = getHomeLimit(set);
+ if (user.isAuthorized("essentials.sethome.multiple." + set) && (limit < getHomeLimit(set)))
+ {
+ limit = getHomeLimit(set);
+ }
}
}
return limit;
@@ -77,11 +80,17 @@ public int getHomeLimit(final String set)
{
return config.getInt("sethome-multiple." + set, config.getInt("sethome-multiple.default", 3));
}
+ private int chatRadius = 0;
+
+ private int _getChatRadius()
+ {
+ return config.getInt("chat.radius", config.getInt("chat-radius", 0));
+ }
@Override
public int getChatRadius()
{
- return config.getInt("chat.radius", config.getInt("chat-radius", 0));
+ return chatRadius;
}
@Override
@@ -113,39 +122,29 @@ public boolean isCommandDisabled(final IEssentialsCommand cmd)
{
return isCommandDisabled(cmd.getName());
}
+ private Set disabledCommands = new HashSet();
@Override
public boolean isCommandDisabled(String label)
{
- for (String c : config.getStringList("disabled-commands"))
- {
- if (!c.equalsIgnoreCase(label))
- {
- continue;
- }
- return true;
- }
- return config.getBoolean("disable-" + label.toLowerCase(Locale.ENGLISH), false);
+ return disabledCommands.contains(label);
}
- @Override
- public boolean isCommandRestricted(IEssentialsCommand cmd)
+ private Set getDisabledCommands()
{
- return isCommandRestricted(cmd.getName());
- }
-
- @Override
- public boolean isCommandRestricted(String label)
- {
- for (String c : config.getStringList("restricted-commands"))
+ Set disCommands = new HashSet();
+ for (String c : config.getStringList("disabled-commands"))
{
- if (!c.equalsIgnoreCase(label))
+ disCommands.add(c.toLowerCase(Locale.ENGLISH));
+ }
+ for (String c : config.getKeys(false))
+ {
+ if (c.startsWith("disable-"))
{
- continue;
+ disCommands.add(c.substring(8).toLowerCase(Locale.ENGLISH));
}
- return true;
}
- return config.getBoolean("restrict-" + label.toLowerCase(Locale.ENGLISH), false);
+ return disCommands;
}
@Override
@@ -175,6 +174,7 @@ public boolean isCommandOverridden(String name)
}
return config.getBoolean("override-" + name.toLowerCase(Locale.ENGLISH), false);
}
+ private ConfigurationSection commandCosts;
@Override
public double getCommandCost(IEssentialsCommand cmd)
@@ -182,23 +182,100 @@ public double getCommandCost(IEssentialsCommand cmd)
return getCommandCost(cmd.getName());
}
+ public ConfigurationSection _getCommandCosts()
+ {
+ if (config.isConfigurationSection("command-costs"))
+ {
+ final ConfigurationSection section = config.getConfigurationSection("command-costs");
+ final ConfigurationSection newSection = new MemoryConfiguration();
+ for (String command : section.getKeys(false))
+ {
+ PluginCommand cmd = ess.getServer().getPluginCommand(command);
+ if (command.charAt(0) == '/')
+ {
+ ess.getLogger().warning("Invalid command cost. '" + command + "' should not start with '/'.");
+ }
+ if (section.isDouble(command))
+ {
+ newSection.set(command.toLowerCase(Locale.ENGLISH), section.getDouble(command));
+ }
+ else if (section.isInt(command))
+ {
+ newSection.set(command.toLowerCase(Locale.ENGLISH), (double)section.getInt(command));
+ }
+ else if (section.isString(command))
+ {
+ String costString = section.getString(command);
+ try
+ {
+ double cost = Double.parseDouble(costString.trim().replace(getCurrencySymbol(), "").replaceAll("\\W", ""));
+ newSection.set(command.toLowerCase(Locale.ENGLISH), cost);
+ }
+ catch (NumberFormatException ex)
+ {
+ ess.getLogger().warning("Invalid command cost for: " + command + " (" + costString + ")");
+ }
+
+ }
+ else
+ {
+ ess.getLogger().warning("Invalid command cost for: " + command);
+ }
+ }
+ return newSection;
+ }
+ return null;
+ }
+
@Override
- public double getCommandCost(String label)
+ public double getCommandCost(String name)
{
- double cost = config.getDouble("command-costs." + label, 0.0);
- if (cost == 0.0)
+ name = name.replace('.', '_').replace('/', '_');
+ if (commandCosts != null)
{
- cost = config.getDouble("cost-" + label, 0.0);
+ return commandCosts.getDouble(name, 0.0);
}
- return cost;
+ return 0.0;
+ }
+ private Set socialSpyCommands = new HashSet();
+
+ public Set _getSocialSpyCommands()
+ {
+ Set socialspyCommands = new HashSet();
+
+ if (config.isList("socialspy-commands"))
+ {
+ for (String c : config.getStringList("socialspy-commands"))
+ {
+ socialspyCommands.add(c.toLowerCase(Locale.ENGLISH));
+ }
+ }
+ else
+ {
+ socialspyCommands.addAll(Arrays.asList("msg", "r", "mail", "m", "whisper", "emsg", "t", "tell", "er", "reply", "ereply", "email", "action", "describe", "eme", "eaction", "edescribe", "etell", "ewhisper", "pm"));
+ }
+
+ return socialspyCommands;
}
@Override
- public String getNicknamePrefix()
+ public Set getSocialSpyCommands()
+ {
+ return socialSpyCommands;
+ }
+ private String nicknamePrefix = "~";
+
+ private String _getNicknamePrefix()
{
return config.getString("nickname-prefix", "~");
}
+ @Override
+ public String getNicknamePrefix()
+ {
+ return nicknamePrefix;
+ }
+
@Override
public double getTeleportCooldown()
{
@@ -240,7 +317,7 @@ public ConfigurationSection getKits()
public Map getKit(String name)
{
name = name.replace('.', '_').replace('/', '_');
- if (config.isConfigurationSection("kits"))
+ if (getKits() != null)
{
final ConfigurationSection kits = getKits();
if (kits.isConfigurationSection(name))
@@ -250,19 +327,25 @@ public Map getKit(String name)
}
return null;
}
+ private ChatColor operatorColor = null;
@Override
- public ChatColor getOperatorColor() throws Exception
+ public ChatColor getOperatorColor()
+ {
+ return operatorColor;
+ }
+
+ private ChatColor _getOperatorColor()
{
String colorName = config.getString("ops-name-color", null);
if (colorName == null)
{
- return ChatColor.RED;
+ return ChatColor.DARK_RED;
}
if ("none".equalsIgnoreCase(colorName) || colorName.isEmpty())
{
- throw new Exception();
+ return null;
}
try
@@ -317,7 +400,7 @@ public String getBackupCommand()
{
return config.getString("backup.command", null);
}
- private Map chatFormats = new HashMap();
+ private Map chatFormats = Collections.synchronizedMap(new HashMap());
@Override
public MessageFormat getChatFormat(String group)
@@ -334,6 +417,7 @@ public MessageFormat getChatFormat(String group)
format = format.replace("{WORLDNAME}", "{1}");
format = format.replace("{SHORTWORLDNAME}", "{2}");
format = format.replaceAll("\\{(\\D*?)\\}", "\\[$1\\]");
+ format = "§r".concat(format);
mFormat = new MessageFormat(format);
chatFormats.put(group, mFormat);
}
@@ -369,11 +453,25 @@ public boolean getPerWarpPermission()
{
return config.getBoolean("per-warp-permission", false);
}
-
+
@Override
- public boolean getSortListByGroups()
+ public Map getListGroupConfig()
{
- return config.getBoolean("sort-list-by-groups", true);
+ if (config.isConfigurationSection("list"))
+ {
+ Map values = config.getConfigurationSection("list").getValues(false);
+ if (!values.isEmpty()) {
+ return values;
+ }
+ }
+ Map defaultMap = new HashMap();
+ if (config.getBoolean("sort-list-by-groups", false)) {
+ defaultMap.put("ListByGroup", "ListByGroup");
+ }
+ else {
+ defaultMap.put("Players", "*");
+ }
+ return defaultMap;
}
@Override
@@ -382,16 +480,33 @@ public void reloadConfig()
config.load();
noGodWorlds = new HashSet(config.getStringList("no-god-in-worlds"));
enabledSigns = _getEnabledSigns();
+ teleportInvulnerabilityTime = _getTeleportInvulnerability();
teleportInvulnerability = _isTeleportInvulnerability();
disableItemPickupWhileAfk = _getDisableItemPickupWhileAfk();
registerBackInListener = _registerBackInListener();
- cancelAfkOnMove = _cancelAfkOnMove();
+ cancelAfkOnInteract = _cancelAfkOnInteract();
+ cancelAfkOnMove = _cancelAfkOnMove() && cancelAfkOnInteract;
getFreezeAfkPlayers = _getFreezeAfkPlayers();
itemSpawnBl = _getItemSpawnBlacklist();
loginAttackDelay = _getLoginAttackDelay();
signUsePerSecond = _getSignUsePerSecond();
kits = _getKits();
chatFormats.clear();
+ changeDisplayName = _changeDisplayName();
+ disabledCommands = getDisabledCommands();
+ nicknamePrefix = _getNicknamePrefix();
+ operatorColor = _getOperatorColor();
+ changePlayerListName = _changePlayerListName();
+ configDebug = _isDebug();
+ prefixsuffixconfigured = _isPrefixSuffixConfigured();
+ addprefixsuffix = _addPrefixSuffix();
+ disablePrefix = _disablePrefix();
+ disableSuffix = _disableSuffix();
+ chatRadius = _getChatRadius();
+ commandCosts = _getCommandCosts();
+ socialSpyCommands = _getSocialSpyCommands();
+ warnOnBuildDisallow = _warnOnBuildDisallow();
+ mailsPerMinute = _getMailsPerMinute();
}
private List itemSpawnBl = new ArrayList();
@@ -466,24 +581,30 @@ private List _getEnabledSigns()
}
return newSigns;
}
+ private boolean warnOnBuildDisallow;
- @Override
- public boolean spawnIfNoHome()
+ private boolean _warnOnBuildDisallow()
{
- return config.getBoolean("spawn-if-no-home", false);
+ return config.getBoolean("protect.disable.warn-on-build-disallow", false);
}
@Override
public boolean warnOnBuildDisallow()
{
- return config.getBoolean("protect.disable.warn-on-build-disallow", false);
+ return warnOnBuildDisallow;
}
private boolean debug = false;
+ private boolean configDebug = false;
+
+ private boolean _isDebug()
+ {
+ return config.getBoolean("debug", false);
+ }
@Override
public boolean isDebug()
{
- return debug || config.getBoolean("debug", false);
+ return debug || configDebug;
}
@Override
@@ -504,10 +625,12 @@ public String getLocale()
return config.getString("locale", "");
}
+ //This method should always only return one character due to the implementation of the calling methods
+ //If you need to use a string currency, for example "coins", use the translation key 'currency'.
@Override
public String getCurrencySymbol()
{
- return config.getString("currency-symbol", "$").substring(0, 1).replaceAll("[0-9]", "$");
+ return config.getString("currency-symbol", "$").concat("$").substring(0, 1).replaceAll("[0-9]", "$");
}
@Override
@@ -610,17 +733,29 @@ public boolean removeGodOnDisconnect()
{
return config.getBoolean("remove-god-on-disconnect", false);
}
+ private boolean changeDisplayName = true;
+
+ private boolean _changeDisplayName()
+ {
+ return config.getBoolean("change-displayname", true);
+ }
@Override
public boolean changeDisplayName()
{
- return config.getBoolean("change-displayname", true);
+ return changeDisplayName;
+ }
+ private boolean changePlayerListName = false;
+
+ private boolean _changePlayerListName()
+ {
+ return config.getBoolean("change-playerlist", false);
}
@Override
public boolean changePlayerListName()
{
- return config.getBoolean("change-playerlist", false);
+ return changePlayerListName;
}
@Override
@@ -628,23 +763,54 @@ public boolean useBukkitPermissions()
{
return config.getBoolean("use-bukkit-permissions", false);
}
+ private boolean prefixsuffixconfigured = false;
+ private boolean addprefixsuffix = false;
+ private boolean essentialsChatActive = false;
+
+ private boolean _addPrefixSuffix()
+ {
+ return config.getBoolean("add-prefix-suffix", false);
+ }
+
+ private boolean _isPrefixSuffixConfigured()
+ {
+ return config.hasProperty("add-prefix-suffix");
+ }
+
+ @Override
+ public void setEssentialsChatActive(boolean essentialsChatActive)
+ {
+ this.essentialsChatActive = essentialsChatActive;
+ }
@Override
public boolean addPrefixSuffix()
{
- return config.getBoolean("add-prefix-suffix", ess.getServer().getPluginManager().isPluginEnabled("EssentialsChat"));
+ return prefixsuffixconfigured ? addprefixsuffix : essentialsChatActive;
+ }
+ private boolean disablePrefix = false;
+
+ private boolean _disablePrefix()
+ {
+ return config.getBoolean("disablePrefix", false);
}
@Override
public boolean disablePrefix()
{
- return config.getBoolean("disablePrefix", false);
+ return disablePrefix;
+ }
+ private boolean disableSuffix = false;
+
+ private boolean _disableSuffix()
+ {
+ return config.getBoolean("disableSuffix", false);
}
@Override
public boolean disableSuffix()
{
- return config.getBoolean("disableSuffix", false);
+ return disableSuffix;
}
@Override
@@ -682,6 +848,18 @@ private boolean _cancelAfkOnMove()
{
return config.getBoolean("cancel-afk-on-move", true);
}
+ private boolean cancelAfkOnInteract;
+
+ @Override
+ public boolean cancelAfkOnInteract()
+ {
+ return cancelAfkOnInteract;
+ }
+
+ private boolean _cancelAfkOnInteract()
+ {
+ return config.getBoolean("cancel-afk-on-interact", true);
+ }
@Override
public boolean areDeathMessagesEnabled()
@@ -708,12 +886,18 @@ public boolean getRepairEnchanted()
return config.getBoolean("repair-enchanted", true);
}
+ @Override
+ public boolean allowUnsafeEnchantments()
+ {
+ return config.getBoolean("unsafe-enchantments", false);
+ }
+
@Override
public boolean isWorldTeleportPermissions()
{
return config.getBoolean("world-teleport-permissions", false);
}
-
+
@Override
public boolean isWorldHomePermissions()
{
@@ -774,7 +958,7 @@ public EventPriority getRespawnPriority()
@Override
public long getTpaAcceptCancellation()
{
- return config.getLong("tpa-accept-cancellation", 0);
+ return config.getLong("tpa-accept-cancellation", 120);
}
@Override
@@ -788,50 +972,87 @@ public void setMetricsEnabled(boolean metricsEnabled)
{
this.metricsEnabled = metricsEnabled;
}
- private boolean teleportInvulnerability;
+ private long teleportInvulnerabilityTime;
+
+ public long _getTeleportInvulnerability()
+ {
+ return config.getLong("teleport-invulnerability", 0) * 1000;
+ }
@Override
public long getTeleportInvulnerability()
{
- return config.getLong("teleport-invulnerability", 0) * 1000;
+ return teleportInvulnerabilityTime;
}
+ private boolean teleportInvulnerability;
private boolean _isTeleportInvulnerability()
{
return (config.getLong("teleport-invulnerability", 0) > 0);
}
-
+
@Override
public boolean isTeleportInvulnerability()
{
return teleportInvulnerability;
}
-
private long loginAttackDelay;
-
+
private long _getLoginAttackDelay()
{
return config.getLong("login-attack-delay", 0) * 1000;
}
-
+
@Override
public long getLoginAttackDelay()
{
return loginAttackDelay;
}
-
private int signUsePerSecond;
-
+
private int _getSignUsePerSecond()
{
final int perSec = config.getInt("sign-use-per-second", 4);
return perSec > 0 ? perSec : 1;
}
-
+
@Override
public int getSignUsePerSecond()
{
return signUsePerSecond;
}
-
+
+ @Override
+ public double getMaxFlySpeed()
+ {
+ double maxSpeed = config.getDouble("max-fly-speed", 0.8);
+ return maxSpeed > 1.0 ? 1.0 : Math.abs(maxSpeed);
+ }
+
+ //This option does not exist in the config.yml because it wasn't yet implemented in bukkit
+ //The code was commented out in the /speed command
+ @Override
+ public double getMaxWalkSpeed()
+ {
+ double maxSpeed = config.getDouble("max-walk-speed", 0.8);
+ return maxSpeed > 1.0 ? 1.0 : Math.abs(maxSpeed);
+ }
+ private int mailsPerMinute;
+
+ private int _getMailsPerMinute()
+ {
+ return config.getInt("mails-per-minute", 1000);
+ }
+
+ @Override
+ public int getMailsPerMinute()
+ {
+ return mailsPerMinute;
+ }
+
+ @Override
+ public long getMaxTempban()
+ {
+ return config.getLong("max-tempban-time", -1);
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/SpawnMob.java b/Essentials/src/com/earth2me/essentials/SpawnMob.java
new file mode 100644
index 0000000000..5305f6539b
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/SpawnMob.java
@@ -0,0 +1,327 @@
+package com.earth2me.essentials;
+
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.Mob.MobException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Random;
+import java.util.Set;
+import org.bukkit.DyeColor;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.block.Block;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.*;
+import org.bukkit.entity.Skeleton.SkeletonType;
+import org.bukkit.material.Colorable;
+
+
+public class SpawnMob
+{
+ public static String mobList(final User user)
+ {
+ final Set mobList = Mob.getMobList();
+ final Set availableList = new HashSet();
+ for (String mob : mobList)
+ {
+ if (user.isAuthorized("essentials.spawnmob." + mob.toLowerCase(Locale.ENGLISH)))
+ {
+ availableList.add(mob);
+ }
+ }
+ if (availableList.isEmpty())
+ {
+ availableList.add(_("none"));
+ }
+ return Util.joinList(availableList);
+ }
+
+ public static List mobParts(final String mobString)
+ {
+ String[] mobParts = mobString.split(",");
+
+ List mobs = new ArrayList();
+
+ for (String mobPart : mobParts)
+ {
+ String[] mobDatas = mobPart.split(":");
+ mobs.add(mobDatas[0]);
+ }
+ return mobs;
+ }
+
+ public static List mobData(final String mobString)
+ {
+ String[] mobParts = mobString.split(",");
+
+ List mobData = new ArrayList();
+
+ for (String mobPart : mobParts)
+ {
+ String[] mobDatas = mobPart.split(":");
+ if (mobDatas.length == 1)
+ {
+ mobData.add(null);
+ }
+ else
+ {
+ mobData.add(mobDatas[1]);
+ }
+ }
+
+ return mobData;
+ }
+
+ // This method spawns a mob where the user is looking, owned by user
+ public static void spawnmob(final IEssentials ess, final Server server, final User user, final List parts, final List data, int mobCount) throws Exception
+ {
+ final Block block = Util.getTarget(user).getBlock();
+ if (block == null)
+ {
+ throw new Exception(_("unableToSpawnMob"));
+ }
+ spawnmob(ess, server, user, user, block.getLocation(), parts, data, mobCount);
+ }
+
+ // This method spawns a mob at loc, owned by noone
+ public static void spawnmob(final IEssentials ess, final Server server, final CommandSender sender, final Location loc, final List parts, final List data, int mobCount) throws Exception
+ {
+ spawnmob(ess, server, sender, null, loc, parts, data, mobCount);
+ }
+
+ // This method spawns a mob at target, owned by target
+ public static void spawnmob(final IEssentials ess, final Server server, final CommandSender sender, final User target, final List parts, final List data, int mobCount) throws Exception
+ {
+ spawnmob(ess, server, sender, target, target.getLocation(), parts, data, mobCount);
+ }
+
+ // This method spawns a mob at loc, owned by target
+ public static void spawnmob(final IEssentials ess, final Server server, final CommandSender sender, final User target, final Location loc, final List parts, final List data, int mobCount) throws Exception
+ {
+ final Location sloc = Util.getSafeDestination(loc);
+
+ for (int i = 0; i < parts.size(); i++)
+ {
+ Mob mob = Mob.fromName(parts.get(i));
+ checkSpawnable(ess, sender, mob);
+ }
+
+ final int serverLimit = ess.getSettings().getSpawnMobLimit();
+ int effectiveLimit = serverLimit / parts.size();
+
+ if (effectiveLimit < 1)
+ {
+ effectiveLimit = 1;
+ while (parts.size() > serverLimit)
+ {
+ parts.remove(serverLimit);
+ }
+ }
+
+ if (mobCount > effectiveLimit)
+ {
+ mobCount = effectiveLimit;
+ sender.sendMessage(_("mobSpawnLimit"));
+ }
+
+ Mob mob = Mob.fromName(parts.get(0)); // Get the first mob
+ try
+ {
+ for (int i = 0; i < mobCount; i++)
+ {
+ spawnMob(ess, server, sender, target, sloc, parts, data);
+ }
+ sender.sendMessage(mobCount * parts.size() + " " + mob.name.toLowerCase(Locale.ENGLISH) + mob.suffix + " " + _("spawned"));
+ }
+ catch (MobException e1)
+ {
+ throw new Exception(_("unableToSpawnMob"), e1);
+ }
+ catch (NumberFormatException e2)
+ {
+ throw new Exception(_("numberRequired"), e2);
+ }
+ catch (NullPointerException np)
+ {
+ throw new Exception(_("soloMob"), np);
+ }
+ }
+
+ private static void spawnMob(final IEssentials ess, final Server server, final CommandSender sender, final User target, final Location sloc, List parts, List data) throws Exception
+ {
+ Mob mob;
+ Entity spawnedMob = null;
+ Entity spawnedMount;
+
+ for (int i = 0; i < parts.size(); i++)
+ {
+ if (i == 0)
+ {
+ mob = Mob.fromName(parts.get(i));
+ spawnedMob = mob.spawn(sloc.getWorld(), server, sloc);
+
+ if (data.get(i) != null)
+ {
+ changeMobData(mob.getType(), spawnedMob, data.get(i), target);
+ }
+ }
+
+ int next = (i + 1);
+ if (next < parts.size()) //If it's the last mob in the list, don't set the mount
+ {
+ Mob mMob = Mob.fromName(parts.get(next));
+ spawnedMount = mMob.spawn(sloc.getWorld(), server, sloc);
+
+ if (data.get(next) != null)
+ {
+ changeMobData(mMob.getType(), spawnedMount, data.get(next), target);
+ }
+
+ spawnedMob.setPassenger(spawnedMount);
+
+ spawnedMob = spawnedMount;
+ }
+ }
+ }
+
+ private static void checkSpawnable(IEssentials ess, CommandSender sender, Mob mob) throws Exception
+ {
+ if (mob == null)
+ {
+ throw new Exception(_("invalidMob"));
+ }
+
+ if (ess.getSettings().getProtectPreventSpawn(mob.getType().toString().toLowerCase(Locale.ENGLISH)))
+ {
+ throw new Exception(_("disabledToSpawnMob"));
+ }
+
+ if (sender instanceof User && !((User)sender).isAuthorized("essentials.spawnmob." + mob.name.toLowerCase(Locale.ENGLISH)))
+ {
+ throw new Exception(_("noPermToSpawnMob"));
+ }
+ }
+
+ private static void changeMobData(final EntityType type, final Entity spawned, String data, final User target) throws Exception
+ {
+ data = data.toLowerCase(Locale.ENGLISH);
+
+ if (spawned instanceof Slime)
+ {
+ try
+ {
+ ((Slime)spawned).setSize(Integer.parseInt(data));
+ }
+ catch (Exception e)
+ {
+ throw new Exception(_("slimeMalformedSize"), e);
+ }
+ }
+
+ if ((spawned instanceof Ageable) && data.contains("baby"))
+ {
+ ((Ageable)spawned).setBaby();
+ data = data.replace("baby", "");
+ }
+
+ if (spawned instanceof Colorable)
+ {
+ final String color = data.toUpperCase(Locale.ENGLISH);
+ try
+ {
+ if (color.equals("RANDOM"))
+ {
+ final Random rand = new Random();
+ ((Colorable)spawned).setColor(DyeColor.values()[rand.nextInt(DyeColor.values().length)]);
+ }
+ else if (color.length() > 1)
+ {
+ ((Colorable)spawned).setColor(DyeColor.valueOf(color));
+ }
+ }
+ catch (Exception e)
+ {
+ throw new Exception(_("sheepMalformedColor"), e);
+ }
+ }
+
+ if (spawned instanceof Tameable && data.contains("tamed") && target != null)
+ {
+ final Tameable tameable = ((Tameable)spawned);
+ tameable.setTamed(true);
+ tameable.setOwner(target.getBase());
+ data = data.replace("tamed", "");
+ }
+
+ if (type == EntityType.WOLF)
+ {
+ if (data.contains("angry"))
+ {
+ ((Wolf)spawned).setAngry(true);
+ }
+ }
+
+ if (type == EntityType.CREEPER && data.contains("powered"))
+ {
+ ((Creeper)spawned).setPowered(true);
+ }
+
+ if (type == EntityType.OCELOT)
+ {
+ if (data.contains("siamese") || data.contains("white"))
+ {
+ ((Ocelot)spawned).setCatType(Ocelot.Type.SIAMESE_CAT);
+ }
+ else if (data.contains("red") || data.contains("orange") || data.contains("tabby"))
+ {
+ ((Ocelot)spawned).setCatType(Ocelot.Type.RED_CAT);
+ }
+ else if (data.contains("black") || data.contains("tuxedo"))
+ {
+ ((Ocelot)spawned).setCatType(Ocelot.Type.BLACK_CAT);
+ }
+ }
+
+ if (type == EntityType.VILLAGER)
+ {
+ for (Villager.Profession prof : Villager.Profession.values())
+ {
+ if (data.contains(prof.toString().toLowerCase(Locale.ENGLISH)))
+ {
+ ((Villager)spawned).setProfession(prof);
+ }
+ }
+ }
+
+ if (spawned instanceof Zombie)
+ {
+ if (data.contains("villager"))
+ {
+ ((Zombie)spawned).setVillager(true);
+ }
+ if (data.contains("baby"))
+ {
+ ((Zombie)spawned).setBaby(true);
+ }
+ }
+
+ if (type == EntityType.SKELETON)
+ {
+ if (data.contains("wither"))
+ {
+ ((Skeleton)spawned).setSkeletonType(SkeletonType.WITHER);
+ }
+ }
+
+ if (type == EntityType.EXPERIENCE_ORB)
+ {
+ if (Util.isInt(data))
+ {
+ ((ExperienceOrb)spawned).setExperience(Integer.parseInt(data));
+
+ }
+ }
+ }
+}
diff --git a/Essentials/src/com/earth2me/essentials/TNTExplodeListener.java b/Essentials/src/com/earth2me/essentials/TNTExplodeListener.java
index 4187f835d0..79cdfa7b45 100644
--- a/Essentials/src/com/earth2me/essentials/TNTExplodeListener.java
+++ b/Essentials/src/com/earth2me/essentials/TNTExplodeListener.java
@@ -24,13 +24,13 @@ public void enable()
if (!enabled)
{
enabled = true;
- timer = ess.scheduleSyncDelayedTask(this, 1000);
+ timer = ess.scheduleSyncDelayedTask(this, 200);
return;
}
if (timer != -1)
{
ess.getScheduler().cancelTask(timer);
- timer = ess.scheduleSyncDelayedTask(this, 1000);
+ timer = ess.scheduleSyncDelayedTask(this, 200);
}
}
diff --git a/Essentials/src/com/earth2me/essentials/Teleport.java b/Essentials/src/com/earth2me/essentials/Teleport.java
index 63ff596443..f295aef1a4 100644
--- a/Essentials/src/com/earth2me/essentials/Teleport.java
+++ b/Essentials/src/com/earth2me/essentials/Teleport.java
@@ -1,12 +1,11 @@
package com.earth2me.essentials;
-import com.earth2me.essentials.api.ITeleport;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.api.ITeleport;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.logging.Logger;
import org.bukkit.Location;
-import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
@@ -17,36 +16,38 @@ public class Teleport implements Runnable, ITeleport
private static final double MOVE_CONSTANT = 0.3;
- private static class Target
+ private class Target
{
private final Location location;
- private final Entity entity;
+ private final String name;
- public Target(Location location)
+ Target(Location location)
{
this.location = location;
- this.entity = null;
+ this.name = null;
}
- public Target(Entity entity)
+ Target(Player entity)
{
- this.entity = entity;
+ this.name = entity.getName();
this.location = null;
}
public Location getLocation()
{
- if (this.entity != null)
+ if (this.name != null)
{
- return this.entity.getLocation();
+
+ return ess.getServer().getPlayerExact(name).getLocation();
}
return location;
}
}
private IUser user;
+ private IUser teleportUser;
private int teleTimer = -1;
private long started; // time this task was initiated
- private long delay; // how long to delay the teleport
+ private long tpdelay; // how long to delay the teleport
private int health;
// note that I initially stored a clone of the location for reference, but...
// when comparing locations, I got incorrect mismatches (rounding errors, looked like)
@@ -55,22 +56,35 @@ public Location getLocation()
private long initY;
private long initZ;
private Target teleportTarget;
+ private boolean respawn;
+ private boolean canMove;
private Trade chargeFor;
private final IEssentials ess;
private static final Logger logger = Logger.getLogger("Minecraft");
private TeleportCause cause;
private void initTimer(long delay, Target target, Trade chargeFor, TeleportCause cause)
+ {
+ initTimer(delay, user, target, chargeFor, cause, false);
+ }
+
+ private void initTimer(long delay, IUser teleportUser, Target target, Trade chargeFor, TeleportCause cause, boolean respawn)
{
this.started = System.currentTimeMillis();
- this.delay = delay;
- this.health = user.getHealth();
- this.initX = Math.round(user.getLocation().getX() * MOVE_CONSTANT);
- this.initY = Math.round(user.getLocation().getY() * MOVE_CONSTANT);
- this.initZ = Math.round(user.getLocation().getZ() * MOVE_CONSTANT);
+ this.tpdelay = delay;
+ this.health = teleportUser.getHealth();
+ this.initX = Math.round(teleportUser.getLocation().getX() * MOVE_CONSTANT);
+ this.initY = Math.round(teleportUser.getLocation().getY() * MOVE_CONSTANT);
+ this.initZ = Math.round(teleportUser.getLocation().getZ() * MOVE_CONSTANT);
+ this.teleportUser = teleportUser;
this.teleportTarget = target;
this.chargeFor = chargeFor;
this.cause = cause;
+ this.respawn = respawn;
+
+ this.canMove = user.isAuthorized("essentials.teleport.timer.move");
+
+ teleTimer = ess.scheduleSyncRepeatingTask(this, 10, 10);
}
@Override
@@ -79,31 +93,53 @@ public void run()
if (user == null || !user.isOnline() || user.getLocation() == null)
{
- cancel();
+ cancel(false);
return;
}
- if (Math.round(user.getLocation().getX() * MOVE_CONSTANT) != initX
- || Math.round(user.getLocation().getY() * MOVE_CONSTANT) != initY
- || Math.round(user.getLocation().getZ() * MOVE_CONSTANT) != initZ
- || user.getHealth() < health)
- { // user moved, cancel teleport
- cancel(true);
+
+ if (teleportUser == null || !teleportUser.isOnline())
+ {
+ cancel(false);
return;
}
- health = user.getHealth(); // in case user healed, then later gets injured
+ final Location currLocation = teleportUser.getLocation();
+ if (currLocation == null)
+ {
+ cancel(false);
+ return;
+ }
- long now = System.currentTimeMillis();
- if (now > started + delay)
+ if (!canMove
+ && (Math.round(currLocation.getX() * MOVE_CONSTANT) != initX
+ || Math.round(currLocation.getY() * MOVE_CONSTANT) != initY
+ || Math.round(currLocation.getZ() * MOVE_CONSTANT) != initZ
+ || teleportUser.getHealth() < health))
+ {
+ // user moved, cancel teleport
+ cancel(true);
+ return;
+ }
+
+ health = teleportUser.getHealth(); // in case user healed, then later gets injured
+ final long now = System.currentTimeMillis();
+ if (now > started + tpdelay)
{
try
{
cooldown(false);
- user.sendMessage(_("teleportationCommencing"));
+ teleportUser.sendMessage(_("teleportationCommencing"));
try
{
-
- now(teleportTarget, cause);
+ if (respawn)
+ {
+ teleportUser.getTeleport().respawn(cause);
+ }
+ else
+ {
+ teleportUser.getTeleport().now(teleportTarget, cause);
+ }
+ cancel(false);
if (chargeFor != null)
{
chargeFor.charge(user);
@@ -117,6 +153,10 @@ public void run()
catch (Exception ex)
{
user.sendMessage(_("cooldownWithMessage", ex.getMessage()));
+ if (user != teleportUser)
+ {
+ teleportUser.sendMessage(_("cooldownWithMessage", ex.getMessage()));
+ }
}
}
}
@@ -127,22 +167,6 @@ public Teleport(IUser user, IEssentials ess)
this.ess = ess;
}
- public void respawn(final Trade chargeFor, TeleportCause cause) throws Exception
- {
- final Player player = user.getBase();
- final Location bed = player.getBedSpawnLocation();
- final PlayerRespawnEvent pre = new PlayerRespawnEvent(player, bed == null ? player.getWorld().getSpawnLocation() : bed, bed != null);
- ess.getServer().getPluginManager().callEvent(pre);
- teleport(new Target(pre.getRespawnLocation()), chargeFor, cause);
- }
-
- public void warp(String warp, Trade chargeFor, TeleportCause cause) throws Exception
- {
- Location loc = ess.getWarps().getWarp(warp);
- teleport(new Target(loc), chargeFor, cause);
- user.sendMessage(_("warpingTo", warp));
- }
-
public void cooldown(boolean check) throws Exception
{
final Calendar time = new GregorianCalendar();
@@ -181,6 +205,7 @@ else if (lastTime > earliestLong && !user.isAuthorized("essentials.teleport.cool
}
}
+ //If we need to cancel a pending teleport call this method
public void cancel(boolean notifyUser)
{
if (teleTimer == -1)
@@ -193,6 +218,10 @@ public void cancel(boolean notifyUser)
if (notifyUser)
{
user.sendMessage(_("pendingTeleportCancelled"));
+ if (teleportUser != user)
+ {
+ teleportUser.sendMessage(_("pendingTeleportCancelled"));
+ }
}
}
finally
@@ -201,14 +230,38 @@ public void cancel(boolean notifyUser)
}
}
- public void cancel()
+ //The now function is used when you want to skip tp delay when teleporting someone to a location or player.
+ public void now(Location loc, boolean cooldown, TeleportCause cause) throws Exception
+ {
+ if (cooldown)
+ {
+ cooldown(false);
+ }
+ now(new Target(loc), cause);
+ }
+
+ public void now(Player entity, boolean cooldown, TeleportCause cause) throws Exception
+ {
+ if (cooldown)
+ {
+ cooldown(false);
+ }
+ now(new Target(entity), cause);
+ }
+
+ private void now(Target target, TeleportCause cause) throws Exception
{
cancel(false);
+ user.setLastLocation();
+ user.getBase().teleport(Util.getSafeDestination(target.getLocation()), cause);
}
+ //The teleport function is used when you want to normally teleport someone to a location or player.
+ //This method is nolonger used internally and will be removed.
+ @Deprecated
public void teleport(Location loc, Trade chargeFor) throws Exception
{
- teleport(new Target(loc), chargeFor, TeleportCause.PLUGIN);
+ teleport(loc, chargeFor, TeleportCause.PLUGIN);
}
public void teleport(Location loc, Trade chargeFor, TeleportCause cause) throws Exception
@@ -216,7 +269,7 @@ public void teleport(Location loc, Trade chargeFor, TeleportCause cause) throws
teleport(new Target(loc), chargeFor, cause);
}
- public void teleport(Entity entity, Trade chargeFor, TeleportCause cause) throws Exception
+ public void teleport(Player entity, Trade chargeFor, TeleportCause cause) throws Exception
{
teleport(new Target(entity), chargeFor, cause);
}
@@ -241,58 +294,112 @@ private void teleport(Target target, Trade chargeFor, TeleportCause cause) throw
return;
}
- cancel();
- Calendar c = new GregorianCalendar();
- c.add(Calendar.SECOND, (int)delay);
- c.add(Calendar.MILLISECOND, (int)((delay * 1000.0) % 1000.0));
- user.sendMessage(_("dontMoveMessage", Util.formatDateDiff(c.getTimeInMillis())));
+ cancel(false);
+ warnUser(user, delay);
initTimer((long)(delay * 1000.0), target, chargeFor, cause);
-
- teleTimer = ess.scheduleSyncRepeatingTask(this, 10, 10);
}
- private void now(Target target, TeleportCause cause) throws Exception
+ //The teleportToMe function is a wrapper used to handle teleporting players to them, like /tphere
+ public void teleportToMe(User otherUser, Trade chargeFor, TeleportCause cause) throws Exception
{
- cancel();
- user.setLastLocation();
- user.getBase().teleport(Util.getSafeDestination(target.getLocation()), cause);
- }
+ Target target = new Target(user);
+ double delay = ess.getSettings().getTeleportDelay();
- public void now(Location loc, boolean cooldown, TeleportCause cause) throws Exception
- {
- if (cooldown)
+ if (chargeFor != null)
+ {
+ chargeFor.isAffordableFor(user);
+ }
+ cooldown(true);
+ if (delay <= 0 || user.isAuthorized("essentials.teleport.timer.bypass"))
{
cooldown(false);
+ otherUser.getTeleport().now(target, cause);
+ if (chargeFor != null)
+ {
+ chargeFor.charge(user);
+ }
+ return;
}
- now(new Target(loc), cause);
+
+ cancel(false);
+ warnUser(otherUser, delay);
+ initTimer((long)(delay * 1000.0), otherUser, target, chargeFor, cause, false);
}
- public void now(Location loc, Trade chargeFor, TeleportCause cause) throws Exception
+ private void warnUser(final IUser user, final double delay)
{
- cooldown(false);
- chargeFor.charge(user);
- now(new Target(loc), cause);
+ Calendar c = new GregorianCalendar();
+ c.add(Calendar.SECOND, (int)delay);
+ c.add(Calendar.MILLISECOND, (int)((delay * 1000.0) % 1000.0));
+ user.sendMessage(_("dontMoveMessage", Util.formatDateDiff(c.getTimeInMillis())));
}
- public void now(Entity entity, boolean cooldown, TeleportCause cause) throws Exception
+ //The respawn function is a wrapper used to handle tp fallback, on /jail and /home
+ public void respawn(final Trade chargeFor, TeleportCause cause) throws Exception
{
- if (cooldown)
+ double delay = ess.getSettings().getTeleportDelay();
+ if (chargeFor != null)
+ {
+ chargeFor.isAffordableFor(user);
+ }
+ cooldown(true);
+ if (delay <= 0 || user.isAuthorized("essentials.teleport.timer.bypass"))
{
cooldown(false);
+ respawn(cause);
+ if (chargeFor != null)
+ {
+ chargeFor.charge(user);
+ }
+ return;
}
- now(new Target(entity), cause);
+
+ cancel(false);
+ warnUser(user, delay);
+ initTimer((long)(delay * 1000.0), user, null, chargeFor, cause, true);
+ }
+
+ public void respawn(TeleportCause cause) throws Exception
+ {
+ final Player player = user.getBase();
+ Location bed = player.getBedSpawnLocation();
+ if (bed != null)
+ {
+ now(new Target(bed), cause);
+ }
+ else
+ {
+ if (ess.getSettings().isDebug())
+ {
+ ess.getLogger().info("Could not find bed spawn, forcing respawn event.");
+ }
+ final PlayerRespawnEvent pre = new PlayerRespawnEvent(player, player.getWorld().getSpawnLocation(), false);
+ ess.getServer().getPluginManager().callEvent(pre);
+ now(new Target(pre.getRespawnLocation()), cause);
+ }
+ }
+
+ //The warp function is a wrapper used to teleport a player to a /warp
+ public void warp(String warp, Trade chargeFor, TeleportCause cause) throws Exception
+ {
+ Location loc = ess.getWarps().getWarp(warp);
+ user.sendMessage(_("warpingTo", warp));
+ teleport(new Target(loc), chargeFor, cause);
}
+ //The back function is a wrapper used to teleport a player /back to their previous location.
public void back(Trade chargeFor) throws Exception
{
teleport(new Target(user.getLastLocation()), chargeFor, TeleportCause.COMMAND);
}
+ //This function is used to throw a user back after a jail sentence
public void back() throws Exception
{
now(new Target(user.getLastLocation()), TeleportCause.COMMAND);
}
+ //This function handles teleporting to /home
public void home(Location loc, Trade chargeFor) throws Exception
{
teleport(new Target(loc), chargeFor, TeleportCause.COMMAND);
diff --git a/Essentials/src/com/earth2me/essentials/Trade.java b/Essentials/src/com/earth2me/essentials/Trade.java
index 3d3f36d8c1..457691bbf1 100644
--- a/Essentials/src/com/earth2me/essentials/Trade.java
+++ b/Essentials/src/com/earth2me/essentials/Trade.java
@@ -1,8 +1,8 @@
package com.earth2me.essentials;
+import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
import com.earth2me.essentials.craftbukkit.SetExpFix;
-import static com.earth2me.essentials.I18n._;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
@@ -20,18 +20,25 @@
public class Trade
{
private final transient String command;
- private final transient String fallbackCommand;
+ private final transient Trade fallbackTrade;
private final transient Double money;
private final transient ItemStack itemStack;
private final transient Integer exp;
private final transient IEssentials ess;
-
+
+ public enum TradeType
+ {
+ MONEY,
+ EXP,
+ ITEM
+ }
+
public Trade(final String command, final IEssentials ess)
{
this(command, null, null, null, null, ess);
}
- public Trade(final String command, final String fallback, final IEssentials ess)
+ public Trade(final String command, final Trade fallback, final IEssentials ess)
{
this(command, fallback, null, null, null, ess);
}
@@ -51,10 +58,10 @@ public Trade(final int exp, final IEssentials ess)
this(null, null, null, null, exp, ess);
}
- private Trade(final String command, final String fallback, final Double money, final ItemStack item, final Integer exp, final IEssentials ess)
+ private Trade(final String command, final Trade fallback, final Double money, final ItemStack item, final Integer exp, final IEssentials ess)
{
this.command = command;
- this.fallbackCommand = fallback;
+ this.fallbackTrade = fallback;
this.money = money;
this.itemStack = item;
this.exp = exp;
@@ -63,6 +70,12 @@ private Trade(final String command, final String fallback, final Double money, f
public void isAffordableFor(final IUser user) throws ChargeException
{
+
+ if (ess.getSettings().isDebug())
+ {
+ ess.getLogger().log(Level.INFO, "checking if " + user.getName() + " can afford charge.");
+ }
+
if (getMoney() != null
&& getMoney() > 0
&& !user.canAfford(getMoney()))
@@ -71,7 +84,7 @@ && getMoney() > 0
}
if (getItemStack() != null
- && !InventoryWorkaround.containsItem(user.getInventory(), true, true, itemStack))
+ && !user.getInventory().containsAtLeast(itemStack, itemStack.getAmount()))
{
throw new ChargeException(_("missingItems", getItemStack().getAmount(), getItemStack().getType().toString().toLowerCase(Locale.ENGLISH).replace("_", " ")));
}
@@ -107,7 +120,7 @@ public boolean pay(final IUser user, final boolean dropItems)
{
if (dropItems)
{
- final Map leftOver = InventoryWorkaround.addItem(user.getInventory(), true, getItemStack());
+ final Map leftOver = InventoryWorkaround.addItems(user.getInventory(), getItemStack());
final Location loc = user.getLocation();
for (ItemStack itemStack : leftOver.values())
{
@@ -131,7 +144,7 @@ public boolean pay(final IUser user, final boolean dropItems)
}
else
{
- success = InventoryWorkaround.addAllItems(user.getInventory(), true, getItemStack());
+ success = InventoryWorkaround.addAllItems(user.getInventory(), getItemStack());
}
user.updateInventory();
}
@@ -144,9 +157,14 @@ public boolean pay(final IUser user, final boolean dropItems)
public void charge(final IUser user) throws ChargeException
{
+ if (ess.getSettings().isDebug())
+ {
+ ess.getLogger().log(Level.INFO, "charging user " + user.getName());
+ }
+
if (getMoney() != null)
{
- if (!user.canAfford(getMoney()) && getMoney() > 0)
+ if (!user.canAfford(getMoney()) && getMoney() > 0.0d)
{
throw new ChargeException(_("notEnoughMoney"));
}
@@ -154,17 +172,17 @@ public void charge(final IUser user) throws ChargeException
}
if (getItemStack() != null)
{
- if (!InventoryWorkaround.containsItem(user.getInventory(), true, true, itemStack))
+ if (!user.getInventory().containsAtLeast(itemStack, itemStack.getAmount()))
{
throw new ChargeException(_("missingItems", getItemStack().getAmount(), getItemStack().getType().toString().toLowerCase(Locale.ENGLISH).replace("_", " ")));
}
- InventoryWorkaround.removeItem(user.getInventory(), true, true, getItemStack());
+ user.getInventory().removeItem(getItemStack());
user.updateInventory();
}
if (command != null)
{
final double cost = getCommandCost(user);
- if (!user.canAfford(cost) && cost > 0)
+ if (!user.canAfford(cost) && cost > 0.0d)
{
throw new ChargeException(_("notEnoughMoney"));
}
@@ -195,26 +213,51 @@ public Integer getExperience()
{
return exp;
}
+
+ public TradeType getType()
+ {
+ if (getExperience() != null) {
+ return TradeType.EXP;
+ }
+
+ if (getItemStack() != null)
+ {
+ return TradeType.ITEM;
+ }
+
+ return TradeType.MONEY;
+ }
public Double getCommandCost(final IUser user)
{
- double cost = 0d;
- if (command != null && !command.isEmpty()
- && !user.isAuthorized("essentials.nocommandcost.all")
- && !user.isAuthorized("essentials.nocommandcost." + command))
+ double cost = 0.0d;
+ if (command != null && !command.isEmpty())
{
cost = ess.getSettings().getCommandCost(command.charAt(0) == '/' ? command.substring(1) : command);
- if (cost == 0.0 && fallbackCommand != null && !fallbackCommand.isEmpty())
+ if (cost == 0.0d && fallbackTrade != null)
+ {
+ cost = fallbackTrade.getCommandCost(user);
+ }
+
+ if (ess.getSettings().isDebug())
{
- cost = ess.getSettings().getCommandCost(fallbackCommand.charAt(0) == '/' ? fallbackCommand.substring(1) : fallbackCommand);
+ ess.getLogger().log(Level.INFO, "calculated command (" + command + ") cost for " + user.getName() + " as " + cost);
}
}
+ if (cost != 0.0d && (user.isAuthorized("essentials.nocommandcost.all")
+ || user.isAuthorized("essentials.nocommandcost." + command)))
+ {
+ return 0.0d;
+ }
return cost;
}
private static FileWriter fw = null;
public static void log(String type, String subtype, String event, String sender, Trade charge, String receiver, Trade pay, Location loc, IEssentials ess)
{
+ //isEcoLogUpdateEnabled() - This refers to log entries with no location, ie API updates #EasterEgg
+ //isEcoLogEnabled() - This refers to log entries with with location, ie /pay /sell and eco signs.
+
if ((loc == null && !ess.getSettings().isEcoLogUpdateEnabled())
|| (loc != null && !ess.getSettings().isEcoLogEnabled()))
{
diff --git a/Essentials/src/com/earth2me/essentials/User.java b/Essentials/src/com/earth2me/essentials/User.java
index 3da49ad8b3..a771fae3f4 100644
--- a/Essentials/src/com/earth2me/essentials/User.java
+++ b/Essentials/src/com/earth2me/essentials/User.java
@@ -7,9 +7,13 @@
import java.util.GregorianCalendar;
import java.util.logging.Level;
import java.util.logging.Logger;
+import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
public class User extends UserData implements Comparable, IReplyTo, IUser
@@ -24,8 +28,11 @@ public class User extends UserData implements Comparable, IReplyTo, IUser
private transient long lastThrottledAction;
private transient long lastActivity = System.currentTimeMillis();
private boolean hidden = false;
+ private boolean rightClickJump = false;
private transient Location afkPosition = null;
private boolean invSee = false;
+ private boolean recipeSee = false;
+ private boolean enderSee = false;
private static final Logger logger = Logger.getLogger("Minecraft");
User(final Player base, final IEssentials ess)
@@ -59,21 +66,18 @@ public boolean isAuthorized(final IEssentialsCommand cmd, final String permissio
@Override
public boolean isAuthorized(final String node)
{
+ final boolean result = isAuthorizedCheck(node);
if (ess.getSettings().isDebug())
{
- ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node);
- }
- if (base instanceof OfflinePlayer)
- {
- return false;
+ ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " - " + result);
}
+ return result;
+ }
- if (isOp())
- {
- return true;
- }
+ private boolean isAuthorizedCheck(final String node)
+ {
- if (isJailed())
+ if (base instanceof OfflinePlayer)
{
return false;
}
@@ -84,7 +88,15 @@ public boolean isAuthorized(final String node)
}
catch (Exception ex)
{
- ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage());
+ if (ess.getSettings().isDebug())
+ {
+ ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage(), ex);
+ }
+ else
+ {
+ ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage());
+ }
+
return false;
}
}
@@ -115,7 +127,7 @@ public void giveMoney(final double value)
public void giveMoney(final double value, final CommandSender initiator)
{
- if (value == 0)
+ if (value == 0.0d)
{
return;
}
@@ -129,7 +141,7 @@ public void giveMoney(final double value, final CommandSender initiator)
public void payUser(final User reciever, final double value) throws Exception
{
- if (value == 0)
+ if (value == 0.0d)
{
return;
}
@@ -154,7 +166,7 @@ public void takeMoney(final double value)
public void takeMoney(final double value, final CommandSender initiator)
{
- if (value == 0)
+ if (value == 0.0d)
{
return;
}
@@ -174,6 +186,10 @@ public boolean canAfford(final double cost)
public boolean canAfford(final double cost, final boolean permcheck)
{
+ if (cost <= 0.0d)
+ {
+ return true;
+ }
final double mon = getMoney();
if (!permcheck || isAuthorized("essentials.eco.loan"))
{
@@ -232,20 +248,16 @@ public Location getHome() throws Exception
return getHome(getHomes().get(0));
}
- public void setHome()
- {
- setHome("home", getLocation());
- }
-
- public void setHome(final String name)
+ @Override
+ public void setLastLocation()
{
- setHome(name, getLocation());
+ setLastLocation(getLocation());
}
@Override
- public void setLastLocation()
+ public void setLogoutLocation()
{
- setLastLocation(getLocation());
+ setLogoutLocation(getLocation());
}
public void requestTeleport(final User player, final boolean here)
@@ -271,7 +283,7 @@ public String getNick(final boolean longnick)
String nickname;
String suffix = "";
final String nick = getNickname();
- if (ess.getSettings().isCommandDisabled("nick") || nick == null || nick.isEmpty() || nick.equals(getName()))
+ if (ess.getSettings().isCommandDisabled("nick") || nick == null || nick.isEmpty() || nick.equalsIgnoreCase(getName()))
{
nickname = getName();
}
@@ -284,11 +296,11 @@ public String getNick(final boolean longnick)
{
try
{
- final String opPrefix = ess.getSettings().getOperatorColor().toString();
- if (opPrefix.length() > 0)
+ final ChatColor opPrefix = ess.getSettings().getOperatorColor();
+ if (opPrefix != null && opPrefix.toString().length() > 0)
{
- prefix.insert(0, opPrefix);
- suffix = "§f";
+ prefix.insert(0, opPrefix.toString());
+ suffix = "§r";
}
}
catch (Exception e)
@@ -298,17 +310,18 @@ public String getNick(final boolean longnick)
if (ess.getSettings().addPrefixSuffix())
{
+ //These two extra toggles are not documented, because they are mostly redundant #EasterEgg
if (!ess.getSettings().disablePrefix())
{
final String ptext = ess.getPermissionsHandler().getPrefix(base).replace('&', '§');
prefix.insert(0, ptext);
- suffix = "§f";
+ suffix = "§r";
}
if (!ess.getSettings().disableSuffix())
{
final String stext = ess.getPermissionsHandler().getSuffix(base).replace('&', '§');
- suffix = stext + "§f";
- suffix = suffix.replace("§f§f", "§f");
+ suffix = stext + "§r";
+ suffix = suffix.replace("§f§f", "§f").replace("§f§r", "§r").replace("§r§r", "§r");
}
}
final String strPrefix = prefix.toString();
@@ -325,7 +338,8 @@ public String getNick(final boolean longnick)
{
output = Util.lastCode(strPrefix) + nickname.substring(0, 14);
}
- if (output.charAt(output.length() - 1) == '§') {
+ if (output.charAt(output.length() - 1) == '§')
+ {
output = output.substring(0, output.length() - 1);
}
return output;
@@ -482,6 +496,13 @@ public boolean checkJailTimeout(final long currentTime)
}
catch (Exception ex)
{
+ try
+ {
+ getTeleport().respawn(null, TeleportCause.PLUGIN);
+ }
+ catch (Exception ex1)
+ {
+ }
}
return true;
}
@@ -515,13 +536,17 @@ public boolean checkBanTimeout(final long currentTime)
public void updateActivity(final boolean broadcast)
{
- if (isAfk())
+ if (isAfk() && ess.getSettings().cancelAfkOnInteract())
{
setAfk(false);
if (broadcast && !isHidden())
{
setDisplayNick();
- ess.broadcastMessage(this, _("userIsNotAway", getDisplayName()));
+ final String msg = _("userIsNotAway", getDisplayName());
+ if (!msg.isEmpty())
+ {
+ ess.broadcastMessage(this, msg);
+ }
}
}
lastActivity = System.currentTimeMillis();
@@ -548,13 +573,17 @@ public void checkActivity()
}
}
final long autoafk = ess.getSettings().getAutoAfk();
- if (!isAfk() && autoafk > 0 && lastActivity + autoafk * 1000 < System.currentTimeMillis() && isAuthorized("essentials.afk"))
+ if (!isAfk() && autoafk > 0 && lastActivity + autoafk * 1000 < System.currentTimeMillis() && isAuthorized("essentials.afk.auto"))
{
setAfk(true);
if (!isHidden())
{
setDisplayNick();
- ess.broadcastMessage(this, _("userIsAway", getDisplayName()));
+ final String msg = _("userIsAway", getDisplayName());
+ if (!msg.isEmpty())
+ {
+ ess.broadcastMessage(this, msg);
+ }
}
}
}
@@ -610,6 +639,16 @@ public void setInvSee(final boolean set)
{
invSee = set;
}
+
+ public boolean isEnderSee()
+ {
+ return enderSee;
+ }
+
+ public void setEnderSee(final boolean set)
+ {
+ enderSee = set;
+ }
private transient long teleportInvulnerabilityTimestamp = 0;
public void enableInvulnerabilityAfterTeleport()
@@ -639,7 +678,7 @@ public boolean isVanished()
{
return vanished;
}
-
+
public void setVanished(final boolean set)
{
vanished = set;
@@ -654,6 +693,10 @@ public void setVanished(final boolean set)
}
setHidden(true);
ess.getVanishedPlayers().add(getName());
+ if (isAuthorized("essentials.vanish.effect"))
+ {
+ this.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, Integer.MAX_VALUE, 1, false));
+ }
}
else
{
@@ -663,6 +706,10 @@ public void setVanished(final boolean set)
}
setHidden(false);
ess.getVanishedPlayers().remove(getName());
+ if (isAuthorized("essentials.vanish.effect"))
+ {
+ this.removePotionEffect(PotionEffectType.INVISIBILITY);
+ }
}
}
@@ -671,23 +718,51 @@ public void toggleVanished()
final boolean set = !vanished;
this.setVanished(set);
}
-
- public boolean checkSignThrottle() {
- if (isSignThrottled()) {
+
+ public boolean checkSignThrottle()
+ {
+ if (isSignThrottled())
+ {
return true;
}
updateThrottle();
return false;
}
-
+
public boolean isSignThrottled()
{
final long minTime = lastThrottledAction + (1000 / ess.getSettings().getSignUsePerSecond());
return (System.currentTimeMillis() < minTime);
}
-
+
public void updateThrottle()
{
lastThrottledAction = System.currentTimeMillis();;
}
+
+ public boolean isFlyClickJump()
+ {
+ return rightClickJump;
+ }
+
+ public void setRightClickJump(boolean rightClickJump)
+ {
+ this.rightClickJump = rightClickJump;
+ }
+
+ @Override
+ public boolean isIgnoreExempt()
+ {
+ return this.isAuthorized("essentials.chat.ignoreexempt");
+ }
+
+ public boolean isRecipeSee()
+ {
+ return recipeSee;
+ }
+
+ public void setRecipeSee(boolean recipeSee)
+ {
+ this.recipeSee = recipeSee;
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/UserData.java b/Essentials/src/com/earth2me/essentials/UserData.java
index 7dd9ebf97f..1769c0f030 100644
--- a/Essentials/src/com/earth2me/essentials/UserData.java
+++ b/Essentials/src/com/earth2me/essentials/UserData.java
@@ -4,6 +4,7 @@
import java.io.File;
import java.util.*;
import org.bukkit.Location;
+import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
@@ -11,13 +12,14 @@
public abstract class UserData extends PlayerExtension implements IConf
{
protected final transient IEssentials ess;
- private final EssentialsConf config;
+ private EssentialsConf config;
+ private final File folder;
protected UserData(Player base, IEssentials ess)
{
super(base);
this.ess = ess;
- File folder = new File(ess.getDataFolder(), "userdata");
+ folder = new File(ess.getDataFolder(), "userdata");
if (!folder.exists())
{
folder.mkdirs();
@@ -26,6 +28,13 @@ protected UserData(Player base, IEssentials ess)
reloadConfig();
}
+ public final void reset()
+ {
+ config.getFile().delete();
+ config = new EssentialsConf(new File(folder, Util.sanitizeFileName(base.getName()) + ".yml"));
+ reloadConfig();
+ }
+
@Override
public final void reloadConfig()
{
@@ -39,23 +48,24 @@ public final void reloadConfig()
lastHealTimestamp = _getLastHealTimestamp();
jail = _getJail();
mails = _getMails();
- teleportEnabled = getTeleportEnabled();
- ignoredPlayers = getIgnoredPlayers();
+ teleportEnabled = _getTeleportEnabled();
godmode = _getGodModeEnabled();
- muted = getMuted();
+ muted = _getMuted();
muteTimeout = _getMuteTimeout();
- jailed = getJailed();
+ jailed = _getJailed();
jailTimeout = _getJailTimeout();
lastLogin = _getLastLogin();
lastLogout = _getLastLogout();
lastLoginAddress = _getLastLoginAddress();
- afk = getAfk();
+ afk = _getAfk();
geolocation = _getGeoLocation();
isSocialSpyEnabled = _isSocialSpyEnabled();
isNPC = _isNPC();
arePowerToolsEnabled = _arePowerToolsEnabled();
kitTimestamps = _getKitTimestamps();
nickname = _getNickname();
+ setIgnoredPlayers(_getIgnoredPlayers());
+ logoutLocation = _getLogoutLocation();
}
private double money;
@@ -99,26 +109,25 @@ private Map _getHomes()
return new HashMap();
}
- public Location getHome(String name) throws Exception
+ private String getHomeName(String search)
{
- Location loc = config.getLocation("homes." + name, getServer());
- if (loc == null)
+ if (Util.isInt(search))
{
try
{
- loc = config.getLocation("homes." + getHomes().get(Integer.parseInt(name) - 1), getServer());
- }
- catch (IndexOutOfBoundsException e)
- {
- return null;
+ search = getHomes().get(Integer.parseInt(search) - 1);
}
- catch (NumberFormatException e)
+ catch (Exception e)
{
- return null;
}
}
-
- return loc;
+ return search;
+ }
+
+ public Location getHome(String name) throws Exception
+ {
+ String search = getHomeName(name);
+ return config.getLocation("homes." + search, getServer());
}
public Location getHome(final Location world)
@@ -152,7 +161,7 @@ public List getHomes()
public void setHome(String name, Location loc)
{
//Invalid names will corrupt the yaml
- name = Util.sanitizeFileName(name);
+ name = Util.safeString(name);
homes.put(name, loc);
config.setProperty("homes." + name, loc);
config.save();
@@ -160,20 +169,20 @@ public void setHome(String name, Location loc)
public void delHome(String name) throws Exception
{
- String search = name;
+ String search = getHomeName(name);
if (!homes.containsKey(search))
{
- search = Util.sanitizeFileName(name);
+ search = Util.safeString(search);
}
if (homes.containsKey(search))
{
- homes.remove(name);
- config.removeProperty("homes." + name);
+ homes.remove(search);
+ config.removeProperty("homes." + search);
config.save();
}
else
{
- throw new Exception(_("invalidHome", name));
+ throw new Exception(_("invalidHome", search));
}
}
@@ -310,6 +319,37 @@ public void setLastLocation(Location loc)
config.setProperty("lastlocation", loc);
config.save();
}
+
+ private Location logoutLocation;
+
+ private Location _getLogoutLocation()
+ {
+ try
+ {
+ return config.getLocation("logoutlocation", getServer());
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ public Location getLogoutLocation()
+ {
+ return logoutLocation;
+ }
+
+ public void setLogoutLocation(Location loc)
+ {
+ if (loc == null || loc.getWorld() == null)
+ {
+ return;
+ }
+ logoutLocation = loc;
+ config.setProperty("logoutlocation", loc);
+ config.save();
+ }
+
private long lastTeleportTimestamp;
private long _getLastTeleportTimestamp()
@@ -406,7 +446,7 @@ public void addMail(String mail)
}
private boolean teleportEnabled;
- private boolean getTeleportEnabled()
+ private boolean _getTeleportEnabled()
{
return config.getBoolean("teleportenabled", true);
}
@@ -438,16 +478,16 @@ public boolean toggleSocialSpy()
}
private List ignoredPlayers;
- public List getIgnoredPlayers()
+ public List _getIgnoredPlayers()
{
- return config.getStringList("ignore");
+ return Collections.synchronizedList(config.getStringList("ignore"));
}
public void setIgnoredPlayers(List players)
{
if (players == null || players.isEmpty())
{
- ignoredPlayers = new ArrayList();
+ ignoredPlayers = Collections.synchronizedList(new ArrayList());
config.removeProperty("ignore");
}
else
@@ -466,12 +506,12 @@ public boolean isIgnoredPlayer(final String userName)
{
return false;
}
- return isIgnoredPlayer(user);
+ return isIgnoredPlayer(user);
}
public boolean isIgnoredPlayer(IUser user)
{
- return (ignoredPlayers.contains(user.getName().toLowerCase(Locale.ENGLISH)) && !user.isAuthorized("essentials.chat.ignoreexempt"));
+ return (ignoredPlayers.contains(user.getName().toLowerCase(Locale.ENGLISH)) && !user.isIgnoreExempt());
}
public void setIgnoredPlayer(IUser user, boolean set)
@@ -506,10 +546,15 @@ public void setGodModeEnabled(boolean set)
}
private boolean muted;
- public boolean getMuted()
+ public boolean _getMuted()
{
return config.getBoolean("muted", false);
}
+
+ public boolean getMuted()
+ {
+ return muted;
+ }
public boolean isMuted()
{
@@ -542,7 +587,7 @@ public void setMuteTimeout(long time)
}
private boolean jailed;
- private boolean getJailed()
+ private boolean _getJailed()
{
return config.getBoolean("jailed", false);
}
@@ -586,7 +631,7 @@ public void setJailTimeout(long time)
public String getBanReason()
{
- return config.getString("ban.reason");
+ return config.getString("ban.reason", "");
}
public void setBanReason(String reason)
@@ -626,7 +671,10 @@ private void _setLastLogin(long time)
public void setLastLogin(long time)
{
_setLastLogin(time);
- _setLastLoginAddress(base.getAddress().getAddress().getHostAddress());
+ if (base.getAddress() != null && base.getAddress().getAddress() != null)
+ {
+ _setLastLoginAddress(base.getAddress().getAddress().getHostAddress());
+ }
config.save();
}
private long lastLogout;
@@ -666,7 +714,7 @@ private void _setLastLoginAddress(String address)
}
private boolean afk;
- private boolean getAfk()
+ private boolean _getAfk()
{
return config.getBoolean("afk", false);
}
@@ -777,22 +825,39 @@ private boolean _arePowerToolsEnabled()
{
return config.getBoolean("powertoolsenabled", true);
}
- private Map kitTimestamps;
-
- private Map _getKitTimestamps()
+ private Map kitTimestamps;
+
+ private Map _getKitTimestamps()
{
-
+
if (config.isConfigurationSection("timestamps.kits"))
{
- return config.getConfigurationSection("timestamps.kits").getValues(false);
+ final ConfigurationSection section = config.getConfigurationSection("timestamps.kits");
+ final Map timestamps = new HashMap();
+ for (String command : section.getKeys(false))
+ {
+ if (section.isLong(command))
+ {
+ timestamps.put(command.toLowerCase(Locale.ENGLISH), section.getLong(command));
+ }
+ else if (section.isInt(command))
+ {
+ timestamps.put(command.toLowerCase(Locale.ENGLISH), (long)section.getInt(command));
+ }
+ }
+ return timestamps;
}
- return new HashMap();
+ return new HashMap();
}
-
- public Long getKitTimestamp(final String name)
+
+ public long getKitTimestamp(String name)
{
- final Number num = (Number)kitTimestamps.get(name.toLowerCase(Locale.ENGLISH));
- return num == null ? null : num.longValue();
+ name = name.replace('.', '_').replace('/', '_');
+ if (kitTimestamps != null && kitTimestamps.containsKey(name))
+ {
+ return kitTimestamps.get(name);
+ }
+ return 0l;
}
public void setKitTimestamp(final String name, final long time)
@@ -802,6 +867,60 @@ public void setKitTimestamp(final String name, final long time)
config.save();
}
+ public void setConfigProperty(String node, Object object)
+ {
+ final String prefix = "info.";
+ node = prefix+node;
+ if (object instanceof Map)
+ {
+ config.setProperty(node, (Map) object);
+ }
+ else if (object instanceof List)
+ {
+ config.setProperty(node, (List) object);
+ }
+ else if (object instanceof Location)
+ {
+ config.setProperty(node, (Location) object);
+ }
+ else if (object instanceof ItemStack)
+ {
+ config.setProperty(node, (ItemStack) object);
+ }
+ else
+ {
+ config.setProperty(node, object);
+ }
+ config.save();
+ }
+
+ public Set getConfigKeys()
+ {
+ if (config.isConfigurationSection("info"))
+ {
+ return config.getConfigurationSection("info").getKeys(true);
+ }
+ return new HashSet();
+ }
+
+ public Map getConfigMap()
+ {
+ if (config.isConfigurationSection("info"))
+ {
+ return config.getConfigurationSection("info").getValues(true);
+ }
+ return new HashMap();
+ }
+
+ public Map getConfigMap(String node)
+ {
+ if (config.isConfigurationSection("info."+node))
+ {
+ return config.getConfigurationSection("info."+node).getValues(true);
+ }
+ return new HashMap();
+ }
+
public void save()
{
config.save();
diff --git a/Essentials/src/com/earth2me/essentials/UserMap.java b/Essentials/src/com/earth2me/essentials/UserMap.java
index 94b5042414..19cfb98e91 100644
--- a/Essentials/src/com/earth2me/essentials/UserMap.java
+++ b/Essentials/src/com/earth2me/essentials/UserMap.java
@@ -27,7 +27,7 @@ public UserMap(final IEssentials ess)
private void loadAllUsersAsync(final IEssentials ess)
{
- ess.scheduleAsyncDelayedTask(new Runnable()
+ ess.runTaskAsynchronously(new Runnable()
{
@Override
public void run()
diff --git a/Essentials/src/com/earth2me/essentials/Util.java b/Essentials/src/com/earth2me/essentials/Util.java
index 112477ecb9..677aa230fa 100644
--- a/Essentials/src/com/earth2me/essentials/Util.java
+++ b/Essentials/src/com/earth2me/essentials/Util.java
@@ -1,6 +1,7 @@
package com.earth2me.essentials;
import static com.earth2me.essentials.I18n._;
+import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
@@ -24,12 +25,19 @@ private Util()
private final static Pattern INVALIDFILECHARS = Pattern.compile("[^a-z0-9]");
private final static Pattern INVALIDCHARS = Pattern.compile("[^\t\n\r\u0020-\u007E\u0085\u00A0-\uD7FF\uE000-\uFFFC]");
+ //Used to clean file names before saving to disk
public static String sanitizeFileName(final String name)
{
- final String newName = INVALIDFILECHARS.matcher(name.toLowerCase(Locale.ENGLISH)).replaceAll("_");
- return newName;
+ return safeString(name);
}
+ //Used to clean strings/names before saving as filenames/permissions
+ public static String safeString(final String string)
+ {
+ return INVALIDFILECHARS.matcher(string.toLowerCase(Locale.ENGLISH)).replaceAll("_");
+ }
+
+ //Less restrictive string sanitizing, when not used as perm or filename
public static String sanitizeString(final String string)
{
return INVALIDCHARS.matcher(string).replaceAll("");
@@ -215,10 +223,11 @@ public static long parseDateDiff(String time, boolean future) throws Exception
{
c.add(Calendar.SECOND, seconds * (future ? 1 : -1));
}
-
+
Calendar max = new GregorianCalendar();
max.add(Calendar.YEAR, 10);
- if (c.after(max)) {
+ if (c.after(max))
+ {
return max.getTimeInMillis();
}
return c.getTimeInMillis();
@@ -284,6 +293,46 @@ public static Location getTarget(final LivingEntity entity) throws Exception
}
return block.getLocation();
}
+ public final static int RADIUS = 3;
+ public final static Vector3D[] VOLUME;
+
+
+ public static class Vector3D
+ {
+ public Vector3D(int x, int y, int z)
+ {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+ public int x;
+ public int y;
+ public int z;
+ }
+
+ static
+ {
+ List pos = new ArrayList();
+ for (int x = -RADIUS; x <= RADIUS; x++)
+ {
+ for (int y = -RADIUS; y <= RADIUS; y++)
+ {
+ for (int z = -RADIUS; z <= RADIUS; z++)
+ {
+ pos.add(new Vector3D(x, y, z));
+ }
+ }
+ }
+ Collections.sort(pos, new Comparator()
+ {
+ @Override
+ public int compare(Vector3D a, Vector3D b)
+ {
+ return (a.x * a.x + a.y * a.y + a.z * a.z) - (b.x * b.x + b.y * b.y + b.z * b.z);
+ }
+ });
+ VOLUME = pos.toArray(new Vector3D[0]);
+ }
public static Location getSafeDestination(final Location loc) throws Exception
{
@@ -295,25 +344,46 @@ public static Location getSafeDestination(final Location loc) throws Exception
int x = loc.getBlockX();
int y = (int)Math.round(loc.getY());
int z = loc.getBlockZ();
+ final int origX = x;
+ final int origY = y;
+ final int origZ = z;
while (isBlockAboveAir(world, x, y, z))
{
y -= 1;
if (y < 0)
{
+ y = origY;
break;
}
}
+ int i = 0;
+ while (isBlockUnsafe(world, x, y, z))
+ {
+ i++;
+ if (i >= VOLUME.length)
+ {
+ x = origX;
+ y = origY + RADIUS;
+ z = origZ;
+ break;
+ }
+ x = origX + VOLUME[i].x;
+ y = origY + VOLUME[i].y;
+ z = origZ + VOLUME[i].z;
+ }
+
while (isBlockUnsafe(world, x, y, z))
{
y += 1;
- if (y >= world.getHighestBlockYAt(x, z))
+ if (y >= world.getMaxHeight())
{
x += 1;
break;
}
}
+
while (isBlockUnsafe(world, x, y, z))
{
y -= 1;
@@ -321,7 +391,7 @@ public static Location getSafeDestination(final Location loc) throws Exception
{
x += 1;
y = world.getHighestBlockYAt(x, z);
- if (x - 32 > loc.getBlockX())
+ if (x - 48 > loc.getBlockX())
{
throw new Exception(_("holeInFloor"));
}
@@ -336,6 +406,15 @@ private static boolean isBlockAboveAir(final World world, final int x, final int
}
public static boolean isBlockUnsafe(final World world, final int x, final int y, final int z)
+ {
+ if (isBlockDamaging(world, x, y, z))
+ {
+ return true;
+ }
+ return isBlockAboveAir(world, x, y, z);
+ }
+
+ public static boolean isBlockDamaging(final World world, final int x, final int y, final int z)
{
final Block below = world.getBlockAt(x, y - 1, z);
if (below.getType() == Material.LAVA || below.getType() == Material.STATIONARY_LAVA)
@@ -348,12 +427,17 @@ public static boolean isBlockUnsafe(final World world, final int x, final int y,
return true;
}
+ if (below.getType() == Material.BED_BLOCK)
+ {
+ return true;
+ }
+
if ((!AIR_MATERIALS.contains(world.getBlockAt(x, y, z).getType().getId()))
|| (!AIR_MATERIALS.contains(world.getBlockAt(x, y + 1, z).getType().getId())))
{
return true;
}
- return isBlockAboveAir(world, x, y, z);
+ return false;
}
public static ItemStack convertBlockToItem(final Block block)
@@ -441,6 +525,7 @@ public static ItemStack convertBlockToItem(final Block block)
public static String formatAsCurrency(final double value)
{
+ dFormat.setRoundingMode(RoundingMode.FLOOR);
String str = dFormat.format(value);
if (str.endsWith(".00"))
{
@@ -459,11 +544,6 @@ public static String shortCurrency(final double value, final IEssentials ess)
return ess.getSettings().getCurrencySymbol() + formatAsCurrency(value);
}
- public static double roundDouble(final double d)
- {
- return Math.round(d * 100.0) / 100.0;
- }
-
public static boolean isInt(final String sInt)
{
try
@@ -510,17 +590,19 @@ public static String joinList(String seperator, Object... list)
}
return buf.toString();
}
-
- public static String lastCode(final String input) {
+
+ public static String lastCode(final String input)
+ {
int pos = input.lastIndexOf("§");
- if (pos == -1 || (pos + 1) == input.length()) {
+ if (pos == -1 || (pos + 1) == input.length())
+ {
return "";
}
- return input.substring(pos, pos + 2);
+ return input.substring(pos, pos + 2);
}
-
private static transient final Pattern URL_PATTERN = Pattern.compile("((?:(?:https?)://)?[\\w-_\\.]{2,})\\.([a-z]{2,3}(?:/\\S+)?)");
- private static transient final Pattern VANILLA_PATTERN = Pattern.compile("\u00A7+[0-9A-FK-ORa-fk-or]");
+ private static transient final Pattern VANILLA_PATTERN = Pattern.compile("\u00A7+[0-9A-FK-ORa-fk-or]?");
+ private static transient final Pattern LOGCOLOR_PATTERN = Pattern.compile("\\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]");
private static transient final Pattern REPLACE_PATTERN = Pattern.compile("&([0-9a-fk-or])");
private static transient final Pattern VANILLA_COLOR_PATTERN = Pattern.compile("\u00A7+[0-9A-Fa-f]");
private static transient final Pattern VANILLA_MAGIC_PATTERN = Pattern.compile("\u00A7+[Kk]");
@@ -529,6 +611,7 @@ public static String lastCode(final String input) {
private static transient final Pattern REPLACE_MAGIC_PATTERN = Pattern.compile("&(k)");
private static transient final Pattern REPLACE_FORMAT_PATTERN = Pattern.compile("&([l-or])");
+ //This method is used to simply strip the native minecraft colour codes
public static String stripFormat(final String input)
{
if (input == null)
@@ -538,29 +621,26 @@ public static String stripFormat(final String input)
return VANILLA_PATTERN.matcher(input).replaceAll("");
}
- public static String replaceFormat(final String input)
+ public static String stripLogColorFormat(final String input)
{
if (input == null)
{
return null;
}
- return REPLACE_PATTERN.matcher(input).replaceAll("\u00a7$1");
+ return LOGCOLOR_PATTERN.matcher(input).replaceAll("");
}
- public static String blockURL(final String input)
+ //This method is used to simply replace the ess colour codes with minecraft ones, ie &c
+ public static String replaceFormat(final String input)
{
if (input == null)
{
return null;
}
- String text = URL_PATTERN.matcher(input).replaceAll("$1 $2");
- while (URL_PATTERN.matcher(text).find())
- {
- text = URL_PATTERN.matcher(text).replaceAll("$1 $2");
- }
- return text;
+ return REPLACE_PATTERN.matcher(input).replaceAll("\u00a7$1");
}
+ //This is the general permission sensitive message format function, does not touch urls.
public static String formatString(final IUser user, final String permBase, final String input)
{
if (input == null)
@@ -595,6 +675,7 @@ public static String formatString(final IUser user, final String permBase, final
return message;
}
+ //This is the general permission sensitive message format function, checks for urls.
public static String formatMessage(final IUser user, final String permBase, final String input)
{
if (input == null)
@@ -609,6 +690,20 @@ public static String formatMessage(final IUser user, final String permBase, fina
return message;
}
+ private static String blockURL(final String input)
+ {
+ if (input == null)
+ {
+ return null;
+ }
+ String text = URL_PATTERN.matcher(input).replaceAll("$1 $2");
+ while (URL_PATTERN.matcher(text).find())
+ {
+ text = URL_PATTERN.matcher(text).replaceAll("$1 $2");
+ }
+ return text;
+ }
+
private static String stripColor(final String input, final Pattern pattern)
{
return pattern.matcher(input).replaceAll("");
@@ -618,4 +713,11 @@ private static String replaceColor(final String input, final Pattern pattern)
{
return pattern.matcher(input).replaceAll("\u00a7$1");
}
+ private static final Pattern IPPATTERN = Pattern.compile(
+ "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
+ "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");
+
+ public static boolean validIP(String ipAddress) {
+ return IPPATTERN.matcher(ipAddress).matches();
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/Warps.java b/Essentials/src/com/earth2me/essentials/Warps.java
index ece987aba6..39f31369c3 100644
--- a/Essentials/src/com/earth2me/essentials/Warps.java
+++ b/Essentials/src/com/earth2me/essentials/Warps.java
@@ -1,8 +1,11 @@
package com.earth2me.essentials;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.api.IWarps;
+import com.earth2me.essentials.api.InvalidNameException;
import com.earth2me.essentials.commands.WarpNotFoundException;
import java.io.File;
+import java.io.IOException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -10,7 +13,7 @@
import org.bukkit.Server;
-public class Warps implements IConf
+public class Warps implements IConf, IWarps
{
private static final Logger logger = Logger.getLogger("Minecraft");
private final Map warpPoints = new HashMap();
@@ -28,6 +31,7 @@ public Warps(Server server, File dataFolder)
reloadConfig();
}
+ @Override
public boolean isEmpty()
{
return warpPoints.isEmpty();
@@ -44,6 +48,7 @@ public Collection getWarpNames()
return keys;
}
+ @Override
public Location getWarp(String warp) throws Exception
{
EssentialsConf conf = warpPoints.get(new StringIgnoreCase(warp));
@@ -54,6 +59,7 @@ public Location getWarp(String warp) throws Exception
return conf.getLocation(null, server);
}
+ @Override
public void setWarp(String name, Location loc) throws Exception
{
String filename = Util.sanitizeFileName(name);
@@ -70,7 +76,14 @@ public void setWarp(String name, Location loc) throws Exception
}
conf.setProperty(null, loc);
conf.setProperty("name", name);
- conf.save();
+ try
+ {
+ conf.saveWithError();
+ }
+ catch (IOException ex)
+ {
+ throw new IOException(_("invalidWarpName"));
+ }
}
public void delWarp(String name) throws Exception
@@ -118,6 +131,26 @@ public final void reloadConfig()
}
}
+ // This is for api support, and so 3.x will not break this api
+ @Override
+ public Collection getList()
+ {
+ return getWarpNames();
+ }
+
+ // This is for api support, and so 3.x will not break this api
+ @Override
+ public void removeWarp(String name) throws Exception
+ {
+ delWarp(name);
+ }
+
+ //This is here for future 3.x api support. Not implemented here becasue storage is handled differently
+ @Override
+ public File getWarpFile(String name) throws InvalidNameException
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
private static class StringIgnoreCase
{
diff --git a/Essentials/src/com/earth2me/essentials/api/Economy.java b/Essentials/src/com/earth2me/essentials/api/Economy.java
index 6ed1829b30..c22145a133 100644
--- a/Essentials/src/com/earth2me/essentials/api/Economy.java
+++ b/Essentials/src/com/earth2me/essentials/api/Economy.java
@@ -8,7 +8,6 @@
import java.io.File;
import java.util.logging.Level;
import java.util.logging.Logger;
-import org.bukkit.entity.Player;
/**
@@ -43,7 +42,7 @@ private static void createNPCFile(String name)
npcConfig.load();
npcConfig.setProperty("npc", true);
npcConfig.setProperty("money", ess.getSettings().getStartingBalance());
- npcConfig.save();
+ npcConfig.forceSave();
}
private static void deleteNPC(String name)
@@ -72,17 +71,7 @@ private static User getUserByName(String name)
{
throw new RuntimeException(noCallBeforeLoad);
}
- User user;
- Player player = ess.getServer().getPlayer(name);
- if (player != null)
- {
- user = ess.getUser(player);
- }
- else
- {
- user = ess.getOfflineUser(name);
- }
- return user;
+ return ess.getUser(name);
}
/**
diff --git a/Essentials/src/com/earth2me/essentials/api/IAlternativeCommandsHandler.java b/Essentials/src/com/earth2me/essentials/api/IAlternativeCommandsHandler.java
deleted file mode 100644
index 11619bca4f..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IAlternativeCommandsHandler.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.earth2me.essentials.api;
-
-import java.util.Map;
-import org.bukkit.command.PluginCommand;
-
-
-public interface IAlternativeCommandsHandler
-{
- Map disabledCommands();
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/IEssentials.java b/Essentials/src/com/earth2me/essentials/api/IEssentials.java
deleted file mode 100644
index c04bed0bd9..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IEssentials.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package com.earth2me.essentials.api;
-
-import com.earth2me.essentials.perm.IPermissionsHandler;
-import com.earth2me.essentials.register.payment.Methods;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.plugin.Plugin;
-
-
-public interface IEssentials extends Plugin, IReload
-{
- void addReloadListener(IReload listener);
-
- IUser getUser(Object base);
-
- int broadcastMessage(IUser sender, String message);
-
- II18n getI18n();
-
- ISettings getSettings();
-
- IJails getJail();
-
- IWarps getWarps();
-
- IWorth getWorth();
-
- IItemDb getItemDb();
-
- IUserMap getUserMap();
-
- IEssentialsEconomy getEconomy();
-
- World getWorld(String name);
-
- Methods getPaymentMethod();
-
- int scheduleAsyncDelayedTask(Runnable run);
-
- int scheduleSyncDelayedTask(Runnable run);
-
- int scheduleSyncDelayedTask(Runnable run, long delay);
-
- int scheduleSyncRepeatingTask(Runnable run, long delay, long period);
-
- IPermissionsHandler getPermissionsHandler();
-
- IAlternativeCommandsHandler getAlternativeCommandsHandler();
-
- void showCommandError(CommandSender sender, String commandLabel, Throwable exception);
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/IEssentialsEconomy.java b/Essentials/src/com/earth2me/essentials/api/IEssentialsEconomy.java
deleted file mode 100644
index 72fb89d262..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IEssentialsEconomy.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package com.earth2me.essentials.api;
-
-
-public interface IEssentialsEconomy
-{
- double getMoney(String name) throws UserDoesNotExistException;
-
- void setMoney(String name, double balance) throws UserDoesNotExistException, NoLoanPermittedException;
-
- void add(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException;
-
- void subtract(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException;
-
- void divide(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException;
-
- void multiply(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException;
-
- void resetBalance(String name) throws UserDoesNotExistException, NoLoanPermittedException;
-
- boolean hasEnough(String name, double amount) throws UserDoesNotExistException;
-
- boolean hasMore(String name, double amount) throws UserDoesNotExistException;
-
- boolean hasLess(String name, double amount) throws UserDoesNotExistException;
-
- boolean isNegative(String name) throws UserDoesNotExistException;
-
- String format(double amount);
-
- boolean playerExists(String name);
-
- boolean isNPC(String name) throws UserDoesNotExistException;
-
- boolean createNPC(String name);
-
- void removeNPC(String name) throws UserDoesNotExistException;
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/ISettings.java b/Essentials/src/com/earth2me/essentials/api/ISettings.java
deleted file mode 100644
index eff65ad872..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/ISettings.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.earth2me.essentials.api;
-
-import com.earth2me.essentials.settings.Settings;
-import com.earth2me.essentials.storage.IStorageObjectHolder;
-
-
-public interface ISettings extends IStorageObjectHolder
-{
-
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/IUser.java b/Essentials/src/com/earth2me/essentials/api/IUser.java
deleted file mode 100644
index 5d2f9d4b87..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IUser.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package com.earth2me.essentials.api;
-
-import com.earth2me.essentials.commands.IEssentialsCommand;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-
-public interface IUser extends Player, IReload
-{
- long getLastTeleportTimestamp();
-
- boolean isAuthorized(String node);
-
- boolean isAuthorized(IEssentialsCommand cmd);
-
- boolean isAuthorized(IEssentialsCommand cmd, String permissionPrefix);
-
- void setLastTeleportTimestamp(long time);
-
- Location getLastLocation();
-
- Player getBase();
-
- double getMoney();
-
- void takeMoney(double value);
-
- void giveMoney(double value);
-
- String getGroup();
-
- void setLastLocation();
-
- Location getHome(String name) throws Exception;
-
- Location getHome(Location loc) throws Exception;
-
- boolean isHidden();
-
- ITeleport getTeleport();
-
- void setJail(String jail);
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/IUserMap.java b/Essentials/src/com/earth2me/essentials/api/IUserMap.java
deleted file mode 100644
index 9e609ab378..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IUserMap.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.earth2me.essentials.api;
-
-import java.io.File;
-import java.util.Set;
-
-
-public interface IUserMap
-{
- boolean userExists(final String name);
-
- IUser getUser(final String name);
-
- void removeUser(final String name);
-
- Set getAllUniqueUsers();
-
- int getUniqueUsers();
-
- File getUserFile(final String name);
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/IWarps.java b/Essentials/src/com/earth2me/essentials/api/IWarps.java
index 14779e327f..8bab073974 100644
--- a/Essentials/src/com/earth2me/essentials/api/IWarps.java
+++ b/Essentials/src/com/earth2me/essentials/api/IWarps.java
@@ -1,16 +1,60 @@
package com.earth2me.essentials.api;
+import java.io.File;
import java.util.Collection;
import org.bukkit.Location;
-public interface IWarps extends IReload
+public interface IWarps
{
+ /**
+ * Get a warp by name
+ *
+ * @param warp - Warp name
+ * @return - Location the warp is set to
+ * @throws Exception
+ */
Location getWarp(String warp) throws Exception;
- Collection getWarps();
+ /**
+ * Gets a list of warps
+ *
+ * @return - A {@link Collection} of warps
+ */
+ Collection getList();
+ /**
+ * Delete a warp from the warp DB
+ *
+ * @param name - Name of warp
+ * @throws Exception
+ */
void removeWarp(String name) throws Exception;
+ /**
+ * Set a warp
+ *
+ * @param name - Name of warp
+ * @param loc - Location of warp
+ * @throws Exception
+ */
void setWarp(String name, Location loc) throws Exception;
+
+ /**
+ * Check to see if the file is empty
+ *
+ * @return
+ */
+ boolean isEmpty();
+
+ /**
+ * Get a warp file
+ * note: this is not yet implemented, as 3.x uses different storage methods
+ *
+ * @param name - name of file
+ * @return - an instance of the file
+ * @throws InvalidNameException - When the file is not found
+ */
+ File getWarpFile(String name) throws InvalidNameException;
+
}
diff --git a/Essentials/src/com/earth2me/essentials/api/IWorth.java b/Essentials/src/com/earth2me/essentials/api/IWorth.java
deleted file mode 100644
index 4add987712..0000000000
--- a/Essentials/src/com/earth2me/essentials/api/IWorth.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.earth2me.essentials.api;
-
-import org.bukkit.inventory.ItemStack;
-
-
-public interface IWorth extends IReload
-{
- double getPrice(ItemStack itemStack);
-
- void setPrice(ItemStack itemStack, double price);
-}
diff --git a/Essentials/src/com/earth2me/essentials/api/InvalidNameException.java b/Essentials/src/com/earth2me/essentials/api/InvalidNameException.java
new file mode 100644
index 0000000000..b62a74ce3f
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/api/InvalidNameException.java
@@ -0,0 +1,16 @@
+package com.earth2me.essentials.api;
+
+
+public class InvalidNameException extends Exception
+{
+ /**
+ * NOTE: This is not implemented yet, just here for future 3.x api support
+ * Allow serialization of the InvalidNameException exception
+ */
+ private static final long serialVersionUID = 1485321420293663139L;
+
+ public InvalidNameException(Throwable thrwbl)
+ {
+ super(thrwbl);
+ }
+}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandafk.java b/Essentials/src/com/earth2me/essentials/commands/Commandafk.java
index c718835710..f426769424 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandafk.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandafk.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import org.bukkit.command.CommandSender;
import org.bukkit.Server;
@@ -17,27 +18,39 @@ public void run(Server server, User user, String commandLabel, String[] args) th
{
if (args.length > 0 && user.isAuthorized("essentials.afk.others"))
{
- User afkUser = ess.getUser(ess.getServer().matchPlayer(args[0]));
- if (afkUser != null)
- {
- toggleAfk(afkUser);
- }
+ User afkUser = getPlayer(server, user, args, 0);
+ toggleAfk(afkUser);
}
else
{
toggleAfk(user);
}
}
+
+ @Override
+ public void run(Server server, CommandSender sender, String commandLabel, String[] args) throws Exception
+ {
+ if (args.length > 0)
+ {
+ User afkUser = getPlayer(server, args, 0, true, false);
+ toggleAfk(afkUser);
+ }
+ else
+ {
+ throw new NotEnoughArgumentsException();
+ }
+ }
private void toggleAfk(User user)
{
user.setDisplayNick();
+ String msg = "";
if (!user.toggleAfk())
{
//user.sendMessage(_("markedAsNotAway"));
if (!user.isHidden())
{
- ess.broadcastMessage(user, _("userIsNotAway", user.getDisplayName()));
+ msg = _("userIsNotAway", user.getDisplayName());
}
user.updateActivity(false);
}
@@ -46,8 +59,13 @@ private void toggleAfk(User user)
//user.sendMessage(_("markedAsAway"));
if (!user.isHidden())
{
- ess.broadcastMessage(user, _("userIsAway", user.getDisplayName()));
+ msg = _("userIsAway", user.getDisplayName());
}
}
+ if (!msg.isEmpty())
+ {
+ ess.broadcastMessage(user, msg);
+ }
}
}
+
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandantioch.java b/Essentials/src/com/earth2me/essentials/commands/Commandantioch.java
index 968d0012cd..79ef1f9693 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandantioch.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandantioch.java
@@ -6,7 +6,7 @@
import org.bukkit.Server;
import org.bukkit.entity.TNTPrimed;
-
+// This command has a in theme message that only shows if you supply a parameter #EasterEgg
public class Commandantioch extends EssentialsCommand
{
public Commandantioch()
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandback.java b/Essentials/src/com/earth2me/essentials/commands/Commandback.java
index d2ed98e698..6943ab8020 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandback.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandback.java
@@ -17,9 +17,9 @@ public Commandback()
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
if (user.getWorld() != user.getLastLocation().getWorld() && ess.getSettings().isWorldTeleportPermissions()
- && !user.isAuthorized("essentials.world." + user.getLastLocation().getWorld().getName()))
+ && !user.isAuthorized("essentials.worlds." + user.getLastLocation().getWorld().getName()))
{
- throw new Exception(_("noPerm", "essentials.world." + user.getLastLocation().getWorld().getName()));
+ throw new Exception(_("noPerm", "essentials.worlds." + user.getLastLocation().getWorld().getName()));
}
final Trade charge = new Trade(this.getName(), ess);
charge.isAffordableFor(user);
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbalance.java b/Essentials/src/com/earth2me/essentials/commands/Commandbalance.java
index 15c3c90889..062709bd47 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandbalance.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbalance.java
@@ -21,17 +21,25 @@ protected void run(final Server server, final CommandSender sender, final String
{
throw new NotEnoughArgumentsException();
}
- sender.sendMessage(_("balance", Util.displayCurrency(getPlayer(server, args, 0, true).getMoney(), ess)));
+
+ User target = getPlayer(server, args, 0, true, true);
+ sender.sendMessage(_("balanceOther", target.getDisplayName(), Util.displayCurrency(target.getMoney(), ess)));
}
@Override
public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
- final double bal = (args.length < 1
- || !(user.isAuthorized("essentials.balance.others")
- || user.isAuthorized("essentials.balance.other"))
- ? user
- : getPlayer(server, args, 0, true)).getMoney();
- user.sendMessage(_("balance", Util.displayCurrency(bal, ess)));
+
+ if (args.length < 1 || !user.isAuthorized("essentials.balance.others"))
+ {
+ final double bal = user.getMoney();
+ user.sendMessage(_("balance", Util.displayCurrency(bal, ess)));
+ }
+ else
+ {
+ final User target = getPlayer(server, args, 0, true, true);
+ final double bal = target.getMoney();
+ user.sendMessage(_("balanceOther", target.getDisplayName(), Util.displayCurrency(bal, ess)));
+ }
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbalancetop.java b/Essentials/src/com/earth2me/essentials/commands/Commandbalancetop.java
index 6c5e96b9f1..b150718059 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandbalancetop.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbalancetop.java
@@ -1,9 +1,9 @@
package com.earth2me.essentials.commands;
-import com.earth2me.essentials.User;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.User;
import com.earth2me.essentials.Util;
-import com.earth2me.essentials.textreader.ArrayListInput;
+import com.earth2me.essentials.textreader.SimpleTextInput;
import com.earth2me.essentials.textreader.TextPager;
import java.text.DateFormat;
import java.util.*;
@@ -12,7 +12,7 @@
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
-
+//TODO: Remove op and replace with perm
public class Commandbalancetop extends EssentialsCommand
{
public Commandbalancetop()
@@ -21,7 +21,7 @@ public Commandbalancetop()
}
private static final int CACHETIME = 2 * 60 * 1000;
public static final int MINUSERS = 50;
- private static ArrayListInput cache = new ArrayListInput();
+ private static SimpleTextInput cache = new SimpleTextInput();
private static long cacheage = 0;
private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
@@ -63,7 +63,7 @@ protected void run(final Server server, final CommandSender sender, final String
{
lock.readLock().unlock();
}
- ess.scheduleAsyncDelayedTask(new Viewer(sender, page, force));
+ ess.runTaskAsynchronously(new Viewer(sender, page, force));
}
else
{
@@ -71,7 +71,7 @@ protected void run(final Server server, final CommandSender sender, final String
{
sender.sendMessage(_("orderBalances", ess.getUserMap().getUniqueUsers()));
}
- ess.scheduleAsyncDelayedTask(new Viewer(sender, page, force));
+ ess.runTaskAsynchronously(new Viewer(sender, page, force));
}
}
@@ -82,7 +82,7 @@ private static void outputCache(final CommandSender sender, int page)
cal.setTimeInMillis(cacheage);
final DateFormat format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
sender.sendMessage(_("balanceTop", format.format(cal.getTime())));
- new TextPager(cache).showPage(Integer.toString(page), "", "balancetop", sender);
+ new TextPager(cache).showPage(Integer.toString(page), null, "balancetop", sender);
}
@@ -144,7 +144,7 @@ public int compare(final Entry entry1, final Entry 1)
{
- banReason = _("banFormat", getFinalArg(args, 1), senderName);
+ banReason = Util.replaceFormat(getFinalArg(args, 1).replace("\\n", "\n").replace("|", "\n"));
}
else
{
- banReason = _("banFormat", _("defaultBanReason"), senderName);
+ banReason = _("defaultBanReason");
}
-
- user.setBanReason(banReason);
+
+ user.setBanReason(_("banFormat", banReason, senderName));
user.setBanned(true);
- user.kickPlayer(banReason);
+ user.setBanTimeout(0);
+ user.kickPlayer(_("banFormat", banReason, senderName));
+
+ server.getLogger().log(Level.INFO, _("playerBanned", senderName, user.getName(), banReason));
+
+ if (nomatch)
+ {
+ sender.sendMessage(_("userUnknown", user.getName()));
+ }
for (Player onlinePlayer : server.getOnlinePlayers())
{
final User player = ess.getUser(onlinePlayer);
- if (player.isAuthorized("essentials.ban.notify"))
+ if (onlinePlayer == sender || player.isAuthorized("essentials.ban.notify"))
{
onlinePlayer.sendMessage(_("playerBanned", senderName, user.getName(), banReason));
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbanip.java b/Essentials/src/com/earth2me/essentials/commands/Commandbanip.java
index 5459bd8fc1..ca0751a51a 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandbanip.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbanip.java
@@ -1,9 +1,12 @@
package com.earth2me.essentials.commands;
+import com.earth2me.essentials.Console;
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.logging.Level;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
public class Commandbanip extends EssentialsCommand
@@ -21,22 +24,33 @@ public void run(final Server server, final CommandSender sender, final String co
throw new NotEnoughArgumentsException();
}
- final User player = ess.getUser(args[0]);
+ final String senderName = sender instanceof Player ? ((Player)sender).getDisplayName() : Console.NAME;
+ final String ipAddress;
+ final User player = ess.getUser(args[0]);
if (player == null)
{
- ess.getServer().banIP(args[0]);
- sender.sendMessage(_("banIpAddress"));
+ ipAddress = args[0];
}
else
{
- final String ipAddress = player.getLastLoginAddress();
+ ipAddress = player.getLastLoginAddress();
if (ipAddress.length() == 0)
{
throw new Exception(_("playerNotFound"));
}
- ess.getServer().banIP(player.getLastLoginAddress());
- sender.sendMessage(_("banIpAddress"));
+ }
+
+ ess.getServer().banIP(ipAddress);
+ server.getLogger().log(Level.INFO, _("playerBanIpAddress", senderName, ipAddress));
+
+ for (Player onlinePlayer : server.getOnlinePlayers())
+ {
+ final User onlineUser = ess.getUser(onlinePlayer);
+ if (onlinePlayer == sender || onlineUser.isAuthorized("essentials.ban.notify"))
+ {
+ onlinePlayer.sendMessage(_("playerBanIpAddress", senderName, ipAddress));
+ }
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbook.java b/Essentials/src/com/earth2me/essentials/commands/Commandbook.java
new file mode 100644
index 0000000000..897069b934
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbook.java
@@ -0,0 +1,92 @@
+package com.earth2me.essentials.commands;
+
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.User;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BookMeta;
+
+
+public class Commandbook extends EssentialsCommand
+{
+ public Commandbook()
+ {
+ super("book");
+ }
+
+ //TODO: Translate this
+ @Override
+ public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
+ {
+ final ItemStack item = user.getItemInHand();
+ final String player = user.getName();
+ if (item.getType() == Material.WRITTEN_BOOK)
+ {
+ BookMeta bmeta = (BookMeta)item.getItemMeta();
+
+ if (args.length > 1 && args[0].equalsIgnoreCase("author"))
+ {
+ if (user.isAuthorized("essentals.book.author") && (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others")))
+ {
+ bmeta.setAuthor(args[1]);
+ item.setItemMeta(bmeta);
+ user.sendMessage(_("bookAuthorSet", getFinalArg(args, 1)));
+ }
+ else
+ {
+ throw new Exception(_("denyChangeAuthor"));
+ }
+ }
+ else if (args.length > 1 && args[0].equalsIgnoreCase("title"))
+ {
+ if (user.isAuthorized("essentials.book.title") && (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others")))
+ {
+ bmeta.setTitle(args[1]);
+ item.setItemMeta(bmeta);
+ user.sendMessage(_("bookTitleSet", getFinalArg(args, 1)));
+ }
+ else
+ {
+ throw new Exception(_("denyChangeTitle"));
+ }
+ }
+ else
+ {
+ if (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others"))
+ {
+ ItemStack newItem = new ItemStack(Material.BOOK_AND_QUILL, item.getAmount());
+ newItem.setItemMeta(bmeta);
+ user.setItemInHand(newItem);
+ user.sendMessage(_("editBookContents"));
+ }
+ else
+ {
+ throw new Exception(_("denyBookEdit"));
+ }
+ }
+ }
+ else if (item.getType() == Material.BOOK_AND_QUILL)
+ {
+ BookMeta bmeta = (BookMeta)item.getItemMeta();
+ if (!user.isAuthorized("essentals.book.author"))
+ {
+ bmeta.setAuthor(player);
+ }
+ ItemStack newItem = new ItemStack(Material.WRITTEN_BOOK, item.getAmount());
+ newItem.setItemMeta(bmeta);
+ user.setItemInHand(newItem);
+ user.sendMessage(_("bookLocked"));
+ }
+ else
+ {
+ throw new Exception(_("holdBook"));
+ }
+ }
+
+ private boolean isAuthor(BookMeta bmeta, String player)
+ {
+ String author = bmeta.getAuthor();
+ return author != null && author.equalsIgnoreCase(player);
+ }
+}
\ No newline at end of file
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbreak.java b/Essentials/src/com/earth2me/essentials/commands/Commandbreak.java
index 242fa9b537..af11f597d7 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandbreak.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbreak.java
@@ -2,13 +2,10 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
-import java.util.ArrayList;
-import java.util.List;
import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.block.Block;
import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.inventory.ItemStack;
public class Commandbreak extends EssentialsCommand
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandbroadcast.java b/Essentials/src/com/earth2me/essentials/commands/Commandbroadcast.java
index e6eeda28b3..2b588d6846 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandbroadcast.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandbroadcast.java
@@ -1,6 +1,7 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.User;
import com.earth2me.essentials.Util;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
@@ -13,6 +14,17 @@ public Commandbroadcast()
super("broadcast");
}
+ @Override
+ public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
+ {
+ if (args.length < 1)
+ {
+ throw new NotEnoughArgumentsException();
+ }
+
+ ess.broadcastMessage(null, _("broadcast", Util.replaceFormat(getFinalArg(args, 0)), user.getDisplayName()));
+ }
+
@Override
public void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
@@ -21,6 +33,6 @@ public void run(final Server server, final CommandSender sender, final String co
throw new NotEnoughArgumentsException();
}
- ess.broadcastMessage(null, _("broadcast", Util.replaceFormat(getFinalArg(args, 0))));
+ ess.broadcastMessage(null, _("broadcast", Util.replaceFormat(getFinalArg(args, 0)), sender.getName()));
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandburn.java b/Essentials/src/com/earth2me/essentials/commands/Commandburn.java
index 5d8d38ce7a..8c98188f71 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandburn.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandburn.java
@@ -4,6 +4,7 @@
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
+import com.earth2me.essentials.User;
public class Commandburn extends EssentialsCommand
@@ -20,11 +21,15 @@ protected void run(final Server server, final CommandSender sender, final String
{
throw new NotEnoughArgumentsException();
}
-
- for (Player p : server.matchPlayer(args[0]))
+
+ //TODO: TL this
+ if (args[0].trim().length() < 2)
{
- p.setFireTicks(Integer.parseInt(args[1]) * 20);
- sender.sendMessage(_("burnMsg", p.getDisplayName(), Integer.parseInt(args[1])));
+ throw new NotEnoughArgumentsException("You need to specify a player to burn.");
}
+
+ User user = getPlayer(server, args, 0);
+ user.setFireTicks(Integer.parseInt(args[1]) * 20);
+ sender.sendMessage(_("burnMsg", user.getDisplayName(), Integer.parseInt(args[1])));
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java b/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java
index ef2502b9bb..5ca434fc64 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java
@@ -2,10 +2,12 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import com.earth2me.essentials.Util;
import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
public class Commandclearinventory extends EssentialsCommand
@@ -21,77 +23,138 @@ public void run(Server server, User user, String commandLabel, String[] args) th
{
if (args.length > 0 && user.isAuthorized("essentials.clearinventory.others"))
{
- //TODO: Fix fringe user match case.
- if (args[0].length() >= 3)
+ if (args[0].contentEquals("*") && user.isAuthorized("essentials.clearinventory.all"))
{
- List online = server.matchPlayer(args[0]);
-
- if (!online.isEmpty())
- {
- for (Player p : online)
- {
- p.getInventory().clear();
- user.sendMessage(_("inventoryClearedOthers", p.getDisplayName()));
- }
- return;
- }
- throw new Exception(_("playerNotFound"));
+ cleanInventoryAll(server, user, args);
+ }
+ else if (args[0].trim().length() < 2)
+ {
+ cleanInventorySelf(server, user, args);
}
else
{
- Player p = server.getPlayer(args[0]);
- if (p != null)
- {
- p.getInventory().clear();
- user.sendMessage(_("inventoryClearedOthers", p.getDisplayName()));
- }
- else
- {
- throw new Exception(_("playerNotFound"));
- }
+ cleanInventoryOthers(server, user, args);
}
}
else
{
- user.getInventory().clear();
- user.sendMessage(_("inventoryCleared"));
+ cleanInventorySelf(server, user, args);
}
}
@Override
protected void run(Server server, CommandSender sender, String commandLabel, String[] args) throws Exception
{
- if (args.length < 1)
+ if (args.length > 0)
+ {
+ if (args[0].contentEquals("*"))
+ {
+ cleanInventoryAll(server, sender, args);
+ }
+ else if (args[0].trim().length() < 2)
+ {
+ throw new Exception(_("playerNotFound"));
+ }
+ else
+ {
+ cleanInventoryOthers(server, sender, args);
+ }
+ }
+ else
{
throw new NotEnoughArgumentsException();
}
+ }
- if (args[0].length() >= 3)
+ private void cleanInventoryAll(Server server, CommandSender sender, String[] args) throws Exception
+ {
+ if (args.length > 1)
{
- List online = server.matchPlayer(args[0]);
+ for (Player onlinePlayer : server.getOnlinePlayers())
+ {
+ clearInventory(onlinePlayer, args[1]);
+ }
+ sender.sendMessage(_("inventoryClearedAll"));
+ }
+ else
+ {
+ throw new NotEnoughArgumentsException();
+ }
+ }
- if (!online.isEmpty())
+ private void cleanInventoryOthers(Server server, CommandSender sender, String[] args) throws Exception
+ {
+ List online = server.matchPlayer(args[0]);
+
+ if (!online.isEmpty())
+ {
+ for (Player p : online)
{
- for (Player p : online)
+ if (args.length > 1)
+ {
+ clearInventory(p, args[1]);
+ }
+ else
{
p.getInventory().clear();
- sender.sendMessage(_("inventoryClearedOthers", p.getDisplayName()));
}
- return;
+ sender.sendMessage(_("inventoryClearedOthers", p.getDisplayName()));
}
+ }
+ else
+ {
throw new Exception(_("playerNotFound"));
}
+ }
+
+ private void cleanInventorySelf(Server server, User user, String[] args) throws Exception
+ {
+ if (args.length > 0)
+ {
+ clearInventory(user, args[0]);
+ }
+ else
+ {
+ user.getInventory().clear();
+ }
+ user.sendMessage(_("inventoryCleared"));
+ }
+
+ private void clearInventory(Player player, String arg) throws Exception
+ {
+ if (arg.equalsIgnoreCase("*"))
+ {
+ player.getInventory().clear();
+ }
+ else if (arg.equalsIgnoreCase("**"))
+ {
+ player.getInventory().clear();
+ player.getInventory().setArmorContents(null);
+ }
else
{
- Player u = server.getPlayer(args[0]);
- if (u != null)
+ final String[] split = arg.split(":");
+ final ItemStack item = ess.getItemDb().get(split[0]);
+ final int type = item.getTypeId();
+
+ if (split.length > 1 && Util.isInt(split[1]))
{
- u.getInventory().clear();
- sender.sendMessage(_("inventoryClearedOthers", u.getDisplayName()));
+ player.getInventory().clear(type, Integer.parseInt(split[1]));
+ }
+ else if (split.length > 1 && split[1].equalsIgnoreCase("*"))
+ {
+ player.getInventory().clear(type, -1);
}
else
{
- throw new Exception(_("playerNotFound"));
+ if (Util.isInt(split[0]))
+ {
+ player.getInventory().clear(type, -1);
+ }
+ else
+ {
+ player.getInventory().clear(type, item.getDurability());
+ }
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commanddelhome.java b/Essentials/src/com/earth2me/essentials/commands/Commanddelhome.java
index c4d0a69464..182b695655 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commanddelhome.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commanddelhome.java
@@ -39,7 +39,7 @@ public void run(final Server server, final CommandSender sender, final String co
if (expandedArg.length > 1 && (user == null || user.isAuthorized("essentials.delhome.others")))
{
- user = getPlayer(server, expandedArg, 0, true);
+ user = getPlayer(server, expandedArg, 0, true, true);
name = expandedArg[1];
}
else if (user == null)
@@ -50,10 +50,10 @@ else if (user == null)
{
name = expandedArg[0];
}
- //TODO: Think up a nice error message
- /*
- * if (name.equalsIgnoreCase("bed")) { throw new Exception("You cannot remove the vanilla home point"); }
- */
+
+
+ if (name.equalsIgnoreCase("bed")) { throw new Exception(_("invalidHomeName")); }
+
user.delHome(name.toLowerCase(Locale.ENGLISH));
sender.sendMessage(_("deleteHome", name));
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandeco.java b/Essentials/src/com/earth2me/essentials/commands/Commandeco.java
index dd6d6ad0d3..5cad0e7bee 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandeco.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandeco.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import com.earth2me.essentials.Util;
import java.util.Locale;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
@@ -22,12 +23,16 @@ public void run(final Server server, final CommandSender sender, final String co
{
throw new NotEnoughArgumentsException();
}
- EcoCommands cmd;
+
+ Commandeco.EcoCommands cmd;
+ double startingBalance = (double)ess.getSettings().getStartingBalance();
double amount;
+ Double broadcast = null;
+ Double broadcastAll = null;
try
{
- cmd = EcoCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH));
- amount = Double.parseDouble(args[2].replaceAll("[^0-9\\.]", ""));
+ cmd = Commandeco.EcoCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH));
+ amount = (cmd == Commandeco.EcoCommands.RESET) ? startingBalance : Double.parseDouble(args[2].replaceAll("[^0-9\\.]", ""));
}
catch (Exception ex)
{
@@ -46,14 +51,13 @@ public void run(final Server server, final CommandSender sender, final String co
break;
case TAKE:
- if (player.canAfford(amount, false))
- {
- player.takeMoney(amount);
- }
+ take(amount, player, null);
break;
case RESET:
- player.setMoney(amount == 0 ? ess.getSettings().getStartingBalance() : amount);
+ case SET:
+ set(amount, player, null);
+ broadcastAll = amount;
break;
}
}
@@ -70,22 +74,20 @@ else if (args[1].contentEquals("*"))
break;
case TAKE:
- if (!player.canAfford(amount, false))
- {
- throw new Exception(_("notEnoughMoney"));
- }
- player.takeMoney(amount);
+ take(amount, player, null);
break;
case RESET:
- player.setMoney(amount == 0 ? ess.getSettings().getStartingBalance() : amount);
+ case SET:
+ set(amount, player, null);
+ broadcast = amount;
break;
}
}
}
else
{
- final User player = getPlayer(server, args, 1, true);
+ final User player = getPlayer(server, args, 1, true, true);
switch (cmd)
{
case GIVE:
@@ -93,23 +95,60 @@ else if (args[1].contentEquals("*"))
break;
case TAKE:
- if (!player.canAfford(amount, false))
- {
- throw new Exception(_("notEnoughMoney"));
- }
- player.takeMoney(amount, sender);
+ take(amount, player, sender);
break;
case RESET:
- player.setMoney(amount == 0 ? ess.getSettings().getStartingBalance() : amount);
+ case SET:
+ set(amount, player, sender);
break;
}
}
+
+ if (broadcast != null)
+ {
+ server.broadcastMessage(_("resetBal", Util.formatAsCurrency(broadcast)));
+ }
+ if (broadcastAll != null)
+ {
+ server.broadcastMessage(_("resetBalAll", Util.formatAsCurrency(broadcastAll)));
+ }
+ }
+
+ private void take(double amount, final User player, final CommandSender sender) throws Exception
+ {
+ double money = player.getMoney();
+ double minBalance = ess.getSettings().getMinMoney();
+ if (money - amount > minBalance)
+ {
+ player.takeMoney(amount, sender);
+ }
+ else if (sender == null)
+ {
+ player.setMoney(minBalance);
+ player.sendMessage(_("takenFromAccount", Util.displayCurrency(money - minBalance, ess)));
+ }
+ else
+ {
+ throw new Exception(_("insufficientFunds"));
+ }
+ }
+
+ private void set(double amount, final User player, final CommandSender sender)
+ {
+ double minBalance = ess.getSettings().getMinMoney();
+ boolean underMinimum = amount < minBalance;
+ player.setMoney(underMinimum ? minBalance : amount);
+ player.sendMessage(_("setBal", Util.displayCurrency(player.getMoney(), ess)));
+ if (sender != null)
+ {
+ sender.sendMessage(_("setBalOthers", player.getDisplayName(), Util.displayCurrency(player.getMoney(), ess)));
+ }
}
private enum EcoCommands
{
- GIVE, TAKE, RESET
+ GIVE, TAKE, SET, RESET
}
-}
+}
\ No newline at end of file
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandenchant.java b/Essentials/src/com/earth2me/essentials/commands/Commandenchant.java
index 51a909d29c..f95b777a24 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandenchant.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandenchant.java
@@ -2,9 +2,14 @@
import com.earth2me.essentials.Enchantments;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.MetaItemStack;
import com.earth2me.essentials.User;
import com.earth2me.essentials.Util;
-import java.util.*;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
@@ -22,7 +27,7 @@ public Commandenchant()
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
final ItemStack stack = user.getItemInHand();
- if (stack == null)
+ if (stack == null || stack.getType() == Material.AIR)
{
throw new Exception(_("nothingInHand"));
}
@@ -32,7 +37,7 @@ protected void run(final Server server, final User user, final String commandLab
for (Map.Entry entry : Enchantments.entrySet())
{
final String enchantmentName = entry.getValue().getName().toLowerCase(Locale.ENGLISH);
- if (enchantmentslist.contains(enchantmentName) || user.isAuthorized("essentials.enchant." + enchantmentName))
+ if (enchantmentslist.contains(enchantmentName) || (user.isAuthorized("essentials.enchantments." + enchantmentName) && entry.getValue().canEnchantItem(stack)))
{
enchantmentslist.add(entry.getKey());
//enchantmentslist.add(enchantmentName);
@@ -40,6 +45,7 @@ protected void run(final Server server, final User user, final String commandLab
}
throw new NotEnoughArgumentsException(_("enchantments", Util.joinList(enchantmentslist.toArray())));
}
+
int level = -1;
if (args.length > 1)
{
@@ -52,20 +58,14 @@ protected void run(final Server server, final User user, final String commandLab
level = -1;
}
}
- final Enchantment enchantment = getEnchantment(args[0], user);
- if (level < 0 || level > enchantment.getMaxLevel())
- {
- level = enchantment.getMaxLevel();
- }
- if (level == 0)
- {
- stack.removeEnchantment(enchantment);
- }
- else
- {
- stack.addEnchantment(enchantment, level);
- }
- user.getInventory().setItemInHand(stack);
+
+ final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments() && user.isAuthorized("essentials.enchantments.allowunsafe");
+
+ final MetaItemStack metaStack = new MetaItemStack(stack);
+ final Enchantment enchantment = metaStack.getEnchantment(user, args[0]);
+ metaStack.addEnchantment(user, allowUnsafe, enchantment, level);
+ user.getInventory().setItemInHand(metaStack.getItemStack());
+
user.updateInventory();
final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);
if (level == 0)
@@ -77,20 +77,4 @@ protected void run(final Server server, final User user, final String commandLab
user.sendMessage(_("enchantmentApplied", enchantmentName.replace('_', ' ')));
}
}
-
- public static Enchantment getEnchantment(final String name, final User user) throws Exception
- {
-
- final Enchantment enchantment = Enchantments.getByName(name);
- if (enchantment == null)
- {
- throw new Exception(_("enchantmentNotFound"));
- }
- final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);
- if (user != null && !user.isAuthorized("essentials.enchant." + enchantmentName))
- {
- throw new Exception(_("enchantmentPerm", enchantmentName));
- }
- return enchantment;
- }
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandenderchest.java b/Essentials/src/com/earth2me/essentials/commands/Commandenderchest.java
new file mode 100644
index 0000000000..d256e97863
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandenderchest.java
@@ -0,0 +1,30 @@
+package com.earth2me.essentials.commands;
+
+import com.earth2me.essentials.User;
+import org.bukkit.Server;
+
+
+public class Commandenderchest extends EssentialsCommand
+{
+ public Commandenderchest()
+ {
+ super("enderchest");
+ }
+
+ @Override
+ protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
+ {
+ if (args.length > 0 && user.isAuthorized("essentials.enderchest.others"))
+ {
+ final User invUser = getPlayer(server, user, args, 0);
+ user.openInventory(invUser.getEnderChest());
+ user.setEnderSee(true);
+ }
+ else
+ {
+ user.openInventory(user.getEnderChest());
+ user.setEnderSee(false);
+ }
+
+ }
+}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandessentials.java b/Essentials/src/com/earth2me/essentials/commands/Commandessentials.java
index 2a89dcd42d..5bb7e6ac0b 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandessentials.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandessentials.java
@@ -1,22 +1,22 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.User;
+import com.earth2me.essentials.UserMap;
import com.earth2me.essentials.Util;
import com.earth2me.essentials.metrics.Metrics;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Server;
+import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
-
+// This command has 4 undocumented behaviours #EasterEgg
public class Commandessentials extends EssentialsCommand
{
public Commandessentials()
@@ -29,7 +29,8 @@ public Commandessentials()
@Override
public void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- if (args.length == 0) {
+ if (args.length == 0)
+ {
run_disabled(server, sender, commandLabel, args);
}
else if (args[0].equalsIgnoreCase("debug"))
@@ -44,122 +45,120 @@ else if (args[0].equalsIgnoreCase("moo"))
{
run_moo(server, sender, commandLabel, args);
}
+ else if (args[0].equalsIgnoreCase("reset"))
+ {
+ run_reset(server, sender, commandLabel, args);
+ }
else if (args[0].equalsIgnoreCase("opt-out"))
{
run_optout(server, sender, commandLabel, args);
}
- else {
+ else if (args[0].equalsIgnoreCase("cleanup"))
+ {
+ run_cleanup(server, sender, commandLabel, args);
+ }
+ else
+ {
run_reload(server, sender, commandLabel, args);
}
}
-
+
+ //If you do not supply an argument this command will list 'overridden' commands.
private void run_disabled(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- sender.sendMessage("Essentials " + ess.getDescription().getVersion());
sender.sendMessage("/ ");
-
+
final StringBuilder disabledCommands = new StringBuilder();
for (Map.Entry entry : ess.getAlternativeCommandsHandler().disabledCommands().entrySet())
{
- if (disabledCommands.length() > 0) {
+ if (disabledCommands.length() > 0)
+ {
disabledCommands.append(", ");
}
disabledCommands.append(entry.getKey()).append(" => ").append(entry.getValue());
}
- if (disabledCommands.length() > 0) {
+ if (disabledCommands.length() > 0)
+ {
sender.sendMessage(_("blockList"));
sender.sendMessage(disabledCommands.toString());
}
}
-
+
+ private void run_reset(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
+ {
+ if (args.length < 2)
+ {
+ throw new Exception("/ reset ");
+ }
+ final User user = getPlayer(server, args, 1, true, true);
+ user.reset();
+ sender.sendMessage("Reset Essentials userdata for player: " + user.getDisplayName());
+ }
+
private void run_debug(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
ess.getSettings().setDebug(!ess.getSettings().isDebug());
sender.sendMessage("Essentials " + ess.getDescription().getVersion() + " debug mode " + (ess.getSettings().isDebug() ? "enabled" : "disabled"));
}
-
+
private void run_reload(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
ess.reload();
sender.sendMessage(_("essentialsReload", ess.getDescription().getVersion()));
}
-
+
private void run_nya(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- final Map noteMap = new HashMap();
- noteMap.put("1F#", (byte)0x0);
- noteMap.put("1G", (byte)0x1);
- noteMap.put("1G#", (byte)0x2);
- noteMap.put("1A", (byte)0x3);
- noteMap.put("1A#", (byte)0x4);
- noteMap.put("1B", (byte)0x5);
- noteMap.put("1C", (byte)0x6);
- noteMap.put("1C#", (byte)0x7);
- noteMap.put("1D", (byte)0x8);
- noteMap.put("1D#", (byte)0x9);
- noteMap.put("1E", (byte)0xA);
- noteMap.put("1F", (byte)0xB);
- noteMap.put("2F#", (byte)(0x0 + 0xC));
- noteMap.put("2G", (byte)(0x1 + 0xC));
- noteMap.put("2G#", (byte)(0x2 + 0xC));
- noteMap.put("2A", (byte)(0x3 + 0xC));
- noteMap.put("2A#", (byte)(0x4 + 0xC));
- noteMap.put("2B", (byte)(0x5 + 0xC));
- noteMap.put("2C", (byte)(0x6 + 0xC));
- noteMap.put("2C#", (byte)(0x7 + 0xC));
- noteMap.put("2D", (byte)(0x8 + 0xC));
- noteMap.put("2D#", (byte)(0x9 + 0xC));
- noteMap.put("2E", (byte)(0xA + 0xC));
- noteMap.put("2F", (byte)(0xB + 0xC));
- if (!noteBlocks.isEmpty())
- {
- return;
- }
- final String tuneStr = "1D#,1E,2F#,,2A#,1E,1D#,1E,2F#,2B,2D#,2E,2D#,2A#,2B,,2F#,,1D#,1E,2F#,2B,2C#,2A#,2B,2C#,2E,2D#,2E,2C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1B,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1B,,";
- final String[] tune = tuneStr.split(",");
- for (Player player : server.getOnlinePlayers())
+ final Map noteMap = new HashMap();
+ noteMap.put("1F#", 0.5f);
+ noteMap.put("1G", 0.53f);
+ noteMap.put("1G#", 0.56f);
+ noteMap.put("1A", 0.6f);
+ noteMap.put("1A#", 0.63f);
+ noteMap.put("1B", 0.67f);
+ noteMap.put("1C", 0.7f);
+ noteMap.put("1C#", 0.76f);
+ noteMap.put("1D", 0.8f);
+ noteMap.put("1D#", 0.84f);
+ noteMap.put("1E", 0.9f);
+ noteMap.put("1F", 0.94f);
+ noteMap.put("2F#", 1.0f);
+ noteMap.put("2G", 1.06f);
+ noteMap.put("2G#", 1.12f);
+ noteMap.put("2A", 1.18f);
+ noteMap.put("2A#", 1.26f);
+ noteMap.put("2B", 1.34f);
+ noteMap.put("2C", 1.42f);
+ noteMap.put("2C#", 1.5f);
+ noteMap.put("2D", 1.6f);
+ noteMap.put("2D#", 1.68f);
+ noteMap.put("2E", 1.78f);
+ noteMap.put("2F", 1.88f);
+ final String tuneStr = "1D#,1E,2F#,,2A#,1E,1D#,1E,2F#,2B,2D#,2E,2D#,2A#,2B,,2F#,,1D#,1E,2F#,2B,2C#,2A#,2B,2C#,2E,2D#,2E,2C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1B,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1B,,";
+ final String[] tune = tuneStr.split(",");
+ taskid = ess.scheduleSyncRepeatingTask(new Runnable()
+ {
+ int i = 0;
+
+ @Override
+ public void run()
{
- final Location loc = player.getLocation();
- loc.add(0, 3, 0);
- while (loc.getBlockY() < player.getLocation().getBlockY() + 10 && loc.getBlock().getTypeId() != 0)
+ final String note = tune[i];
+ i++;
+ if (i >= tune.length)
{
- loc.add(0, 1, 0);
+ Commandessentials.this.stopTune();
}
- if (loc.getBlock().getTypeId() == 0)
+ if (note.isEmpty() || note == null)
{
- noteBlocks.put(player, loc.getBlock());
- loc.getBlock().setType(Material.NOTE_BLOCK);
+ return;
}
- }
- taskid = ess.scheduleSyncRepeatingTask(new Runnable()
- {
- int i = 0;
-
- @Override
- public void run()
+ for (Player onlinePlayer : server.getOnlinePlayers())
{
- final String note = tune[i];
- i++;
- if (i >= tune.length)
- {
- Commandessentials.this.stopTune();
- }
- if (note.isEmpty())
- {
- return;
- }
- Map noteBlocks = Commandessentials.this.noteBlocks;
- for (Player onlinePlayer : server.getOnlinePlayers())
- {
- final Block block = noteBlocks.get(onlinePlayer);
- if (block == null || block.getType() != Material.NOTE_BLOCK)
- {
- continue;
- }
- onlinePlayer.playNote(block.getLocation(), (byte)0, noteMap.get(note));
- }
+ onlinePlayer.playSound(onlinePlayer.getLocation(), Sound.NOTE_PIANO, 1, noteMap.get(note));
}
- }, 20, 2);
+ }
+ }, 20, 2);
}
private void stopTune()
@@ -174,24 +173,39 @@ private void stopTune()
}
noteBlocks.clear();
}
-
+
private void run_moo(final Server server, final CommandSender sender, final String command, final String args[])
{
- if(sender instanceof ConsoleCommandSender)
- sender.sendMessage(new String[]{" (__)", " (oo)", " /------\\/", " / | ||", " * /\\---/\\", " ~~ ~~", "....\"Have you mooed today?\"..." } );
+ if (sender instanceof ConsoleCommandSender)
+ {
+ sender.sendMessage(new String[]
+ {
+ " (__)", " (oo)", " /------\\/", " / | ||", " * /\\---/\\", " ~~ ~~", "....\"Have you mooed today?\"..."
+ });
+ }
else
- sender.sendMessage(new String[]{" (__)", " (oo)", " /------\\/", " / | | |", " * /\\---/\\", " ~~ ~~", "....\"Have you mooed today?\"..." } );
+ {
+ sender.sendMessage(new String[]
+ {
+ " (__)", " (oo)", " /------\\/", " / | | |", " * /\\---/\\", " ~~ ~~", "....\"Have you mooed today?\"..."
+ });
+ final Player player = (Player)sender;
+ player.playSound(player.getLocation(), Sound.COW_IDLE, 1, 1.0f);
+ }
}
-
+
private void run_optout(final Server server, final CommandSender sender, final String command, final String args[])
{
final Metrics metrics = ess.getMetrics();
try
{
sender.sendMessage("Essentials collects simple metrics to highlight which features to concentrate work on in the future.");
- if (metrics.isOptOut()) {
- metrics.enable();
- } else {
+ if (metrics.isOptOut())
+ {
+ metrics.enable();
+ }
+ else
+ {
metrics.disable();
}
sender.sendMessage("Anonymous Metrics are now: " + (metrics.isOptOut() ? "disabled" : "enabled"));
@@ -201,4 +215,59 @@ private void run_optout(final Server server, final CommandSender sender, final S
sender.sendMessage("Unable to modify 'plugins/PluginMetrics/config.yml': " + ex.getMessage());
}
}
+
+ private void run_cleanup(final Server server, final CommandSender sender, final String command, final String args[]) throws Exception
+ {
+ if (args.length < 2 || !Util.isInt(args[1]))
+ {
+ sender.sendMessage("This sub-command will delete users who havent logged in in the last days.");
+ sender.sendMessage("Optional parameters define the minium amount required to prevent deletion.");
+ throw new Exception("/ cleanup [money] [homes] [ban count]");
+ }
+ sender.sendMessage(_("cleaning"));
+
+ final long daysArg = Long.parseLong(args[1]);
+ final double moneyArg = args.length >= 3 ? Double.parseDouble(args[2].replaceAll("[^0-9\\.]", "")) : 0;
+ final int homesArg = args.length >= 4 && Util.isInt(args[3]) ? Integer.parseInt(args[3]) : 0;
+ final int bansArg = args.length >= 5 && Util.isInt(args[4]) ? Integer.parseInt(args[4]) : 0;
+ final UserMap userMap = ess.getUserMap();
+
+ ess.runTaskAsynchronously(new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ for (String u : userMap.getAllUniqueUsers())
+ {
+ final User user = ess.getUserMap().getUser(u);
+ if (user == null)
+ {
+ continue;
+ }
+
+ int ban = user.getBanReason().equals("") ? 0 : 1;
+ long lastLog = user.getLastLogout();
+ long timeDiff = System.currentTimeMillis() - lastLog;
+ long milliDays = daysArg * 24L * 60L * 60L * 1000L;
+ int homeCount = user.getHomes().size();
+ double moneyCount = user.getMoney();
+
+ if ((lastLog == 0) || (ban > bansArg) || (timeDiff < milliDays)
+ || (homeCount > homesArg) || (moneyCount > moneyArg))
+ {
+ continue;
+ }
+
+ if (ess.getSettings().isDebug())
+ {
+ ess.getLogger().info("Deleting user: " + user.getName() + " Money: " + moneyCount + " Homes: " + homeCount + " Last seen: " + Util.formatDateDiff(lastLog));
+ }
+
+ user.reset();
+ }
+ sender.sendMessage(_("cleaned"));
+ }
+ });
+
+ }
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandexp.java b/Essentials/src/com/earth2me/essentials/commands/Commandexp.java
index de4727fa02..89ea456e71 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandexp.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandexp.java
@@ -4,6 +4,8 @@
import com.earth2me.essentials.User;
import com.earth2me.essentials.Util;
import com.earth2me.essentials.craftbukkit.SetExpFix;
+import java.util.List;
+import java.util.Locale;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -45,21 +47,40 @@ else if (args[0].equalsIgnoreCase("give") && user.isAuthorized("essentials.exp.g
setExp(user, user, args[1], true);
}
}
- else
+ else if (args[0].equalsIgnoreCase("show"))
{
- String match = args[0].trim();
- if (args.length == 2)
+ if (args.length >= 2 && user.isAuthorized("essentials.exp.others"))
{
- match = args[1].trim();
+ String match = args[1].trim();
+ showMatch(server, user, match);
}
- if (match.equalsIgnoreCase("show") || !user.isAuthorized("essentials.exp.others"))
+ else
{
showExp(user, user);
}
- else
+ }
+ else
+ {
+ if (args.length >= 1 && Util.isInt(args[0].toLowerCase(Locale.ENGLISH).replace("l", "")) && user.isAuthorized("essentials.exp.give"))
{
+ if (args.length >= 2 && user.isAuthorized("essentials.exp.give.others"))
+ {
+ expMatch(server, user, args[1], args[0], true);
+ }
+ else
+ {
+ setExp(user, user, args[0], true);
+ }
+ }
+ else if (args.length >= 1 && user.isAuthorized("essentials.exp.others"))
+ {
+ String match = args[0].trim();
showMatch(server, user, match);
}
+ else
+ {
+ showExp(user, user);
+ }
}
}
@@ -81,9 +102,14 @@ else if (args.length > 2 && args[0].equalsIgnoreCase("give"))
else
{
String match = args[0].trim();
- if (args.length == 2)
+ if (args.length >= 2 && Util.isInt(args[0].toLowerCase(Locale.ENGLISH).replace("l", "")))
{
match = args[1].trim();
+ expMatch(server, sender, match, args[0], true);
+ }
+ else if (args.length == 1)
+ {
+ match = args[0].trim();
}
showMatch(server, sender, match);
}
@@ -91,12 +117,18 @@ else if (args.length > 2 && args[0].equalsIgnoreCase("give"))
private void showMatch(final Server server, final CommandSender sender, final String match) throws NotEnoughArgumentsException
{
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
boolean foundUser = false;
- for (Player matchPlayer : server.matchPlayer(match))
+ final List matchedPlayers = server.matchPlayer(match);
+ for (Player matchPlayer : matchedPlayers)
{
+ final User player = ess.getUser(matchPlayer);
+ if (skipHidden && player.isHidden())
+ {
+ continue;
+ }
foundUser = true;
- final User target = ess.getUser(matchPlayer);
- showExp(sender, target);
+ showExp(sender, player);
}
if (!foundUser)
{
@@ -104,14 +136,19 @@ private void showMatch(final Server server, final CommandSender sender, final St
}
}
- private void expMatch(final Server server, final CommandSender sender, final String match, final String amount, final boolean toggle) throws NotEnoughArgumentsException
+ private void expMatch(final Server server, final CommandSender sender, final String match, String amount, final boolean give) throws NotEnoughArgumentsException
{
boolean foundUser = false;
- for (Player matchPlayer : server.matchPlayer(match))
+ final List matchedPlayers = server.matchPlayer(match);
+ for (Player matchPlayer : matchedPlayers)
{
- final User target = ess.getUser(matchPlayer);
- setExp(sender, target, amount, toggle);
+ final User player = ess.getUser(matchPlayer);
+ if (player.isHidden())
+ {
+ continue;
+ }
foundUser = true;
+ setExp(sender, player, amount, give);
}
if (!foundUser)
{
@@ -121,14 +158,34 @@ private void expMatch(final Server server, final CommandSender sender, final Str
private void showExp(final CommandSender sender, final User target)
{
- final int totalExp = SetExpFix.getTotalExperience(target);
- final int expLeft = (int)Util.roundDouble(((((3.5 * target.getLevel()) + 6.7) - (totalExp - ((1.75 * (target.getLevel() * target.getLevel())) + (5.00 * target.getLevel())))) + 1));
- sender.sendMessage(_("exp", target.getDisplayName(), SetExpFix.getTotalExperience(target), target.getLevel(), expLeft));
+ sender.sendMessage(_("exp", target.getDisplayName(), SetExpFix.getTotalExperience(target), target.getLevel(), SetExpFix.getExpUntilNextLevel(target)));
}
- private void setExp(final CommandSender sender, final User target, final String strAmount, final boolean give)
+ //TODO: Limit who can give negative exp?
+ private void setExp(final CommandSender sender, final User target, String strAmount, final boolean give) throws NotEnoughArgumentsException
{
- Long amount = Long.parseLong(strAmount);
+ long amount;
+ strAmount = strAmount.toLowerCase(Locale.ENGLISH);
+ if (strAmount.contains("l"))
+ {
+ strAmount = strAmount.replaceAll("l", "");
+ int neededLevel = Integer.parseInt(strAmount);
+ if (give)
+ {
+ neededLevel += target.getLevel();
+ }
+ amount = (long)SetExpFix.getExpToLevel(neededLevel);
+ SetExpFix.setTotalExperience(target, 0);
+ }
+ else
+ {
+ amount = Long.parseLong(strAmount);
+ if (amount > Integer.MAX_VALUE || amount < Integer.MIN_VALUE)
+ {
+ throw new NotEnoughArgumentsException();
+ }
+ }
+
if (give)
{
amount += SetExpFix.getTotalExperience(target);
@@ -137,7 +194,11 @@ private void setExp(final CommandSender sender, final User target, final String
{
amount = (long)Integer.MAX_VALUE;
}
- SetExpFix.setTotalExperience(target, amount.intValue());
+ if (amount < 0l)
+ {
+ amount = 0l;
+ }
+ SetExpFix.setTotalExperience(target, (int)amount);
sender.sendMessage(_("expSet", target.getDisplayName(), amount));
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandext.java b/Essentials/src/com/earth2me/essentials/commands/Commandext.java
index 3855e7b681..552f74db29 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandext.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandext.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -40,10 +41,23 @@ public void run(final Server server, final User user, final String commandLabel,
private void extinguishPlayers(final Server server, final CommandSender sender, final String name) throws Exception
{
- for (Player matchPlayer : server.matchPlayer(name))
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(name);
+ for (Player matchPlayer : matchedPlayers)
{
+ final User player = ess.getUser(matchPlayer);
+ if (skipHidden && player.isHidden())
+ {
+ continue;
+ }
+ foundUser = true;
matchPlayer.setFireTicks(0);
sender.sendMessage(_("extinguishOthers", matchPlayer.getDisplayName()));
}
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
+ }
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandfeed.java b/Essentials/src/com/earth2me/essentials/commands/Commandfeed.java
index 0c1579835e..4644e6c3ac 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandfeed.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandfeed.java
@@ -20,7 +20,7 @@ protected void run(final Server server, final User user, final String commandLab
{
if (args.length > 0 && user.isAuthorized("essentials.feed.others"))
{
- feedOtherPlayers(server,user,args[0]);
+ feedOtherPlayers(server, user, args[0]);
}
else
{
@@ -29,24 +29,27 @@ protected void run(final Server server, final User user, final String commandLab
user.sendMessage(_("feed"));
}
}
-
- private void feedOtherPlayers(final Server server, final CommandSender sender, final String name)
+
+ private void feedOtherPlayers(final Server server, final CommandSender sender, final String name) throws NotEnoughArgumentsException
{
- final List players = server.matchPlayer(name);
- if (players.isEmpty())
- {
- sender.sendMessage(_("playerNotFound"));
- return;
- }
- for (Player player : players)
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(name);
+ for (Player matchPlayer : matchedPlayers)
{
- if (ess.getUser(player).isHidden())
+ final User player = ess.getUser(matchPlayer);
+ if (skipHidden && player.isHidden())
{
continue;
}
- player.setFoodLevel(20);
- player.setSaturation(10);
- sender.sendMessage(_("feedOther", player.getDisplayName()));
+ foundUser = true;
+ matchPlayer.setFoodLevel(20);
+ matchPlayer.setSaturation(10);
+ sender.sendMessage(_("feedOther", matchPlayer.getDisplayName()));
+ }
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandfireball.java b/Essentials/src/com/earth2me/essentials/commands/Commandfireball.java
index 671d0f72b8..f1aae3ca7c 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandfireball.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandfireball.java
@@ -2,8 +2,7 @@
import com.earth2me.essentials.User;
import org.bukkit.Server;
-import org.bukkit.entity.Fireball;
-import org.bukkit.entity.SmallFireball;
+import org.bukkit.entity.*;
import org.bukkit.util.Vector;
@@ -18,12 +17,43 @@ public Commandfireball()
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
boolean small = false;
- if (args.length > 0 && args[0].equalsIgnoreCase("small"))
+ Class type = Fireball.class;
+ Projectile projectile;
+ int speed = 2;
+ if (args.length > 0)
{
- small = true;
+ if (args[0].equalsIgnoreCase("small"))
+ {
+ type = SmallFireball.class;
+ }
+ else if (args[0].equalsIgnoreCase("arrow"))
+ {
+ type = Arrow.class;
+ }
+ else if (args[0].equalsIgnoreCase("skull"))
+ {
+ type = WitherSkull.class;
+ }
+ else if (args[0].equalsIgnoreCase("egg"))
+ {
+ type = Egg.class;
+ }
+ else if(args[0].equalsIgnoreCase("snowball"))
+ {
+ type = Snowball.class;
+ }
+ else if(args[0].equalsIgnoreCase("expbottle"))
+ {
+ type = ThrownExpBottle.class;
+ }
+ else if(args[0].equalsIgnoreCase("large"))
+ {
+ type = LargeFireball.class;
+ }
}
- final Vector direction = user.getEyeLocation().getDirection().multiply(2);
- Fireball fireball = user.getWorld().spawn(user.getEyeLocation().add(direction.getX(), direction.getY(), direction.getZ()), small ? SmallFireball.class : Fireball.class);
- fireball.setShooter(user.getBase());
+ final Vector direction = user.getEyeLocation().getDirection().multiply(speed);
+ projectile = (Projectile)user.getWorld().spawn(user.getEyeLocation().add(direction.getX(), direction.getY(), direction.getZ()), type);
+ projectile.setShooter(user.getBase());
+ projectile.setVelocity(direction);
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandfirework.java b/Essentials/src/com/earth2me/essentials/commands/Commandfirework.java
new file mode 100644
index 0000000000..41a844fbd1
--- /dev/null
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandfirework.java
@@ -0,0 +1,153 @@
+package com.earth2me.essentials.commands;
+
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.MetaItemStack;
+import com.earth2me.essentials.User;
+import com.earth2me.essentials.Util;
+import java.util.regex.Pattern;
+import org.bukkit.FireworkEffect;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Firework;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.FireworkMeta;
+import org.bukkit.util.Vector;
+
+//This command has quite a complicated syntax, in theory it has 4 seperate syntaxes which are all variable:
+//
+//1: /firework clear - This clears all of the effects on a firework stack
+//
+//2: /firework power - This changes the base power of a firework
+//
+//3: /firework fire - This 'fires' a copy of the firework held.
+//3: /firework fire - This 'fires' a number of copies of the firework held.
+//3: /firework fire - This 'fires' a copy of the firework held, in the direction you are looking, #easteregg
+//
+//4: /firework [meta] - This will add an effect to the firework stack held
+//4: /firework color: - The minimum you need to set an effect is 'color'
+//4: Full Syntax: color: [fade:] [shape:] [effect:]
+//4: Possible Shapes: star, ball, large, creeper, burst
+//4: Possible Effects trail, twinkle
+
+public class Commandfirework extends EssentialsCommand
+{
+ private final transient Pattern splitPattern = Pattern.compile("[:+',;.]");
+
+ public Commandfirework()
+ {
+ super("firework");
+ }
+
+ @Override
+ protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
+ {
+ final ItemStack stack = user.getItemInHand();
+ if (stack.getType() == Material.FIREWORK)
+ {
+ if (args.length > 0)
+ {
+ if (args[0].equalsIgnoreCase("clear"))
+ {
+ FireworkMeta fmeta = (FireworkMeta)stack.getItemMeta();
+ fmeta.clearEffects();
+ stack.setItemMeta(fmeta);
+ user.sendMessage(_("fireworkEffectsCleared"));
+ }
+ else if (args.length > 1 && (args[0].equalsIgnoreCase("power") || (args[0].equalsIgnoreCase("p"))))
+ {
+ FireworkMeta fmeta = (FireworkMeta)stack.getItemMeta();
+ try
+ {
+ int power = Integer.parseInt(args[1]);
+ fmeta.setPower(power > 3 ? 4 : power);
+ }
+ catch (NumberFormatException e)
+ {
+ throw new Exception(_("invalidFireworkFormat", args[1], args[0]));
+ }
+ stack.setItemMeta(fmeta);
+ }
+ else if ((args[0].equalsIgnoreCase("fire") || (args[0].equalsIgnoreCase("f")))
+ && user.isAuthorized("essentials.firework.fire"))
+ {
+ int amount = 1;
+ boolean direction = false;
+ if (args.length > 1)
+ {
+ if (Util.isInt(args[1]))
+ {
+ final int serverLimit = ess.getSettings().getSpawnMobLimit();
+ amount = Integer.parseInt(args[1]);
+ if (amount > serverLimit)
+ {
+ amount = serverLimit;
+ user.sendMessage(_("mobSpawnLimit"));
+ }
+ }
+ else
+ {
+ direction = true;
+ }
+ }
+ for (int i = 0; i < amount; i++)
+ {
+ Firework firework = (Firework)user.getWorld().spawnEntity(user.getLocation(), EntityType.FIREWORK);
+ FireworkMeta fmeta = (FireworkMeta)stack.getItemMeta();
+ if (direction)
+ {
+ final Vector vector = user.getEyeLocation().getDirection().multiply(0.070);
+ if (fmeta.getPower() > 1)
+ {
+ fmeta.setPower(1);
+ }
+ firework.setVelocity(vector);
+ }
+ firework.setFireworkMeta(fmeta);
+ }
+ }
+ else
+ {
+ final MetaItemStack mStack = new MetaItemStack(stack);
+ for (String arg : args)
+ {
+ try
+ {
+ mStack.addFireworkMeta(user, true, arg, ess);
+ }
+ catch (Exception e)
+ {
+ user.sendMessage(_("fireworkSyntax"));
+ throw e;
+ }
+ }
+
+ if (mStack.isValidFirework())
+ {
+ FireworkMeta fmeta = (FireworkMeta)mStack.getItemStack().getItemMeta();
+ FireworkEffect effect = mStack.getFireworkBuilder().build();
+ if (fmeta.getEffects().size() > 0 && !user.isAuthorized("essentials.firework.multiple"))
+ {
+ throw new Exception(_("multipleCharges"));
+ }
+ fmeta.addEffect(effect);
+ stack.setItemMeta(fmeta);
+ }
+ else
+ {
+ user.sendMessage(_("fireworkSyntax"));
+ throw new Exception(_("fireworkColor"));
+ }
+ }
+ }
+ else
+ {
+ throw new NotEnoughArgumentsException();
+ }
+ }
+ else
+ {
+ throw new Exception(_("holdFirework"));
+ }
+ }
+}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandfly.java b/Essentials/src/com/earth2me/essentials/commands/Commandfly.java
index 86347d3e97..1d5353fb1c 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandfly.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandfly.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -28,29 +29,51 @@ protected void run(final Server server, final CommandSender sender, final String
@Override
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
- if (args.length > 0 && args[0].trim().length() > 2 && user.isAuthorized("essentials.fly.others"))
+ if (args.length == 1)
+ {
+ if (args[0].equalsIgnoreCase("on") || args[0].startsWith("ena") || args[0].equalsIgnoreCase("1"))
+ {
+ user.setAllowFlight(true);
+ }
+ else if (args[0].equalsIgnoreCase("off") || args[0].startsWith("dis") || args[0].equalsIgnoreCase("0"))
+ {
+ user.setAllowFlight(false);
+ }
+ else if (user.isAuthorized("essentials.fly.others"))
+ {
+ flyOtherPlayers(server, user, args);
+ return;
+ }
+ }
+ else if (args.length == 2 && user.isAuthorized("essentials.fly.others"))
{
flyOtherPlayers(server, user, args);
return;
}
- user.setAllowFlight(!user.getAllowFlight());
- if (!user.getAllowFlight())
+ else
{
- user.setFlying(false);
+ user.setAllowFlight(!user.getAllowFlight());
+ if (!user.getAllowFlight())
+ {
+ user.setFlying(false);
+ }
}
user.sendMessage(_("flyMode", _(user.getAllowFlight() ? "enabled" : "disabled"), user.getDisplayName()));
}
- private void flyOtherPlayers(final Server server, final CommandSender sender, final String[] args)
+ private void flyOtherPlayers(final Server server, final CommandSender sender, final String[] args) throws NotEnoughArgumentsException
{
- for (Player matchPlayer : server.matchPlayer(args[0]))
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(args[0]);
+ for (Player matchPlayer : matchedPlayers)
{
final User player = ess.getUser(matchPlayer);
- if (player.isHidden())
+ if (skipHidden && player.isHidden())
{
continue;
}
-
+ foundUser = true;
if (args.length > 1)
{
if (args[1].contains("on") || args[1].contains("ena") || args[1].equalsIgnoreCase("1"))
@@ -73,5 +96,9 @@ private void flyOtherPlayers(final Server server, final CommandSender sender, fi
}
sender.sendMessage(_("flyMode", _(player.getAllowFlight() ? "enabled" : "disabled"), player.getDisplayName()));
}
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
+ }
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgamemode.java b/Essentials/src/com/earth2me/essentials/commands/Commandgamemode.java
index 5fdc69d68e..9707c8403c 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandgamemode.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandgamemode.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.List;
import java.util.Locale;
import org.bukkit.GameMode;
import org.bukkit.Server;
@@ -19,53 +20,118 @@ public Commandgamemode()
@Override
protected void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- if (args.length < 1)
+ GameMode gameMode;
+ if (args.length == 0)
{
throw new NotEnoughArgumentsException();
}
+ else if (args.length == 1)
+ {
+ gameMode = matchGameMode(commandLabel);
+ gamemodeOtherPlayers(server, sender, gameMode, args[0]);
+ }
+ else if (args.length == 2)
+ {
+ gameMode = matchGameMode(args[0].toLowerCase(Locale.ENGLISH));
+ gamemodeOtherPlayers(server, sender, gameMode, args[1]);
+ }
- gamemodeOtherPlayers(server, sender, args);
}
@Override
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
- if (args.length > 0 && args[0].trim().length() > 2 && user.isAuthorized("essentials.gamemode.others"))
+ GameMode gameMode;
+ if (args.length == 0)
+ {
+ gameMode = matchGameMode(commandLabel);
+ }
+ else if (args.length > 1 && args[1].trim().length() > 2 && user.isAuthorized("essentials.gamemode.others"))
{
- gamemodeOtherPlayers(server, user, args);
+ gameMode = matchGameMode(args[0].toLowerCase(Locale.ENGLISH));
+ gamemodeOtherPlayers(server, user, gameMode, args[1]);
return;
}
-
- user.setGameMode(user.getGameMode() == GameMode.SURVIVAL ? GameMode.CREATIVE : GameMode.SURVIVAL);
- user.sendMessage(_("gameMode", _(user.getGameMode().toString().toLowerCase(Locale.ENGLISH)), user.getDisplayName()));
- }
-
- private void gamemodeOtherPlayers(final Server server, final CommandSender sender, final String[] args)
- {
- for (Player matchPlayer : server.matchPlayer(args[0]))
+ else
{
- final User player = ess.getUser(matchPlayer);
- if (player.isHidden())
+ try
{
- continue;
+ gameMode = matchGameMode(args[0].toLowerCase(Locale.ENGLISH));
}
-
- if (args.length > 1)
+ catch (NotEnoughArgumentsException e)
{
- if (args[1].contains("creat") || args[1].equalsIgnoreCase("1"))
- {
- player.setGameMode(GameMode.CREATIVE);
- }
- else
+ if (user.isAuthorized("essentials.gamemode.others"))
{
- player.setGameMode(GameMode.SURVIVAL);
+ gameMode = matchGameMode(commandLabel);
+ gamemodeOtherPlayers(server, user, gameMode, args[0]);
+ return;
}
+ throw new NotEnoughArgumentsException();
}
- else
+ }
+ if (gameMode == null)
+ {
+ gameMode = user.getGameMode() == GameMode.SURVIVAL ? GameMode.CREATIVE : user.getGameMode() == GameMode.CREATIVE ? GameMode.ADVENTURE : GameMode.SURVIVAL;
+ }
+ user.setGameMode(gameMode);
+ user.sendMessage(_("gameMode", _(user.getGameMode().toString().toLowerCase(Locale.ENGLISH)), user.getDisplayName()));
+ }
+
+ private void gamemodeOtherPlayers(final Server server, final CommandSender sender, final GameMode gameMode, final String name) throws NotEnoughArgumentsException
+ {
+ //TODO: TL this
+ if (name.trim().length() < 2 || gameMode == null)
+ {
+ throw new NotEnoughArgumentsException("You need to specify a valid player/mode.");
+ }
+
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(name);
+ for (Player matchPlayer : matchedPlayers)
+ {
+ final User player = ess.getUser(matchPlayer);
+ if (skipHidden && player.isHidden())
{
- player.setGameMode(player.getGameMode() == GameMode.SURVIVAL ? GameMode.CREATIVE : GameMode.SURVIVAL);
+ continue;
}
+ foundUser = true;
+ player.setGameMode(gameMode);
sender.sendMessage(_("gameMode", _(player.getGameMode().toString().toLowerCase(Locale.ENGLISH)), player.getDisplayName()));
}
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
+ }
+ }
+
+ private GameMode matchGameMode(String modeString) throws NotEnoughArgumentsException
+ {
+ GameMode mode = null;
+ if (modeString.equalsIgnoreCase("gmc") || modeString.equalsIgnoreCase("egmc")
+ || modeString.contains("creat") || modeString.equalsIgnoreCase("1") || modeString.equalsIgnoreCase("c"))
+ {
+ mode = GameMode.CREATIVE;
+ }
+ else if (modeString.equalsIgnoreCase("gms") || modeString.equalsIgnoreCase("egms")
+ || modeString.contains("survi") || modeString.equalsIgnoreCase("0") || modeString.equalsIgnoreCase("s"))
+ {
+ mode = GameMode.SURVIVAL;
+ }
+ else if (modeString.equalsIgnoreCase("gma") || modeString.equalsIgnoreCase("egma")
+ || modeString.contains("advent") || modeString.equalsIgnoreCase("2") || modeString.equalsIgnoreCase("a"))
+ {
+ mode = GameMode.ADVENTURE;
+ }
+ else if (modeString.equalsIgnoreCase("gmt") || modeString.equalsIgnoreCase("egmt")
+ || modeString.contains("toggle") || modeString.contains("cycle") || modeString.equalsIgnoreCase("t"))
+ {
+ mode = null;
+ }
+ else
+ {
+ throw new NotEnoughArgumentsException();
+ }
+ return mode;
}
-}
+}
\ No newline at end of file
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgc.java b/Essentials/src/com/earth2me/essentials/commands/Commandgc.java
index d9b08b50f0..71851f8833 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandgc.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandgc.java
@@ -1,6 +1,9 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.Util;
+import java.lang.management.ManagementFactory;
+import java.util.List;
import org.bukkit.ChatColor;
import org.bukkit.Server;
import org.bukkit.World;
@@ -17,13 +20,13 @@ public Commandgc()
@Override
protected void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- float tps = ess.getTimer().getAverageTPS();
+ double tps = ess.getTimer().getAverageTPS();
ChatColor color;
- if (tps >= 18)
+ if (tps >= 18.0)
{
color = ChatColor.GREEN;
}
- else if (tps >= 15)
+ else if (tps >= 15.0)
{
color = ChatColor.YELLOW;
}
@@ -31,17 +34,28 @@ else if (tps >= 15)
{
color = ChatColor.RED;
}
+
+ sender.sendMessage(_("uptime", Util.formatDateDiff(ManagementFactory.getRuntimeMXBean().getStartTime())));
sender.sendMessage(_("tps", "" + color + tps));
sender.sendMessage(_("gcmax", (Runtime.getRuntime().maxMemory() / 1024 / 1024)));
sender.sendMessage(_("gctotal", (Runtime.getRuntime().totalMemory() / 1024 / 1024)));
sender.sendMessage(_("gcfree", (Runtime.getRuntime().freeMemory() / 1024 / 1024)));
- for (World w : server.getWorlds())
+ List worlds = server.getWorlds();
+ for (World w : worlds)
{
- sender.sendMessage(
- (w.getEnvironment() == World.Environment.NETHER ? "Nether" : "World") + " \"" + w.getName() + "\": "
- + w.getLoadedChunks().length + _("gcchunks")
- + w.getEntities().size() + _("gcentities"));
+ String worldType = "World";
+ switch (w.getEnvironment())
+ {
+ case NETHER:
+ worldType = "Nether";
+ break;
+ case THE_END:
+ worldType = "The End";
+ break;
+ }
+
+ sender.sendMessage(_("gcWorld", worldType, w.getName(), w.getLoadedChunks().length, w.getEntities().size()));
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgetpos.java b/Essentials/src/com/earth2me/essentials/commands/Commandgetpos.java
index c985ef7257..6e6dfcee77 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandgetpos.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandgetpos.java
@@ -1,5 +1,6 @@
package com.earth2me.essentials.commands;
+import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
import org.bukkit.Location;
import org.bukkit.Server;
@@ -18,7 +19,7 @@ public void run(final Server server, final User user, final String commandLabel,
{
if (args.length > 0 && user.isAuthorized("essentials.getpos.others"))
{
- final User otherUser = getPlayer(server, args, 0);
+ final User otherUser = getPlayer(server, args, 0, true, false);
if (!otherUser.isHidden() || user.isAuthorized("essentials.list.hidden"))
{
outputPosition(user, otherUser.getLocation(), user.getLocation());
@@ -36,22 +37,21 @@ protected void run(final Server server, final CommandSender sender, final String
{
throw new NotEnoughArgumentsException();
}
- final User user = getPlayer(server, args, 0);
+ final User user = getPlayer(server, args, 0, true, false);
outputPosition(sender, user.getLocation(), null);
}
- //TODO: Translate
private void outputPosition(final CommandSender sender, final Location coords, final Location distance)
{
- sender.sendMessage("§7World: " + coords.getWorld().getName());
- sender.sendMessage("§7X: " + coords.getBlockX() + " (+East <-> -West)");
- sender.sendMessage("§7Y: " + coords.getBlockY() + " (+Up <-> -Down)");
- sender.sendMessage("§7Z: " + coords.getBlockZ() + " (+South <-> -North)");
- sender.sendMessage("§7Yaw: " + (coords.getYaw() + 180 + 360) % 360 + " (Rotation)");
- sender.sendMessage("§7Pitch: " + coords.getPitch() + " (Head angle)");
+ sender.sendMessage(_("currentWorld", coords.getWorld().getName()));
+ sender.sendMessage(_("posX", coords.getBlockX()));
+ sender.sendMessage(_("posY", coords.getBlockY()));
+ sender.sendMessage(_("posZ", coords.getBlockZ()));
+ sender.sendMessage(_("posYaw", (coords.getYaw() + 180 + 360) % 360));
+ sender.sendMessage(_("posPitch", coords.getPitch()));
if (distance != null && coords.getWorld().equals(distance.getWorld()))
{
- sender.sendMessage("§7Distance: " + coords.distance(distance));
+ sender.sendMessage(_("distance", coords.distance(distance)));
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgive.java b/Essentials/src/com/earth2me/essentials/commands/Commandgive.java
index 21903e98b6..d7c6feaa9b 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandgive.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandgive.java
@@ -1,15 +1,14 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.MetaItemStack;
import com.earth2me.essentials.User;
import com.earth2me.essentials.Util;
+import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
import java.util.Locale;
-import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
-import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
@@ -29,14 +28,14 @@ public void run(final Server server, final CommandSender sender, final String co
throw new NotEnoughArgumentsException();
}
- final ItemStack stack = ess.getItemDb().get(args[1]);
+ ItemStack stack = ess.getItemDb().get(args[1]);
final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "");
if (sender instanceof Player
&& (ess.getSettings().permissionBasedItemSpawn()
- ? (!ess.getUser(sender).isAuthorized("essentials.give.item-all")
- && !ess.getUser(sender).isAuthorized("essentials.give.item-" + itemname)
- && !ess.getUser(sender).isAuthorized("essentials.give.item-" + stack.getTypeId()))
+ ? (!ess.getUser(sender).isAuthorized("essentials.itemspawn.item-all")
+ && !ess.getUser(sender).isAuthorized("essentials.itemspawn.item-" + itemname)
+ && !ess.getUser(sender).isAuthorized("essentials.itemspawn.item-" + stack.getTypeId()))
: (!ess.getUser(sender).isAuthorized("essentials.itemspawn.exempt")
&& !ess.getUser(sender).canSpawnItem(stack.getTypeId()))))
{
@@ -45,45 +44,43 @@ public void run(final Server server, final CommandSender sender, final String co
final User giveTo = getPlayer(server, args, 0);
- if (args.length > 3 && Util.isInt(args[2]) && Util.isInt(args[3]))
- {
- stack.setAmount(Integer.parseInt(args[2]));
- stack.setDurability(Short.parseShort(args[3]));
- }
- else if (args.length > 2 && Integer.parseInt(args[2]) > 0)
+ try
{
- stack.setAmount(Integer.parseInt(args[2]));
- }
- else if (ess.getSettings().getDefaultStackSize() > 0)
- {
- stack.setAmount(ess.getSettings().getDefaultStackSize());
+ if (args.length > 3 && Util.isInt(args[2]) && Util.isInt(args[3]))
+ {
+ stack.setAmount(Integer.parseInt(args[2]));
+ stack.setDurability(Short.parseShort(args[3]));
+ }
+ else if (args.length > 2 && Integer.parseInt(args[2]) > 0)
+ {
+ stack.setAmount(Integer.parseInt(args[2]));
+ }
+ else if (ess.getSettings().getDefaultStackSize() > 0)
+ {
+ stack.setAmount(ess.getSettings().getDefaultStackSize());
+ }
+ else if (ess.getSettings().getOversizedStackSize() > 0 && giveTo.isAuthorized("essentials.oversizedstacks"))
+ {
+ stack.setAmount(ess.getSettings().getOversizedStackSize());
+ }
}
- else if (ess.getSettings().getOversizedStackSize() > 0 && giveTo.isAuthorized("essentials.oversizedstacks"))
+ catch (NumberFormatException e)
{
- stack.setAmount(ess.getSettings().getOversizedStackSize());
+ throw new NotEnoughArgumentsException();
}
if (args.length > 3)
{
- for (int i = Util.isInt(args[3]) ? 4 : 3; i < args.length; i++)
+ MetaItemStack metaStack = new MetaItemStack(stack);
+ boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments();
+ if (allowUnsafe && sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.enchantments.allowunsafe"))
{
- final String[] split = args[i].split("[:+',;.]", 2);
- if (split.length < 1)
- {
- continue;
- }
- final Enchantment enchantment = Commandenchant.getEnchantment(split[0], sender instanceof Player ? ess.getUser(sender) : null);
- int level;
- if (split.length > 1)
- {
- level = Integer.parseInt(split[1]);
- }
- else
- {
- level = enchantment.getMaxLevel();
- }
- stack.addEnchantment(enchantment, level);
+ allowUnsafe = false;
}
+
+ metaStack.parseStringMeta(sender, allowUnsafe, args, Util.isInt(args[3]) ? 4 : 3, ess);
+
+ stack = metaStack.getItemStack();
}
if (stack.getType() == Material.AIR)
@@ -91,16 +88,15 @@ else if (ess.getSettings().getOversizedStackSize() > 0 && giveTo.isAuthorized("e
throw new Exception(_("cantSpawnItem", "Air"));
}
- //TODO: TL this.
final String itemName = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace('_', ' ');
- sender.sendMessage(ChatColor.BLUE + "Giving " + stack.getAmount() + " of " + itemName + " to " + giveTo.getDisplayName() + ".");
+ sender.sendMessage(_("giveSpawn", stack.getAmount(), itemName, giveTo.getDisplayName()));
if (giveTo.isAuthorized("essentials.oversizedstacks"))
{
- InventoryWorkaround.addItem(giveTo.getInventory(), true, ess.getSettings().getOversizedStackSize(), stack);
+ InventoryWorkaround.addOversizedItems(giveTo.getInventory(), ess.getSettings().getOversizedStackSize(), stack);
}
else
{
- InventoryWorkaround.addItem(giveTo.getInventory(), true, stack);
+ InventoryWorkaround.addItems(giveTo.getInventory(), stack);
}
giveTo.updateInventory();
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgod.java b/Essentials/src/com/earth2me/essentials/commands/Commandgod.java
index 5ca2aad9ac..a77648c864 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandgod.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandgod.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -33,44 +34,57 @@ protected void run(final Server server, final User user, final String commandLab
godOtherPlayers(server, user, args);
return;
}
- user.setGodModeEnabled(!user.isGodModeEnabled());
+ godPlayer(user, !user.isGodModeEnabled());
user.sendMessage(_("godMode", (user.isGodModeEnabled() ? _("enabled") : _("disabled"))));
}
- private void godOtherPlayers(final Server server, final CommandSender sender, final String[] args)
+ private void godPlayer(User player, boolean enabled)
{
- for (Player matchPlayer : server.matchPlayer(args[0]))
+ player.setGodModeEnabled(enabled);
+ if (enabled && player.getHealth() != 0)
+ {
+ player.setHealth(player.getMaxHealth());
+ player.setFoodLevel(20);
+ }
+ }
+
+ private void godOtherPlayers(final Server server, final CommandSender sender, final String[] args) throws NotEnoughArgumentsException
+ {
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(args[0]);
+ for (Player matchPlayer : matchedPlayers)
{
final User player = ess.getUser(matchPlayer);
- if (player.isHidden())
+ if (skipHidden && player.isHidden())
{
continue;
}
-
+ foundUser = true;
+ boolean enabled;
if (args.length > 1)
{
if (args[1].contains("on") || args[1].contains("ena") || args[1].equalsIgnoreCase("1"))
{
- player.setGodModeEnabled(true);
+ enabled = true;
}
else
{
- player.setGodModeEnabled(false);
+ enabled = false;
}
}
else
{
- player.setGodModeEnabled(!player.isGodModeEnabled());
- }
-
- final boolean enabled = player.isGodModeEnabled();
- if (enabled)
- {
- player.setFoodLevel(20);
+ enabled = !player.isGodModeEnabled();
}
+ godPlayer(player, enabled);
player.sendMessage(_("godMode", (enabled ? _("enabled") : _("disabled"))));
sender.sendMessage(_("godMode", _(enabled ? "godEnabledFor" : "godDisabledFor", matchPlayer.getDisplayName())));
}
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
+ }
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandhat.java b/Essentials/src/com/earth2me/essentials/commands/Commandhat.java
index 5dd0fbb747..0b28ef1e3f 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandhat.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandhat.java
@@ -31,7 +31,7 @@ protected void run(final Server server, final User user, final String commandLab
{
final ItemStack air = new ItemStack(Material.AIR);
inv.setHelmet(air);
- InventoryWorkaround.addItem(user.getInventory(), true, head);
+ InventoryWorkaround.addItems(user.getInventory(), head);
user.sendMessage(_("hatRemoved"));
}
}
@@ -44,7 +44,6 @@ protected void run(final Server server, final User user, final String commandLab
{
final PlayerInventory inv = user.getInventory();
final ItemStack head = inv.getHelmet();
- inv.removeItem(hand);
inv.setHelmet(hand);
inv.setItemInHand(head);
user.sendMessage(_("hatPlaced"));
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandheal.java b/Essentials/src/com/earth2me/essentials/commands/Commandheal.java
index 82678c96e7..e1495bdc6b 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandheal.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandheal.java
@@ -6,6 +6,7 @@
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
public class Commandheal extends EssentialsCommand
@@ -33,9 +34,7 @@ public void run(final Server server, final User user, final String commandLabel,
{
user.healCooldown();
}
- user.setHealth(20);
- user.setFoodLevel(20);
- user.sendMessage(_("heal"));
+ healPlayer(user);
}
@Override
@@ -49,24 +48,41 @@ public void run(final Server server, final CommandSender sender, final String co
healOtherPlayers(server, sender, args[0]);
}
- private void healOtherPlayers(final Server server, final CommandSender sender, final String name)
+ private void healOtherPlayers(final Server server, final CommandSender sender, final String name) throws Exception
{
- final List players = server.matchPlayer(name);
- if (players.isEmpty())
+ boolean skipHidden = sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.vanish.interact");
+ boolean foundUser = false;
+ final List matchedPlayers = server.matchPlayer(name);
+ for (Player matchPlayer : matchedPlayers)
{
- sender.sendMessage(_("playerNotFound"));
- return;
- }
- for (Player p : players)
- {
- if (ess.getUser(p).isHidden())
+ final User player = ess.getUser(matchPlayer);
+ if (skipHidden && player.isHidden())
{
continue;
}
- p.setHealth(20);
- p.setFoodLevel(20);
- p.sendMessage(_("heal"));
- sender.sendMessage(_("healOther", p.getDisplayName()));
+ foundUser = true;
+ healPlayer(matchPlayer);
+ sender.sendMessage(_("healOther", matchPlayer.getDisplayName()));
+ }
+ if (!foundUser)
+ {
+ throw new NotEnoughArgumentsException(_("playerNotFound"));
+ }
+ }
+
+ private void healPlayer(final Player player) throws Exception
+ {
+ if (player.getHealth() == 0)
+ {
+ throw new Exception(_("healDead"));
+ }
+ player.setHealth(player.getMaxHealth());
+ player.setFoodLevel(20);
+ player.setFireTicks(0);
+ player.sendMessage(_("heal"));
+ for (PotionEffect effect : player.getActivePotionEffects())
+ {
+ player.removePotionEffect(effect.getType());
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandhome.java b/Essentials/src/com/earth2me/essentials/commands/Commandhome.java
index 2c91a06c9d..a13616dc08 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandhome.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandhome.java
@@ -7,7 +7,6 @@
import java.util.List;
import java.util.Locale;
import org.bukkit.Location;
-import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
@@ -23,7 +22,6 @@ public Commandhome()
public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
final Trade charge = new Trade(this.getName(), ess);
- charge.isAffordableFor(user);
User player = user;
String homeName = "";
String[] nameParts;
@@ -36,7 +34,7 @@ public void run(final Server server, final User user, final String commandLabel,
}
else
{
- player = getPlayer(server, nameParts, 0, true);
+ player = getPlayer(server, nameParts, 0, true, true);
if (nameParts.length > 1)
{
homeName = nameParts[1];
@@ -45,38 +43,32 @@ public void run(final Server server, final User user, final String commandLabel,
}
try
{
- if ("bed".equalsIgnoreCase(homeName))
+ if ("bed".equalsIgnoreCase(homeName) && user.isAuthorized("essentials.home.bed"))
{
final Location bed = player.getBedSpawnLocation();
- if (bed != null && bed.getBlock().getType() == Material.BED_BLOCK)
+ if (bed != null)
{
user.getTeleport().teleport(bed, charge, TeleportCause.COMMAND);
throw new NoChargeException();
}
+ else
+ {
+ throw new Exception(_("bedMissing"));
+ }
}
goHome(user, player, homeName.toLowerCase(Locale.ENGLISH), charge);
}
catch (NotEnoughArgumentsException e)
{
Location bed = player.getBedSpawnLocation();
- if (bed != null && bed.getBlock().getType() != Material.BED_BLOCK)
- {
- bed = null;
- }
final List homes = player.getHomes();
if (homes.isEmpty() && player.equals(user))
{
- if (bed != null)
- {
- user.getTeleport().teleport(bed, charge, TeleportCause.COMMAND);
- throw new NoChargeException();
- }
user.getTeleport().respawn(charge, TeleportCause.COMMAND);
-
}
else if (homes.isEmpty())
{
- throw new Exception(player == user ? _("noHomeSet") : _("noHomeSetPlayer"));
+ throw new Exception(_("noHomeSetPlayer"));
}
else if (homes.size() == 1 && player.equals(user))
{
@@ -84,9 +76,16 @@ else if (homes.size() == 1 && player.equals(user))
}
else
{
- if (bed != null)
+ if (user.isAuthorized("essentials.home.bed"))
{
- homes.add("bed");
+ if (bed != null)
+ {
+ homes.add(_("bed"));
+ }
+ else
+ {
+ homes.add(_("bedNull"));
+ }
}
user.sendMessage(_("homes", Util.joinList(homes)));
}
@@ -102,9 +101,9 @@ private void goHome(final User user, final User player, final String home, final
throw new NotEnoughArgumentsException();
}
if (user.getWorld() != loc.getWorld() && ess.getSettings().isWorldHomePermissions()
- && !user.isAuthorized("essentials.world." + loc.getWorld().getName()))
+ && !user.isAuthorized("essentials.worlds." + loc.getWorld().getName()))
{
- throw new Exception(_("noPerm", "essentials.world." + loc.getWorld().getName()));
+ throw new Exception(_("noPerm", "essentials.worlds." + loc.getWorld().getName()));
}
user.getTeleport().home(loc, charge);
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandignore.java b/Essentials/src/com/earth2me/essentials/commands/Commandignore.java
index 8f160e9bae..090903c969 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandignore.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandignore.java
@@ -22,7 +22,7 @@ protected void run(final Server server, final User user, final String commandLab
User player;
try
{
- player = getPlayer(server, args, 0);
+ player = getPlayer(server, args, 0, true, true);
}
catch (NoSuchFieldException ex)
{
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandinvsee.java b/Essentials/src/com/earth2me/essentials/commands/Commandinvsee.java
index a4a659e97c..1528dc3539 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandinvsee.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandinvsee.java
@@ -1,10 +1,8 @@
package com.earth2me.essentials.commands;
-import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
-import java.util.Arrays;
import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Inventory;
public class Commandinvsee extends EssentialsCommand
@@ -13,6 +11,8 @@ public Commandinvsee()
{
super("invsee");
}
+
+ //This method has a hidden param, which if given will display the equip slots. #easteregg
@Override
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
@@ -21,8 +21,20 @@ protected void run(final Server server, final User user, final String commandLab
{
throw new NotEnoughArgumentsException();
}
- final User invUser = getPlayer(server, args, 0);
+
+ final User invUser = getPlayer(server, user, args, 0);
+ Inventory inv;
+
+ if (args.length > 1 && user.isAuthorized("essentials.invsee.equip"))
+ {
+ inv = server.createInventory(invUser, 9, "Equipped");
+ inv.setContents(invUser.getInventory().getArmorContents());
+ }
+ else
+ {
+ inv = invUser.getInventory();
+ }
+ user.openInventory(inv);
user.setInvSee(true);
- user.openInventory(invUser.getInventory());
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commanditem.java b/Essentials/src/com/earth2me/essentials/commands/Commanditem.java
index 0e35dda719..09a56ebd93 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commanditem.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commanditem.java
@@ -1,12 +1,12 @@
package com.earth2me.essentials.commands;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.MetaItemStack;
import com.earth2me.essentials.User;
+import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
import java.util.Locale;
import org.bukkit.Material;
import org.bukkit.Server;
-import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
@@ -24,7 +24,7 @@ public void run(final Server server, final User user, final String commandLabel,
{
throw new NotEnoughArgumentsException();
}
- final ItemStack stack = ess.getItemDb().get(args[0]);
+ ItemStack stack = ess.getItemDb().get(args[0]);
final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "");
if (ess.getSettings().permissionBasedItemSpawn()
@@ -50,33 +50,21 @@ else if (ess.getSettings().getOversizedStackSize() > 0 && user.isAuthorized("ess
{
stack.setAmount(ess.getSettings().getOversizedStackSize());
}
- if (args.length > 2)
- {
- for (int i = 2; i < args.length; i++)
- {
- final String[] split = args[i].split("[:+',;.]", 2);
- if (split.length < 1)
- {
- continue;
- }
- final Enchantment enchantment = Commandenchant.getEnchantment(split[0], user);
- int level;
- if (split.length > 1)
- {
- level = Integer.parseInt(split[1]);
- }
- else
- {
- level = enchantment.getMaxLevel();
- }
- stack.addEnchantment(enchantment, level);
- }
- }
}
catch (NumberFormatException e)
{
throw new NotEnoughArgumentsException();
}
+ if (args.length > 2)
+ {
+ MetaItemStack metaStack = new MetaItemStack(stack);
+ final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments() && user.isAuthorized("essentials.enchantments.allowunsafe");
+
+ metaStack.parseStringMeta(user, allowUnsafe, args, 2, ess);
+
+ stack = metaStack.getItemStack();
+ }
+
if (stack.getType() == Material.AIR)
{
@@ -87,11 +75,11 @@ else if (ess.getSettings().getOversizedStackSize() > 0 && user.isAuthorized("ess
user.sendMessage(_("itemSpawn", stack.getAmount(), displayName));
if (user.isAuthorized("essentials.oversizedstacks"))
{
- InventoryWorkaround.addItem(user.getInventory(), true, ess.getSettings().getOversizedStackSize(), stack);
+ InventoryWorkaround.addOversizedItems(user.getInventory(), ess.getSettings().getOversizedStackSize(), stack);
}
else
{
- InventoryWorkaround.addItem(user.getInventory(), true, stack);
+ InventoryWorkaround.addItems(user.getInventory(), stack);
}
user.updateInventory();
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java b/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java
index 8a408924db..11d633286d 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java
@@ -19,10 +19,12 @@ public Commanditemdb()
protected void run(Server server, CommandSender sender, String commandLabel, String[] args) throws Exception
{
ItemStack itemStack = null;
+ boolean itemHeld = false;
if (args.length < 1)
{
if (sender instanceof Player)
{
+ itemHeld = true;
itemStack = ((Player)sender).getItemInHand();
}
if (itemStack == null)
@@ -34,9 +36,9 @@ protected void run(Server server, CommandSender sender, String commandLabel, Str
{
itemStack = ess.getItemDb().get(args[0]);
}
- sender.sendMessage(itemStack.getType().toString() + "- " + itemStack.getTypeId() + ":" + Integer.toString(itemStack.getData().getData()));
-
- if (itemStack.getType() != Material.AIR)
+ sender.sendMessage(_("itemType", itemStack.getType().toString(), itemStack.getTypeId() + ":" + Integer.toString(itemStack.getDurability())));
+
+ if (itemHeld && itemStack.getType() != Material.AIR)
{
int maxuses = itemStack.getType().getMaxDurability();
int durability = ((maxuses + 1) - itemStack.getDurability());
@@ -44,6 +46,11 @@ protected void run(Server server, CommandSender sender, String commandLabel, Str
{
sender.sendMessage(_("durability", Integer.toString(durability)));
}
- }
+ }
+ final String itemNameList = ess.getItemDb().names(itemStack);
+ if (itemNameList != null)
+ {
+ sender.sendMessage(_("itemNames", ess.getItemDb().names(itemStack)));
+ }
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandjump.java b/Essentials/src/com/earth2me/essentials/commands/Commandjump.java
index ab73c6e012..073c20dce0 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandjump.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandjump.java
@@ -8,7 +8,7 @@
import org.bukkit.Server;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
+// This method contains an undocumented sub command #EasterEgg
public class Commandjump extends EssentialsCommand
{
public Commandjump()
@@ -19,6 +19,21 @@ public Commandjump()
@Override
public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception
{
+ if (args.length > 0 && args[0].contains("lock") && user.isAuthorized("essentials.jump.lock"))
+ {
+ if (user.isFlyClickJump())
+ {
+ user.setRightClickJump(false);
+ user.sendMessage("Flying wizard mode disabled");
+ }
+ else
+ {
+ user.setRightClickJump(true);
+ user.sendMessage("Enabling flying wizard mode");
+ }
+ return;
+ }
+
Location loc;
final Location cloc = user.getLocation();
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkick.java b/Essentials/src/com/earth2me/essentials/commands/Commandkick.java
index 3e2e08b508..18884964b2 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkick.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkick.java
@@ -3,6 +3,8 @@
import com.earth2me.essentials.Console;
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import com.earth2me.essentials.Util;
+import java.util.logging.Level;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -23,21 +25,35 @@ public void run(final Server server, final CommandSender sender, final String co
throw new NotEnoughArgumentsException();
}
- final User user = getPlayer(server, args, 0);
- if (sender instanceof Player && user.isAuthorized("essentials.kick.exempt"))
+ final User target = getPlayer(server, args, 0, true, false);
+ if (sender instanceof Player)
{
- throw new Exception(_("kickExempt"));
+ User user = ess.getUser(sender);
+ if (target.isHidden() && !user.isAuthorized("essentials.vanish.interact"))
+ {
+ throw new PlayerNotFoundException();
+ }
+
+ if (target.isAuthorized("essentials.kick.exempt"))
+ {
+ throw new Exception(_("kickExempt"));
+ }
}
- final String kickReason = args.length > 1 ? getFinalArg(args, 1) : _("kickDefault");
- user.kickPlayer(kickReason);
+
+ String kickReason = args.length > 1 ? getFinalArg(args, 1) : _("kickDefault");
+ kickReason = Util.replaceFormat(kickReason.replace("\\n", "\n").replace("|", "\n"));
+
+ target.kickPlayer(kickReason);
final String senderName = sender instanceof Player ? ((Player)sender).getDisplayName() : Console.NAME;
+ server.getLogger().log(Level.INFO, _("playerKicked", senderName, target.getName(), kickReason));
+
for (Player onlinePlayer : server.getOnlinePlayers())
{
User player = ess.getUser(onlinePlayer);
if (player.isAuthorized("essentials.kick.notify"))
{
- onlinePlayer.sendMessage(_("playerKicked", senderName, user.getName(), kickReason));
+ onlinePlayer.sendMessage(_("playerKicked", senderName, target.getName(), kickReason));
}
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkickall.java b/Essentials/src/com/earth2me/essentials/commands/Commandkickall.java
index 4722b7d68e..6944823f31 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkickall.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkickall.java
@@ -1,6 +1,7 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.Util;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -16,6 +17,9 @@ public Commandkickall()
@Override
public void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
+ String kickReason = args.length > 0 ? getFinalArg(args, 0) : _("kickDefault");
+ kickReason = Util.replaceFormat(kickReason.replace("\\n", "\n").replace("|", "\n"));
+
for (Player onlinePlayer : server.getOnlinePlayers())
{
if (sender instanceof Player && onlinePlayer.getName().equalsIgnoreCase(((Player)sender).getName()))
@@ -24,7 +28,7 @@ public void run(final Server server, final CommandSender sender, final String co
}
else
{
- onlinePlayer.kickPlayer(args.length > 0 ? getFinalArg(args, 0) : _("kickDefault"));
+ onlinePlayer.kickPlayer(kickReason);
}
}
sender.sendMessage(_("kickedAll"));
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkill.java b/Essentials/src/com/earth2me/essentials/commands/Commandkill.java
index 77994f156f..88086900aa 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkill.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkill.java
@@ -1,6 +1,7 @@
package com.earth2me.essentials.commands;
import static com.earth2me.essentials.I18n._;
+import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -22,16 +23,32 @@ public void run(final Server server, final CommandSender sender, final String co
throw new NotEnoughArgumentsException();
}
- for (Player matchPlayer : server.matchPlayer(args[0]))
+ //TODO: TL this
+ if (args[0].trim().length() < 2)
{
+ throw new NotEnoughArgumentsException("You need to specify a player to kill.");
+ }
+
+ final List matchedPlayers = server.matchPlayer(args[0]);
+ for (Player matchPlayer : matchedPlayers)
+ {
+ if (ess.getUser(matchPlayer).isAuthorized("essentials.kill.exempt") && !ess.getUser(sender).isAuthorized("essentials.kill.force"))
+ {
+ throw new Exception(_("killExempt", matchPlayer.getDisplayName()));
+ }
final EntityDamageEvent ede = new EntityDamageEvent(matchPlayer, sender instanceof Player && ((Player)sender).getName().equals(matchPlayer.getName()) ? EntityDamageEvent.DamageCause.SUICIDE : EntityDamageEvent.DamageCause.CUSTOM, Short.MAX_VALUE);
server.getPluginManager().callEvent(ede);
- if (ede.isCancelled() && !sender.hasPermission("essentials.kill.force"))
+ if (ede.isCancelled() && sender instanceof Player && !ess.getUser(sender).isAuthorized("essentials.kill.force"))
{
continue;
+ }
+ matchPlayer.damage(Short.MAX_VALUE);
+
+ if (matchPlayer.getHealth() > 0)
+ {
+ matchPlayer.setHealth(0);
}
- matchPlayer.damage(Short.MAX_VALUE);
sender.sendMessage(_("kill", matchPlayer.getDisplayName()));
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkillall.java b/Essentials/src/com/earth2me/essentials/commands/Commandkillall.java
index d918eeffb9..854ed252cd 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkillall.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkillall.java
@@ -1,28 +1,16 @@
package com.earth2me.essentials.commands;
-import com.earth2me.essentials.Mob;
import static com.earth2me.essentials.I18n._;
-import java.util.Collections;
+import com.earth2me.essentials.Mob;
+import java.util.ArrayList;
import java.util.Locale;
import org.bukkit.Chunk;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Animals;
-import org.bukkit.entity.ComplexLivingEntity;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Flying;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Monster;
-import org.bukkit.entity.NPC;
-import org.bukkit.entity.Ocelot;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Slime;
-import org.bukkit.entity.Snowman;
-import org.bukkit.entity.WaterMob;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.*;
import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.inventory.ItemStack;
public class Commandkillall extends EssentialsCommand
@@ -65,6 +53,10 @@ else if (args.length > 1)
throw new Exception(_("numberRequired"), e);
}
}
+ if (args.length > 2)
+ {
+ world = ess.getWorld(args[2]);
+ }
}
else
{
@@ -122,7 +114,7 @@ else if (args.length == 1)
continue;
}
}
- if(entity instanceof Ocelot)
+ if (entity instanceof Ocelot)
{
if (((Ocelot)entity).isTamed())
{
@@ -133,7 +125,7 @@ else if (args.length == 1)
{
if (entity instanceof Animals || entity instanceof NPC || entity instanceof Snowman || entity instanceof WaterMob)
{
- EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, Collections.EMPTY_LIST);
+ EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, new ArrayList(0));
ess.getServer().getPluginManager().callEvent(event);
entity.remove();
numKills++;
@@ -143,7 +135,7 @@ else if (monster)
{
if (entity instanceof Monster || entity instanceof ComplexLivingEntity || entity instanceof Flying || entity instanceof Slime)
{
- EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, Collections.EMPTY_LIST);
+ EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, new ArrayList(0));
ess.getServer().getPluginManager().callEvent(event);
entity.remove();
numKills++;
@@ -151,14 +143,14 @@ else if (monster)
}
else if (all)
{
- EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, Collections.EMPTY_LIST);
+ EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, new ArrayList(0));
ess.getServer().getPluginManager().callEvent(event);
entity.remove();
numKills++;
}
else if (entityClass != null && entityClass.isAssignableFrom(entity.getClass()))
{
- EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, Collections.EMPTY_LIST);
+ EntityDeathEvent event = new EntityDeathEvent((LivingEntity)entity, new ArrayList(0));
ess.getServer().getPluginManager().callEvent(event);
entity.remove();
numKills++;
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkit.java b/Essentials/src/com/earth2me/essentials/commands/Commandkit.java
index baa8ba0147..1c9bec8d39 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkit.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkit.java
@@ -1,8 +1,13 @@
package com.earth2me.essentials.commands;
-import com.earth2me.essentials.*;
import static com.earth2me.essentials.I18n._;
-import java.util.*;
+import com.earth2me.essentials.Kit;
+import com.earth2me.essentials.Trade;
+import com.earth2me.essentials.User;
+import com.earth2me.essentials.Util;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
@@ -25,13 +30,13 @@ public void run(final Server server, final User user, final String commandLabel,
}
else if (args.length > 1 && user.isAuthorized("essentials.kit.others"))
{
- final User userTo = getPlayer(server, args, 1, true);
- final String kitName = Util.sanitizeString(args[0].toLowerCase(Locale.ENGLISH));
+ final User userTo = getPlayer(server, user, args, 1);
+ final String kitName = Util.sanitizeString(args[0].toLowerCase(Locale.ENGLISH)).trim();
giveKit(userTo, user, kitName);
}
else
{
- final String kitName = Util.sanitizeString(args[0].toLowerCase(Locale.ENGLISH));
+ final String kitName = Util.sanitizeString(args[0].toLowerCase(Locale.ENGLISH)).trim();
giveKit(user, user, kitName);
}
}
@@ -47,24 +52,30 @@ public void run(final Server server, final CommandSender sender, final String co
}
else
{
- final User userTo = getPlayer(server, args, 1, true);
+ final User userTo = getPlayer(server, args, 1, true, false);
final String kitName = args[0].toLowerCase(Locale.ENGLISH);
final Map kit = ess.getSettings().getKit(kitName);
final List items = Kit.getItems(userTo, kit);
Kit.expandItems(ess, userTo, items);
- sender.sendMessage(_("kitGive", kitName));
+ sender.sendMessage(_("kitGiveTo", kitName, userTo.getDisplayName()));
+ userTo.sendMessage(_("kitReceive", kitName));
}
}
private void giveKit(User userTo, User userFrom, String kitName) throws Exception
- {
+ {
+ if (kitName.isEmpty())
+ {
+ throw new Exception(_("kitError2"));
+ }
+
final Map kit = ess.getSettings().getKit(kitName);
- if (!userFrom.isAuthorized("essentials.kit." + kitName))
+ if (!userFrom.isAuthorized("essentials.kits." + kitName))
{
- throw new Exception(_("noKitPermission", "essentials.kit." + kitName));
+ throw new Exception(_("noKitPermission", "essentials.kits." + kitName));
}
final List items = Kit.getItems(userTo, kit);
@@ -77,6 +88,7 @@ private void giveKit(User userTo, User userFrom, String kitName) throws Exceptio
Kit.expandItems(ess, userTo, items);
charge.charge(userFrom);
- userTo.sendMessage(_("kitGive", kitName));
+ userFrom.sendMessage(_("kitGiveTo", kitName, userTo.getDisplayName()));
+ userTo.sendMessage(_("kitReceive", kitName));
}
}
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandkittycannon.java b/Essentials/src/com/earth2me/essentials/commands/Commandkittycannon.java
index 9db608235e..da22235701 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandkittycannon.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandkittycannon.java
@@ -7,7 +7,7 @@
import org.bukkit.Server;
import org.bukkit.entity.Ocelot;
-
+// This command is not documented on the wiki #EasterEgg
public class Commandkittycannon extends EssentialsCommand
{
private static Random random = new Random();
@@ -29,6 +29,7 @@ protected void run(final Server server, final User user, final String commandLab
final int i = random.nextInt(Ocelot.Type.values().length);
ocelot.setCatType(Ocelot.Type.values()[i]);
ocelot.setTamed(true);
+ ocelot.setBaby();
ocelot.setVelocity(user.getEyeLocation().getDirection().multiply(2));
ess.scheduleSyncDelayedTask(new Runnable()
{
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandlightning.java b/Essentials/src/com/earth2me/essentials/commands/Commandlightning.java
index 5d72d0b55c..449c949304 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandlightning.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandlightning.java
@@ -2,6 +2,7 @@
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.User;
+import java.util.List;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.LightningStrike;
@@ -30,11 +31,6 @@ public void run(final Server server, final CommandSender sender, final String co
}
}
- if (server.matchPlayer(args[0]).isEmpty())
- {
- throw new Exception(_("playerNotFound"));
- }
-
int power = 5;
if (args.length > 1)
{
@@ -47,12 +43,13 @@ public void run(final Server server, final CommandSender sender, final String co
}
}
- for (Player matchPlayer : server.matchPlayer(args[0]))
+ final List matchedPlayers = server.matchPlayer(args[0]);
+ for (Player matchPlayer : matchedPlayers)
{
sender.sendMessage(_("lightningUse", matchPlayer.getDisplayName()));
final LightningStrike strike = matchPlayer.getWorld().strikeLightningEffect(matchPlayer.getLocation());
-
+
if (!ess.getUser(matchPlayer).isGodModeEnabled())
{
matchPlayer.damage(power, strike);
diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandlist.java b/Essentials/src/com/earth2me/essentials/commands/Commandlist.java
index c981f45c19..d4f75df14e 100644
--- a/Essentials/src/com/earth2me/essentials/commands/Commandlist.java
+++ b/Essentials/src/com/earth2me/essentials/commands/Commandlist.java
@@ -19,18 +19,28 @@ public Commandlist()
@Override
public void run(final Server server, final CommandSender sender, final String commandLabel, final String[] args) throws Exception
{
- boolean showhidden = false;
+ boolean showHidden = true;
if (sender instanceof Player)
{
- if (ess.getUser(sender).isAuthorized("essentials.list.hidden"))
- {
- showhidden = true;
- }
+ showHidden = ess.getUser(sender).isAuthorized("essentials.list.hidden");
+ }
+
+ sender.sendMessage(listSummary(server, showHidden));
+ Map> playerList = getPlayerLists(server, showHidden);
+
+ if (args.length > 0)
+ {
+ sender.sendMessage(listGroupUsers(playerList, args[0].toLowerCase()));
}
else
{
- showhidden = true;
+ sendGroupedList(sender, commandLabel, playerList);
}
+ }
+
+ // Produce a user summary: There are 5 out of maximum 10 players online.
+ private String listSummary(final Server server, final boolean showHidden)
+ {
int playerHidden = 0;
for (Player onlinePlayer : server.getOnlinePlayers())
{
@@ -41,7 +51,7 @@ public void run(final Server server, final CommandSender sender, final String co
}
String online;
- if (showhidden && playerHidden > 0)
+ if (showHidden && playerHidden > 0)
{
online = _("listAmountHidden", server.getOnlinePlayers().length - playerHidden, playerHidden, server.getMaxPlayers());
}
@@ -49,101 +59,212 @@ public void run(final Server server, final CommandSender sender, final String co
{
online = _("listAmount", server.getOnlinePlayers().length - playerHidden, server.getMaxPlayers());
}
- sender.sendMessage(online);
+ return online;
+ }
- if (ess.getSettings().getSortListByGroups())
+ // Build the basic player list, divided by groups.
+ private Map> getPlayerLists(final Server server, final boolean showHidden)
+ {
+ Map> playerList = new HashMap>();
+ for (Player onlinePlayer : server.getOnlinePlayers())
{
- Map> sort = new HashMap>();
- for (Player OnlinePlayer : server.getOnlinePlayers())
+ final User onlineUser = ess.getUser(onlinePlayer);
+ if (onlineUser.isHidden() && !showHidden)
{
- final User player = ess.getUser(OnlinePlayer);
- if (player.isHidden() && !showhidden)
- {
- continue;
- }
- final String group = player.getGroup();
- List list = sort.get(group);
- if (list == null)
- {
- list = new ArrayList();
- sort.put(group, list);
- }
- list.add(player);
+ continue;
+ }
+ final String group = Util.stripFormat(onlineUser.getGroup().toLowerCase());
+ List list = playerList.get(group);
+ if (list == null)
+ {
+ list = new ArrayList();
+ playerList.put(group, list);
}
- final String[] groups = sort.keySet().toArray(new String[0]);
- Arrays.sort(groups, String.CASE_INSENSITIVE_ORDER);
- for (String group : groups)
+ list.add(onlineUser);
+ }
+ return playerList;
+ }
+
+ // Output a playerlist of just a single group, /list
+ private String listGroupUsers(final Map> playerList, final String groupName) throws Exception
+ {
+ final List users = getMergedList(playerList, groupName);
+
+ List groupUsers = playerList.get(groupName);
+ if (groupUsers != null && !groupUsers.isEmpty())
+ {
+ users.addAll(groupUsers);
+ }
+ if (users == null || users.isEmpty())
+ {
+ throw new Exception(_("groupDoesNotExist"));
+ }
+
+ return outputFormat(groupName, listUsers(users));
+ }
+
+ // Handle the merging of groups
+ private List getMergedList(final Map> playerList, final String groupName)
+ {
+ Set configGroups = ess.getSettings().getListGroupConfig().keySet();
+ final List