3.7 add prestige-based requirements

This commit is contained in:
okx-code
2020-04-13 14:24:31 +01:00
parent fe01ce1c4f
commit b7dfd5d9e3
92 changed files with 5908 additions and 5906 deletions
+13 -13
View File
@@ -1,14 +1,14 @@
.gradle .gradle
build/ build/
.idea/ .idea/
*.iml *.iml
# Ignore Gradle GUI config # Ignore Gradle GUI config
gradle-app.setting gradle-app.setting
# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
!gradle-wrapper.jar !gradle-wrapper.jar
out/ out/
spigot/ spigot/
+5 -5
View File
@@ -1,5 +1,5 @@
## Style Guide ## Style Guide
Rankup using the Google Java Style guide apart from the following exceptions: Rankup using the Google Java Style guide apart from the following exceptions:
- The column limit of 100 is more flexible - The column limit of 100 is more flexible
+21 -21
View File
@@ -1,21 +1,21 @@
The MIT License (MIT) The MIT License (MIT)
Copyright (c) 2018-2020 Okx Copyright (c) 2018-2020 Okx
Permission is hereby granted, free of charge, to any person obtaining a copy Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software. copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. SOFTWARE.
+61 -61
View File
@@ -1,61 +1,61 @@
# Rankup3 # Rankup3
## Installation ## Installation
Rankup can be compiled with the `gradle build` command. The compiled plugin jar will be in the `/build/libs` directory. Rankup can be compiled with the `gradle build` command. The compiled plugin jar will be in the `/build/libs` directory.
## Translation ## Translation
If you would like to contribute to translating the plugin, you can fork it. If you would like to contribute to translating the plugin, you can fork it.
Locale names are in ISO-639-1 and are in the folder [`src/main/resources/locale`](https://github.com/okx-code/Rankup3/tree/master/src/main/resources/locale) Locale names are in ISO-639-1 and are in the folder [`src/main/resources/locale`](https://github.com/okx-code/Rankup3/tree/master/src/main/resources/locale)
When a locale is added, it should be saved [here](https://github.com/okx-code/Rankup3/blob/master/src/main/java/sh/okx/rankup/Rankup.java#L242), ie through adding a line such as `saveLocale("es");`. However, I can do it if you forget. When a locale is added, it should be saved [here](https://github.com/okx-code/Rankup3/blob/master/src/main/java/sh/okx/rankup/Rankup.java#L242), ie through adding a line such as `saveLocale("es");`. However, I can do it if you forget.
You can use the [English](https://github.com/okx-code/Rankup3/blob/locale/src/main/resources/locale/en.yml) locale to help translate. You can use the [English](https://github.com/okx-code/Rankup3/blob/locale/src/main/resources/locale/en.yml) locale to help translate.
Locales should be added or modified with a pull request, but if you wish to contribute often I can give you push access to this branch. Locales should be added or modified with a pull request, but if you wish to contribute often I can give you push access to this branch.
Here is a blank template for new locales: Here is a blank template for new locales:
```yaml ```yaml
rankup: rankup:
requirements-not-met: requirements-not-met:
no-rankup: no-rankup:
success-public: success-public:
success-private: success-private:
confirmation: confirmation:
title: title:
must-prestige: must-prestige:
list: list:
complete: complete:
current: current:
incomplete: incomplete:
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: singular:
plural: plural:
prestige: prestige:
requirements-not-met: requirements-not-met:
no-prestige: no-prestige:
success-public: success-public:
success-private: success-private:
confirmation: confirmation:
title: title:
list: list:
complete: complete:
current: current:
incomplete: incomplete:
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: singular:
plural: plural:
not-high-enough: not-high-enough:
not-in-ladder: not-in-ladder:
invalid-rankup: invalid-rankup:
``` ```
+70 -70
View File
@@ -1,71 +1,71 @@
plugins { plugins {
id 'java' id 'java'
id "io.freefair.lombok" version "4.1.6" id "io.freefair.lombok" version "4.1.6"
} }
group 'sh.okx' group 'sh.okx'
version '3.7-beta' version '3.7-beta'
repositories { repositories {
mavenCentral() mavenCentral()
mavenLocal() mavenLocal()
maven { maven {
url 'http://nexus.hc.to/content/repositories/pub_releases' url 'http://nexus.hc.to/content/repositories/pub_releases'
} }
maven { maven {
url 'https://hub.spigotmc.org/nexus/content/groups/public/' url 'https://hub.spigotmc.org/nexus/content/groups/public/'
} }
maven { maven {
url 'http://repo.extendedclip.com/content/repositories/placeholderapi/' url 'http://repo.extendedclip.com/content/repositories/placeholderapi/'
} }
maven { maven {
url 'https://raw.github.com/PyvesB/AdvancedAchievements/mvn-repo/' url 'https://raw.github.com/PyvesB/AdvancedAchievements/mvn-repo/'
} }
// for plugins without repos, namely mcmmo, votingplugin, and towny // for plugins without repos, namely mcmmo, votingplugin, and towny
maven { maven {
url 'https://jitpack.io' url 'https://jitpack.io'
} }
} }
dependencies { dependencies {
testImplementation group: 'junit', name: 'junit', version: '4.12' testImplementation group: 'junit', name: 'junit', version: '4.12'
compileOnly 'org.jetbrains:annotations:16.0.2' compileOnly 'org.jetbrains:annotations:16.0.2'
implementation 'org.spigotmc:spigot:1.15.2-R0.1-SNAPSHOT' implementation 'org.spigotmc:spigot:1.15.2-R0.1-SNAPSHOT'
implementation('com.github.Realizedd:TokenManager:3.2.4') { implementation('com.github.Realizedd:TokenManager:3.2.4') {
transitive = false transitive = false
} }
implementation('net.milkbowl.vault:VaultAPI:1.7') { implementation('net.milkbowl.vault:VaultAPI:1.7') {
exclude group: 'org.bukkit' exclude group: 'org.bukkit'
} }
implementation 'me.clip:placeholderapi:2.9.2' implementation 'me.clip:placeholderapi:2.9.2'
implementation 'com.hm.achievement:advanced-achievements-api:1.1.0' implementation 'com.hm.achievement:advanced-achievements-api:1.1.0'
implementation('com.github.mcMMO-Dev:mcMMO:601297') { implementation('com.github.mcMMO-Dev:mcMMO:601297') {
exclude group: 'com.sk89q.worldguard' exclude group: 'com.sk89q.worldguard'
} }
implementation 'com.github.Ben12345rocks:VotingPlugin:5.18.2' implementation 'com.github.Ben12345rocks:VotingPlugin:5.18.2'
implementation 'com.github.LlmDl:Towny:25fc18a' implementation 'com.github.LlmDl:Towny:25fc18a'
} }
// automatically copy the version to plugin.yml // automatically copy the version to plugin.yml
processResources { processResources {
// do this again whenever version changes // do this again whenever version changes
inputs.property 'version', project.version inputs.property 'version', project.version
// copy plugin.yml and replace version // copy plugin.yml and replace version
from(sourceSets.main.resources.srcDirs) { from(sourceSets.main.resources.srcDirs) {
include 'plugin.yml' include 'plugin.yml'
expand 'version': project.version expand 'version': project.version
} }
// copy everything else // copy everything else
from(sourceSets.main.resources.srcDirs) { from(sourceSets.main.resources.srcDirs) {
exclude 'plugin.yml' exclude 'plugin.yml'
} }
} }
task spigot(type: Jar) { task spigot(type: Jar) {
from sourceSets.main.runtimeClasspath from sourceSets.main.runtimeClasspath
destinationDirectory = file("./spigot/plugins/") destinationDirectory = file("./spigot/plugins/")
archiveFileName = "Rankup.jar" archiveFileName = "Rankup.jar"
} }
+6 -6
View File
@@ -1,6 +1,6 @@
#Sun Apr 05 14:05:23 BST 2020 #Sun Apr 05 14:05:23 BST 2020
distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-all.zip distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-all.zip
distributionBase=GRADLE_USER_HOME distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists distributionPath=wrapper/dists
zipStorePath=wrapper/dists zipStorePath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME zipStoreBase=GRADLE_USER_HOME
Vendored
+188 -188
View File
@@ -1,188 +1,188 @@
#!/usr/bin/env sh #!/usr/bin/env sh
# #
# Copyright 2015 the original author or authors. # Copyright 2015 the original author or authors.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
# #
############################################################################## ##############################################################################
## ##
## Gradle start up script for UN*X ## Gradle start up script for UN*X
## ##
############################################################################## ##############################################################################
# Attempt to set APP_HOME # Attempt to set APP_HOME
# Resolve links: $0 may be a link # Resolve links: $0 may be a link
PRG="$0" PRG="$0"
# Need this for relative symlinks. # Need this for relative symlinks.
while [ -h "$PRG" ] ; do while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"` ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'` link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then if expr "$link" : '/.*' > /dev/null; then
PRG="$link" PRG="$link"
else else
PRG=`dirname "$PRG"`"/$link" PRG=`dirname "$PRG"`"/$link"
fi fi
done done
SAVED="`pwd`" SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`" APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null cd "$SAVED" >/dev/null
APP_NAME="Gradle" APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"` APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value. # Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum" MAX_FD="maximum"
warn () { warn () {
echo "$*" echo "$*"
} }
die () { die () {
echo echo
echo "$*" echo "$*"
echo echo
exit 1 exit 1
} }
# OS specific support (must be 'true' or 'false'). # OS specific support (must be 'true' or 'false').
cygwin=false cygwin=false
msys=false msys=false
darwin=false darwin=false
nonstop=false nonstop=false
case "`uname`" in case "`uname`" in
CYGWIN* ) CYGWIN* )
cygwin=true cygwin=true
;; ;;
Darwin* ) Darwin* )
darwin=true darwin=true
;; ;;
MINGW* ) MINGW* )
msys=true msys=true
;; ;;
NONSTOP* ) NONSTOP* )
nonstop=true nonstop=true
;; ;;
esac esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM. # Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables # IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java" JAVACMD="$JAVA_HOME/jre/sh/java"
else else
JAVACMD="$JAVA_HOME/bin/java" JAVACMD="$JAVA_HOME/bin/java"
fi fi
if [ ! -x "$JAVACMD" ] ; then if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the Please set the JAVA_HOME variable in your environment to match the
location of your Java installation." location of your Java installation."
fi fi
else else
JAVACMD="java" JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the Please set the JAVA_HOME variable in your environment to match the
location of your Java installation." location of your Java installation."
fi fi
# Increase the maximum file descriptors if we can. # Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n` MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT" MAX_FD="$MAX_FD_LIMIT"
fi fi
ulimit -n $MAX_FD ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD" warn "Could not set maximum file descriptor limit: $MAX_FD"
fi fi
else else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi fi
fi fi
# For Darwin, add options to specify how the application appears in the dock # For Darwin, add options to specify how the application appears in the dock
if $darwin; then if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi fi
# For Cygwin, switch paths to Windows format before running java # For Cygwin, switch paths to Windows format before running java
if $cygwin ; then if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"` APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"` JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath # We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP="" SEP=""
for dir in $ROOTDIRSRAW ; do for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir" ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|" SEP="|"
done done
OURCYGPATTERN="(^($ROOTDIRS))" OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments # Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh # Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0 i=0
for arg in "$@" ; do for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else else
eval `echo args$i`="\"$arg\"" eval `echo args$i`="\"$arg\""
fi fi
i=$((i+1)) i=$((i+1))
done done
case $i in case $i in
(0) set -- ;; (0) set -- ;;
(1) set -- "$args0" ;; (1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;; (2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;; (3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac esac
fi fi
# Escape application args # Escape application args
save () { save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " " echo " "
} }
APP_ARGS=$(save "$@") APP_ARGS=$(save "$@")
# Collect all arguments for the java command, following the shell quoting and substitution rules # Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")" cd "$(dirname "$0")"
fi fi
exec "$JAVACMD" "$@" exec "$JAVACMD" "$@"
Vendored
+100 -100
View File
@@ -1,100 +1,100 @@
@rem @rem
@rem Copyright 2015 the original author or authors. @rem Copyright 2015 the original author or authors.
@rem @rem
@rem Licensed under the Apache License, Version 2.0 (the "License"); @rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License. @rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at @rem You may obtain a copy of the License at
@rem @rem
@rem http://www.apache.org/licenses/LICENSE-2.0 @rem http://www.apache.org/licenses/LICENSE-2.0
@rem @rem
@rem Unless required by applicable law or agreed to in writing, software @rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS, @rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and @rem See the License for the specific language governing permissions and
@rem limitations under the License. @rem limitations under the License.
@rem @rem
@if "%DEBUG%" == "" @echo off @if "%DEBUG%" == "" @echo off
@rem ########################################################################## @rem ##########################################################################
@rem @rem
@rem Gradle startup script for Windows @rem Gradle startup script for Windows
@rem @rem
@rem ########################################################################## @rem ##########################################################################
@rem Set local scope for the variables with windows NT shell @rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0 set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=. if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0 set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME% set APP_HOME=%DIRNAME%
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe @rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1 %JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init if "%ERRORLEVEL%" == "0" goto init
echo. echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo. echo.
echo Please set the JAVA_HOME variable in your environment to match the echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation. echo location of your Java installation.
goto fail goto fail
:findJavaFromJavaHome :findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=% set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init if exist "%JAVA_EXE%" goto init
echo. echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo. echo.
echo Please set the JAVA_HOME variable in your environment to match the echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation. echo location of your Java installation.
goto fail goto fail
:init :init
@rem Get command-line arguments, handling Windows variants @rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args :win9xME_args
@rem Slurp the command line arguments. @rem Slurp the command line arguments.
set CMD_LINE_ARGS= set CMD_LINE_ARGS=
set _SKIP=2 set _SKIP=2
:win9xME_args_slurp :win9xME_args_slurp
if "x%~1" == "x" goto execute if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%* set CMD_LINE_ARGS=%*
:execute :execute
@rem Setup the command line @rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle @rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end :end
@rem End local scope for the variables with windows NT shell @rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd if "%ERRORLEVEL%"=="0" goto mainEnd
:fail :fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code! rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1 exit /b 1
:mainEnd :mainEnd
if "%OS%"=="Windows_NT" endlocal if "%OS%"=="Windows_NT" endlocal
:omega :omega
+2 -2
View File
@@ -1,2 +1,2 @@
# This file is generated by the 'io.freefair.lombok' Gradle plugin # This file is generated by the 'io.freefair.lombok' Gradle plugin
config.stopBubbling = true config.stopBubbling = true
+2 -2
View File
@@ -1,2 +1,2 @@
rootProject.name = 'Rankup' rootProject.name = 'Rankup'
+29 -29
View File
@@ -1,29 +1,29 @@
package sh.okx.rankup; package sh.okx.rankup;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.scheduler.BukkitRunnable;
@RequiredArgsConstructor @RequiredArgsConstructor
public class AutoRankup extends BukkitRunnable { public class AutoRankup extends BukkitRunnable {
private final RankupPlugin rankup; private final RankupPlugin rankup;
@Override @Override
public void run() { public void run() {
if (rankup.error()) { if (rankup.error()) {
return; return;
} }
RankupHelper helper = rankup.getHelper(); RankupHelper helper = rankup.getHelper();
for (Player player : Bukkit.getOnlinePlayers()) { for (Player player : Bukkit.getOnlinePlayers()) {
if (player.hasPermission("rankup.auto")) { if (player.hasPermission("rankup.auto")) {
if (helper.checkRankup(player, false)) { if (helper.checkRankup(player, false)) {
helper.rankup(player); helper.rankup(player);
} else if (rankup.getPrestiges() != null && helper.checkPrestige(player, false)) { } else if (rankup.getPrestiges() != null && helper.checkPrestige(player, false)) {
helper.prestige(player); helper.prestige(player);
} }
} }
} }
} }
} }
@@ -1,31 +1,31 @@
package sh.okx.rankup; package sh.okx.rankup;
import java.util.function.Supplier; import java.util.function.Supplier;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerJoinEvent;
import sh.okx.rankup.util.UpdateNotifier; import sh.okx.rankup.util.UpdateNotifier;
public class JoinUpdateNotifier implements Listener { public class JoinUpdateNotifier implements Listener {
private final UpdateNotifier notifier; private final UpdateNotifier notifier;
private final Supplier<Boolean> enabledSupplier; private final Supplier<Boolean> enabledSupplier;
private final String permission; private final String permission;
public JoinUpdateNotifier(UpdateNotifier notifier, public JoinUpdateNotifier(UpdateNotifier notifier,
Supplier<Boolean> enabledSupplier, String permission) { Supplier<Boolean> enabledSupplier, String permission) {
this.notifier = notifier; this.notifier = notifier;
this.enabledSupplier = enabledSupplier; this.enabledSupplier = enabledSupplier;
this.permission = permission; this.permission = permission;
} }
@EventHandler @EventHandler
public void on(PlayerJoinEvent e) { public void on(PlayerJoinEvent e) {
if (enabledSupplier.get()) { if (enabledSupplier.get()) {
Player player = e.getPlayer(); Player player = e.getPlayer();
if (player.hasPermission(permission)) { if (player.hasPermission(permission)) {
notifier.notify(player, true); notifier.notify(player, true);
} }
} }
} }
} }
File diff suppressed because it is too large Load Diff
+128 -128
View File
@@ -1,128 +1,128 @@
package sh.okx.rankup; package sh.okx.rankup;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.function.Function; import java.util.function.Function;
import lombok.Getter; import lombok.Getter;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.hook.PermissionProvider; import sh.okx.rankup.hook.PermissionProvider;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
public class RankList<T extends Rank> { public class RankList<T extends Rank> {
@Getter @Getter
protected final FileConfiguration config; protected final FileConfiguration config;
protected final Set<T> ranks = new HashSet<>(); protected final Set<T> ranks = new HashSet<>();
public RankList(FileConfiguration config, Function<ConfigurationSection, T> deserializer) { public RankList(FileConfiguration config, Function<ConfigurationSection, T> deserializer) {
this.config = config; this.config = config;
for (Map.Entry<String, Object> entry : config.getValues(false).entrySet()) { for (Map.Entry<String, Object> entry : config.getValues(false).entrySet()) {
ConfigurationSection rankSection = (ConfigurationSection) entry.getValue(); ConfigurationSection rankSection = (ConfigurationSection) entry.getValue();
validateSection(rankSection); validateSection(rankSection);
T apply = deserializer.apply(rankSection); T apply = deserializer.apply(rankSection);
if (apply != null) { if (apply != null) {
ranks.add(apply); ranks.add(apply);
} }
} }
List<T> ordered = getOrderedList(); List<T> ordered = getOrderedList();
Set<T> provisionalRanks = new HashSet<>(ordered); Set<T> provisionalRanks = new HashSet<>(ordered);
this.ranks.clear(); this.ranks.clear();
this.ranks.addAll(provisionalRanks); this.ranks.addAll(provisionalRanks);
} }
protected void validateSection(ConfigurationSection section) { protected void validateSection(ConfigurationSection section) {
String name = "'" + section.getName() + "'"; String name = "'" + section.getName() + "'";
/*if (section.getConfigurationSection("requirements") != null) { /*if (section.getConfigurationSection("requirements") != null) {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"Rankup/prestige section " + name + " is using the old requirements system.\n" + "Rankup/prestige section " + name + " is using the old requirements system.\n" +
"Instead of a configuration section, it is now a list of strings.\n" + "Instead of a configuration section, it is now a list of strings.\n" +
"For example, instead of \"requirements: money: 1000\" you should use \"requirements: - 'money 1000'\"."); "For example, instead of \"requirements: money: 1000\" you should use \"requirements: - 'money 1000'\".");
}*/ }*/
Set<String> keys = section.getKeys(false); Set<String> keys = section.getKeys(false);
if (keys.size() == 1 && keys.iterator().next().equalsIgnoreCase("rank")) { if (keys.size() == 1 && keys.iterator().next().equalsIgnoreCase("rank")) {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"Having a final rank (for example: \"Z: rank: 'Z'\") from 3.4.2 or earlier should no longer be used.\n" + "Having a final rank (for example: \"Z: rank: 'Z'\") from 3.4.2 or earlier should no longer be used.\n" +
"It is safe to just delete the final rank " + name + ""); "It is safe to just delete the final rank " + name + "");
} else if (!section.contains("requirements")) { } else if (!section.contains("requirements")) {
throw new IllegalArgumentException("Rank " + name + " does not have any requirements."); throw new IllegalArgumentException("Rank " + name + " does not have any requirements.");
} }
} }
public T getFirst() { public T getFirst() {
OUTER: OUTER:
for (T rank : ranks) { for (T rank : ranks) {
// see if anything ranks up to this // see if anything ranks up to this
for (T rank0 : ranks) { for (T rank0 : ranks) {
if (rank0.getNext().equals(rank.getRank())) { if (rank0.getNext().equals(rank.getRank())) {
continue OUTER; continue OUTER;
} }
} }
// nothing ranks up to this // nothing ranks up to this
return rank; return rank;
} }
throw new IllegalArgumentException("Could not find a first rank. First ranks must not have anything that ranks up to them."); throw new IllegalArgumentException("Could not find a first rank. First ranks must not have anything that ranks up to them.");
} }
public List<T> getOrderedList() { public List<T> getOrderedList() {
List<T> list = new ArrayList<>(); List<T> list = new ArrayList<>();
T t = getFirst(); T t = getFirst();
while (t != null) { while (t != null) {
for (T existing : list) { for (T existing : list) {
if (existing.equals(t)) { if (existing.equals(t)) {
throw new IllegalArgumentException("Infinite rankup loop detected at rank " + t.getRank() + " to " + t.getNext() throw new IllegalArgumentException("Infinite rankup loop detected at rank " + t.getRank() + " to " + t.getNext()
+ "\nMake sure no there are no rankups to previous ranks or to the same rank"); + "\nMake sure no there are no rankups to previous ranks or to the same rank");
} }
} }
list.add(t); list.add(t);
t = next(t); t = next(t);
} }
return list; return list;
} }
public T getByName(String name) { public T getByName(String name) {
if (name == null) { if (name == null) {
return null; return null;
} }
for (T rank : ranks) { for (T rank : ranks) {
if (name.equalsIgnoreCase(rank.getRank())) { if (name.equalsIgnoreCase(rank.getRank())) {
return rank; return rank;
} }
} }
return null; return null;
} }
public T getByPlayer(Player player) { public T getByPlayer(Player player) {
List<T> list = getOrderedList(); List<T> list = getOrderedList();
Collections.reverse(list); Collections.reverse(list);
for (T t : list) { for (T t : list) {
if (t.isIn(player)) { if (t.isIn(player)) {
return t; return t;
} }
} }
return null; return null;
} }
public String getLast() { public String getLast() {
List<T> list = getOrderedList(); List<T> list = getOrderedList();
return list.get(list.size() - 1).getNext(); return list.get(list.size() - 1).getNext();
} }
public boolean isLast(PermissionProvider perms, Player player) { public boolean isLast(PermissionProvider perms, Player player) {
String last = getLast(); String last = getLast();
return perms.inGroup(player.getUniqueId(), last); return perms.inGroup(player.getUniqueId(), last);
} }
public T next(T rank) { public T next(T rank) {
for (T nextRank : ranks) { for (T nextRank : ranks) {
if (rank.getNext() != null && rank.getNext().equalsIgnoreCase(nextRank.getRank())) { if (rank.getNext() != null && rank.getNext().equalsIgnoreCase(nextRank.getRank())) {
return nextRank; return nextRank;
} }
} }
return null; return null;
} }
} }
+211 -211
View File
@@ -1,211 +1,211 @@
package sh.okx.rankup; package sh.okx.rankup;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.hook.PermissionProvider; import sh.okx.rankup.hook.PermissionProvider;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.messages.Variable; import sh.okx.rankup.messages.Variable;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.Rankups; import sh.okx.rankup.ranks.Rankups;
/** /**
* Actually performs the ranking up and prestiging for the plugin and also manages the cooldowns * Actually performs the ranking up and prestiging for the plugin and also manages the cooldowns
* between ranking up. * between ranking up.
*/ */
public class RankupHelper { public class RankupHelper {
private final RankupPlugin plugin; private final RankupPlugin plugin;
private final ConfigurationSection config; private final ConfigurationSection config;
private final PermissionProvider permissions; private final PermissionProvider permissions;
/** /**
* Players who cannot rankup/prestige for a certain amount of time. * Players who cannot rankup/prestige for a certain amount of time.
*/ */
private Map<Player, Long> cooldowns = new HashMap<>(); private Map<Player, Long> cooldowns = new HashMap<>();
public RankupHelper(RankupPlugin plugin) { public RankupHelper(RankupPlugin plugin) {
this.plugin = plugin; this.plugin = plugin;
this.config = plugin.getConfig(); this.config = plugin.getConfig();
this.permissions = plugin.getPermissions(); this.permissions = plugin.getPermissions();
} }
public void doRankup(Player player, Rank rank) { public void doRankup(Player player, Rank rank) {
rank.runCommands(player); rank.runCommands(player);
if (rank.getRank() != null) { if (rank.getRank() != null) {
permissions.removeGroup(player.getUniqueId(), rank.getRank()); permissions.removeGroup(player.getUniqueId(), rank.getRank());
} }
permissions.addGroup(player.getUniqueId(), rank.getNext()); permissions.addGroup(player.getUniqueId(), rank.getNext());
} }
public void sendRankupMessages(Player player, Rank rank) { public void sendRankupMessages(Player player, Rank rank) {
plugin.getMessage(rank, Message.SUCCESS_PUBLIC) plugin.getMessage(rank, Message.SUCCESS_PUBLIC)
.failIfEmpty() .failIfEmpty()
.replaceRanks(player, rank, rank.getNext()) .replaceRanks(player, rank, rank.getNext())
.broadcast(); .broadcast();
plugin.getMessage(rank, Message.SUCCESS_PRIVATE) plugin.getMessage(rank, Message.SUCCESS_PRIVATE)
.failIfEmpty() .failIfEmpty()
.replaceRanks(player, rank, rank.getNext()) .replaceRanks(player, rank, rank.getNext())
.send(player); .send(player);
} }
public void doPrestige(Player player, Prestige prestige) { public void doPrestige(Player player, Prestige prestige) {
prestige.runCommands(player); prestige.runCommands(player);
permissions.removeGroup(player.getUniqueId(), prestige.getFrom()); permissions.removeGroup(player.getUniqueId(), prestige.getFrom());
permissions.addGroup(player.getUniqueId(), prestige.getTo()); permissions.addGroup(player.getUniqueId(), prestige.getTo());
if (prestige.getRank() != null) { if (prestige.getRank() != null) {
permissions.removeGroup(player.getUniqueId(), prestige.getRank()); permissions.removeGroup(player.getUniqueId(), prestige.getRank());
} }
permissions.addGroup(player.getUniqueId(), prestige.getNext()); permissions.addGroup(player.getUniqueId(), prestige.getNext());
} }
public void sendPrestigeMessages(Player player, Prestige prestige) { public void sendPrestigeMessages(Player player, Prestige prestige) {
plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PUBLIC) plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PUBLIC)
.failIfEmpty() .failIfEmpty()
.replaceRanks(player, prestige, prestige.getNext()) .replaceRanks(player, prestige, prestige.getNext())
.replaceFromTo(prestige) .replaceFromTo(prestige)
.broadcast(); .broadcast();
plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PRIVATE) plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PRIVATE)
.failIfEmpty() .failIfEmpty()
.replaceRanks(player, prestige, prestige.getNext()) .replaceRanks(player, prestige, prestige.getNext())
.replaceFromTo(prestige) .replaceFromTo(prestige)
.send(player); .send(player);
} }
private boolean checkCooldown(Player player, Rank rank) { private boolean checkCooldown(Player player, Rank rank) {
if (cooldowns.containsKey(player)) { if (cooldowns.containsKey(player)) {
long time = System.currentTimeMillis() - cooldowns.get(player); long time = System.currentTimeMillis() - cooldowns.get(player);
// if time passed is less than the cooldown // if time passed is less than the cooldown
long cooldownSeconds = config.getInt("cooldown"); long cooldownSeconds = config.getInt("cooldown");
long timeLeft = (cooldownSeconds * 1000) - time; long timeLeft = (cooldownSeconds * 1000) - time;
if (timeLeft > 0) { if (timeLeft > 0) {
long secondsLeft = (long) Math.ceil(timeLeft / 1000f); long secondsLeft = (long) Math.ceil(timeLeft / 1000f);
plugin plugin
.getMessage(rank, secondsLeft > 1 ? Message.COOLDOWN_PLURAL : Message.COOLDOWN_SINGULAR) .getMessage(rank, secondsLeft > 1 ? Message.COOLDOWN_PLURAL : Message.COOLDOWN_SINGULAR)
.failIfEmpty() .failIfEmpty()
.replaceRanks(player, rank.getRank()) .replaceRanks(player, rank.getRank())
.replaceFromTo(rank) .replaceFromTo(rank)
.replace(Variable.SECONDS, cooldownSeconds) .replace(Variable.SECONDS, cooldownSeconds)
.replace(Variable.SECONDS_LEFT, secondsLeft) .replace(Variable.SECONDS_LEFT, secondsLeft)
.send(player); .send(player);
return true; return true;
} }
// cooldown has expired so remove it // cooldown has expired so remove it
cooldowns.remove(player); cooldowns.remove(player);
} }
return false; return false;
} }
private void applyCooldown(Player player) { private void applyCooldown(Player player) {
if (config.getInt("cooldown") > 0) { if (config.getInt("cooldown") > 0) {
cooldowns.put(player, System.currentTimeMillis()); cooldowns.put(player, System.currentTimeMillis());
} }
} }
public void rankup(Player player) { public void rankup(Player player) {
if (!checkRankup(player)) { if (!checkRankup(player)) {
return; return;
} }
Rank rank = plugin.getRankups().getByPlayer(player); Rank rank = plugin.getRankups().getByPlayer(player);
rank.applyRequirements(player); rank.applyRequirements(player);
applyCooldown(player); applyCooldown(player);
doRankup(player, rank); doRankup(player, rank);
sendRankupMessages(player, rank); sendRankupMessages(player, rank);
} }
public boolean checkRankup(Player player) { public boolean checkRankup(Player player) {
return checkRankup(player, true); return checkRankup(player, true);
} }
/** /**
* Checks if a player can rankup, and if they can't, sends the player a message and returns false * Checks if a player can rankup, and if they can't, sends the player a message and returns false
* *
* @param player the player to check if they can rankup * @param player the player to check if they can rankup
* @return true if the player can rankup, false otherwise * @return true if the player can rankup, false otherwise
*/ */
public boolean checkRankup(Player player, boolean message) { public boolean checkRankup(Player player, boolean message) {
Rankups rankups = plugin.getRankups(); Rankups rankups = plugin.getRankups();
Rank rank = rankups.getByPlayer(player); Rank rank = rankups.getByPlayer(player);
if (rankups.isLast(permissions, player)) { if (rankups.isLast(permissions, player)) {
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
plugin.getMessage(prestiges == null || prestiges.isLast(permissions, player) ? Message.NO_RANKUP : Message.MUST_PRESTIGE) plugin.getMessage(prestiges == null || prestiges.isLast(permissions, player) ? Message.NO_RANKUP : Message.MUST_PRESTIGE)
.failIf(!message) .failIf(!message)
.replaceRanks(player, rankups.getLast()) .replaceRanks(player, rankups.getLast())
.send(player); .send(player);
return false; return false;
} else if (rank == null) { // check if in ladder } else if (rank == null) { // check if in ladder
plugin.getMessage(Message.NOT_IN_LADDER) plugin.getMessage(Message.NOT_IN_LADDER)
.failIf(!message) .failIf(!message)
.replace(Variable.PLAYER, player.getName()) .replace(Variable.PLAYER, player.getName())
.send(player); .send(player);
return false; return false;
} else if (!rank.hasRequirements(player)) { // check if they can afford it } else if (!rank.hasRequirements(player)) { // check if they can afford it
if (message) { if (message) {
plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.REQUIREMENTS_NOT_MET) plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.REQUIREMENTS_NOT_MET)
.replaceRanks(player, rank, rank.getNext()), player, rank) .replaceRanks(player, rank, rank.getNext()), player, rank)
.send(player); .send(player);
} }
return false; return false;
} else if (message && checkCooldown(player, rank)) { } else if (message && checkCooldown(player, rank)) {
return false; return false;
} }
return true; return true;
} }
public void prestige(Player player) { public void prestige(Player player) {
if (!checkPrestige(player)) { if (!checkPrestige(player)) {
return; return;
} }
Prestige prestige = plugin.getPrestiges().getByPlayer(player); Prestige prestige = plugin.getPrestiges().getByPlayer(player);
prestige.applyRequirements(player); prestige.applyRequirements(player);
applyCooldown(player); applyCooldown(player);
doPrestige(player, prestige); doPrestige(player, prestige);
sendPrestigeMessages(player, prestige); sendPrestigeMessages(player, prestige);
} }
public boolean checkPrestige(Player player) { public boolean checkPrestige(Player player) {
return checkPrestige(player, true); return checkPrestige(player, true);
} }
public boolean checkPrestige(Player player, boolean message) { public boolean checkPrestige(Player player, boolean message) {
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
Prestige prestige = prestiges.getByPlayer(player); Prestige prestige = prestiges.getByPlayer(player);
if (prestige == null || !prestige.isEligable(player)) { // check if in ladder if (prestige == null || !prestige.isEligable(player)) { // check if in ladder
plugin.getMessage(Message.NOT_HIGH_ENOUGH) plugin.getMessage(Message.NOT_HIGH_ENOUGH)
.failIf(!message) .failIf(!message)
.replace(Variable.PLAYER, player.getName()) .replace(Variable.PLAYER, player.getName())
.send(player); .send(player);
return false; return false;
} else if (prestiges } else if (prestiges
.isLast(plugin.getPermissions(), player)) { // check if they are at the highest rank .isLast(plugin.getPermissions(), player)) { // check if they are at the highest rank
plugin.getMessage(prestige, Message.PRESTIGE_NO_PRESTIGE) plugin.getMessage(prestige, Message.PRESTIGE_NO_PRESTIGE)
.failIf(!message) .failIf(!message)
.replaceRanks(player, prestige.getRank()) .replaceRanks(player, prestige.getRank())
.replaceFromTo(prestige) .replaceFromTo(prestige)
.send(player); .send(player);
return false; return false;
} else if (!prestige.hasRequirements(player)) { // check if they can afford it } else if (!prestige.hasRequirements(player)) { // check if they can afford it
plugin.replaceMoneyRequirements( plugin.replaceMoneyRequirements(
plugin.getMessage(prestige, Message.PRESTIGE_REQUIREMENTS_NOT_MET) plugin.getMessage(prestige, Message.PRESTIGE_REQUIREMENTS_NOT_MET)
.failIf(!message) .failIf(!message)
.replaceRanks(player, prestige, prestiges.next(prestige).getRank()), player, prestige) .replaceRanks(player, prestige, prestiges.next(prestige).getRank()), player, prestige)
.replaceFromTo(prestige) .replaceFromTo(prestige)
.send(player); .send(player);
return false; return false;
} else if (checkCooldown(player, prestige)) { } else if (checkCooldown(player, prestige)) {
return false; return false;
} }
return true; return true;
} }
} }
File diff suppressed because it is too large Load Diff
@@ -1,38 +1,38 @@
package sh.okx.rankup; package sh.okx.rankup;
import lombok.Getter; import lombok.Getter;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.event.Event; import org.bukkit.event.Event;
import org.bukkit.event.HandlerList; import org.bukkit.event.HandlerList;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import sh.okx.rankup.requirements.RequirementRegistry; import sh.okx.rankup.requirements.RequirementRegistry;
/** /**
* Called immediately before rankups and prestiges are registered, * Called immediately before rankups and prestiges are registered,
* and immediately after the built-in requirements are registered. * and immediately after the built-in requirements are registered.
* This is used to register custom requirements. * This is used to register custom requirements.
* This is called when the plugin is enabled, and when it is reloaded from a command. * This is called when the plugin is enabled, and when it is reloaded from a command.
*/ */
@RequiredArgsConstructor @RequiredArgsConstructor
public class RankupRegisterEvent extends Event { public class RankupRegisterEvent extends Event {
private static final HandlerList handlers = new HandlerList(); private static final HandlerList handlers = new HandlerList();
@Getter @Getter
private final RankupPlugin plugin; private final RankupPlugin plugin;
public static HandlerList getHandlerList() { public static HandlerList getHandlerList() {
return handlers; return handlers;
} }
public RequirementRegistry getRequirementRegistry() { public RequirementRegistry getRequirementRegistry() {
return plugin.getRequirements(); return plugin.getRequirements();
} }
public void addRequirement(Requirement requirement) { public void addRequirement(Requirement requirement) {
plugin.getRequirements().addRequirement(requirement); plugin.getRequirements().addRequirement(requirement);
} }
@Override @Override
public HandlerList getHandlers() { public HandlerList getHandlers() {
return handlers; return handlers;
} }
} }
@@ -1,130 +1,130 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.plugin.PluginDescriptionFile; import org.bukkit.plugin.PluginDescriptionFile;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.Rankups; import sh.okx.rankup.ranks.Rankups;
import sh.okx.rankup.util.UpdateNotifier; import sh.okx.rankup.util.UpdateNotifier;
public class InfoCommand implements CommandExecutor { public class InfoCommand implements CommandExecutor {
private final RankupPlugin plugin; private final RankupPlugin plugin;
private final UpdateNotifier notifier; private final UpdateNotifier notifier;
public InfoCommand(RankupPlugin plugin, UpdateNotifier notifier) { public InfoCommand(RankupPlugin plugin, UpdateNotifier notifier) {
this.plugin = plugin; this.plugin = plugin;
this.notifier = notifier; this.notifier = notifier;
} }
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (args.length > 0) { if (args.length > 0) {
if (args[0].equalsIgnoreCase("reload") && sender.hasPermission("rankup.reload")) { if (args[0].equalsIgnoreCase("reload") && sender.hasPermission("rankup.reload")) {
plugin.reload(false); plugin.reload(false);
if (!plugin.error(sender)) { if (!plugin.error(sender)) {
sender.sendMessage(ChatColor.GREEN + "" + ChatColor.BOLD + "Rankup " + ChatColor.YELLOW + "Reloaded configuration files."); sender.sendMessage(ChatColor.GREEN + "" + ChatColor.BOLD + "Rankup " + ChatColor.YELLOW + "Reloaded configuration files.");
} }
return true; return true;
} else if (args[0].equalsIgnoreCase("forcerankup") && sender.hasPermission("rankup.force")) { } else if (args[0].equalsIgnoreCase("forcerankup") && sender.hasPermission("rankup.force")) {
if (args.length < 2) { if (args.length < 2) {
sender.sendMessage(ChatColor.YELLOW + "Usage: /" + label + " forcerankup <player>"); sender.sendMessage(ChatColor.YELLOW + "Usage: /" + label + " forcerankup <player>");
return true; return true;
} }
Player player = Bukkit.getPlayer(args[1]); Player player = Bukkit.getPlayer(args[1]);
if (player == null) { if (player == null) {
sender.sendMessage(ChatColor.YELLOW + "Player not found."); sender.sendMessage(ChatColor.YELLOW + "Player not found.");
return true; return true;
} }
Rankups rankups = plugin.getRankups(); Rankups rankups = plugin.getRankups();
if (rankups.isLast(plugin.getPermissions(), player)) { if (rankups.isLast(plugin.getPermissions(), player)) {
sender.sendMessage(ChatColor.YELLOW + "That player is at the last rank."); sender.sendMessage(ChatColor.YELLOW + "That player is at the last rank.");
return true; return true;
} }
Rank rank = rankups.getByPlayer(player); Rank rank = rankups.getByPlayer(player);
if (rank == null) { if (rank == null) {
sender.sendMessage(ChatColor.YELLOW + "That player is not in any rankup groups."); sender.sendMessage(ChatColor.YELLOW + "That player is not in any rankup groups.");
return true; return true;
} }
plugin.getHelper().doRankup(player, rank); plugin.getHelper().doRankup(player, rank);
plugin.getHelper().sendRankupMessages(player, rank); plugin.getHelper().sendRankupMessages(player, rank);
sender.sendMessage(ChatColor.GREEN + "Successfully forced " sender.sendMessage(ChatColor.GREEN + "Successfully forced "
+ ChatColor.GOLD + player.getName() + ChatColor.GOLD + player.getName()
+ ChatColor.GREEN + " to rankup from " + ChatColor.GOLD + rank.getRank() + ChatColor.GREEN + " to rankup from " + ChatColor.GOLD + rank.getRank()
+ ChatColor.GREEN + " to " + ChatColor.GOLD + rank.getNext()); + ChatColor.GREEN + " to " + ChatColor.GOLD + rank.getNext());
return true; return true;
} else if (args[0].equalsIgnoreCase("forceprestige") && sender.hasPermission("rankup.force")) { } else if (args[0].equalsIgnoreCase("forceprestige") && sender.hasPermission("rankup.force")) {
if (plugin.getPrestiges() == null) { if (plugin.getPrestiges() == null) {
sender.sendMessage(ChatColor.RED + "Prestige is disabled."); sender.sendMessage(ChatColor.RED + "Prestige is disabled.");
return true; return true;
} }
if (args.length < 2) { if (args.length < 2) {
sender.sendMessage(ChatColor.YELLOW + "Usage: /" + label + " forceprestige <player>"); sender.sendMessage(ChatColor.YELLOW + "Usage: /" + label + " forceprestige <player>");
return true; return true;
} }
Player player = Bukkit.getPlayer(args[1]); Player player = Bukkit.getPlayer(args[1]);
if (player == null) { if (player == null) {
sender.sendMessage(ChatColor.YELLOW + "Player not found."); sender.sendMessage(ChatColor.YELLOW + "Player not found.");
return true; return true;
} }
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
if (prestiges.isLast(plugin.getPermissions(), player)) { if (prestiges.isLast(plugin.getPermissions(), player)) {
sender.sendMessage(ChatColor.YELLOW + "That player is at the last prestige."); sender.sendMessage(ChatColor.YELLOW + "That player is at the last prestige.");
return true; return true;
} }
Prestige prestige = prestiges.getByPlayer(player); Prestige prestige = prestiges.getByPlayer(player);
if (prestige == null) { if (prestige == null) {
sender.sendMessage(ChatColor.YELLOW + "That player is not in any prestige groups."); sender.sendMessage(ChatColor.YELLOW + "That player is not in any prestige groups.");
return true; return true;
} }
plugin.getHelper().doPrestige(player, prestige); plugin.getHelper().doPrestige(player, prestige);
plugin.getHelper().sendPrestigeMessages(player, prestige); plugin.getHelper().sendPrestigeMessages(player, prestige);
sender.sendMessage(ChatColor.GREEN + "Successfully forced " sender.sendMessage(ChatColor.GREEN + "Successfully forced "
+ ChatColor.GOLD + player.getName() + ChatColor.GOLD + player.getName()
+ ChatColor.GREEN + " to prestige " + ChatColor.GREEN + " to prestige "
+ ChatColor.GOLD + prestige.getRank() + ChatColor.GOLD + prestige.getRank()
+ ChatColor.GREEN + " from " + ChatColor.GOLD + prestige.getFrom() + ChatColor.GREEN + " from " + ChatColor.GOLD + prestige.getFrom()
+ ChatColor.GREEN + " to " + ChatColor.GOLD + prestige.getTo()); + ChatColor.GREEN + " to " + ChatColor.GOLD + prestige.getTo());
return true; return true;
} }
} }
PluginDescriptionFile description = plugin.getDescription(); PluginDescriptionFile description = plugin.getDescription();
String version = description.getVersion(); String version = description.getVersion();
sender.sendMessage( sender.sendMessage(
ChatColor.GREEN + "" + ChatColor.BOLD + description.getName() + " " + version + ChatColor.GREEN + "" + ChatColor.BOLD + description.getName() + " " + version +
ChatColor.YELLOW + " by " + ChatColor.BLUE + ChatColor.BOLD + String.join(", ", description.getAuthors())); ChatColor.YELLOW + " by " + ChatColor.BLUE + ChatColor.BOLD + String.join(", ", description.getAuthors()));
if (sender.hasPermission("rankup.reload")) { if (sender.hasPermission("rankup.reload")) {
sender.sendMessage(ChatColor.GREEN + "/" + label + " reload " + ChatColor.YELLOW + "Reloads configuration files."); sender.sendMessage(ChatColor.GREEN + "/" + label + " reload " + ChatColor.YELLOW + "Reloads configuration files.");
sender.sendMessage(ChatColor.GREEN + "/" + label + " forcerankup <player> " + ChatColor.YELLOW + "Force a player to rankup, bypassing requirements."); sender.sendMessage(ChatColor.GREEN + "/" + label + " forcerankup <player> " + ChatColor.YELLOW + "Force a player to rankup, bypassing requirements.");
if (plugin.getPrestiges() != null) { if (plugin.getPrestiges() != null) {
sender.sendMessage( sender.sendMessage(
ChatColor.GREEN + "/" + label + " forceprestige <player> " + ChatColor.YELLOW ChatColor.GREEN + "/" + label + " forceprestige <player> " + ChatColor.YELLOW
+ "Force a player to prestige, bypassing requirements."); + "Force a player to prestige, bypassing requirements.");
} }
} }
if (sender.hasPermission("rankup.checkversion")) { if (sender.hasPermission("rankup.checkversion")) {
notifier.notify(sender, false); notifier.notify(sender, false);
} }
return true; return true;
} }
} }
@@ -1,45 +1,45 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.RankupHelper; import sh.okx.rankup.RankupHelper;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
@RequiredArgsConstructor @RequiredArgsConstructor
public class MaxRankupCommand implements CommandExecutor { public class MaxRankupCommand implements CommandExecutor {
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (!(sender instanceof Player)) { if (!(sender instanceof Player)) {
return false; return false;
} }
RankupHelper helper = plugin.getHelper(); RankupHelper helper = plugin.getHelper();
Player player = (Player) sender; Player player = (Player) sender;
if (!helper.checkRankup(player)) { if (!helper.checkRankup(player)) {
return true; return true;
} }
do { do {
Rank rank = plugin.getRankups().getByPlayer(player); Rank rank = plugin.getRankups().getByPlayer(player);
rank.applyRequirements(player); rank.applyRequirements(player);
helper.doRankup(player, rank); helper.doRankup(player, rank);
// if the individual-messages setting is disabled, only send the "well done you ranked up" // if the individual-messages setting is disabled, only send the "well done you ranked up"
// messages if they can't rank up any more. // messages if they can't rank up any more.
if (plugin.getConfig().getBoolean("max-rankup.individual-messages") if (plugin.getConfig().getBoolean("max-rankup.individual-messages")
|| !helper.checkRankup(player, false)) { || !helper.checkRankup(player, false)) {
helper.sendRankupMessages(player, rank); helper.sendRankupMessages(player, rank);
} }
} while (helper.checkRankup(player, false)); } while (helper.checkRankup(player, false));
return true; return true;
} }
} }
@@ -1,73 +1,73 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.gui.Gui; import sh.okx.rankup.gui.Gui;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import java.util.Map; import java.util.Map;
import java.util.WeakHashMap; import java.util.WeakHashMap;
@RequiredArgsConstructor @RequiredArgsConstructor
public class PrestigeCommand implements CommandExecutor { public class PrestigeCommand implements CommandExecutor {
private final Map<Player, Long> confirming = new WeakHashMap<>(); private final Map<Player, Long> confirming = new WeakHashMap<>();
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (plugin.error(sender)) { if (plugin.error(sender)) {
return true; return true;
} }
// check if player // check if player
if (!(sender instanceof Player)) { if (!(sender instanceof Player)) {
return false; return false;
} }
Player player = (Player) sender; Player player = (Player) sender;
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
Prestige prestige = prestiges.getByPlayer(player); Prestige prestige = prestiges.getByPlayer(player);
if (!plugin.getHelper().checkPrestige(player)) { if (!plugin.getHelper().checkPrestige(player)) {
return true; return true;
} }
FileConfiguration config = plugin.getConfig(); FileConfiguration config = plugin.getConfig();
String confirmationType = config.getString("confirmation-type").toLowerCase(); String confirmationType = config.getString("confirmation-type").toLowerCase();
if (confirmationType.equals("text") && confirming.containsKey(player)) { if (confirmationType.equals("text") && confirming.containsKey(player)) {
long time = System.currentTimeMillis() - confirming.remove(player); long time = System.currentTimeMillis() - confirming.remove(player);
if (time < config.getInt("text.timeout") * 1000) { if (time < config.getInt("text.timeout") * 1000) {
plugin.getHelper().prestige(player); plugin.getHelper().prestige(player);
return true; return true;
} }
} }
switch (confirmationType) { switch (confirmationType) {
case "text": case "text":
confirming.put(player, System.currentTimeMillis()); confirming.put(player, System.currentTimeMillis());
Prestige next = prestiges.next(prestige); Prestige next = prestiges.next(prestige);
String nextRank = next == null ? prestiges.getLast() : next.getRank(); String nextRank = next == null ? prestiges.getLast() : next.getRank();
plugin.replaceMoneyRequirements(plugin.getMessage(prestige, Message.PRESTIGE_CONFIRMATION) plugin.replaceMoneyRequirements(plugin.getMessage(prestige, Message.PRESTIGE_CONFIRMATION)
.replaceRanks(player, prestige, nextRank), player, prestige) .replaceRanks(player, prestige, nextRank), player, prestige)
.replaceFromTo(prestige) .replaceFromTo(prestige)
.send(player); .send(player);
break; break;
case "gui": case "gui":
Gui.of(player, prestige, prestige.getNext(), plugin).open(player); Gui.of(player, prestige, prestige.getNext(), plugin).open(player);
break; break;
case "none": case "none":
plugin.getHelper().prestige(player); plugin.getHelper().prestige(player);
break; break;
default: default:
throw new IllegalArgumentException("Invalid confirmation type " + confirmationType); throw new IllegalArgumentException("Invalid confirmation type " + confirmationType);
} }
return true; return true;
} }
} }
@@ -1,50 +1,50 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
@RequiredArgsConstructor @RequiredArgsConstructor
public class PrestigesCommand implements CommandExecutor { public class PrestigesCommand implements CommandExecutor {
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (plugin.error(sender)) { if (plugin.error(sender)) {
return true; return true;
} }
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
Prestige playerRank = null; Prestige playerRank = null;
if (sender instanceof Player) { if (sender instanceof Player) {
playerRank = prestiges.getByPlayer((Player) sender); playerRank = prestiges.getByPlayer((Player) sender);
} }
plugin.sendHeaderFooter(sender, playerRank, Message.PRESTIGES_HEADER); plugin.sendHeaderFooter(sender, playerRank, Message.PRESTIGES_HEADER);
Message message = playerRank == null ? Message.PRESTIGES_INCOMPLETE : Message.PRESTIGES_COMPLETE; Message message = playerRank == null ? Message.PRESTIGES_INCOMPLETE : Message.PRESTIGES_COMPLETE;
Prestige prestige = prestiges.getFirst(); Prestige prestige = prestiges.getFirst();
String nextRank; String nextRank;
do { do {
nextRank = prestige.getNext(); nextRank = prestige.getNext();
if (prestige.equals(playerRank)) { if (prestige.equals(playerRank)) {
plugin.getMessage(sender, Message.PRESTIGES_CURRENT, prestige, nextRank) plugin.getMessage(sender, Message.PRESTIGES_CURRENT, prestige, nextRank)
.send(sender); .send(sender);
message = Message.PRESTIGES_INCOMPLETE; message = Message.PRESTIGES_INCOMPLETE;
} else { } else {
plugin.getMessage(sender, message, prestige, nextRank) plugin.getMessage(sender, message, prestige, nextRank)
.replaceFirstPrestige(prestige, prestiges, prestige.getFrom()) .replaceFirstPrestige(prestige, prestiges, prestige.getFrom())
.send(sender); .send(sender);
} }
} while((prestige = prestiges.getByName(nextRank)) != null); } while((prestige = prestiges.getByName(nextRank)) != null);
plugin.sendHeaderFooter(sender, playerRank, Message.PRESTIGES_FOOTER); plugin.sendHeaderFooter(sender, playerRank, Message.PRESTIGES_FOOTER);
return true; return true;
} }
} }
@@ -1,47 +1,47 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.Rankups; import sh.okx.rankup.ranks.Rankups;
@RequiredArgsConstructor @RequiredArgsConstructor
public class RanksCommand implements CommandExecutor { public class RanksCommand implements CommandExecutor {
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (plugin.error(sender)) { if (plugin.error(sender)) {
return true; return true;
} }
Rankups rankups = plugin.getRankups(); Rankups rankups = plugin.getRankups();
Rank playerRank = null; Rank playerRank = null;
if (sender instanceof Player) { if (sender instanceof Player) {
playerRank = rankups.getByPlayer((Player) sender); playerRank = rankups.getByPlayer((Player) sender);
} }
plugin.sendHeaderFooter(sender, playerRank, Message.RANKS_HEADER); plugin.sendHeaderFooter(sender, playerRank, Message.RANKS_HEADER);
Message message = !(sender instanceof Player && rankups.isLast(plugin.getPermissions(), (Player) sender)) Message message = !(sender instanceof Player && rankups.isLast(plugin.getPermissions(), (Player) sender))
&& playerRank == null ? Message.RANKS_INCOMPLETE : Message.RANKS_COMPLETE; && playerRank == null ? Message.RANKS_INCOMPLETE : Message.RANKS_COMPLETE;
Rank rank = rankups.getFirst(); Rank rank = rankups.getFirst();
while (rank != null) { while (rank != null) {
String name = rank.getNext(); String name = rank.getNext();
if (rank.equals(playerRank)) { if (rank.equals(playerRank)) {
plugin.getMessage(sender, Message.RANKS_CURRENT, rank, name).send(sender); plugin.getMessage(sender, Message.RANKS_CURRENT, rank, name).send(sender);
message = Message.RANKS_INCOMPLETE; message = Message.RANKS_INCOMPLETE;
} else { } else {
plugin.getMessage(sender, message, rank, name).send(sender); plugin.getMessage(sender, message, rank, name).send(sender);
} }
rank = rankups.getByName(name); rank = rankups.getByName(name);
} }
plugin.sendHeaderFooter(sender, playerRank, Message.RANKS_FOOTER); plugin.sendHeaderFooter(sender, playerRank, Message.RANKS_FOOTER);
return true; return true;
} }
} }
@@ -1,81 +1,81 @@
package sh.okx.rankup.commands; package sh.okx.rankup.commands;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.gui.Gui; import sh.okx.rankup.gui.Gui;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.Rankups; import sh.okx.rankup.ranks.Rankups;
import java.util.Map; import java.util.Map;
import java.util.WeakHashMap; import java.util.WeakHashMap;
@RequiredArgsConstructor @RequiredArgsConstructor
public class RankupCommand implements CommandExecutor { public class RankupCommand implements CommandExecutor {
// weak hash maps so players going offline are automatically removed. // weak hash maps so players going offline are automatically removed.
// otherwise there is a potential (albeit small) memory leak. // otherwise there is a potential (albeit small) memory leak.
private final Map<Player, Long> confirming = new WeakHashMap<>(); private final Map<Player, Long> confirming = new WeakHashMap<>();
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (plugin.error(sender)) { if (plugin.error(sender)) {
return true; return true;
} }
// check if player // check if player
if (!(sender instanceof Player)) { if (!(sender instanceof Player)) {
return false; return false;
} }
Player player = (Player) sender; Player player = (Player) sender;
Rankups rankups = plugin.getRankups(); Rankups rankups = plugin.getRankups();
Rank rank = rankups.getByPlayer(player); Rank rank = rankups.getByPlayer(player);
if (!plugin.getHelper().checkRankup(player)) { if (!plugin.getHelper().checkRankup(player)) {
return true; return true;
} }
/*Rank next = rankups.next(rank); /*Rank next = rankups.next(rank);
if (next == null) { if (next == null) {
plugin.getLogger().severe("Rankup from " + rank.getRank() + " to " + rank.getNext() + plugin.getLogger().severe("Rankup from " + rank.getRank() + " to " + rank.getNext() +
" is defined but " + rank.getNext() + " does not exist."); " is defined but " + rank.getNext() + " does not exist.");
plugin.getMessage(Message.INVALID_RANKUP).failIfEmpty().send(player); plugin.getMessage(Message.INVALID_RANKUP).failIfEmpty().send(player);
return true; return true;
}*/ }*/
String next = rank.getNext(); String next = rank.getNext();
FileConfiguration config = plugin.getConfig(); FileConfiguration config = plugin.getConfig();
String confirmationType = config.getString("confirmation-type").toLowerCase(); String confirmationType = config.getString("confirmation-type").toLowerCase();
// if they are on text confirming, rank them up // if they are on text confirming, rank them up
if (confirmationType.equals("text") && confirming.containsKey(player)) { if (confirmationType.equals("text") && confirming.containsKey(player)) {
long time = System.currentTimeMillis() - confirming.remove(player); long time = System.currentTimeMillis() - confirming.remove(player);
if (time < config.getInt("text.timeout") * 1000) { if (time < config.getInt("text.timeout") * 1000) {
plugin.getHelper().rankup(player); plugin.getHelper().rankup(player);
return true; return true;
} }
} }
switch (confirmationType) { switch (confirmationType) {
case "text": case "text":
confirming.put(player, System.currentTimeMillis()); confirming.put(player, System.currentTimeMillis());
plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.CONFIRMATION) plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.CONFIRMATION)
.replaceRanks(player, rank, next), player, rank) .replaceRanks(player, rank, next), player, rank)
.send(player); .send(player);
break; break;
case "gui": case "gui":
Gui.of(player, rank, next, plugin).open(player); Gui.of(player, rank, next, plugin).open(player);
break; break;
case "none": case "none":
plugin.getHelper().rankup(player); plugin.getHelper().rankup(player);
break; break;
default: default:
throw new IllegalArgumentException("Invalid confirmation type " + confirmationType); throw new IllegalArgumentException("Invalid confirmation type " + confirmationType);
} }
return true; return true;
} }
} }
+139 -139
View File
@@ -1,139 +1,139 @@
package sh.okx.rankup.gui; package sh.okx.rankup.gui;
import lombok.AccessLevel; import lombok.AccessLevel;
import lombok.Getter; import lombok.Getter;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory; import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder; import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.ItemMeta;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.Message;
import sh.okx.rankup.messages.MessageBuilder; import sh.okx.rankup.messages.MessageBuilder;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import java.util.Arrays; import java.util.Arrays;
import java.util.Objects; import java.util.Objects;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import sh.okx.rankup.util.ItemUtil; import sh.okx.rankup.util.ItemUtil;
@NoArgsConstructor(access = AccessLevel.PRIVATE) @NoArgsConstructor(access = AccessLevel.PRIVATE)
public class Gui implements InventoryHolder { public class Gui implements InventoryHolder {
@Getter @Getter
private Inventory inventory; private Inventory inventory;
@Getter @Getter
private ItemStack rankup; private ItemStack rankup;
@Getter @Getter
private ItemStack cancel; private ItemStack cancel;
@Getter @Getter
private boolean prestige; private boolean prestige;
public static Gui of(Player player, Rank oldRank, String rank, RankupPlugin plugin) { public static Gui of(Player player, Rank oldRank, String rank, RankupPlugin plugin) {
Gui gui = new Gui(); Gui gui = new Gui();
gui.prestige = oldRank instanceof Prestige; gui.prestige = oldRank instanceof Prestige;
String type = gui.prestige ? "prestige" : "rankup"; String type = gui.prestige ? "prestige" : "rankup";
String basePath = type + ".gui"; String basePath = type + ".gui";
ConfigurationSection config = plugin.getSection(oldRank, basePath); ConfigurationSection config = plugin.getSection(oldRank, basePath);
ItemStack[] items = new ItemStack[config.getInt("rows", 1) * 9]; ItemStack[] items = new ItemStack[config.getInt("rows", 1) * 9];
ItemStack fill = getItem(plugin, plugin.getSection(oldRank, basePath + ".fill"), player, oldRank, rank); ItemStack fill = getItem(plugin, plugin.getSection(oldRank, basePath + ".fill"), player, oldRank, rank);
ItemStack cancel = getItem(plugin, plugin.getSection(oldRank, basePath + ".cancel"), player, oldRank, rank); ItemStack cancel = getItem(plugin, plugin.getSection(oldRank, basePath + ".cancel"), player, oldRank, rank);
ItemStack rankup = getItem(plugin, plugin.getSection(oldRank, basePath + ".rankup"), player, oldRank, rank); ItemStack rankup = getItem(plugin, plugin.getSection(oldRank, basePath + ".rankup"), player, oldRank, rank);
addItem(items, plugin.getSection(oldRank, basePath + ".rankup"), rankup); addItem(items, plugin.getSection(oldRank, basePath + ".rankup"), rankup);
addItem(items, plugin.getSection(oldRank, basePath + ".cancel"), cancel); addItem(items, plugin.getSection(oldRank, basePath + ".cancel"), cancel);
addItem(items, plugin.getSection(oldRank, basePath + ".fill"), fill); addItem(items, plugin.getSection(oldRank, basePath + ".fill"), fill);
gui.rankup = rankup; gui.rankup = rankup;
gui.cancel = cancel; gui.cancel = cancel;
Inventory inventory = Bukkit.createInventory(gui, items.length, Inventory inventory = Bukkit.createInventory(gui, items.length,
plugin.replaceMoneyRequirements( plugin.replaceMoneyRequirements(
plugin.getMessage(oldRank, gui.prestige ? Message.PRESTIGE_TITLE : Message.TITLE) plugin.getMessage(oldRank, gui.prestige ? Message.PRESTIGE_TITLE : Message.TITLE)
.replaceRanks(player, oldRank, rank) .replaceRanks(player, oldRank, rank)
.replaceFromTo(oldRank), player, oldRank).toString()); .replaceFromTo(oldRank), player, oldRank).toString());
inventory.setContents(items); inventory.setContents(items);
gui.inventory = inventory; gui.inventory = inventory;
return gui; return gui;
} }
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
private static ItemStack getItem(RankupPlugin plugin, ConfigurationSection section, Player player, Rank oldRank, String rank) { private static ItemStack getItem(RankupPlugin plugin, ConfigurationSection section, Player player, Rank oldRank, String rank) {
String materialName = section.getString("material").toUpperCase(); String materialName = section.getString("material").toUpperCase();
ItemStack item; ItemStack item;
if (ItemUtil.isServerFlattened()) { if (ItemUtil.isServerFlattened()) {
Material material = Material.valueOf(materialName); Material material = Material.valueOf(materialName);
item = new ItemStack(material); item = new ItemStack(material);
} else { } else {
// handle default material correctly on older vesions // handle default material correctly on older vesions
if (materialName.equals("BLACK_STAINED_GLASS_PANE")) { if (materialName.equals("BLACK_STAINED_GLASS_PANE")) {
materialName = "STAINED_GLASS_PANE:15"; materialName = "STAINED_GLASS_PANE:15";
} }
String[] parts = materialName.split(":"); String[] parts = materialName.split(":");
Material material = Material.valueOf(parts[0]); Material material = Material.valueOf(parts[0]);
short type = parts.length > 1 ? Short.parseShort(parts[1]) : 0; short type = parts.length > 1 ? Short.parseShort(parts[1]) : 0;
item = new ItemStack(material, 1, type); item = new ItemStack(material, 1, type);
} }
if (item.getType() == Material.AIR && section.getName().equalsIgnoreCase("fill")) { if (item.getType() == Material.AIR && section.getName().equalsIgnoreCase("fill")) {
return item; return item;
} }
ItemMeta meta = item.getItemMeta(); ItemMeta meta = item.getItemMeta();
if (section.contains("lore")) { if (section.contains("lore")) {
meta.setLore(Arrays.stream(format(plugin, section.getString("lore"), player, oldRank, rank).split("\n")) meta.setLore(Arrays.stream(format(plugin, section.getString("lore"), player, oldRank, rank).split("\n"))
.map(string -> ChatColor.RESET + string) .map(string -> ChatColor.RESET + string)
.collect(Collectors.toList())); .collect(Collectors.toList()));
} }
if (section.contains("name")) { if (section.contains("name")) {
meta.setDisplayName(ChatColor.RESET + format(plugin, section.getString("name"), player, oldRank, rank)); meta.setDisplayName(ChatColor.RESET + format(plugin, section.getString("name"), player, oldRank, rank));
} }
item.setItemMeta(meta); item.setItemMeta(meta);
return item; return item;
} }
private static String format(RankupPlugin plugin, String message, Player player, Rank oldRank, String rank) { private static String format(RankupPlugin plugin, String message, Player player, Rank oldRank, String rank) {
return plugin.replaceMoneyRequirements(new MessageBuilder(ChatColor.translateAlternateColorCodes('&', message)) return plugin.replaceMoneyRequirements(new MessageBuilder(ChatColor.translateAlternateColorCodes('&', message))
.replaceRanks(player, oldRank, rank), player, oldRank) .replaceRanks(player, oldRank, rank), player, oldRank)
.toString(); .toString();
} }
private static void addItem(ItemStack[] items, ConfigurationSection section, ItemStack item) { private static void addItem(ItemStack[] items, ConfigurationSection section, ItemStack item) {
Objects.requireNonNull(section, "GUI configuration section not found"); Objects.requireNonNull(section, "GUI configuration section not found");
if (section.getName().equalsIgnoreCase("fill")) { if (section.getName().equalsIgnoreCase("fill")) {
for (int i = 0; i < items.length; i++) { for (int i = 0; i < items.length; i++) {
if (items[i] == null) { if (items[i] == null) {
items[i] = item; items[i] = item;
} }
} }
return; return;
} }
String[] locations = section.getString("index").split(" "); String[] locations = section.getString("index").split(" ");
for (String location : locations) { for (String location : locations) {
String[] parts = location.split("-"); String[] parts = location.split("-");
if (parts.length == 1) { if (parts.length == 1) {
items[Integer.parseInt(parts[0])] = item; items[Integer.parseInt(parts[0])] = item;
} else { } else {
for (int i = Integer.parseInt(parts[0]); i <= Integer.parseInt(parts[1]); i++) { for (int i = Integer.parseInt(parts[0]); i <= Integer.parseInt(parts[1]); i++) {
items[i] = item; items[i] = item;
} }
} }
} }
} }
public void open(Player player) { public void open(Player player) {
player.openInventory(inventory); player.openInventory(inventory);
} }
} }
@@ -1,40 +1,40 @@
package sh.okx.rankup.gui; package sh.okx.rankup.gui;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory; import org.bukkit.inventory.Inventory;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
@RequiredArgsConstructor @RequiredArgsConstructor
public class GuiListener implements Listener { public class GuiListener implements Listener {
private final RankupPlugin plugin; private final RankupPlugin plugin;
@EventHandler @EventHandler
public void on(InventoryClickEvent e) { public void on(InventoryClickEvent e) {
Inventory inventory = e.getInventory(); Inventory inventory = e.getInventory();
if (inventory == null if (inventory == null
|| !(inventory.getHolder() instanceof Gui) || !(inventory.getHolder() instanceof Gui)
|| !inventory.equals(e.getClickedInventory())) { || !inventory.equals(e.getClickedInventory())) {
return; return;
} }
e.setCancelled(true); e.setCancelled(true);
Player player = (Player) e.getWhoClicked(); Player player = (Player) e.getWhoClicked();
Gui gui = (Gui) inventory.getHolder(); Gui gui = (Gui) inventory.getHolder();
if (gui.getRankup().isSimilar(e.getCurrentItem())) { if (gui.getRankup().isSimilar(e.getCurrentItem())) {
Bukkit.getScheduler().runTask(plugin, player::closeInventory); Bukkit.getScheduler().runTask(plugin, player::closeInventory);
if (gui.isPrestige()) { if (gui.isPrestige()) {
plugin.getHelper().prestige(player); plugin.getHelper().prestige(player);
} else { } else {
plugin.getHelper().rankup(player); plugin.getHelper().rankup(player);
} }
} else if (gui.getCancel().isSimilar(e.getCurrentItem())) { } else if (gui.getCancel().isSimilar(e.getCurrentItem())) {
Bukkit.getScheduler().runTask(plugin, player::closeInventory); Bukkit.getScheduler().runTask(plugin, player::closeInventory);
} }
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.hook; package sh.okx.rankup.hook;
import net.milkbowl.vault.permission.Permission; import net.milkbowl.vault.permission.Permission;
import org.bukkit.plugin.RegisteredServiceProvider; import org.bukkit.plugin.RegisteredServiceProvider;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
public class PermissionManager { public class PermissionManager {
private final RankupPlugin plugin; private final RankupPlugin plugin;
public PermissionManager(RankupPlugin plugin) { public PermissionManager(RankupPlugin plugin) {
this.plugin = plugin; this.plugin = plugin;
} }
public PermissionProvider findPermissionProvider() { public PermissionProvider findPermissionProvider() {
return getVaultPermissionProvider(); return getVaultPermissionProvider();
} }
private PermissionProvider getVaultPermissionProvider() { private PermissionProvider getVaultPermissionProvider() {
RegisteredServiceProvider<Permission> rsp = plugin.getServer().getServicesManager() RegisteredServiceProvider<Permission> rsp = plugin.getServer().getServicesManager()
.getRegistration(Permission.class); .getRegistration(Permission.class);
if (rsp == null) { if (rsp == null) {
return null; return null;
} }
Permission provider = rsp.getProvider(); Permission provider = rsp.getProvider();
if (!provider.hasGroupSupport()) { if (!provider.hasGroupSupport()) {
return null; return null;
} }
return new VaultPermissionProvider(provider); return new VaultPermissionProvider(provider);
} }
} }
@@ -1,9 +1,9 @@
package sh.okx.rankup.hook; package sh.okx.rankup.hook;
import java.util.UUID; import java.util.UUID;
public interface PermissionProvider { public interface PermissionProvider {
boolean inGroup(UUID uuid, String group); boolean inGroup(UUID uuid, String group);
void addGroup(UUID uuid, String group); void addGroup(UUID uuid, String group);
void removeGroup(UUID uuid, String group); void removeGroup(UUID uuid, String group);
} }
@@ -1,44 +1,44 @@
package sh.okx.rankup.hook; package sh.okx.rankup.hook;
import java.util.Objects; import java.util.Objects;
import java.util.UUID; import java.util.UUID;
import net.milkbowl.vault.permission.Permission; import net.milkbowl.vault.permission.Permission;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
public class VaultPermissionProvider implements PermissionProvider { public class VaultPermissionProvider implements PermissionProvider {
private final Permission permission; private final Permission permission;
public VaultPermissionProvider(Permission permission) { public VaultPermissionProvider(Permission permission) {
this.permission = permission; this.permission = permission;
} }
@Override @Override
public boolean inGroup(UUID uuid, String group) { public boolean inGroup(UUID uuid, String group) {
Objects.requireNonNull(uuid); Objects.requireNonNull(uuid);
Objects.requireNonNull(group); Objects.requireNonNull(group);
String[] playerGroups = permission.getPlayerGroups(null, Bukkit.getOfflinePlayer(uuid)); String[] playerGroups = permission.getPlayerGroups(null, Bukkit.getOfflinePlayer(uuid));
for (String playerGroup : playerGroups) { for (String playerGroup : playerGroups) {
if (group.equalsIgnoreCase(playerGroup)) { if (group.equalsIgnoreCase(playerGroup)) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public void addGroup(UUID uuid, String group) { public void addGroup(UUID uuid, String group) {
Objects.requireNonNull(uuid); Objects.requireNonNull(uuid);
Objects.requireNonNull(group); Objects.requireNonNull(group);
permission.playerAddGroup(null, Bukkit.getOfflinePlayer(uuid), group); permission.playerAddGroup(null, Bukkit.getOfflinePlayer(uuid), group);
} }
@Override @Override
public void removeGroup(UUID uuid, String group) { public void removeGroup(UUID uuid, String group) {
Objects.requireNonNull(uuid); Objects.requireNonNull(uuid);
Objects.requireNonNull(group); Objects.requireNonNull(group);
permission.playerRemoveGroup(null, Bukkit.getOfflinePlayer(uuid), group); permission.playerRemoveGroup(null, Bukkit.getOfflinePlayer(uuid), group);
} }
} }
@@ -1,41 +1,41 @@
package sh.okx.rankup.messages; package sh.okx.rankup.messages;
import lombok.Getter; import lombok.Getter;
public enum Message { public enum Message {
NOT_IN_LADDER("not-in-ladder"), NOT_IN_LADDER("not-in-ladder"),
REQUIREMENTS_NOT_MET("rankup.requirements-not-met"), REQUIREMENTS_NOT_MET("rankup.requirements-not-met"),
NO_RANKUP("rankup.no-rankup"), NO_RANKUP("rankup.no-rankup"),
SUCCESS_PUBLIC("rankup.success-public"), SUCCESS_PUBLIC("rankup.success-public"),
SUCCESS_PRIVATE("rankup.success-private"), SUCCESS_PRIVATE("rankup.success-private"),
CONFIRMATION("rankup.confirmation"), CONFIRMATION("rankup.confirmation"),
TITLE("rankup.gui.title"), TITLE("rankup.gui.title"),
RANKS_HEADER("rankup.list.header"), RANKS_HEADER("rankup.list.header"),
RANKS_FOOTER("rankup.list.footer"), RANKS_FOOTER("rankup.list.footer"),
RANKS_COMPLETE("rankup.list.complete"), RANKS_COMPLETE("rankup.list.complete"),
RANKS_CURRENT("rankup.list.current"), RANKS_CURRENT("rankup.list.current"),
RANKS_INCOMPLETE("rankup.list.incomplete"), RANKS_INCOMPLETE("rankup.list.incomplete"),
PRESTIGE_REQUIREMENTS_NOT_MET("prestige.requirements-not-met"), PRESTIGE_REQUIREMENTS_NOT_MET("prestige.requirements-not-met"),
PRESTIGE_NO_PRESTIGE("prestige.no-prestige"), PRESTIGE_NO_PRESTIGE("prestige.no-prestige"),
PRESTIGES_HEADER("prestige.list.header"), PRESTIGES_HEADER("prestige.list.header"),
PRESTIGES_FOOTER("prestige.list.footer"), PRESTIGES_FOOTER("prestige.list.footer"),
PRESTIGES_COMPLETE("prestige.list.complete"), PRESTIGES_COMPLETE("prestige.list.complete"),
PRESTIGES_CURRENT("prestige.list.current"), PRESTIGES_CURRENT("prestige.list.current"),
PRESTIGES_INCOMPLETE("prestige.list.incomplete"), PRESTIGES_INCOMPLETE("prestige.list.incomplete"),
PRESTIGE_TITLE("prestige.gui.title"), PRESTIGE_TITLE("prestige.gui.title"),
COOLDOWN_SINGULAR("rankup.cooldown.singular"), COOLDOWN_SINGULAR("rankup.cooldown.singular"),
COOLDOWN_PLURAL("rankup.cooldown.plural"), COOLDOWN_PLURAL("rankup.cooldown.plural"),
MUST_PRESTIGE("rankup.must-prestige"), MUST_PRESTIGE("rankup.must-prestige"),
NOT_HIGH_ENOUGH("not-high-enough"), NOT_HIGH_ENOUGH("not-high-enough"),
PRESTIGE_SUCCESS_PUBLIC("prestige.success-public"), PRESTIGE_SUCCESS_PUBLIC("prestige.success-public"),
PRESTIGE_SUCCESS_PRIVATE("prestige.success-private"), PRESTIGE_SUCCESS_PRIVATE("prestige.success-private"),
PRESTIGE_CONFIRMATION("prestige.confirmation"), PRESTIGE_CONFIRMATION("prestige.confirmation"),
INVALID_RANKUP("invalid-rankup"); INVALID_RANKUP("invalid-rankup");
@Getter @Getter
private final String name; private final String name;
Message(String name) { Message(String name) {
this.name = name; this.name = name;
} }
} }
@@ -1,124 +1,124 @@
package sh.okx.rankup.messages; package sh.okx.rankup.messages;
import me.clip.placeholderapi.PlaceholderAPI; import me.clip.placeholderapi.PlaceholderAPI;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import java.util.Objects; import java.util.Objects;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
public class MessageBuilder { public class MessageBuilder {
private String message; private String message;
public MessageBuilder(String message) { public MessageBuilder(String message) {
this.message = message; this.message = message;
} }
public static MessageBuilder of(ConfigurationSection config, Message message) { public static MessageBuilder of(ConfigurationSection config, Message message) {
return MessageBuilder.of(config, message.getName()); return MessageBuilder.of(config, message.getName());
} }
private static MessageBuilder of(ConfigurationSection config, String message) { private static MessageBuilder of(ConfigurationSection config, String message) {
String string = config.getString(message); String string = config.getString(message);
Objects.requireNonNull(string, "Configuration message '" + message + "' not found!"); Objects.requireNonNull(string, "Configuration message '" + message + "' not found!");
return new MessageBuilder(ChatColor.translateAlternateColorCodes('&', string)); return new MessageBuilder(ChatColor.translateAlternateColorCodes('&', string));
} }
public MessageBuilder replace(Variable variable, Object value) { public MessageBuilder replace(Variable variable, Object value) {
return replace(variable.name(), value); return replace(variable.name(), value);
} }
public MessageBuilder replace(String name, Object value) { public MessageBuilder replace(String name, Object value) {
Pattern pattern = Pattern.compile("\\{" + name + "}", Pattern.CASE_INSENSITIVE); Pattern pattern = Pattern.compile("\\{" + name + "}", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(message); Matcher matcher = pattern.matcher(message);
this.message = matcher.replaceAll(String.valueOf(value)); this.message = matcher.replaceAll(String.valueOf(value));
return this; return this;
} }
public MessageBuilder replaceFirstPrestige(Rank rank, Prestiges prestiges, String with) { public MessageBuilder replaceFirstPrestige(Rank rank, Prestiges prestiges, String with) {
if (prestiges != null && prestiges.getFirst().equals(rank)) { if (prestiges != null && prestiges.getFirst().equals(rank)) {
replace(Variable.OLD_RANK, with); replace(Variable.OLD_RANK, with);
} }
return this; return this;
} }
public MessageBuilder replaceRanks(CommandSender player, String rankName) { public MessageBuilder replaceRanks(CommandSender player, String rankName) {
replace(Variable.PLAYER, player.getName()); replace(Variable.PLAYER, player.getName());
replaceRanks(rankName); replaceRanks(rankName);
return this; return this;
} }
public MessageBuilder replaceRanks(CommandSender player, Rank oldRank, String rankName) { public MessageBuilder replaceRanks(CommandSender player, Rank oldRank, String rankName) {
replace(Variable.PLAYER, player.getName()); replace(Variable.PLAYER, player.getName());
replaceRanks(oldRank, rankName); replaceRanks(oldRank, rankName);
return this; return this;
} }
public MessageBuilder replaceRanks(String rankName) { public MessageBuilder replaceRanks(String rankName) {
replace(Variable.RANK, rankName); replace(Variable.RANK, rankName);
return this; return this;
} }
public MessageBuilder replaceRanks(Rank oldRank, String rankName) { public MessageBuilder replaceRanks(Rank oldRank, String rankName) {
replaceRanks(rankName); replaceRanks(rankName);
replace(Variable.OLD_RANK, oldRank.getRank()); replace(Variable.OLD_RANK, oldRank.getRank());
return this; return this;
} }
public MessageBuilder replaceFromTo(Rank rank) { public MessageBuilder replaceFromTo(Rank rank) {
if (rank instanceof Prestige) { if (rank instanceof Prestige) {
Prestige prestige = (Prestige) rank; Prestige prestige = (Prestige) rank;
replace(Variable.FROM, prestige.getFrom()); replace(Variable.FROM, prestige.getFrom());
replace(Variable.TO, prestige.getTo()); replace(Variable.TO, prestige.getTo());
} }
return this; return this;
} }
/** /**
* Fails the MessageBuilder if the message is empty. * Fails the MessageBuilder if the message is empty.
* if this fails, all subsequent calls to that MessageBuilder will do nothing * if this fails, all subsequent calls to that MessageBuilder will do nothing
* @return a NullMessageBuilder if the message is empty, itself otherwise * @return a NullMessageBuilder if the message is empty, itself otherwise
*/ */
public MessageBuilder failIfEmpty() { public MessageBuilder failIfEmpty() {
return failIf(message.isEmpty()); return failIf(message.isEmpty());
} }
public MessageBuilder failIf(boolean value) { public MessageBuilder failIf(boolean value) {
if (value) { if (value) {
return new NullMessageBuilder(); return new NullMessageBuilder();
} else { } else {
return this; return this;
} }
} }
public void send(CommandSender sender) { public void send(CommandSender sender) {
String msg = message; String msg = message;
if (sender instanceof Player && Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { if (sender instanceof Player && Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) {
msg = PlaceholderAPI.setPlaceholders((Player) sender, msg); msg = PlaceholderAPI.setPlaceholders((Player) sender, msg);
} }
sender.sendMessage(msg); sender.sendMessage(msg);
} }
/** /**
* Sends the message to all players * Sends the message to all players
* ie, calls MessageBuilder#send(Player) for all players online, and sends the message in the console. * ie, calls MessageBuilder#send(Player) for all players online, and sends the message in the console.
*/ */
public void broadcast() { public void broadcast() {
for (Player player : Bukkit.getOnlinePlayers()) { for (Player player : Bukkit.getOnlinePlayers()) {
send(player); send(player);
} }
send(Bukkit.getConsoleSender()); send(Bukkit.getConsoleSender());
} }
@Override @Override
public String toString() { public String toString() {
return message; return message;
} }
} }
@@ -1,35 +1,35 @@
package sh.okx.rankup.messages; package sh.okx.rankup.messages;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
/** /**
* A no-op implementation of MessageBuilder * A no-op implementation of MessageBuilder
*/ */
public class NullMessageBuilder extends MessageBuilder { public class NullMessageBuilder extends MessageBuilder {
NullMessageBuilder() { NullMessageBuilder() {
super(null); super(null);
} }
@Override @Override
public MessageBuilder failIf(boolean value) { public MessageBuilder failIf(boolean value) {
return this; return this;
} }
@Override @Override
public MessageBuilder replace(Variable variable, Object value) { public MessageBuilder replace(Variable variable, Object value) {
return this; return this;
} }
@Override @Override
public void send(CommandSender sender) { public void send(CommandSender sender) {
} }
@Override @Override
public void broadcast() { public void broadcast() {
} }
@Override @Override
public String toString() { public String toString() {
return null; return null;
} }
} }
@@ -1,18 +1,18 @@
package sh.okx.rankup.messages; package sh.okx.rankup.messages;
public enum Variable { public enum Variable {
PLAYER, PLAYER,
OLD_RANK, OLD_RANK,
RANK, RANK,
FROM, FROM,
TO, TO,
MONEY, MONEY,
MONEY_NEEDED, MONEY_NEEDED,
AMOUNT, AMOUNT,
AMOUNT_NEEDED, AMOUNT_NEEDED,
AMOUNT_DONE, AMOUNT_DONE,
PERCENT_DONE, PERCENT_DONE,
PERCENT_LEFT, PERCENT_LEFT,
SECONDS, SECONDS,
SECONDS_LEFT SECONDS_LEFT
} }
@@ -1,44 +1,44 @@
package sh.okx.rankup.placeholders; package sh.okx.rankup.placeholders;
import lombok.Getter; import lombok.Getter;
import me.clip.placeholderapi.PlaceholderAPI; import me.clip.placeholderapi.PlaceholderAPI;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import java.text.DecimalFormat; import java.text.DecimalFormat;
public class Placeholders { public class Placeholders {
private final RankupPlugin plugin; private final RankupPlugin plugin;
@Getter @Getter
private final DecimalFormat moneyFormat; private final DecimalFormat moneyFormat;
@Getter @Getter
private final DecimalFormat percentFormat; private final DecimalFormat percentFormat;
@Getter @Getter
private final DecimalFormat simpleFormat; private final DecimalFormat simpleFormat;
@Getter @Getter
private RankupExpansion expansion; private RankupExpansion expansion;
private boolean registered; private boolean registered;
public Placeholders(RankupPlugin plugin) { public Placeholders(RankupPlugin plugin) {
this.plugin = plugin; this.plugin = plugin;
this.moneyFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.money-format")); this.moneyFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.money-format"));
this.percentFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.percent-format")); this.percentFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.percent-format"));
this.simpleFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.simple-format")); this.simpleFormat = new DecimalFormat(plugin.getConfig().getString("placeholders.simple-format"));
} }
public void register() { public void register() {
if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) {
expansion = new RankupExpansion(plugin, this); expansion = new RankupExpansion(plugin, this);
expansion.register(); expansion.register();
registered = true; registered = true;
} else { } else {
registered = false; registered = false;
} }
} }
public void unregister() { public void unregister() {
if (registered) { if (registered) {
PlaceholderAPI.unregisterPlaceholderHook("rankup"); PlaceholderAPI.unregisterPlaceholderHook("rankup");
} }
} }
} }
@@ -1,219 +1,219 @@
package sh.okx.rankup.placeholders; package sh.okx.rankup.placeholders;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import me.clip.placeholderapi.expansion.PlaceholderExpansion; import me.clip.placeholderapi.expansion.PlaceholderExpansion;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.Rankups; import sh.okx.rankup.ranks.Rankups;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import java.util.Objects; import java.util.Objects;
import java.util.function.Function; import java.util.function.Function;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
@RequiredArgsConstructor @RequiredArgsConstructor
public class RankupExpansion extends PlaceholderExpansion { public class RankupExpansion extends PlaceholderExpansion {
private static final Pattern PATTERN = Pattern.compile("(.*)#(.*)"); private static final Pattern PATTERN = Pattern.compile("(.*)#(.*)");
private final RankupPlugin plugin; private final RankupPlugin plugin;
private final Placeholders placeholders; private final Placeholders placeholders;
@Override @Override
public String onPlaceholderRequest(Player player, String params) { public String onPlaceholderRequest(Player player, String params) {
if (player == null) { if (player == null) {
return ""; return "";
} }
params = params.toLowerCase(); params = params.toLowerCase();
Rankups rankups = plugin.getRankups(); Rankups rankups = plugin.getRankups();
Rank rank = rankups.getByPlayer(player); Rank rank = rankups.getByPlayer(player);
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
Prestige prestige = null; Prestige prestige = null;
if (prestiges != null) { if (prestiges != null) {
prestige = prestiges.getByPlayer(player); prestige = prestiges.getByPlayer(player);
} }
if (params.startsWith("requirement_")) { if (params.startsWith("requirement_")) {
String[] parts = params.split("_", 3); String[] parts = params.split("_", 3);
return getPlaceholderRequirement(player, rank, return getPlaceholderRequirement(player, rank,
replacePattern(parts[1]), parts.length > 2 ? parts[2] : ""); replacePattern(parts[1]), parts.length > 2 ? parts[2] : "");
} else if (params.startsWith("rank_requirement_")) { } else if (params.startsWith("rank_requirement_")) {
String[] parts = params.split("_", 5); String[] parts = params.split("_", 5);
return getPlaceholderRequirement(player, rankups.getByName(parts[2]), return getPlaceholderRequirement(player, rankups.getByName(parts[2]),
replacePattern(parts[3]), parts.length > 4 ? parts[4] : ""); replacePattern(parts[3]), parts.length > 4 ? parts[4] : "");
// return placeholders.getSimpleFormat().format(orElse(rankups.getByName(parts[2]).getRequirement(parts[3]), Requirement::getValueDouble, 0)); // return placeholders.getSimpleFormat().format(orElse(rankups.getByName(parts[2]).getRequirement(parts[3]), Requirement::getValueDouble, 0));
} else if (params.startsWith("rank_money_")) { } else if (params.startsWith("rank_money_")) {
String[] parts = params.split("_", 4); String[] parts = params.split("_", 4);
double amount = Objects.requireNonNull(rankups.getByName(parts[2]), "Rankup " + parts[2] + " does not exist").getRequirement(player, "money").getValueDouble(); double amount = Objects.requireNonNull(rankups.getByName(parts[2]), "Rankup " + parts[2] + " does not exist").getRequirement(player, "money").getValueDouble();
if (parts.length > 3 && parts[3].equalsIgnoreCase("left")) { if (parts.length > 3 && parts[3].equalsIgnoreCase("left")) {
amount = amount - plugin.getEconomy().getBalance(player); amount = amount - plugin.getEconomy().getBalance(player);
} }
return plugin.formatMoney(Math.max(0, amount)); return plugin.formatMoney(Math.max(0, amount));
} }
switch (params) { switch (params) {
case "current_prestige": case "current_prestige":
requirePrestiging(prestiges, params); requirePrestiging(prestiges, params);
if (prestiges.isLast(plugin.getPermissions(), player)) { if (prestiges.isLast(plugin.getPermissions(), player)) {
return prestiges.getLast(); return prestiges.getLast();
} else if (prestige == null || prestige.getRank() == null) { } else if (prestige == null || prestige.getRank() == null) {
return getPlaceholder("no-prestige"); return getPlaceholder("no-prestige");
} else { } else {
return prestige.getRank(); return prestige.getRank();
} }
case "next_prestige": case "next_prestige":
requirePrestiging(prestiges, params); requirePrestiging(prestiges, params);
if (prestiges.isLast(plugin.getPermissions(), player)) { if (prestiges.isLast(plugin.getPermissions(), player)) {
return getPlaceholder("highest-rank"); return getPlaceholder("highest-rank");
} }
return orElse(prestige, Prestige::getNext, prestiges.getFirst().getNext()); return orElse(prestige, Prestige::getNext, prestiges.getFirst().getNext());
case "prestige_money": case "prestige_money":
requirePrestiging(prestiges, params); requirePrestiging(prestiges, params);
return String.valueOf(simplify(orElse(prestige, r -> r.isIn(player) ? r.getRequirement(player, "money").getValueDouble() : 0, 0))); return String.valueOf(simplify(orElse(prestige, r -> r.isIn(player) ? r.getRequirement(player, "money").getValueDouble() : 0, 0)));
case "prestige_money_formatted": case "prestige_money_formatted":
requirePrestiging(prestiges, params); requirePrestiging(prestiges, params);
return plugin.formatMoney(orElse(prestige, r -> r.isIn(player) ? r.getRequirement(player, "money").getValueDouble() : 0, 0D)); return plugin.formatMoney(orElse(prestige, r -> r.isIn(player) ? r.getRequirement(player, "money").getValueDouble() : 0, 0D));
case "current_rank": case "current_rank":
if (rankups.isLast(plugin.getPermissions(), player)) { if (rankups.isLast(plugin.getPermissions(), player)) {
return rankups.getLast(); return rankups.getLast();
} else if (rank == null) { } else if (rank == null) {
return getPlaceholder("not-in-ladder"); return getPlaceholder("not-in-ladder");
} else { } else {
return rank.getRank(); return rank.getRank();
} }
case "next_rank": case "next_rank":
if (rankups.isLast(plugin.getPermissions(), player)) { if (rankups.isLast(plugin.getPermissions(), player)) {
return getPlaceholder("highest-rank"); return getPlaceholder("highest-rank");
} }
return orElsePlaceholder(rank, r -> orElsePlaceholder(rank, Rank::getNext, "highest-rank"), "not-in-ladder"); return orElsePlaceholder(rank, r -> orElsePlaceholder(rank, Rank::getNext, "highest-rank"), "not-in-ladder");
case "money": case "money":
return String.valueOf(getMoney(player, rank)); return String.valueOf(getMoney(player, rank));
case "money_formatted": case "money_formatted":
return plugin.formatMoney(getMoney(player, rank).doubleValue()); return plugin.formatMoney(getMoney(player, rank).doubleValue());
case "money_left": case "money_left":
return String.valueOf(Math.max(0, orElse(rank, r -> simplify(plugin.getEconomy().getBalance(player) - r.getRequirement(player, "money").getValueDouble()), 0).doubleValue())); return String.valueOf(Math.max(0, orElse(rank, r -> simplify(plugin.getEconomy().getBalance(player) - r.getRequirement(player, "money").getValueDouble()), 0).doubleValue()));
case "money_left_formatted": case "money_left_formatted":
return plugin.formatMoney(Math.max(0D, orElse(rank, r -> plugin.getEconomy().getBalance(player) - r.getRequirement(player, "money").getValueDouble(), 0D))); return plugin.formatMoney(Math.max(0D, orElse(rank, r -> plugin.getEconomy().getBalance(player) - r.getRequirement(player, "money").getValueDouble(), 0D)));
case "percent_left": case "percent_left":
return String.valueOf(Math.max(0D, orElse(rank, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue())); return String.valueOf(Math.max(0D, orElse(rank, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue()));
case "percent_left_formatted": case "percent_left_formatted":
return placeholders.getPercentFormat().format(Math.max(0D, orElse(rank, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue())); return placeholders.getPercentFormat().format(Math.max(0D, orElse(rank, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue()));
case "percent_done": case "percent_done":
return String.valueOf(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue())); return String.valueOf(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue()));
case "percent_done_formatted": case "percent_done_formatted":
return placeholders.getPercentFormat().format(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue())); return placeholders.getPercentFormat().format(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue()));
case "prestige_percent_left_formatted": case "prestige_percent_left_formatted":
return placeholders.getPercentFormat().format(Math.max(0D, orElse(prestige, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue())); return placeholders.getPercentFormat().format(Math.max(0D, orElse(prestige, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble())) * 100, 0).doubleValue()));
case "prestige_percent_done_formatted": case "prestige_percent_done_formatted":
return placeholders.getPercentFormat().format(Math.min(100D, orElse(prestige, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue())); return placeholders.getPercentFormat().format(Math.min(100D, orElse(prestige, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement(player, "money").getValueDouble()) * 100, 0).doubleValue()));
default: default:
return null; return null;
} }
} }
private Number getMoney(Player player, Rank rank) { private Number getMoney(Player player, Rank rank) {
return orElse(rank, r -> simplify(r.getRequirement(player, "money").getValueDouble()), 0); return orElse(rank, r -> simplify(r.getRequirement(player, "money").getValueDouble()), 0);
} }
private void requirePrestiging(Prestiges prestiges, String params) { private void requirePrestiging(Prestiges prestiges, String params) {
Objects.requireNonNull(prestiges, "Using %rankup_" + params + "% prestige placeholder but prestiging is disabled."); Objects.requireNonNull(prestiges, "Using %rankup_" + params + "% prestige placeholder but prestiging is disabled.");
} }
private String getPlaceholderRequirement(Player player, Rank rank, String requirementName, String params) { private String getPlaceholderRequirement(Player player, Rank rank, String requirementName, String params) {
if (rank == null) { if (rank == null) {
return ""; return "";
} }
Requirement requirement = rank.getRequirement(player, requirementName); Requirement requirement = rank.getRequirement(player, requirementName);
switch (params) { switch (params) {
case "": case "":
return orElse(requirement, Requirement::getValueString, "0"); return orElse(requirement, Requirement::getValueString, "0");
case "left": case "left":
return placeholders.getSimpleFormat().format(orElse(requirement, r -> r.getRemaining(player), 0)); return placeholders.getSimpleFormat().format(orElse(requirement, r -> r.getRemaining(player), 0));
case "done": case "done":
return placeholders.getSimpleFormat().format(orElse(requirement, r -> r.getValueDouble() - r.getRemaining(player), 0)); return placeholders.getSimpleFormat().format(orElse(requirement, r -> r.getValueDouble() - r.getRemaining(player), 0));
case "percent_left": case "percent_left":
return placeholders.getPercentFormat().format(orElse(requirement, r -> (r.getRemaining(player) / r.getValueDouble()) * 100, 0)); return placeholders.getPercentFormat().format(orElse(requirement, r -> (r.getRemaining(player) / r.getValueDouble()) * 100, 0));
case "percent_done": case "percent_done":
return placeholders.getPercentFormat().format(orElse(requirement, r -> (1 - (r.getRemaining(player) / r.getValueDouble())) * 100, 100)); return placeholders.getPercentFormat().format(orElse(requirement, r -> (1 - (r.getRemaining(player) / r.getValueDouble())) * 100, 100));
default: default:
return null; return null;
} }
} }
private Number simplify(Number number) { private Number simplify(Number number) {
if (number instanceof Float) { if (number instanceof Float) {
return (float) number % 1 == 0 ? number.intValue() : number; return (float) number % 1 == 0 ? number.intValue() : number;
} else if (number instanceof Double) { } else if (number instanceof Double) {
return (double) number % 1 == 0 ? number.longValue() : number; return (double) number % 1 == 0 ? number.longValue() : number;
} else { } else {
return number; return number;
} }
} }
private <T> String orElsePlaceholder(T t, Function<T, Object> value, Object fallback) { private <T> String orElsePlaceholder(T t, Function<T, Object> value, Object fallback) {
if (t == null) { if (t == null) {
return getPlaceholder(String.valueOf(fallback)); return getPlaceholder(String.valueOf(fallback));
} }
try { try {
return String.valueOf(value.apply(t)); return String.valueOf(value.apply(t));
} catch (NullPointerException ex) { } catch (NullPointerException ex) {
return getPlaceholder(String.valueOf(fallback)); return getPlaceholder(String.valueOf(fallback));
} }
} }
private <T, R> R orElse(T t, Function<T, R> value, R fallback) { private <T, R> R orElse(T t, Function<T, R> value, R fallback) {
if (t == null) { if (t == null) {
return fallback; return fallback;
} }
try { try {
return value.apply(t); return value.apply(t);
} catch (NullPointerException ex) { } catch (NullPointerException ex) {
return fallback; return fallback;
} }
} }
private String replacePattern(String string) { private String replacePattern(String string) {
Matcher matcher = PATTERN.matcher(string); Matcher matcher = PATTERN.matcher(string);
if (matcher.matches()) { if (matcher.matches()) {
return matcher.group(1) + "#" + matcher.group(2).replace("-", "_"); return matcher.group(1) + "#" + matcher.group(2).replace("-", "_");
} else { } else {
return string; return string;
} }
} }
private String getPlaceholder(String name) { private String getPlaceholder(String name) {
return plugin.getConfig().getString("placeholders." + name); return plugin.getConfig().getString("placeholders." + name);
} }
@Override @Override
public String getIdentifier() { public String getIdentifier() {
return "rankup"; return "rankup";
} }
@Override @Override
public String getAuthor() { public String getAuthor() {
return String.join(", ", plugin.getDescription().getAuthors()); return String.join(", ", plugin.getDescription().getAuthors());
} }
@Override @Override
public String getVersion() { public String getVersion() {
return plugin.getDescription().getVersion(); return plugin.getDescription().getVersion();
} }
@Override @Override
public boolean persist() { public boolean persist() {
return true; return true;
} }
@Override @Override
public boolean canRegister() { public boolean canRegister() {
return true; return true;
} }
} }
@@ -1,79 +1,79 @@
package sh.okx.rankup.prestige; package sh.okx.rankup.prestige;
import lombok.EqualsAndHashCode; import lombok.EqualsAndHashCode;
import lombok.Getter; import lombok.Getter;
import lombok.ToString; import lombok.ToString;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rank;
import sh.okx.rankup.ranks.requirements.ListRankRequirements; import sh.okx.rankup.ranks.requirements.ListRankRequirements;
import sh.okx.rankup.ranks.requirements.RankRequirements; import sh.okx.rankup.ranks.requirements.RankRequirements;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
@EqualsAndHashCode(callSuper = true) @EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true) @ToString(callSuper = true)
public class Prestige extends Rank { public class Prestige extends Rank {
@Getter @Getter
private final String from; private final String from;
@Getter @Getter
private final String to; private final String to;
private Prestige(ConfigurationSection section, RankupPlugin plugin, String next, String rank, RankRequirements requirements, List<String> commands, String from, String to) { private Prestige(ConfigurationSection section, RankupPlugin plugin, String next, String rank, RankRequirements requirements, List<String> commands, String from, String to) {
super(section, plugin, next, rank, requirements, commands); super(section, plugin, next, rank, requirements, commands);
this.from = from; this.from = from;
this.to = to; this.to = to;
} }
public static Prestige deserialize(RankupPlugin plugin, ConfigurationSection section) { public static Prestige deserialize(RankupPlugin plugin, ConfigurationSection section) {
List<String> requirementsList = section.getStringList("requirements"); List<String> requirementsList = section.getStringList("requirements");
Set<Requirement> requirements = plugin.getRequirements().getRequirements(requirementsList); Set<Requirement> requirements = plugin.getRequirements().getRequirements(requirementsList);
return new Prestige(section, plugin, return new Prestige(section, plugin,
section.getString("next"), section.getString("next"),
section.getString("rank"), section.getString("rank"),
new ListRankRequirements(requirements), new ListRankRequirements(requirements),
section.getStringList("commands"), section.getStringList("commands"),
section.getString("from"), section.getString("from"),
section.getString("to")); section.getString("to"));
} }
@Override @Override
public boolean isIn(Player player) { public boolean isIn(Player player) {
// first prestige does not have a rank // first prestige does not have a rank
boolean inFrom = plugin.getPermissions().inGroup(player.getUniqueId(), from); boolean inFrom = plugin.getPermissions().inGroup(player.getUniqueId(), from);
if (rank == null && inFrom) { if (rank == null && inFrom) {
// not in any other prestiges // not in any other prestiges
for (Prestige prestige : plugin.getPrestiges().getOrderedList()) { for (Prestige prestige : plugin.getPrestiges().getOrderedList()) {
if (prestige != this && prestige.isIn(player)) { if (prestige != this && prestige.isIn(player)) {
return false; return false;
} }
} }
return true; return true;
} }
if (rank == null) { if (rank == null) {
return false; return false;
} }
// subsequent prestiges // subsequent prestiges
boolean inRank = plugin.getPermissions().inGroup(player.getUniqueId(), rank); boolean inRank = plugin.getPermissions().inGroup(player.getUniqueId(), rank);
if (inRank) { if (inRank) {
return true; return true;
} }
return false; return false;
} }
public boolean isEligable(Player player) { public boolean isEligable(Player player) {
return plugin.getPermissions().inGroup(player.getUniqueId(), from); return plugin.getPermissions().inGroup(player.getUniqueId(), from);
} }
@Override @Override
public boolean isLast() { public boolean isLast() {
return plugin.getPrestiges().getByName(next) == null; return plugin.getPrestiges().getByName(next) == null;
} }
} }
@@ -1,22 +1,22 @@
package sh.okx.rankup.prestige; package sh.okx.rankup.prestige;
import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.FileConfiguration;
import sh.okx.rankup.RankList; import sh.okx.rankup.RankList;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
public class Prestiges extends RankList<Prestige> { public class Prestiges extends RankList<Prestige> {
public Prestiges(RankupPlugin plugin, FileConfiguration config) { public Prestiges(RankupPlugin plugin, FileConfiguration config) {
super(config, section -> Prestige.deserialize(plugin, section)); super(config, section -> Prestige.deserialize(plugin, section));
} }
@Override @Override
public Prestige getFirst() { public Prestige getFirst() {
for (Prestige prestige : ranks) { for (Prestige prestige : ranks) {
if (prestige.getRank() == null) { if (prestige.getRank() == null) {
return prestige; return prestige;
} }
} }
throw new IllegalStateException("No prestige found for first prestige (first prestige is counted as a prestige without a rank set). " + throw new IllegalStateException("No prestige found for first prestige (first prestige is counted as a prestige without a rank set). " +
"Disable prestiges in config.yml if you don't want any."); "Disable prestiges in config.yml if you don't want any.");
} }
} }
+63 -63
View File
@@ -1,63 +1,63 @@
package sh.okx.rankup.ranks; package sh.okx.rankup.ranks;
import java.util.List; import java.util.List;
import lombok.AccessLevel; import lombok.AccessLevel;
import lombok.EqualsAndHashCode; import lombok.EqualsAndHashCode;
import lombok.Getter; import lombok.Getter;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.ToString; import lombok.ToString;
import me.clip.placeholderapi.PlaceholderAPI; import me.clip.placeholderapi.PlaceholderAPI;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.messages.MessageBuilder; import sh.okx.rankup.messages.MessageBuilder;
import sh.okx.rankup.ranks.requirements.RankRequirements; import sh.okx.rankup.ranks.requirements.RankRequirements;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
@EqualsAndHashCode @EqualsAndHashCode
@ToString @ToString
@RequiredArgsConstructor(access = AccessLevel.PROTECTED) @RequiredArgsConstructor(access = AccessLevel.PROTECTED)
public class Rank { public class Rank {
@Getter @Getter
protected final ConfigurationSection section; protected final ConfigurationSection section;
protected final RankupPlugin plugin; protected final RankupPlugin plugin;
@Getter @Getter
protected final String next; protected final String next;
@Getter @Getter
protected final String rank; protected final String rank;
@Getter @Getter
protected final RankRequirements requirements; protected final RankRequirements requirements;
protected final List<String> commands; protected final List<String> commands;
public boolean isIn(Player player) { public boolean isIn(Player player) {
return plugin.getPermissions().inGroup(player.getUniqueId(), rank); return plugin.getPermissions().inGroup(player.getUniqueId(), rank);
} }
public boolean isLast() { public boolean isLast() {
return plugin.getRankups().getByName(next) == null; return plugin.getRankups().getByName(next) == null;
} }
public boolean hasRequirements(Player player) { public boolean hasRequirements(Player player) {
return requirements.hasRequirements(player); return requirements.hasRequirements(player);
} }
public Requirement getRequirement(Player player, String name) { public Requirement getRequirement(Player player, String name) {
return requirements.getRequirement(player, name); return requirements.getRequirement(player, name);
} }
public void applyRequirements(Player player) { public void applyRequirements(Player player) {
requirements.applyRequirements(player); requirements.applyRequirements(player);
} }
public void runCommands(Player player) { public void runCommands(Player player) {
for (String command : commands) { for (String command : commands) {
String string = new MessageBuilder(command).replaceRanks(player, this, next).toString(); String string = new MessageBuilder(command).replaceRanks(player, this, next).toString();
if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) {
string = PlaceholderAPI.setPlaceholders(player, string); string = PlaceholderAPI.setPlaceholders(player, string);
} }
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), string); Bukkit.dispatchCommand(Bukkit.getConsoleSender(), string);
} }
} }
} }
+32 -32
View File
@@ -1,32 +1,32 @@
package sh.okx.rankup.ranks; package sh.okx.rankup.ranks;
import java.util.List; import java.util.List;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.ranks.requirements.RankRequirements; import sh.okx.rankup.ranks.requirements.RankRequirements;
import sh.okx.rankup.ranks.requirements.RankRequirementsFactory; import sh.okx.rankup.ranks.requirements.RankRequirementsFactory;
public class Rankup extends Rank { public class Rankup extends Rank {
public static Rank deserialize(RankupPlugin plugin, ConfigurationSection section) { public static Rank deserialize(RankupPlugin plugin, ConfigurationSection section) {
String next = section.getString("next"); String next = section.getString("next");
String rank = section.getString("rank"); String rank = section.getString("rank");
if (next != null && next.isEmpty()) { if (next != null && next.isEmpty()) {
plugin.getLogger().warning("Rankup section '" + section.getName() + "' has a blank 'next' field, will be ignored."); plugin.getLogger().warning("Rankup section '" + section.getName() + "' has a blank 'next' field, will be ignored.");
return null; return null;
} }
return new Rank(section, plugin, return new Rank(section, plugin,
next, next,
rank, rank,
RankRequirementsFactory.getRequirements(plugin, section), RankRequirementsFactory.getRequirements(plugin, section),
section.getStringList("commands")); section.getStringList("commands"));
} }
protected Rankup(ConfigurationSection section, protected Rankup(ConfigurationSection section,
RankupPlugin plugin, String next, String rank, RankupPlugin plugin, String next, String rank,
RankRequirements requirements, RankRequirements requirements,
List<String> commands) { List<String> commands) {
super(section, plugin, next, rank, requirements, commands); super(section, plugin, next, rank, requirements, commands);
} }
} }
+11 -11
View File
@@ -1,11 +1,11 @@
package sh.okx.rankup.ranks; package sh.okx.rankup.ranks;
import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.FileConfiguration;
import sh.okx.rankup.RankList; import sh.okx.rankup.RankList;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
public class Rankups extends RankList<Rank> { public class Rankups extends RankList<Rank> {
public Rankups(RankupPlugin plugin, FileConfiguration config) { public Rankups(RankupPlugin plugin, FileConfiguration config) {
super(config, section -> Rankup.deserialize(plugin, section)); super(config, section -> Rankup.deserialize(plugin, section));
} }
} }
@@ -1,48 +1,48 @@
package sh.okx.rankup.ranks.requirements; package sh.okx.rankup.ranks.requirements;
import java.util.Set; import java.util.Set;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.requirements.DeductibleRequirement; import sh.okx.rankup.requirements.DeductibleRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class ListRankRequirements implements RankRequirements { public class ListRankRequirements implements RankRequirements {
private final Set<Requirement> requirements; private final Set<Requirement> requirements;
public ListRankRequirements(Set<Requirement> requirements) { public ListRankRequirements(Set<Requirement> requirements) {
this.requirements = requirements; this.requirements = requirements;
} }
@Override @Override
public Set<Requirement> getRequirements(Player player) { public Set<Requirement> getRequirements(Player player) {
return requirements; return requirements;
} }
@Override @Override
public boolean hasRequirements(Player player) { public boolean hasRequirements(Player player) {
for (Requirement requirement : requirements) { for (Requirement requirement : requirements) {
if (!requirement.check(player)) { if (!requirement.check(player)) {
return false; return false;
} }
} }
return true; return true;
} }
@Override @Override
public Requirement getRequirement(Player player, String name) { public Requirement getRequirement(Player player, String name) {
for (Requirement requirement : requirements) { for (Requirement requirement : requirements) {
if (requirement.getFullName().equalsIgnoreCase(name)) { if (requirement.getFullName().equalsIgnoreCase(name)) {
return requirement; return requirement;
} }
} }
return null; return null;
} }
@Override @Override
public void applyRequirements(Player player) { public void applyRequirements(Player player) {
for (Requirement requirement : requirements) { for (Requirement requirement : requirements) {
if (requirement instanceof DeductibleRequirement) { if (requirement instanceof DeductibleRequirement) {
((DeductibleRequirement) requirement).apply(player); ((DeductibleRequirement) requirement).apply(player);
} }
} }
} }
} }
@@ -1,63 +1,63 @@
package sh.okx.rankup.ranks.requirements; package sh.okx.rankup.ranks.requirements;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.Set; import java.util.Set;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestige;
import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.prestige.Prestiges;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class PrestigeListRankRequirements implements RankRequirements { public class PrestigeListRankRequirements implements RankRequirements {
private final RankupPlugin plugin; private final RankupPlugin plugin;
private final RankRequirements defaultRequirements; private final RankRequirements defaultRequirements;
private final Map<String, RankRequirements> requirements; private final Map<String, RankRequirements> requirements;
public PrestigeListRankRequirements(RankupPlugin plugin, RankRequirements defaultRequirements, Map<String, RankRequirements> requirements) { public PrestigeListRankRequirements(RankupPlugin plugin, RankRequirements defaultRequirements, Map<String, RankRequirements> requirements) {
Objects.requireNonNull(plugin); Objects.requireNonNull(plugin);
Objects.requireNonNull(defaultRequirements); Objects.requireNonNull(defaultRequirements);
this.plugin = plugin; this.plugin = plugin;
this.defaultRequirements = defaultRequirements; this.defaultRequirements = defaultRequirements;
this.requirements = requirements; this.requirements = requirements;
} }
@Override @Override
public Set<Requirement> getRequirements(Player player) { public Set<Requirement> getRequirements(Player player) {
return getRankRequirements(player).getRequirements(player); return getRankRequirements(player).getRequirements(player);
} }
@Override @Override
public boolean hasRequirements(Player player) { public boolean hasRequirements(Player player) {
return getRankRequirements(player).hasRequirements(player); return getRankRequirements(player).hasRequirements(player);
} }
@Override @Override
public Requirement getRequirement(Player player, String name) { public Requirement getRequirement(Player player, String name) {
return getRankRequirements(player).getRequirement(player, name); return getRankRequirements(player).getRequirement(player, name);
} }
@Override @Override
public void applyRequirements(Player player) { public void applyRequirements(Player player) {
getRankRequirements(player).applyRequirements(player); getRankRequirements(player).applyRequirements(player);
} }
private RankRequirements getRankRequirements(Player player) { private RankRequirements getRankRequirements(Player player) {
Prestiges prestiges = plugin.getPrestiges(); Prestiges prestiges = plugin.getPrestiges();
if (player == null || prestiges == null) { if (player == null || prestiges == null) {
return defaultRequirements; return defaultRequirements;
} }
for (Prestige prestige : prestiges.getOrderedList()) { for (Prestige prestige : prestiges.getOrderedList()) {
String next = prestige.getNext(); String next = prestige.getNext();
if(plugin.getPermissions().inGroup(player.getUniqueId(), next)) { if(plugin.getPermissions().inGroup(player.getUniqueId(), next)) {
RankRequirements rankRequirements = this.requirements.get(next.toLowerCase()); RankRequirements rankRequirements = this.requirements.get(next.toLowerCase());
if (rankRequirements != null) { if (rankRequirements != null) {
return rankRequirements; return rankRequirements;
} }
} }
} }
return defaultRequirements; return defaultRequirements;
} }
} }
@@ -1,13 +1,13 @@
package sh.okx.rankup.ranks.requirements; package sh.okx.rankup.ranks.requirements;
import java.util.Set; import java.util.Set;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public interface RankRequirements { public interface RankRequirements {
Set<Requirement> getRequirements(Player player); Set<Requirement> getRequirements(Player player);
boolean hasRequirements(Player player); boolean hasRequirements(Player player);
Requirement getRequirement(Player player, String name); Requirement getRequirement(Player player, String name);
void applyRequirements(Player player); void applyRequirements(Player player);
} }
@@ -1,72 +1,72 @@
package sh.okx.rankup.ranks.requirements; package sh.okx.rankup.ranks.requirements;
import java.util.Collection; import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.ConfigurationSection;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class RankRequirementsFactory { public class RankRequirementsFactory {
private static final String REQUIREMENTS = "requirements"; private static final String REQUIREMENTS = "requirements";
public static RankRequirements getRequirements(RankupPlugin plugin, ConfigurationSection section) { public static RankRequirements getRequirements(RankupPlugin plugin, ConfigurationSection section) {
if (section.isConfigurationSection(REQUIREMENTS)) { if (section.isConfigurationSection(REQUIREMENTS)) {
return getPrestigeListRequirements(plugin, section.getConfigurationSection(REQUIREMENTS)); return getPrestigeListRequirements(plugin, section.getConfigurationSection(REQUIREMENTS));
} else { } else {
return getListRequirements(plugin, getRequirementStrings(section, REQUIREMENTS)); return getListRequirements(plugin, getRequirementStrings(section, REQUIREMENTS));
} }
} }
private static Collection<String> getRequirementStrings(ConfigurationSection section, String key) { private static Collection<String> getRequirementStrings(ConfigurationSection section, String key) {
if (section.isList(key)) { if (section.isList(key)) {
return section.getStringList(key); return section.getStringList(key);
} else { } else {
String string = section.getString(key); String string = section.getString(key);
if (string == null) { if (string == null) {
return null; return null;
} else { } else {
return Collections.singleton(string); return Collections.singleton(string);
} }
} }
} }
private static Set<Requirement> stringsToRequirements(RankupPlugin plugin, Iterable<String> strings) { private static Set<Requirement> stringsToRequirements(RankupPlugin plugin, Iterable<String> strings) {
return plugin.getRequirements().getRequirements(strings); return plugin.getRequirements().getRequirements(strings);
} }
private static RankRequirements getListRequirements(RankupPlugin plugin, Iterable<String> list) { private static RankRequirements getListRequirements(RankupPlugin plugin, Iterable<String> list) {
Set<Requirement> requirements = stringsToRequirements(plugin, list); Set<Requirement> requirements = stringsToRequirements(plugin, list);
return new ListRankRequirements(requirements); return new ListRankRequirements(requirements);
} }
private static RankRequirements getPrestigeListRequirements(RankupPlugin plugin, ConfigurationSection section) { private static RankRequirements getPrestigeListRequirements(RankupPlugin plugin, ConfigurationSection section) {
if (plugin.getPrestiges() == null) { if (plugin.getPrestiges() == null) {
// don't know what to do here // don't know what to do here
return null; return null;
} }
RankRequirements defaultRequirements = null; RankRequirements defaultRequirements = null;
Map<String, RankRequirements> requirements = new HashMap<>(); Map<String, RankRequirements> requirements = new HashMap<>();
for (String key : section.getKeys(false)) { for (String key : section.getKeys(false)) {
Collection<String> stringRequirements = getRequirementStrings(section, key); Collection<String> stringRequirements = getRequirementStrings(section, key);
if (stringRequirements != null) { if (stringRequirements != null) {
RankRequirements rankRequirements = getListRequirements(plugin, stringRequirements); RankRequirements rankRequirements = getListRequirements(plugin, stringRequirements);
if ("default".equalsIgnoreCase(key)) { if ("default".equalsIgnoreCase(key)) {
defaultRequirements = rankRequirements; defaultRequirements = rankRequirements;
} else { } else {
requirements.put(key.toLowerCase(), rankRequirements); requirements.put(key.toLowerCase(), rankRequirements);
} }
} }
} }
if (defaultRequirements == null) { if (defaultRequirements == null) {
throw new IllegalArgumentException("No default requirements set for rank " + section.getParent().getName() + ". See the wiki for info."); throw new IllegalArgumentException("No default requirements set for rank " + section.getParent().getName() + ". See the wiki for info.");
} }
return new PrestigeListRankRequirements(plugin, defaultRequirements, requirements); return new PrestigeListRankRequirements(plugin, defaultRequirements, requirements);
} }
} }
@@ -1,20 +1,22 @@
package sh.okx.rankup.requirements; package sh.okx.rankup.requirements;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
public interface DeductibleRequirement { public interface DeductibleRequirement {
/** /**
* Apply the effect of this requirement to the player. * Apply the effect of this requirement to the player.
* For money, this could be taking money away from the player. * For money, this could be taking money away from the player.
* You can assume that <code>Requirement#check(Player)</code> has been called, * You can assume that <code>Requirement#check(Player)</code> has been called,
* and has returned true immediately prior to this. * and has returned true immediately prior to this.
* *
* @param player the player to take from * Currently the multiplier will always be 1, but that may change in the future.
* @param multiplier The multiplier for the value *
*/ * @param player the player to take from
void apply(Player player, double multiplier); * @param multiplier The multiplier for the value
*/
default void apply(Player player) { void apply(Player player, double multiplier);
apply(player, 1);
} default void apply(Player player) {
} apply(player, 1);
}
}
@@ -1,34 +1,34 @@
package sh.okx.rankup.requirements; package sh.okx.rankup.requirements;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
public abstract class ProgressiveRequirement extends Requirement { public abstract class ProgressiveRequirement extends Requirement {
public ProgressiveRequirement(RankupPlugin plugin, String name) { public ProgressiveRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
public ProgressiveRequirement(RankupPlugin plugin, String name, boolean subRequirement) { public ProgressiveRequirement(RankupPlugin plugin, String name, boolean subRequirement) {
super(plugin, name, subRequirement); super(plugin, name, subRequirement);
} }
protected ProgressiveRequirement(Requirement clone) { protected ProgressiveRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
return getRemaining(player) <= 0; return getRemaining(player) <= 0;
} }
@Override @Override
public final double getRemaining(Player player) { public final double getRemaining(Player player) {
return getRemaining(player, 1); return getRemaining(player, 1);
} }
public double getRemaining(Player player, double multiplier) { public double getRemaining(Player player, double multiplier) {
return Math.max(0, (multiplier * getTotal(player)) - getProgress(player)); return Math.max(0, (multiplier * getTotal(player)) - getProgress(player));
} }
public abstract double getProgress(Player player); public abstract double getProgress(Player player);
} }
@@ -1,104 +1,104 @@
package sh.okx.rankup.requirements; package sh.okx.rankup.requirements;
import lombok.Getter; import lombok.Getter;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
public abstract class Requirement implements Cloneable { public abstract class Requirement implements Cloneable {
protected final RankupPlugin plugin; protected final RankupPlugin plugin;
@Getter @Getter
protected final String name; protected final String name;
private String value; private String value;
@Getter @Getter
private String sub; private String sub;
private boolean subRequirement; private boolean subRequirement;
public Requirement(RankupPlugin plugin, String name) { public Requirement(RankupPlugin plugin, String name) {
this(plugin, name, false); this(plugin, name, false);
} }
public Requirement(RankupPlugin plugin, String name, boolean subRequirement) { public Requirement(RankupPlugin plugin, String name, boolean subRequirement) {
this.plugin = plugin; this.plugin = plugin;
this.name = name; this.name = name;
this.subRequirement = subRequirement; this.subRequirement = subRequirement;
} }
protected Requirement(Requirement clone) { protected Requirement(Requirement clone) {
this.plugin = clone.plugin; this.plugin = clone.plugin;
this.name = clone.name; this.name = clone.name;
this.value = clone.value; this.value = clone.value;
this.sub = clone.sub; this.sub = clone.sub;
this.subRequirement = clone.subRequirement; this.subRequirement = clone.subRequirement;
} }
public void setValue(String value) { public void setValue(String value) {
if (hasSubRequirement()) { if (hasSubRequirement()) {
String[] parts = value.split(" ", 2); String[] parts = value.split(" ", 2);
if (parts.length < 2) { if (parts.length < 2) {
throw new IllegalArgumentException("Amount and sub-requirement not present for requirement '" + getName() + "'. You must use the format '" + getName() + " <sub-requirement> <amount>'"); throw new IllegalArgumentException("Amount and sub-requirement not present for requirement '" + getName() + "'. You must use the format '" + getName() + " <sub-requirement> <amount>'");
} }
this.sub = parts[0]; this.sub = parts[0];
this.value = parts[1]; this.value = parts[1];
} else { } else {
this.value = value; this.value = value;
} }
} }
public String getValueString() { public String getValueString() {
return value; return value;
} }
public String[] getValuesString() { public String[] getValuesString() {
return value.split(" "); return value.split(" ");
} }
public double getValueDouble() { public double getValueDouble() {
return Double.parseDouble(value); return Double.parseDouble(value);
} }
public int getValueInt() { public int getValueInt() {
return Integer.parseInt(value); return Integer.parseInt(value);
} }
public boolean getValueBoolean() { public boolean getValueBoolean() {
return Boolean.parseBoolean(value); return Boolean.parseBoolean(value);
} }
public String getFullName() { public String getFullName() {
if (hasSubRequirement()) { if (hasSubRequirement()) {
return name + "#" + sub; return name + "#" + sub;
} else { } else {
return name; return name;
} }
} }
/** /**
* Check if a player meets this requirement * Check if a player meets this requirement
* *
* @param player the player to check * @param player the player to check
* @return true if they meet the requirement, false otherwise * @return true if they meet the requirement, false otherwise
*/ */
public abstract boolean check(Player player); public abstract boolean check(Player player);
/** /**
* Get the remaining amount needed for <code>Requirement#check(Player)</code> to yield true. * Get the remaining amount needed for <code>Requirement#check(Player)</code> to yield true.
* This is not required and is only used in placeholders. * This is not required and is only used in placeholders.
* *
* @param player the player to find the remaining amount of * @param player the player to find the remaining amount of
* @return the remaining amount needed. Should be non-negative. * @return the remaining amount needed. Should be non-negative.
*/ */
public double getRemaining(Player player) { public double getRemaining(Player player) {
return check(player) ? 0 : 1; return check(player) ? 0 : 1;
} }
public final boolean hasSubRequirement() { public final boolean hasSubRequirement() {
return subRequirement; return subRequirement;
} }
public abstract Requirement clone(); public abstract Requirement clone();
public double getTotal(Player player) { public double getTotal(Player player) {
return getValueDouble(); return getValueDouble();
} }
} }
@@ -1,49 +1,49 @@
package sh.okx.rankup.requirements; package sh.okx.rankup.requirements;
import java.util.Collections; import java.util.Collections;
import java.util.HashSet; import java.util.HashSet;
import java.util.Objects; import java.util.Objects;
import java.util.Set; import java.util.Set;
public class RequirementRegistry { public class RequirementRegistry {
private Set<Requirement> requirements = new HashSet<>(); private Set<Requirement> requirements = new HashSet<>();
public void addRequirement(Requirement requirement) { public void addRequirement(Requirement requirement) {
requirements.add(requirement); requirements.add(requirement);
} }
public void addRequirements(Requirement... requirements) { public void addRequirements(Requirement... requirements) {
Collections.addAll(this.requirements, requirements); Collections.addAll(this.requirements, requirements);
} }
public Requirement newRequirement(String name, String value) { public Requirement newRequirement(String name, String value) {
for (Requirement requirement : requirements) { for (Requirement requirement : requirements) {
if (requirement.getName().equalsIgnoreCase(name)) { if (requirement.getName().equalsIgnoreCase(name)) {
Requirement newRequirement = requirement.clone(); Requirement newRequirement = requirement.clone();
newRequirement.setValue(value); newRequirement.setValue(value);
return newRequirement; return newRequirement;
} }
} }
return null; return null;
} }
public Set<Requirement> getRequirements(Iterable<String> list) { public Set<Requirement> getRequirements(Iterable<String> list) {
Set<Requirement> requirements = new HashSet<>(); Set<Requirement> requirements = new HashSet<>();
for (String req : list) { for (String req : list) {
String[] parts = req.split(" ", 2); String[] parts = req.split(" ", 2);
if (parts.length < 2) { if (parts.length < 2) {
throw new IllegalArgumentException("For requirement: '" + req + "'. Requirements must contain a space between" + throw new IllegalArgumentException("For requirement: '" + req + "'. Requirements must contain a space between" +
" the name of the requirement and the value of the requirement. If it already looks like it has a space, " + " the name of the requirement and the value of the requirement. If it already looks like it has a space, " +
"make sure it is not a tab or has an invisible character."); "make sure it is not a tab or has an invisible character.");
} }
String name = parts[0]; String name = parts[0];
String value = parts[1]; String value = parts[1];
Requirement requirement = newRequirement(name, value); Requirement requirement = newRequirement(name, value);
Objects.requireNonNull(requirement, name.equalsIgnoreCase("money") ? "The 'money' requirement is being used but no economy is found" : "Unknown requirement: " + name); Objects.requireNonNull(requirement, name.equalsIgnoreCase("money") ? "The 'money' requirement is being used but no economy is found" : "Unknown requirement: " + name);
requirements.add(requirement); requirements.add(requirement);
} }
return requirements; return requirements;
} }
} }
@@ -1,26 +1,26 @@
package sh.okx.rankup.requirements; package sh.okx.rankup.requirements;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.requirement.XpLevelRequirement; import sh.okx.rankup.requirements.requirement.XpLevelRequirement;
public class XpLevelDeductibleRequirement extends XpLevelRequirement implements DeductibleRequirement { public class XpLevelDeductibleRequirement extends XpLevelRequirement implements DeductibleRequirement {
public XpLevelDeductibleRequirement(RankupPlugin plugin, String name) { public XpLevelDeductibleRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
private XpLevelDeductibleRequirement(XpLevelDeductibleRequirement clone) { private XpLevelDeductibleRequirement(XpLevelDeductibleRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public void apply(Player player, double multiplier) { public void apply(Player player, double multiplier) {
player.setLevel(player.getLevel() - (int) Math.round(getValueInt() * multiplier)); player.setLevel(player.getLevel() - (int) Math.round(getValueInt() * multiplier));
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new XpLevelDeductibleRequirement(this); return new XpLevelDeductibleRequirement(this);
} }
} }
@@ -1,32 +1,32 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class BlockBreakRequirement extends ProgressiveRequirement { public class BlockBreakRequirement extends ProgressiveRequirement {
public BlockBreakRequirement(RankupPlugin plugin) { public BlockBreakRequirement(RankupPlugin plugin) {
super(plugin, "block-break", true); super(plugin, "block-break", true);
} }
protected BlockBreakRequirement(BlockBreakRequirement clone) { protected BlockBreakRequirement(BlockBreakRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
Material material = Material.matchMaterial(getSub()); Material material = Material.matchMaterial(getSub());
if (material == null || !material.isBlock()) { if (material == null || !material.isBlock()) {
throw new IllegalArgumentException("'" + getSub() + "' is not a valid block"); throw new IllegalArgumentException("'" + getSub() + "' is not a valid block");
} }
return player.getStatistic(Statistic.MINE_BLOCK, material); return player.getStatistic(Statistic.MINE_BLOCK, material);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new BlockBreakRequirement(this); return new BlockBreakRequirement(this);
} }
} }
@@ -1,32 +1,32 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class CraftItemRequirement extends ProgressiveRequirement { public class CraftItemRequirement extends ProgressiveRequirement {
public CraftItemRequirement(RankupPlugin plugin) { public CraftItemRequirement(RankupPlugin plugin) {
super(plugin, "craft-item", true); super(plugin, "craft-item", true);
} }
protected CraftItemRequirement(CraftItemRequirement clone) { protected CraftItemRequirement(CraftItemRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
Material material = Material.matchMaterial(getSub()); Material material = Material.matchMaterial(getSub());
if (material == null) { if (material == null) {
throw new IllegalArgumentException("'" + getSub() + "' is not a valid item"); throw new IllegalArgumentException("'" + getSub() + "' is not a valid item");
} }
return player.getStatistic(Statistic.CRAFT_ITEM, material); return player.getStatistic(Statistic.CRAFT_ITEM, material);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new CraftItemRequirement(this); return new CraftItemRequirement(this);
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class GroupRequirement extends Requirement { public class GroupRequirement extends Requirement {
public GroupRequirement(RankupPlugin plugin) { public GroupRequirement(RankupPlugin plugin) {
super(plugin, "group"); super(plugin, "group");
} }
protected GroupRequirement(Requirement clone) { protected GroupRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
for (String group : getValuesString()) { for (String group : getValuesString()) {
if (plugin.getPermissions().inGroup(player.getUniqueId(), group)) { if (plugin.getPermissions().inGroup(player.getUniqueId(), group)) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new GroupRequirement(this); return new GroupRequirement(this);
} }
} }
@@ -1,49 +1,49 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.DeductibleRequirement; import sh.okx.rankup.requirements.DeductibleRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class ItemDeductibleRequirement extends ItemRequirement implements DeductibleRequirement { public class ItemDeductibleRequirement extends ItemRequirement implements DeductibleRequirement {
public ItemDeductibleRequirement(RankupPlugin plugin, String name) { public ItemDeductibleRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
public ItemDeductibleRequirement(ItemDeductibleRequirement clone) { public ItemDeductibleRequirement(ItemDeductibleRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public void apply(Player player, double multiplier) { public void apply(Player player, double multiplier) {
int count = (int) (getTotal(player) * multiplier); int count = (int) (getTotal(player) * multiplier);
ItemStack[] contents = player.getInventory().getStorageContents(); ItemStack[] contents = player.getInventory().getStorageContents();
for (int i = 0; i < contents.length && count > 0; i++) { for (int i = 0; i < contents.length && count > 0; i++) {
ItemStack item = contents[i]; ItemStack item = contents[i];
if (matchItem(item)) { if (matchItem(item)) {
if (count < item.getAmount()) { if (count < item.getAmount()) {
item.setAmount(item.getAmount() - count); item.setAmount(item.getAmount() - count);
count = 0; count = 0;
} else { } else {
count -= item.getAmount(); count -= item.getAmount();
contents[i] = null; contents[i] = null;
} }
} }
} }
player.getInventory().setStorageContents(contents); player.getInventory().setStorageContents(contents);
if (count > 0) { if (count > 0) {
throw new IllegalStateException("REPORT THIS ERROR TO THE DEV - COULD NOT DEDUCT ALL ITEMS"); throw new IllegalStateException("REPORT THIS ERROR TO THE DEV - COULD NOT DEDUCT ALL ITEMS");
} }
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new ItemDeductibleRequirement(this); return new ItemDeductibleRequirement(this);
} }
} }
@@ -1,62 +1,62 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import java.util.Arrays; import java.util.Arrays;
public class ItemRequirement extends ProgressiveRequirement { public class ItemRequirement extends ProgressiveRequirement {
public ItemRequirement(RankupPlugin plugin, String name) { public ItemRequirement(RankupPlugin plugin, String name) {
super(plugin, name, true); super(plugin, name, true);
} }
protected ItemRequirement(ItemRequirement clone) { protected ItemRequirement(ItemRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new ItemRequirement(this); return new ItemRequirement(this);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return Arrays.stream(player.getInventory().getStorageContents()) return Arrays.stream(player.getInventory().getStorageContents())
.filter(this::matchItem) .filter(this::matchItem)
.mapToInt(ItemStack::getAmount).sum(); .mapToInt(ItemStack::getAmount).sum();
} }
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
protected boolean matchItem(ItemStack item) { protected boolean matchItem(ItemStack item) {
if (item == null) { if (item == null) {
return false; return false;
} }
String sub = getSub(); String sub = getSub();
String[] parts = sub.split(":"); String[] parts = sub.split(":");
Material material = Material.matchMaterial(parts[0]); Material material = Material.matchMaterial(parts[0]);
if (material == null) { if (material == null) {
throw new IllegalArgumentException("[item requirement] could not find material name: " + parts[0]); throw new IllegalArgumentException("[item requirement] could not find material name: " + parts[0]);
} }
if (parts.length > 1) { if (parts.length > 1) {
int durability; int durability;
try { try {
durability = Integer.parseInt(parts[1]); durability = Integer.parseInt(parts[1]);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
throw new IllegalArgumentException("[item requirement] durability '" + parts[1] + "' must be a number in item: '" + sub + "'"); throw new IllegalArgumentException("[item requirement] durability '" + parts[1] + "' must be a number in item: '" + sub + "'");
} }
if (durability != item.getDurability()) { if (durability != item.getDurability()) {
return false; return false;
} }
} }
return material == item.getType(); return material == item.getType();
} }
} }
@@ -1,32 +1,32 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.EntityType; import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import java.util.Objects; import java.util.Objects;
public class MobKillsRequirement extends ProgressiveRequirement { public class MobKillsRequirement extends ProgressiveRequirement {
public MobKillsRequirement(RankupPlugin plugin) { public MobKillsRequirement(RankupPlugin plugin) {
super(plugin, "mob-kills", true); super(plugin, "mob-kills", true);
} }
protected MobKillsRequirement(Requirement clone) { protected MobKillsRequirement(Requirement clone) {
super(clone); super(clone);
} }
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
EntityType entity = Objects.requireNonNull(EntityType.fromName(getSub()), "Invalid entity type '" + getSub() + "' in mob-kills requirement."); EntityType entity = Objects.requireNonNull(EntityType.fromName(getSub()), "Invalid entity type '" + getSub() + "' in mob-kills requirement.");
return player.getStatistic(Statistic.KILL_ENTITY, entity); return player.getStatistic(Statistic.KILL_ENTITY, entity);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new MobKillsRequirement(this); return new MobKillsRequirement(this);
} }
} }
@@ -1,29 +1,29 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import net.milkbowl.vault.economy.Economy; import net.milkbowl.vault.economy.Economy;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.DeductibleRequirement; import sh.okx.rankup.requirements.DeductibleRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class MoneyDeductibleRequirement extends MoneyRequirement implements DeductibleRequirement { public class MoneyDeductibleRequirement extends MoneyRequirement implements DeductibleRequirement {
public MoneyDeductibleRequirement(RankupPlugin plugin, String name) { public MoneyDeductibleRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
protected MoneyDeductibleRequirement(MoneyDeductibleRequirement clone) { protected MoneyDeductibleRequirement(MoneyDeductibleRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public void apply(Player player, double multiplier) { public void apply(Player player, double multiplier) {
Economy economy = plugin.getEconomy(); Economy economy = plugin.getEconomy();
economy.withdrawPlayer(player, getValueDouble() * multiplier); economy.withdrawPlayer(player, getValueDouble() * multiplier);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new MoneyDeductibleRequirement(this); return new MoneyDeductibleRequirement(this);
} }
} }
@@ -1,26 +1,26 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class MoneyRequirement extends ProgressiveRequirement { public class MoneyRequirement extends ProgressiveRequirement {
public MoneyRequirement(RankupPlugin plugin, String name) { public MoneyRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
protected MoneyRequirement(MoneyRequirement clone) { protected MoneyRequirement(MoneyRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return plugin.getEconomy().getBalance(player); return plugin.getEconomy().getBalance(player);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new MoneyRequirement(this); return new MoneyRequirement(this);
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class PermissionRequirement extends Requirement { public class PermissionRequirement extends Requirement {
public PermissionRequirement(RankupPlugin plugin) { public PermissionRequirement(RankupPlugin plugin) {
super(plugin, "permission"); super(plugin, "permission");
} }
protected PermissionRequirement(Requirement clone) { protected PermissionRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
for (String permission : getValuesString()) { for (String permission : getValuesString()) {
if (player.hasPermission(permission)) { if (player.hasPermission(permission)) {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new PermissionRequirement(this); return new PermissionRequirement(this);
} }
} }
@@ -1,90 +1,90 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import me.clip.placeholderapi.PlaceholderAPI; import me.clip.placeholderapi.PlaceholderAPI;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class PlaceholderRequirement extends ProgressiveRequirement { public class PlaceholderRequirement extends ProgressiveRequirement {
public static final double DELTA = 0.00001D; public static final double DELTA = 0.00001D;
public PlaceholderRequirement(RankupPlugin plugin) { public PlaceholderRequirement(RankupPlugin plugin) {
super(plugin, "placeholder"); super(plugin, "placeholder");
} }
public PlaceholderRequirement(PlaceholderRequirement clone) { public PlaceholderRequirement(PlaceholderRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
String[] parts = getParts(player); String[] parts = getParts(player);
String parsed = parts[0]; String parsed = parts[0];
String value = parts[2]; String value = parts[2];
// string operations // string operations
switch (parts[1]) { switch (parts[1]) {
case "=": case "=":
return parsed.equals(value) ? 1 : 0; return parsed.equals(value) ? 1 : 0;
} }
// numeric operations // numeric operations
double p = Double.parseDouble(parsed); double p = Double.parseDouble(parsed);
double v = Double.parseDouble(value); double v = Double.parseDouble(value);
switch (parts[1]) { switch (parts[1]) {
case ">": case ">":
return p > v ? v : 0; return p > v ? v : 0;
case ">=": case ">=":
return Math.min(p, v); return Math.min(p, v);
case "<": case "<":
return p < v ? v : 0; return p < v ? v : 0;
case "<=": case "<=":
return p <= v ? 1 : 0; return p <= v ? 1 : 0;
case "==": case "==":
return p == v ? v : 0; return p == v ? v : 0;
} }
throw new IllegalArgumentException("Invalid operation: " + parts[1]); throw new IllegalArgumentException("Invalid operation: " + parts[1]);
} }
@Override @Override
public double getTotal(Player player) { public double getTotal(Player player) {
String[] parts = getParts(player); String[] parts = getParts(player);
if (parts[1].equalsIgnoreCase("=")) { if (parts[1].equalsIgnoreCase("=")) {
return 1; return 1;
} else { } else {
return Double.parseDouble(parts[2]); return Double.parseDouble(parts[2]);
} }
} }
private String[] getParts(Player player) { private String[] getParts(Player player) {
String[] parts = getValueString().split(" "); String[] parts = getValueString().split(" ");
if (parts.length < 3) { if (parts.length < 3) {
throw new IllegalArgumentException("Placeholder requirements must be in the form %placeholder% <operation> string"); throw new IllegalArgumentException("Placeholder requirements must be in the form %placeholder% <operation> string");
} }
String parsed = PlaceholderAPI.setPlaceholders(player, parts[0]); String parsed = PlaceholderAPI.setPlaceholders(player, parts[0]);
if (!PlaceholderAPI.containsPlaceholders(parts[0]) || parsed.equals(parts[0])) { if (!PlaceholderAPI.containsPlaceholders(parts[0]) || parsed.equals(parts[0])) {
throw new IllegalArgumentException(parts[0] + " is not a PlaceholderAPI placeholder!"); throw new IllegalArgumentException(parts[0] + " is not a PlaceholderAPI placeholder!");
} }
parts[0] = parsed; parts[0] = parsed;
return parts; return parts;
} }
@Override @Override
public String getFullName() { public String getFullName() {
String[] parts = getValueString().split(" "); String[] parts = getValueString().split(" ");
return name + "#" + parts[0].replace("%", ""); return name + "#" + parts[0].replace("%", "");
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
return getRemaining(player) <= 0; return getRemaining(player) <= 0;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new PlaceholderRequirement(this); return new PlaceholderRequirement(this);
} }
} }
@@ -1,27 +1,27 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class PlayerKillsRequirement extends ProgressiveRequirement { public class PlayerKillsRequirement extends ProgressiveRequirement {
public PlayerKillsRequirement(RankupPlugin plugin) { public PlayerKillsRequirement(RankupPlugin plugin) {
super(plugin, "player-kills"); super(plugin, "player-kills");
} }
protected PlayerKillsRequirement(Requirement clone) { protected PlayerKillsRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return player.getStatistic(Statistic.PLAYER_KILLS); return player.getStatistic(Statistic.PLAYER_KILLS);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new PlayerKillsRequirement(this); return new PlayerKillsRequirement(this);
} }
} }
@@ -1,37 +1,37 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class PlaytimeMinutesRequirement extends ProgressiveRequirement { public class PlaytimeMinutesRequirement extends ProgressiveRequirement {
private static final int TICKS_PER_MINUTE = 20 * 60; private static final int TICKS_PER_MINUTE = 20 * 60;
private Statistic playOneTick; private Statistic playOneTick;
public PlaytimeMinutesRequirement(RankupPlugin plugin) { public PlaytimeMinutesRequirement(RankupPlugin plugin) {
super(plugin, "playtime-minutes"); super(plugin, "playtime-minutes");
try { try {
playOneTick = Statistic.valueOf("PLAY_ONE_MINUTE"); playOneTick = Statistic.valueOf("PLAY_ONE_MINUTE");
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
// statistic was changed in 1.13. // statistic was changed in 1.13.
playOneTick = Statistic.valueOf("PLAY_ONE_TICK"); playOneTick = Statistic.valueOf("PLAY_ONE_TICK");
} }
} }
protected PlaytimeMinutesRequirement(PlaytimeMinutesRequirement clone) { protected PlaytimeMinutesRequirement(PlaytimeMinutesRequirement clone) {
super(clone); super(clone);
this.playOneTick = clone.playOneTick; this.playOneTick = clone.playOneTick;
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return player.getStatistic(playOneTick) / TICKS_PER_MINUTE; return player.getStatistic(playOneTick) / TICKS_PER_MINUTE;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new PlaytimeMinutesRequirement(this); return new PlaytimeMinutesRequirement(this);
} }
} }
@@ -1,26 +1,26 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.DeductibleRequirement; import sh.okx.rankup.requirements.DeductibleRequirement;
import sh.okx.rankup.requirements.requirement.tokenmanager.TokensRequirement; import sh.okx.rankup.requirements.requirement.tokenmanager.TokensRequirement;
public class TokensDeductibleRequirement extends TokensRequirement implements DeductibleRequirement { public class TokensDeductibleRequirement extends TokensRequirement implements DeductibleRequirement {
public TokensDeductibleRequirement(RankupPlugin plugin, String name) { public TokensDeductibleRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
protected TokensDeductibleRequirement(TokensDeductibleRequirement clone) { protected TokensDeductibleRequirement(TokensDeductibleRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public void apply(Player player, double multiplier) { public void apply(Player player, double multiplier) {
manager.removeTokens(player, (long) (getValueInt() * multiplier)); manager.removeTokens(player, (long) (getValueInt() * multiplier));
} }
@Override @Override
public TokensRequirement clone() { public TokensRequirement clone() {
return new TokensDeductibleRequirement(this); return new TokensDeductibleRequirement(this);
} }
} }
@@ -1,27 +1,27 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TotalMobKillsRequirement extends ProgressiveRequirement { public class TotalMobKillsRequirement extends ProgressiveRequirement {
public TotalMobKillsRequirement(RankupPlugin plugin) { public TotalMobKillsRequirement(RankupPlugin plugin) {
super(plugin, "total-mob-kills"); super(plugin, "total-mob-kills");
} }
private TotalMobKillsRequirement(Requirement clone) { private TotalMobKillsRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return player.getStatistic(Statistic.MOB_KILLS); return player.getStatistic(Statistic.MOB_KILLS);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TotalMobKillsRequirement(this); return new TotalMobKillsRequirement(this);
} }
} }
@@ -1,32 +1,32 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.Statistic; import org.bukkit.Statistic;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class UseItemRequirement extends ProgressiveRequirement { public class UseItemRequirement extends ProgressiveRequirement {
public UseItemRequirement(RankupPlugin plugin) { public UseItemRequirement(RankupPlugin plugin) {
super(plugin, "use-item", true); super(plugin, "use-item", true);
} }
protected UseItemRequirement(UseItemRequirement clone) { protected UseItemRequirement(UseItemRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
Material material = Material.matchMaterial(getSub()); Material material = Material.matchMaterial(getSub());
if (material == null) { if (material == null) {
throw new IllegalArgumentException("'" + getSub() + "' is not a valid item"); throw new IllegalArgumentException("'" + getSub() + "' is not a valid item");
} }
return player.getStatistic(Statistic.USE_ITEM, material); return player.getStatistic(Statistic.USE_ITEM, material);
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new UseItemRequirement(this); return new UseItemRequirement(this);
} }
} }
@@ -1,29 +1,29 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class WorldRequirement extends Requirement { public class WorldRequirement extends Requirement {
public WorldRequirement(RankupPlugin plugin) { public WorldRequirement(RankupPlugin plugin) {
super(plugin, "world"); super(plugin, "world");
} }
protected WorldRequirement(Requirement clone) { protected WorldRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
String[] worlds = getValuesString(); String[] worlds = getValuesString();
for (String world : worlds) { for (String world : worlds) {
return player.getWorld().getName().equalsIgnoreCase(world); return player.getWorld().getName().equalsIgnoreCase(world);
} }
return false; return false;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new WorldRequirement(this); return new WorldRequirement(this);
} }
} }
@@ -1,26 +1,26 @@
package sh.okx.rankup.requirements.requirement; package sh.okx.rankup.requirements.requirement;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class XpLevelRequirement extends ProgressiveRequirement { public class XpLevelRequirement extends ProgressiveRequirement {
public XpLevelRequirement(RankupPlugin plugin, String name) { public XpLevelRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
protected XpLevelRequirement(XpLevelRequirement clone) { protected XpLevelRequirement(XpLevelRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return player.getLevel(); return player.getLevel();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new XpLevelRequirement(this); return new XpLevelRequirement(this);
} }
} }
@@ -1,38 +1,38 @@
package sh.okx.rankup.requirements.requirement.advancedachievements; package sh.okx.rankup.requirements.requirement.advancedachievements;
import com.hm.achievement.api.AdvancedAchievementsAPI; import com.hm.achievement.api.AdvancedAchievementsAPI;
import com.hm.achievement.api.AdvancedAchievementsAPIFetcher; import com.hm.achievement.api.AdvancedAchievementsAPIFetcher;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class AdvancedAchievementsAchievementRequirement extends Requirement { public class AdvancedAchievementsAchievementRequirement extends Requirement {
public AdvancedAchievementsAchievementRequirement(RankupPlugin plugin) { public AdvancedAchievementsAchievementRequirement(RankupPlugin plugin) {
super(plugin, "advancedachievements-achievement"); super(plugin, "advancedachievements-achievement");
} }
protected AdvancedAchievementsAchievementRequirement(Requirement clone) { protected AdvancedAchievementsAchievementRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
AdvancedAchievementsAPI api = AdvancedAchievementsAPIFetcher.fetchInstance().get(); AdvancedAchievementsAPI api = AdvancedAchievementsAPIFetcher.fetchInstance().get();
return api.hasPlayerReceivedAchievement(player.getUniqueId(), getValueString()); return api.hasPlayerReceivedAchievement(player.getUniqueId(), getValueString());
} }
@Override @Override
public String getFullName() { public String getFullName() {
return super.getFullName() + "#" + getValueString(); return super.getFullName() + "#" + getValueString();
} }
@Override @Override
public double getTotal(Player player) { public double getTotal(Player player) {
return 1; return 1;
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new AdvancedAchievementsAchievementRequirement(this); return new AdvancedAchievementsAchievementRequirement(this);
} }
} }
@@ -1,27 +1,27 @@
package sh.okx.rankup.requirements.requirement.advancedachievements; package sh.okx.rankup.requirements.requirement.advancedachievements;
import com.hm.achievement.api.AdvancedAchievementsAPIFetcher; import com.hm.achievement.api.AdvancedAchievementsAPIFetcher;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
public class AdvancedAchievementsTotalRequirement extends ProgressiveRequirement { public class AdvancedAchievementsTotalRequirement extends ProgressiveRequirement {
public AdvancedAchievementsTotalRequirement(RankupPlugin plugin) { public AdvancedAchievementsTotalRequirement(RankupPlugin plugin) {
super(plugin, "advancedachievements-total"); super(plugin, "advancedachievements-total");
} }
private AdvancedAchievementsTotalRequirement(Requirement clone) { private AdvancedAchievementsTotalRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return AdvancedAchievementsAPIFetcher.fetchInstance().get().getPlayerTotalAchievements(player.getUniqueId()); return AdvancedAchievementsAPIFetcher.fetchInstance().get().getPlayerTotalAchievements(player.getUniqueId());
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new AdvancedAchievementsTotalRequirement(this); return new AdvancedAchievementsTotalRequirement(this);
} }
} }
@@ -1,27 +1,27 @@
package sh.okx.rankup.requirements.requirement.mcmmo; package sh.okx.rankup.requirements.requirement.mcmmo;
import com.gmail.nossr50.util.player.UserManager; import com.gmail.nossr50.util.player.UserManager;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
public class McMMOPowerLevelRequirement extends ProgressiveRequirement { public class McMMOPowerLevelRequirement extends ProgressiveRequirement {
public McMMOPowerLevelRequirement(RankupPlugin plugin) { public McMMOPowerLevelRequirement(RankupPlugin plugin) {
super(plugin, "mcmmo-power-level"); super(plugin, "mcmmo-power-level");
} }
protected McMMOPowerLevelRequirement(Requirement clone) { protected McMMOPowerLevelRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return UserManager.getPlayer(player).getPowerLevel(); return UserManager.getPlayer(player).getPowerLevel();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new McMMOPowerLevelRequirement(this); return new McMMOPowerLevelRequirement(this);
} }
} }
@@ -1,26 +1,26 @@
package sh.okx.rankup.requirements.requirement.mcmmo; package sh.okx.rankup.requirements.requirement.mcmmo;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
public class McMMOSkillRequirement extends ProgressiveRequirement { public class McMMOSkillRequirement extends ProgressiveRequirement {
public McMMOSkillRequirement(RankupPlugin plugin) { public McMMOSkillRequirement(RankupPlugin plugin) {
super(plugin, "mcmmo", true); super(plugin, "mcmmo", true);
} }
protected McMMOSkillRequirement(McMMOSkillRequirement clone) { protected McMMOSkillRequirement(McMMOSkillRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return McMMOSkillUtil.getInstance().getSkillLevel(player, getSub()); return McMMOSkillUtil.getInstance().getSkillLevel(player, getSub());
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new McMMOSkillRequirement(this); return new McMMOSkillRequirement(this);
} }
} }
@@ -1,91 +1,91 @@
package sh.okx.rankup.requirements.requirement.mcmmo; package sh.okx.rankup.requirements.requirement.mcmmo;
import com.gmail.nossr50.datatypes.player.McMMOPlayer; import com.gmail.nossr50.datatypes.player.McMMOPlayer;
import com.gmail.nossr50.util.player.UserManager; import com.gmail.nossr50.util.player.UserManager;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; import java.lang.reflect.Method;
/** /**
* Because mcMMO like changing the name of their skill types. * Because mcMMO like changing the name of their skill types.
* Singleton class to access different mcMMO versions. * Singleton class to access different mcMMO versions.
*/ */
public class McMMOSkillUtil { public class McMMOSkillUtil {
private static McMMOSkillUtil instance; private static McMMOSkillUtil instance;
private Class<?> skillTypeClass; private Class<?> skillTypeClass;
private Method values; private Method values;
private Method valueOf; private Method valueOf;
//private Class<?> userManagerClass; //private Class<?> userManagerClass;
private Method getSkillLevel; private Method getSkillLevel;
private McMMOSkillUtil() { private McMMOSkillUtil() {
final String pckg = "com.gmail.nossr50.datatypes.skills."; final String pckg = "com.gmail.nossr50.datatypes.skills.";
try { try {
skillTypeClass = Class.forName(pckg + "PrimarySkillType"); skillTypeClass = Class.forName(pckg + "PrimarySkillType");
} catch (ClassNotFoundException e0) { } catch (ClassNotFoundException e0) {
try { try {
skillTypeClass = Class.forName(pckg + "PrimarySkill"); skillTypeClass = Class.forName(pckg + "PrimarySkill");
} catch (ClassNotFoundException e1) { } catch (ClassNotFoundException e1) {
try { try {
skillTypeClass = Class.forName(pckg + "SkillType"); skillTypeClass = Class.forName(pckg + "SkillType");
} catch (ClassNotFoundException e2) { } catch (ClassNotFoundException e2) {
throw new UnsupportedOperationException("mcMMO Skill Type class not found"); throw new UnsupportedOperationException("mcMMO Skill Type class not found");
} }
} }
} }
try { try {
values = skillTypeClass.getMethod("values"); values = skillTypeClass.getMethod("values");
} catch (NoSuchMethodException e) { } catch (NoSuchMethodException e) {
throw new UnsupportedOperationException("mcMMO " + skillTypeClass + ".values() not found"); throw new UnsupportedOperationException("mcMMO " + skillTypeClass + ".values() not found");
} }
try { try {
valueOf = skillTypeClass.getMethod("valueOf", String.class); valueOf = skillTypeClass.getMethod("valueOf", String.class);
} catch (NoSuchMethodException e) { } catch (NoSuchMethodException e) {
throw new UnsupportedOperationException("mcMMO" + skillTypeClass + ".valueOf(String) not found"); throw new UnsupportedOperationException("mcMMO" + skillTypeClass + ".valueOf(String) not found");
} }
/*try { /*try {
userManagerClass = Class.forName("com.gmail.nossr50.util.player.UserManager"); userManagerClass = Class.forName("com.gmail.nossr50.util.player.UserManager");
} catch (ClassNotFoundException e) { } catch (ClassNotFoundException e) {
throw new RuntimeException("mcMMO UserManager class not found"); throw new RuntimeException("mcMMO UserManager class not found");
}*/ }*/
try { try {
getSkillLevel = McMMOPlayer.class.getMethod("getSkillLevel", skillTypeClass); getSkillLevel = McMMOPlayer.class.getMethod("getSkillLevel", skillTypeClass);
} catch (NoSuchMethodException e) { } catch (NoSuchMethodException e) {
throw new UnsupportedOperationException("mcMMO UserManager.getSkillLevel(" + skillTypeClass + ") not found"); throw new UnsupportedOperationException("mcMMO UserManager.getSkillLevel(" + skillTypeClass + ") not found");
} }
} }
public static McMMOSkillUtil getInstance() { public static McMMOSkillUtil getInstance() {
if (instance == null) { if (instance == null) {
instance = new McMMOSkillUtil(); instance = new McMMOSkillUtil();
} }
return instance; return instance;
} }
/*public String[] getSkills() { /*public String[] getSkills() {
try { try {
Enum<?>[] skills = (Enum<?>[]) values.invoke(null); Enum<?>[] skills = (Enum<?>[]) values.invoke(null);
String[] stringSkills = new String[skills.length]; String[] stringSkills = new String[skills.length];
for (int i = 0; i < skills.length; i++) { for (int i = 0; i < skills.length; i++) {
stringSkills[i] = skills[i].name(); stringSkills[i] = skills[i].name();
} }
return stringSkills; return stringSkills;
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
}*/ }*/
public int getSkillLevel(Player player, String skill) { public int getSkillLevel(Player player, String skill) {
McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player); McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
try { try {
Object skillType = skillTypeClass.cast(valueOf.invoke(null, skill.toUpperCase())); Object skillType = skillTypeClass.cast(valueOf.invoke(null, skill.toUpperCase()));
return (int) getSkillLevel.invoke(mcMMOPlayer, skillType); return (int) getSkillLevel.invoke(mcMMOPlayer, skillType);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement.tokenmanager; package sh.okx.rankup.requirements.requirement.tokenmanager;
import java.util.Objects; import java.util.Objects;
import me.realized.tokenmanager.api.TokenManager; import me.realized.tokenmanager.api.TokenManager;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
public class TokensRequirement extends ProgressiveRequirement { public class TokensRequirement extends ProgressiveRequirement {
protected final TokenManager manager = (TokenManager) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("TokenManager")); protected final TokenManager manager = (TokenManager) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("TokenManager"));
public TokensRequirement(RankupPlugin plugin, String name) { public TokensRequirement(RankupPlugin plugin, String name) {
super(plugin, name); super(plugin, name);
} }
protected TokensRequirement(TokensRequirement clone) { protected TokensRequirement(TokensRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return manager.getTokens(player).orElse(0); return manager.getTokens(player).orElse(0);
} }
@Override @Override
public TokensRequirement clone() { public TokensRequirement clone() {
return new TokensRequirement(this); return new TokensRequirement(this);
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyKingNumberResidentsRequirement extends ProgressiveRequirement { public class TownyKingNumberResidentsRequirement extends ProgressiveRequirement {
public TownyKingNumberResidentsRequirement(RankupPlugin plugin) { public TownyKingNumberResidentsRequirement(RankupPlugin plugin) {
super(plugin, "towny-king-residents"); super(plugin, "towny-king-residents");
} }
protected TownyKingNumberResidentsRequirement(Requirement clone) { protected TownyKingNumberResidentsRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
if (TownyUtils.getInstance().isKing(player)) { if (TownyUtils.getInstance().isKing(player)) {
return TownyUtils.getInstance().getNation(player).getNumResidents(); return TownyUtils.getInstance().getNation(player).getNumResidents();
} else { } else {
return 0; return 0;
} }
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyKingNumberResidentsRequirement(this); return new TownyKingNumberResidentsRequirement(this);
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyKingNumberTownsRequirement extends ProgressiveRequirement { public class TownyKingNumberTownsRequirement extends ProgressiveRequirement {
public TownyKingNumberTownsRequirement(RankupPlugin plugin) { public TownyKingNumberTownsRequirement(RankupPlugin plugin) {
super(plugin, "towny-king-towns"); super(plugin, "towny-king-towns");
} }
protected TownyKingNumberTownsRequirement(TownyKingNumberTownsRequirement clone) { protected TownyKingNumberTownsRequirement(TownyKingNumberTownsRequirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
if (TownyUtils.getInstance().isKing(player)) { if (TownyUtils.getInstance().isKing(player)) {
return TownyUtils.getInstance().getNation(player).getNumTowns(); return TownyUtils.getInstance().getNation(player).getNumTowns();
} else { } else {
return 0; return 0;
} }
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyKingNumberTownsRequirement(this); return new TownyKingNumberTownsRequirement(this);
} }
} }
@@ -1,25 +1,25 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyKingRequirement extends Requirement { public class TownyKingRequirement extends Requirement {
public TownyKingRequirement(RankupPlugin plugin) { public TownyKingRequirement(RankupPlugin plugin) {
super(plugin, "towny-king"); super(plugin, "towny-king");
} }
protected TownyKingRequirement(Requirement clone) { protected TownyKingRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
return TownyUtils.getInstance().isKing(player) == getValueBoolean(); return TownyUtils.getInstance().isKing(player) == getValueBoolean();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyKingRequirement(this); return new TownyKingRequirement(this);
} }
} }
@@ -1,30 +1,30 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyMayorNumberResidentsRequirement extends ProgressiveRequirement { public class TownyMayorNumberResidentsRequirement extends ProgressiveRequirement {
public TownyMayorNumberResidentsRequirement(RankupPlugin plugin) { public TownyMayorNumberResidentsRequirement(RankupPlugin plugin) {
super(plugin, "towny-mayor-residents"); super(plugin, "towny-mayor-residents");
} }
protected TownyMayorNumberResidentsRequirement(Requirement clone) { protected TownyMayorNumberResidentsRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
if (TownyUtils.getInstance().isMayor(player)) { if (TownyUtils.getInstance().isMayor(player)) {
return TownyUtils.getInstance().getTown(player).getNumResidents(); return TownyUtils.getInstance().getTown(player).getNumResidents();
} else { } else {
return 0; return 0;
} }
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyMayorNumberResidentsRequirement(this); return new TownyMayorNumberResidentsRequirement(this);
} }
} }
@@ -1,25 +1,25 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyMayorRequirement extends Requirement { public class TownyMayorRequirement extends Requirement {
public TownyMayorRequirement(RankupPlugin plugin) { public TownyMayorRequirement(RankupPlugin plugin) {
super(plugin, "towny-mayor"); super(plugin, "towny-mayor");
} }
protected TownyMayorRequirement(Requirement clone) { protected TownyMayorRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
return TownyUtils.getInstance().isMayor(player) == getValueBoolean(); return TownyUtils.getInstance().isMayor(player) == getValueBoolean();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyMayorRequirement(this); return new TownyMayorRequirement(this);
} }
} }
@@ -1,25 +1,25 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
public class TownyResidentRequirement extends Requirement { public class TownyResidentRequirement extends Requirement {
public TownyResidentRequirement(RankupPlugin plugin) { public TownyResidentRequirement(RankupPlugin plugin) {
super(plugin, "towny-resident"); super(plugin, "towny-resident");
} }
protected TownyResidentRequirement(Requirement clone) { protected TownyResidentRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public boolean check(Player player) { public boolean check(Player player) {
return TownyUtils.getInstance().isResident(player) == getValueBoolean(); return TownyUtils.getInstance().isResident(player) == getValueBoolean();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new TownyResidentRequirement(this); return new TownyResidentRequirement(this);
} }
} }
@@ -1,71 +1,71 @@
package sh.okx.rankup.requirements.requirement.towny; package sh.okx.rankup.requirements.requirement.towny;
import com.palmergames.bukkit.towny.exceptions.NotRegisteredException; import com.palmergames.bukkit.towny.exceptions.NotRegisteredException;
import com.palmergames.bukkit.towny.object.Nation; import com.palmergames.bukkit.towny.object.Nation;
import com.palmergames.bukkit.towny.object.Resident; import com.palmergames.bukkit.towny.object.Resident;
import com.palmergames.bukkit.towny.object.Town; import com.palmergames.bukkit.towny.object.Town;
import com.palmergames.bukkit.towny.object.TownyUniverse; import com.palmergames.bukkit.towny.object.TownyUniverse;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
public class TownyUtils { public class TownyUtils {
private static TownyUtils instance; private static TownyUtils instance;
public static TownyUtils getInstance() { public static TownyUtils getInstance() {
if (instance == null) { if (instance == null) {
instance = new TownyUtils(); instance = new TownyUtils();
} }
return instance; return instance;
} }
public boolean isResident(Player player) { public boolean isResident(Player player) {
try { try {
Town town = TownyUniverse.getDataSource().getResident(player.getName()).getTown(); Town town = TownyUniverse.getDataSource().getResident(player.getName()).getTown();
return town != null; return town != null;
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return false; return false;
} }
} }
public Resident getResident(Player player) { public Resident getResident(Player player) {
try { try {
return TownyUniverse.getDataSource().getResident(player.getName()); return TownyUniverse.getDataSource().getResident(player.getName());
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return null; return null;
} }
} }
public Town getTown(Player player) { public Town getTown(Player player) {
try { try {
return TownyUniverse.getDataSource().getResident(player.getName()).getTown(); return TownyUniverse.getDataSource().getResident(player.getName()).getTown();
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return null; return null;
} }
} }
public Nation getNation(Player player) { public Nation getNation(Player player) {
Town town = getTown(player); Town town = getTown(player);
try { try {
return getTown(player) == null ? null : town.getNation(); return getTown(player) == null ? null : town.getNation();
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return null; return null;
} }
} }
public boolean isMayor(Player player) { public boolean isMayor(Player player) {
try { try {
return TownyUniverse.getDataSource().getResident(player.getName()).isMayor(); return TownyUniverse.getDataSource().getResident(player.getName()).isMayor();
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return false; return false;
} }
} }
public boolean isKing(Player player) { public boolean isKing(Player player) {
try { try {
return TownyUniverse.getDataSource().getResident(player.getName()).isKing(); return TownyUniverse.getDataSource().getResident(player.getName()).isKing();
} catch (NotRegisteredException e) { } catch (NotRegisteredException e) {
return false; return false;
} }
} }
} }
@@ -1,27 +1,27 @@
package sh.okx.rankup.requirements.requirement.votingplugin; package sh.okx.rankup.requirements.requirement.votingplugin;
import com.Ben12345rocks.VotingPlugin.UserManager.UserManager; import com.Ben12345rocks.VotingPlugin.UserManager.UserManager;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import sh.okx.rankup.RankupPlugin; import sh.okx.rankup.RankupPlugin;
import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.Requirement;
import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement;
public class VotingPluginVotesRequirement extends ProgressiveRequirement { public class VotingPluginVotesRequirement extends ProgressiveRequirement {
public VotingPluginVotesRequirement(RankupPlugin plugin) { public VotingPluginVotesRequirement(RankupPlugin plugin) {
super(plugin, "votingplugin-votes"); super(plugin, "votingplugin-votes");
} }
protected VotingPluginVotesRequirement(Requirement clone) { protected VotingPluginVotesRequirement(Requirement clone) {
super(clone); super(clone);
} }
@Override @Override
public double getProgress(Player player) { public double getProgress(Player player) {
return UserManager.getInstance().getVotingPluginUser(player).getPoints(); return UserManager.getInstance().getVotingPluginUser(player).getPoints();
} }
@Override @Override
public Requirement clone() { public Requirement clone() {
return new VotingPluginVotesRequirement(this); return new VotingPluginVotesRequirement(this);
} }
} }
+29 -29
View File
@@ -1,29 +1,29 @@
package sh.okx.rankup.util; package sh.okx.rankup.util;
import org.bukkit.Material; import org.bukkit.Material;
public class ItemUtil { public class ItemUtil {
private static boolean flattened; private static boolean flattened;
static { static {
try { try {
Material.valueOf("BLACK_STAINED_GLASS_PANE"); Material.valueOf("BLACK_STAINED_GLASS_PANE");
flattened = true; flattened = true;
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
flattened = false; flattened = false;
} }
} }
/** /**
* Determines if a server is post-flattening or pre-flattening. * Determines if a server is post-flattening or pre-flattening.
* The flattening is the name for the event where, instead of using durability to represent * The flattening is the name for the event where, instead of using durability to represent
* similar items, Mojang decided to use distinct item types for each item. * similar items, Mojang decided to use distinct item types for each item.
* This caused many {@link Material} names to change, making some things incompatible. * This caused many {@link Material} names to change, making some things incompatible.
* The flattening happened in 1.13. * The flattening happened in 1.13.
* *
* @return true if the server is post-flattening (server versions 1.13, 1.14, 1.15) or false if it is pre-flattening (1.12, 1.11, 1.10 etc) * @return true if the server is post-flattening (server versions 1.13, 1.14, 1.15) or false if it is pre-flattening (1.12, 1.11, 1.10 etc)
*/ */
public static boolean isServerFlattened() { public static boolean isServerFlattened() {
return flattened; return flattened;
} }
} }
@@ -1,57 +1,57 @@
package sh.okx.rankup.util; package sh.okx.rankup.util;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import sh.okx.rankup.util.VersionChecker.VersionCheckerCallback; import sh.okx.rankup.util.VersionChecker.VersionCheckerCallback;
public class UpdateNotifier { public class UpdateNotifier {
private final String prefix; private final String prefix;
private final VersionChecker checker; private final VersionChecker checker;
public UpdateNotifier(VersionChecker checker) { public UpdateNotifier(VersionChecker checker) {
this.prefix = ChatColor.GREEN + "" + ChatColor.BOLD + checker.getPlugin().getName() + ChatColor.RESET + " "; this.prefix = ChatColor.GREEN + "" + ChatColor.BOLD + checker.getPlugin().getName() + ChatColor.RESET + " ";
this.checker = checker; this.checker = checker;
} }
public void notify(CommandSender sender, boolean join) { public void notify(CommandSender sender, boolean join) {
if (!checker.hasChecked() && !join) { if (!checker.hasChecked() && !join) {
send(sender, false, ChatColor.YELLOW + "Checking version..."); send(sender, false, ChatColor.YELLOW + "Checking version...");
} }
checker.checkVersion(new VersionCheckerCallback() { checker.checkVersion(new VersionCheckerCallback() {
@Override @Override
public void onLatestVersion(String version) { public void onLatestVersion(String version) {
if (!join) { if (!join) {
send(sender, false, ChatColor.GREEN + "You are on the latest version."); send(sender, false, ChatColor.GREEN + "You are on the latest version.");
} }
} }
@Override @Override
public void onOutdatedVersion(String currentVersion, String latestVersion) { public void onOutdatedVersion(String currentVersion, String latestVersion) {
send(sender, join, ChatColor.YELLOW + "A new version is available: " + ChatColor.GOLD + latestVersion send(sender, join, ChatColor.YELLOW + "A new version is available: " + ChatColor.GOLD + latestVersion
+ ChatColor.YELLOW + ". You are on: " + ChatColor.GOLD + currentVersion + ChatColor.YELLOW + ". You are on: " + ChatColor.GOLD + currentVersion
+ ChatColor.GOLD + "\nhttps://www.spigotmc.org/resources/" + VersionChecker.RESOURCE_ID + "/"); + ChatColor.GOLD + "\nhttps://www.spigotmc.org/resources/" + VersionChecker.RESOURCE_ID + "/");
} }
@Override @Override
public void onPreReleaseVersion(String version) { public void onPreReleaseVersion(String version) {
send(sender, join, ChatColor.RED + "You are on a pre-release version."); send(sender, join, ChatColor.RED + "You are on a pre-release version.");
} }
@Override @Override
public void onFailure() { public void onFailure() {
if (!join) { if (!join) {
send(sender, false, ChatColor.RED + "Error while checking version."); send(sender, false, ChatColor.RED + "Error while checking version.");
} }
} }
}); });
} }
private void send(CommandSender sender, boolean prefix, String message) { private void send(CommandSender sender, boolean prefix, String message) {
if (prefix) { if (prefix) {
sender.sendMessage(this.prefix + message); sender.sendMessage(this.prefix + message);
} else { } else {
sender.sendMessage(message); sender.sendMessage(message);
} }
} }
} }
@@ -1,150 +1,150 @@
package sh.okx.rankup.util; package sh.okx.rankup.util;
import com.google.common.base.Charsets; import com.google.common.base.Charsets;
import com.google.common.io.CharStreams; import com.google.common.io.CharStreams;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.net.URL; import java.net.URL;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.plugin.Plugin; import org.bukkit.plugin.Plugin;
public class VersionChecker { public class VersionChecker {
public static final int RESOURCE_ID = 76964; public static final int RESOURCE_ID = 76964;
private final Plugin plugin; private final Plugin plugin;
private final String currentVersion; private final String currentVersion;
private String latestVersion; private String latestVersion;
private boolean checked = false; private boolean checked = false;
public VersionChecker(Plugin plugin) { public VersionChecker(Plugin plugin) {
this.currentVersion = plugin.getDescription().getVersion(); this.currentVersion = plugin.getDescription().getVersion();
this.plugin = plugin; this.plugin = plugin;
} }
public Plugin getPlugin() { public Plugin getPlugin() {
return plugin; return plugin;
} }
/** /**
* Checks if the version checker has already made an asynchronous call to the web server to check * Checks if the version checker has already made an asynchronous call to the web server to check
* the version, so future checks will run instantly. * the version, so future checks will run instantly.
* *
* @return true if the version checker already knows the latest version, false otherwise * @return true if the version checker already knows the latest version, false otherwise
*/ */
public boolean hasChecked() { public boolean hasChecked() {
return checked; return checked;
} }
public void checkVersion(VersionCheckerCallback callback) { public void checkVersion(VersionCheckerCallback callback) {
if (latestVersion != null) { if (latestVersion != null) {
if (currentVersion.equals(latestVersion)) { if (currentVersion.equals(latestVersion)) {
callback.onLatestVersion(currentVersion); callback.onLatestVersion(currentVersion);
} else { } else {
callback.onOutdatedVersion(currentVersion, latestVersion); callback.onOutdatedVersion(currentVersion, latestVersion);
} }
} else if (currentVersion.contains("alpha") } else if (currentVersion.contains("alpha")
|| currentVersion.contains("beta") || currentVersion.contains("beta")
|| currentVersion.contains("rc")) { || currentVersion.contains("rc")) {
checked = true; checked = true;
callback.onPreReleaseVersion(currentVersion); callback.onPreReleaseVersion(currentVersion);
} else { } else {
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> checkVersionAsync(callback)); Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> checkVersionAsync(callback));
} }
} }
private void checkVersionAsync(VersionCheckerCallback callback) { private void checkVersionAsync(VersionCheckerCallback callback) {
try { try {
latestVersion = getLatestVersion(); latestVersion = getLatestVersion();
checked = true; checked = true;
if (currentVersion.equals(latestVersion)) { if (currentVersion.equals(latestVersion)) {
callback.onLatestVersion(currentVersion); callback.onLatestVersion(currentVersion);
} else { } else {
callback.onOutdatedVersion(currentVersion, latestVersion); callback.onOutdatedVersion(currentVersion, latestVersion);
} }
} catch (IOException e) { } catch (IOException e) {
callback.onFailure(); callback.onFailure();
} }
} }
private String getLatestVersion() throws IOException { private String getLatestVersion() throws IOException {
URL url = new URL("https://api.spigotmc.org/legacy/update.php?resource=" + RESOURCE_ID); URL url = new URL("https://api.spigotmc.org/legacy/update.php?resource=" + RESOURCE_ID);
return CharStreams.toString(new InputStreamReader(url.openStream(), Charsets.UTF_8)); return CharStreams.toString(new InputStreamReader(url.openStream(), Charsets.UTF_8));
} }
/** /**
* A callback used when a version check runs * A callback used when a version check runs
*/ */
public interface VersionCheckerCallback { public interface VersionCheckerCallback {
/** /**
* Called when the plugin is already on the latest version * Called when the plugin is already on the latest version
* May be called asynchronously * May be called asynchronously
* *
* @param version the current, and latest, version of the plugin * @param version the current, and latest, version of the plugin
*/ */
void onLatestVersion(String version); void onLatestVersion(String version);
/** /**
* Called when the plugin is on a version other than the latest on the SpigotMC plugin page. * Called when the plugin is on a version other than the latest on the SpigotMC plugin page.
* May be called asynchronously. * May be called asynchronously.
* *
* @param currentVersion the current version of the plugin specified in plugin.yml * @param currentVersion the current version of the plugin specified in plugin.yml
* @param latestVersion the latest version of the plugin specified on SpigotMC. * @param latestVersion the latest version of the plugin specified on SpigotMC.
*/ */
void onOutdatedVersion(String currentVersion, String latestVersion); void onOutdatedVersion(String currentVersion, String latestVersion);
/** /**
* Called when the plugin is on a pre-release version and is exempt to the usual update system. * Called when the plugin is on a pre-release version and is exempt to the usual update system.
* *
* @param version the current version of the plugin * @param version the current version of the plugin
*/ */
void onPreReleaseVersion(String version); void onPreReleaseVersion(String version);
/** /**
* Called when the version checker was unable to retrieve the latest version. * Called when the version checker was unable to retrieve the latest version.
* May be called asynchronously. * May be called asynchronously.
*/ */
void onFailure(); void onFailure();
} }
/** /**
* An implementation of {@link VersionCheckerCallback} that is called asynchronously, and then * An implementation of {@link VersionCheckerCallback} that is called asynchronously, and then
* forwards the calls an underlying VersionCheckerCallback synchronously on the main Bukkit * forwards the calls an underlying VersionCheckerCallback synchronously on the main Bukkit
* thread. * thread.
*/ */
static class SyncVersionCheckerCallback implements VersionCheckerCallback { static class SyncVersionCheckerCallback implements VersionCheckerCallback {
private final Plugin plugin; private final Plugin plugin;
private final VersionCheckerCallback callback; private final VersionCheckerCallback callback;
SyncVersionCheckerCallback(Plugin plugin, VersionCheckerCallback callback) { SyncVersionCheckerCallback(Plugin plugin, VersionCheckerCallback callback) {
this.plugin = plugin; this.plugin = plugin;
this.callback = callback; this.callback = callback;
} }
@Override @Override
public void onLatestVersion(String version) { public void onLatestVersion(String version) {
doSync(() -> callback.onLatestVersion(version)); doSync(() -> callback.onLatestVersion(version));
} }
@Override @Override
public void onOutdatedVersion(String currentVersion, String latestVersion) { public void onOutdatedVersion(String currentVersion, String latestVersion) {
doSync(() -> callback.onOutdatedVersion(currentVersion, latestVersion)); doSync(() -> callback.onOutdatedVersion(currentVersion, latestVersion));
} }
@Override @Override
public void onPreReleaseVersion(String version) { public void onPreReleaseVersion(String version) {
doSync(() -> callback.onPreReleaseVersion(version)); doSync(() -> callback.onPreReleaseVersion(version));
} }
@Override @Override
public void onFailure() { public void onFailure() {
doSync(callback::onFailure); doSync(callback::onFailure);
} }
private void doSync(Runnable r) { private void doSync(Runnable r) {
Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, r); Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, r);
} }
} }
} }
+21 -21
View File
@@ -1,21 +1,21 @@
The MIT License (MIT) The MIT License (MIT)
Copyright (c) 2018-2020 Okx Copyright (c) 2018-2020 Okx
Permission is hereby granted, free of charge, to any person obtaining a copy Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software. copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. SOFTWARE.
+91 -91
View File
@@ -1,92 +1,92 @@
# this is used for letting you know that you need to update/change your config file # this is used for letting you know that you need to update/change your config file
version: 6 version: 6
# the locale to use for messages # the locale to use for messages
# all messages can be customised but this allows you to # all messages can be customised but this allows you to
# choose messages that are already translated # choose messages that are already translated
# locales can be found in the locale/ folder # locales can be found in the locale/ folder
locale: en locale: en
# interval (in minutes) to check to autorankup players # interval (in minutes) to check to autorankup players
# ranking up manually wil always be enabled # ranking up manually wil always be enabled
# set to 0 to disable # set to 0 to disable
autorankup-interval: 0 autorankup-interval: 0
# whether /ranks and /prestiges should be enabled (true) or disabled (false) # whether /ranks and /prestiges should be enabled (true) or disabled (false)
# /rankup3 reload will not do anything if this is changed, # /rankup3 reload will not do anything if this is changed,
# you will have to restart your server. # you will have to restart your server.
ranks: true ranks: true
# you can alternatively negate the permission rankup.prestiges # you can alternatively negate the permission rankup.prestiges
# this will also make the command not autocomplete in 1.13 # this will also make the command not autocomplete in 1.13
prestiges: true prestiges: true
# whether or not /prestige and /prestiges should be enabled. # whether or not /prestige and /prestiges should be enabled.
# when a player reaches the top rank, they can do /prestige to return to the first rank, # when a player reaches the top rank, they can do /prestige to return to the first rank,
# but you will be able to grant them an additional "prestige" group or additional items. # but you will be able to grant them an additional "prestige" group or additional items.
# #
# if you do not want this command to autocomplete, make sure # if you do not want this command to autocomplete, make sure
# you negate the permission rankup.prestige with your permissions plugin. # you negate the permission rankup.prestige with your permissions plugin.
# if enabled, a prestiges.yml file will be generated with some example prestiges # if enabled, a prestiges.yml file will be generated with some example prestiges
# You must restart your server when you change this for it to work! # You must restart your server when you change this for it to work!
prestige: false prestige: false
# if true, players with the permission rankup.notify will receive notifications when they join # if true, players with the permission rankup.notify will receive notifications when they join
# to update if the server is on an older version of Rankup. # to update if the server is on an older version of Rankup.
notify-update: true notify-update: true
# how people should confirm ranking up # how people should confirm ranking up
# options are: gui, text or none # options are: gui, text or none
confirmation-type: 'gui' confirmation-type: 'gui'
# how long, in seconds, people have to wait between a successful /rankup or /prestige # how long, in seconds, people have to wait between a successful /rankup or /prestige
# set to 0 to disable. # set to 0 to disable.
cooldown: 1 cooldown: 1
# if enabled, players can run /maxrankup to rankup as many times as possible, # if enabled, players can run /maxrankup to rankup as many times as possible,
# before they fail the requirements for the next rank. # before they fail the requirements for the next rank.
# the permission rankup.maxrankup is used for this command, but it is usually given by default. # the permission rankup.maxrankup is used for this command, but it is usually given by default.
# note that /maxrankup, if enabled, has no confirmation. # note that /maxrankup, if enabled, has no confirmation.
max-rankup: max-rankup:
# You must restart your server if you enable or disable /maxrankup! # You must restart your server if you enable or disable /maxrankup!
enabled: false enabled: false
# whether to send a message for each rankup a player does # whether to send a message for each rankup a player does
# if set to true, the chat may be spammed for each rankup a player goes through with /maxrankup # if set to true, the chat may be spammed for each rankup a player goes through with /maxrankup
# if set to false, only the last rankup will be shown (if a player starts on rank A, then does # if set to false, only the last rankup will be shown (if a player starts on rank A, then does
# /maxrankup and ranks up to B and then C, it will just say "player has ranked up to C") # /maxrankup and ranks up to B and then C, it will just say "player has ranked up to C")
individual-messages: true individual-messages: true
# options when using the text rankup confirmation # options when using the text rankup confirmation
text: text:
# the time in seconds for a player to # the time in seconds for a player to
# confirm by typing /rankup again # confirm by typing /rankup again
timeout: 10 timeout: 10
# placeholders: # placeholders:
# https://github.com/okx-code/Rankup3/wiki/PAPI-Placeholders # https://github.com/okx-code/Rankup3/wiki/PAPI-Placeholders
placeholders: placeholders:
# format for money. for more information, see # format for money. for more information, see
# https://docs.oracle.com/javase/8/docs/api/java/text/DecimalFormat.html # https://docs.oracle.com/javase/8/docs/api/java/text/DecimalFormat.html
money-format: "#,##0.##" money-format: "#,##0.##"
percent-format: "0.##" percent-format: "0.##"
# the format used for requirements # the format used for requirements
simple-format: "#.##" simple-format: "#.##"
# used for current_rank and next_rank placeholders when a player is not in anything in rankups.yml # used for current_rank and next_rank placeholders when a player is not in anything in rankups.yml
not-in-ladder: "None" not-in-ladder: "None"
# used in the current_prestige placeholders when a player hasn't prestiged yet # used in the current_prestige placeholders when a player hasn't prestiged yet
no-prestige: "None" no-prestige: "None"
# used in the next_rank and next_prestige placeholders when a player is at the highest rank or prestige # used in the next_rank and next_prestige placeholders when a player is at the highest rank or prestige
highest-rank: "None" highest-rank: "None"
# what to shorten money by. # what to shorten money by.
# ie 1000 -> 1k # ie 1000 -> 1k
# set to an empty list to disable # set to an empty list to disable
# for each entry here, it counts as increasing by a factor of 1,000 # for each entry here, it counts as increasing by a factor of 1,000
# the first represents thousands (1,000) then millions (1,000,000) then billions (1,000,000,000) etc. # the first represents thousands (1,000) then millions (1,000,000) then billions (1,000,000,000) etc.
shorten: shorten:
- 'k' - 'k'
- 'M' - 'M'
- 'B' - 'B'
- 'T' - 'T'
- 'Q' - 'Q'
- 'Qu' - 'Qu'
- 'S' - 'S'
+102 -102
View File
@@ -1,103 +1,103 @@
# the messages in this section can be customised for each rankup in rankups.yml. # the messages in this section can be customised for each rankup in rankups.yml.
rankup: rankup:
requirements-not-met: "&cYou need {MONEY} money to rankup." requirements-not-met: "&cYou need {MONEY} money to rankup."
no-rankup: "&eYou are at the highest rank." no-rankup: "&eYou are at the highest rank."
# set to an empty string, ie: success-public: "" # set to an empty string, ie: success-public: ""
# to hide that message. # to hide that message.
success-public: "&a{PLAYER} &ehas ranked up to: &d{RANK}" success-public: "&a{PLAYER} &ehas ranked up to: &d{RANK}"
success-private: "&aYou have ranked up to: &d{RANK}" success-private: "&aYou have ranked up to: &d{RANK}"
# used for the text confirmation # used for the text confirmation
confirmation: |- confirmation: |-
&eAre you sure you want to rankup to &a{RANK}&e? &eAre you sure you want to rankup to &a{RANK}&e?
&eType &c/rankup &eagain to confirm. &eType &c/rankup &eagain to confirm.
# used for the GUI confirmation # used for the GUI confirmation
title: "Rankup to {RANK}" title: "Rankup to {RANK}"
must-prestige: "&cYou must prestige to /rankup further!" must-prestige: "&cYou must prestige to /rankup further!"
gui: gui:
title: "Rankup to {RANK}" title: "Rankup to {RANK}"
rankup: rankup:
material: EMERALD_BLOCK material: EMERALD_BLOCK
# index can be separated by spaces to show in multiple groups # index can be separated by spaces to show in multiple groups
# for example: 0-3 9-12 18-21 # for example: 0-3 9-12 18-21
# you can also just use a single number instead of a range. # you can also just use a single number instead of a range.
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
# lore is optional # lore is optional
lore: '&6Rankup to &b{RANK}' lore: '&6Rankup to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
# you can (and probably should) you override these in rankups.yml # you can (and probably should) you override these in rankups.yml
# to show the specific requirements for each rank. # to show the specific requirements for each rank.
# however if you are just using money or don't need to change the message per rank, you can use any combination of: # however if you are just using money or don't need to change the message per rank, you can use any combination of:
# {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>} # {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>}
# {MONEY} and {MONEY_NEEDED} are different from {AMOUNT money} and {AMOUNT_NEEDED money} in that they use a different format. # {MONEY} and {MONEY_NEEDED} are different from {AMOUNT money} and {AMOUNT_NEEDED money} in that they use a different format.
# here is an example of showing the requirements for just money: # here is an example of showing the requirements for just money:
#list: #list:
# complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}" # complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}"
# current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%" # current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%"
# incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}" # incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}"
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
# an empty string disables the header/footer # an empty string disables the header/footer
header: "" header: ""
footer: "" footer: ""
# sent when a player tries to rankup when they are on cooldown # sent when a player tries to rankup when they are on cooldown
cooldown: cooldown:
singular: "&cYou must wait {SECONDS_LEFT} more second to rankup again." singular: "&cYou must wait {SECONDS_LEFT} more second to rankup again."
plural: "&cYou must wait {SECONDS_LEFT} more seconds to rankup again." plural: "&cYou must wait {SECONDS_LEFT} more seconds to rankup again."
# prestige messages can also be customised # prestige messages can also be customised
prestige: prestige:
requirements-not-met: "&cYou need {MONEY} money to prestige." requirements-not-met: "&cYou need {MONEY} money to prestige."
no-prestige: "&eYou are at the highest prestige." no-prestige: "&eYou are at the highest prestige."
success-public: "&a{PLAYER} &ehas prestiged to: &d{RANK}" success-public: "&a{PLAYER} &ehas prestiged to: &d{RANK}"
success-private: "&aYou have prestiged to: &d{RANK}" success-private: "&aYou have prestiged to: &d{RANK}"
confirmation: |- confirmation: |-
&eAre you sure you want to prestige to &a{RANK}&e? &eAre you sure you want to prestige to &a{RANK}&e?
&eType &c/prestige &eagain to confirm. &eType &c/prestige &eagain to confirm.
gui: gui:
title: "Prestige to {RANK}" title: "Prestige to {RANK}"
rankup: rankup:
material: GOLD_BLOCK material: GOLD_BLOCK
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
lore: '&6Prestige to &b{RANK}' lore: '&6Prestige to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: "&cYou must wait {SECONDS_LEFT} second to prestige again." singular: "&cYou must wait {SECONDS_LEFT} second to prestige again."
plural: "&cYou must wait {SECONDS_LEFT} more seconds to prestige again." plural: "&cYou must wait {SECONDS_LEFT} more seconds to prestige again."
not-high-enough: "&cYou cannot prestige at your rank!" not-high-enough: "&cYou cannot prestige at your rank!"
not-in-ladder: "&cSorry, but we could not find any rankups for the group(s) you are in. Use /ranks to list the rankups." not-in-ladder: "&cSorry, but we could not find any rankups for the group(s) you are in. Use /ranks to list the rankups."
invalid-rankup: "&cInvalid rankup defined in config, please check console." invalid-rankup: "&cInvalid rankup defined in config, please check console."
+106 -106
View File
@@ -1,107 +1,107 @@
# As mensagens nessa sessão podem ser customizadas para cada rankup em rankups.yml. # As mensagens nessa sessão podem ser customizadas para cada rankup em rankups.yml.
rankup: rankup:
requirements-not-met: "&cVocê {MONEY} para poder dar subir de rank." requirements-not-met: "&cVocê {MONEY} para poder dar subir de rank."
no-rankup: "&eVocê já está no maior rank." no-rankup: "&eVocê já está no maior rank."
# coloque como uma String vazia, ex: success-public: "" # coloque como uma String vazia, ex: success-public: ""
# para ocultar a mensagem. # para ocultar a mensagem.
success-public: "&a{PLAYER} &eacaba de subir para: &d{RANK}" success-public: "&a{PLAYER} &eacaba de subir para: &d{RANK}"
success-private: "&aVocê subiu para: &d{RANK}" success-private: "&aVocê subiu para: &d{RANK}"
# Utilizado para a confirmação via mensagem. # Utilizado para a confirmação via mensagem.
confirmation: |- confirmation: |-
&eVocê tem certeza que deseja subir para &a{RANK}&e? &eVocê tem certeza que deseja subir para &a{RANK}&e?
&eDigite &c/rankup &enovamente para confirmar. &eDigite &c/rankup &enovamente para confirmar.
must-prestige: "&cVocê deve subir de prestígio para dar /rankup a frente!" must-prestige: "&cVocê deve subir de prestígio para dar /rankup a frente!"
gui: gui:
rows: 1 rows: 1
title: "Rankup to {RANK}" title: "Rankup to {RANK}"
rankup: rankup:
material: EMERALD_BLOCK material: EMERALD_BLOCK
# index can be separated by spaces to show in multiple groups # index can be separated by spaces to show in multiple groups
# for example: 0-3 9-12 18-21 # for example: 0-3 9-12 18-21
# you can also just use a single number instead of a range. # you can also just use a single number instead of a range.
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
# lore is optional # lore is optional
lore: '&6Rankup to &b{RANK}' lore: '&6Rankup to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
# Você pode (e deveria) substituir isto em rankups.yml # Você pode (e deveria) substituir isto em rankups.yml
# para mostrar os requerimentos específicos para cada rank. # para mostrar os requerimentos específicos para cada rank.
# contudo, se você está apenas usando dinheiro ou não precisa mudar as mensagens por rank, você pode usar qualquer combinação de: # contudo, se você está apenas usando dinheiro ou não precisa mudar as mensagens por rank, você pode usar qualquer combinação de:
# {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>} # {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>}
# {MONEY} e {MONEY_NEEDED} são diferentes de {AMOUNT money} e {AMOUNT_NEEDED money} pois eles usam diferentes formatos. # {MONEY} e {MONEY_NEEDED} são diferentes de {AMOUNT money} e {AMOUNT_NEEDED money} pois eles usam diferentes formatos.
# here is an example of showing the requirements for just money: # here is an example of showing the requirements for just money:
# Segue um exemplo de como mostrar um requerimento para apenas dinheiro. # Segue um exemplo de como mostrar um requerimento para apenas dinheiro.
#list: #list:
# complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}" # complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}"
# current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%" # current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%"
# incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}" # incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}"
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
# Uma string vázia desativa o cabeçalho/rodapé # Uma string vázia desativa o cabeçalho/rodapé
header: "" header: ""
footer: "" footer: ""
# sent when a player tries to rankup when they are on cooldown. # sent when a player tries to rankup when they are on cooldown.
# Enviado quando um jogador tenta dar rankup enquanto ele está em um cooldown (tempo de espera entre comandos, freeze). # Enviado quando um jogador tenta dar rankup enquanto ele está em um cooldown (tempo de espera entre comandos, freeze).
cooldown: cooldown:
singular: "&cVocê precisa esperar {SECONDS_LEFT} segundo para dar rankup novamente." singular: "&cVocê precisa esperar {SECONDS_LEFT} segundo para dar rankup novamente."
plural: "&cVocê precisa {SECONDS_LEFT} segundos para dar rankup novamente." plural: "&cVocê precisa {SECONDS_LEFT} segundos para dar rankup novamente."
# prestige messages can also be customised # prestige messages can also be customised
# Mensagens de prestígio também podem ser customizadas # Mensagens de prestígio também podem ser customizadas
prestige: prestige:
requirements-not-met: "&cVocê precisa {MONEY} para dar prestigiar." requirements-not-met: "&cVocê precisa {MONEY} para dar prestigiar."
no-prestige: "&eVocê está no maior prestígio." no-prestige: "&eVocê está no maior prestígio."
success-public: "&a{PLAYER} &esubiu de prestígio para: &d{RANK}" success-public: "&a{PLAYER} &esubiu de prestígio para: &d{RANK}"
success-private: "&aVocê subiu de prestígio para: &d{RANK}" success-private: "&aVocê subiu de prestígio para: &d{RANK}"
confirmation: |- confirmation: |-
&eVocê tem certeza que deseja subir de prestígio para &a{RANK}&e? &eVocê tem certeza que deseja subir de prestígio para &a{RANK}&e?
&eDigite &c/prestige &enovamente para confimar. &eDigite &c/prestige &enovamente para confimar.
title: "Subiu de prestígio para {RANK}" title: "Subiu de prestígio para {RANK}"
gui: gui:
rows: 1 rows: 1
title: "Prestige to {RANK}" title: "Prestige to {RANK}"
rankup: rankup:
material: GOLD_BLOCK material: GOLD_BLOCK
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
lore: '&6Prestige to &b{RANK}' lore: '&6Prestige to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: "&cVocê deve esperar {SECONDS_LEFT} segundo para subir de prestígio novamente." singular: "&cVocê deve esperar {SECONDS_LEFT} segundo para subir de prestígio novamente."
plural: "&cVocê deve esperar {SECONDS_LEFT} segundos para subir de prestígio novamente." plural: "&cVocê deve esperar {SECONDS_LEFT} segundos para subir de prestígio novamente."
not-high-enough: "&cVocê não pode subir de prestígio nesse rank!" not-high-enough: "&cVocê não pode subir de prestígio nesse rank!"
not-in-ladder: "&cDesculpa, não conseguimos achar nenhum rank para você subir." not-in-ladder: "&cDesculpa, não conseguimos achar nenhum rank para você subir."
invalid-rankup: "Rankup inválido definido na config, por favor confira o console." invalid-rankup: "Rankup inválido definido na config, por favor confira o console."
+104 -104
View File
@@ -1,104 +1,104 @@
# Сообщения в этой секции могут быть изменены для каждого повышения уровня в rankups.yml # Сообщения в этой секции могут быть изменены для каждого повышения уровня в rankups.yml
rankup: rankup:
requirements-not-met: "&cВам нужно ещё {MONEY} денег для повышения уровня." requirements-not-met: "&cВам нужно ещё {MONEY} денег для повышения уровня."
no-rankup: "&eУ Вас уже самый высокий ранг." no-rankup: "&eУ Вас уже самый высокий ранг."
# Оставьте это поле пустым, чтобы скрыть сообщение (success-public: '') # Оставьте это поле пустым, чтобы скрыть сообщение (success-public: '')
success-public: "&eРанг игрока &a{PLAYER} &eбыл повышен до: &d{RANK}" success-public: "&eРанг игрока &a{PLAYER} &eбыл повышен до: &d{RANK}"
success-private: "&aВаш ранг повысился до: &d{RANK}" success-private: "&aВаш ранг повысился до: &d{RANK}"
# Используется как текст подтверждения # Используется как текст подтверждения
confirmation: |- confirmation: |-
&eВы уверены, что хотите ранг до &a{RANK}&e? &eВы уверены, что хотите ранг до &a{RANK}&e?
&eВведите &c/rankup &eещё раз, чтобы подтвердить. &eВведите &c/rankup &eещё раз, чтобы подтвердить.
gui: gui:
rows: 1 rows: 1
title: "Повысить до {RANK}" title: "Повысить до {RANK}"
rankup: rankup:
material: EMERALD_BLOCK material: EMERALD_BLOCK
# index can be separated by spaces to show in multiple groups # index can be separated by spaces to show in multiple groups
# for example: 0-3 9-12 18-21 # for example: 0-3 9-12 18-21
# you can also just use a single number instead of a range. # you can also just use a single number instead of a range.
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
# lore is optional # lore is optional
lore: '&6Rankup to &b{RANK}' lore: '&6Rankup to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
must-prestige: "&cВам нужно будет больше престижа для /rankup в будущем!" must-prestige: "&cВам нужно будет больше престижа для /rankup в будущем!"
# Вы можете (вам стоит ;D) переписать это в rankups.yml, чтобы показать специфичные требования для каждого ранга. # Вы можете (вам стоит ;D) переписать это в rankups.yml, чтобы показать специфичные требования для каждого ранга.
# Тем не менее, если Вы просто используете деньги или не нуждаетесь в смене сообщений для кажого ранга - Вы # Тем не менее, если Вы просто используете деньги или не нуждаетесь в смене сообщений для кажого ранга - Вы
# можете использовать комбинации из: {MONEY} {MONEY_NEEDED} {PERCENT_DONE <требование>} {PERCENT_LEFT <требование>} # можете использовать комбинации из: {MONEY} {MONEY_NEEDED} {PERCENT_DONE <требование>} {PERCENT_LEFT <требование>}
# {AMOUNT <требование>} {AMOUNT_NEDDED <требование>}. "{MONEY}" и "{MONEY_NEEDED}" отличаются от # {AMOUNT <требование>} {AMOUNT_NEDDED <требование>}. "{MONEY}" и "{MONEY_NEEDED}" отличаются от
# {AMOUNT сумма} {AMOUNT_NEDDED сумма} тем, что они используют разный формат. # {AMOUNT сумма} {AMOUNT_NEDDED сумма} тем, что они используют разный формат.
# Вот пример показа требований только для денег # Вот пример показа требований только для денег
# P.S. \xbb - "»" в Unicode. # P.S. \xbb - "»" в Unicode.
#list: #list:
# complete: "&7{OLD_RANK} &8\xbb &7{RANK} &eза &7${MONEY}" # complete: "&7{OLD_RANK} &8\xbb &7{RANK} &eза &7${MONEY}"
# current: "&c{OLD_RANK} &e\xbb &c{RANK} &eза &a${MONEY} &e{PERCENT_DONE money}%" # current: "&c{OLD_RANK} &e\xbb &c{RANK} &eза &a${MONEY} &e{PERCENT_DONE money}%"
# incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &eза &a${MONEY}" # incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &eза &a${MONEY}"
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
# Пустая строка выключает заголовок/нижнюю часть # Пустая строка выключает заголовок/нижнюю часть
header: '' header: ''
footer: '' footer: ''
# Отправляется игроку, который попытался повысить уровень, когда ещё не прошёл кулдаун (откат/перезарядка) # Отправляется игроку, который попытался повысить уровень, когда ещё не прошёл кулдаун (откат/перезарядка)
cooldown: cooldown:
singular: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова." singular: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова."
plural: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова." plural: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова."
# Сообщения престижа тоже могут быть изменены # Сообщения престижа тоже могут быть изменены
prestige: prestige:
requirements-not-met: "&cВам нужно {MONEY} денг для повышения престижа." requirements-not-met: "&cВам нужно {MONEY} денг для повышения престижа."
no-prestige: "&eУ Вас уже самый высокий уровень престижа." no-prestige: "&eУ Вас уже самый высокий уровень престижа."
success-public: "Престиж игрока &a{PLAYER} &eповышен в: &d{RANK}" success-public: "Престиж игрока &a{PLAYER} &eповышен в: &d{RANK}"
success-private: "&aВаш престиж повышен в: &d{RANK}" success-private: "&aВаш престиж повышен в: &d{RANK}"
confirmation: |- confirmation: |-
&eВы уверены, что хотите престиж в &a{RANK}&e? &eВы уверены, что хотите престиж в &a{RANK}&e?
&eВведите &c/prestige &eснова для подтверждения. &eВведите &c/prestige &eснова для подтверждения.
title: "Повысить престиж в {RANK}" title: "Повысить престиж в {RANK}"
gui: gui:
rows: 1 rows: 1
title: "Prestige to {RANK}" title: "Prestige to {RANK}"
rankup: rankup:
material: GOLD_BLOCK material: GOLD_BLOCK
index: 0-3 index: 0-3
name: '&a&lConfirm' name: '&a&lConfirm'
lore: '&6Prestige to &b{RANK}' lore: '&6Prestige to &b{RANK}'
cancel: cancel:
material: REDSTONE_BLOCK material: REDSTONE_BLOCK
index: 5-8 index: 5-8
name: '&c&lCancel' name: '&c&lCancel'
fill: fill:
name: ' ' name: ' '
# if you are using a 1.8-1.12 and you want to change this # if you are using a 1.8-1.12 and you want to change this
# you can use MATERIAL:data, for example STAINED_GLASS_PANE:8 # you can use MATERIAL:data, for example STAINED_GLASS_PANE:8
# this works for both the rankup and cancel blocks as well # this works for both the rankup and cancel blocks as well
material: BLACK_STAINED_GLASS_PANE material: BLACK_STAINED_GLASS_PANE
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова." singular: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова."
plural: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова." plural: "&cПожалуйста, подождите {SECONDS_LEFT} сек., чтобы повысить ранг снова."
not-high-enough: "&cВы не можете поднять уровень престижа в этом ранге" not-high-enough: "&cВы не можете поднять уровень престижа в этом ранге"
not-in-ladder: "&cПростите, но мне не можем найти какие-нибудь повышения для Вашей группы." not-in-ladder: "&cПростите, но мне не можем найти какие-нибудь повышения для Вашей группы."
invalid-rankup: "В конфигурации определён неверное повышение, пожалуйста, проверьте консоль." invalid-rankup: "В конфигурации определён неверное повышение, пожалуйста, проверьте консоль."
+63 -63
View File
@@ -1,64 +1,64 @@
# the messages in this section can be customised for each rankup in rankups.yml. # the messages in this section can be customised for each rankup in rankups.yml.
rankup: rankup:
requirements-not-met: "&c 你还需要 {MONEY} 才能够升级。" requirements-not-met: "&c 你还需要 {MONEY} 才能够升级。"
no-rankup: "&e你已经处在最高的等级了。" no-rankup: "&e你已经处在最高的等级了。"
# set to an empty string, ie: success-public: "" # set to an empty string, ie: success-public: ""
# to hide that message. # to hide that message.
success-public: "&a玩家 {PLAYER} &e升级到: &d{RANK}" success-public: "&a玩家 {PLAYER} &e升级到: &d{RANK}"
success-private: "&a你已经升级到: &d{RANK}" success-private: "&a你已经升级到: &d{RANK}"
# used for the text confirmation # used for the text confirmation
confirmation: |- confirmation: |-
&e你确定要升级到 &a{RANK}&e &e你确定要升级到 &a{RANK}&e
&e再次输入 &c/rankup &e来确定。 &e再次输入 &c/rankup &e来确定。
# used for the GUI confirmation # used for the GUI confirmation
title: "升级到 {RANK}" title: "升级到 {RANK}"
must-prestige: "&cYou must prestige to /rankup further!" must-prestige: "&cYou must prestige to /rankup further!"
# you can (and probably should) you override these in rankups.yml # you can (and probably should) you override these in rankups.yml
# to show the specific requirements for each rank. # to show the specific requirements for each rank.
# however if you are just using money or don't need to change the message per rank, you can use any combination of: # however if you are just using money or don't need to change the message per rank, you can use any combination of:
# {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>} # {MONEY} {MONEY_NEEDED} {PERCENT_DONE <requirement>} {PERCENT_LEFT <requirement>} {AMOUNT <requirement>} {AMOUNT_NEEDED <requirement>}
# {MONEY} and {MONEY_NEEDED} are different from {AMOUNT money} and {AMOUNT_NEEDED money} in that they use a different format. # {MONEY} and {MONEY_NEEDED} are different from {AMOUNT money} and {AMOUNT_NEEDED money} in that they use a different format.
# here is an example of showing the requirements for just money: # here is an example of showing the requirements for just money:
#list: #list:
# complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}" # complete: "&7{OLD_RANK} &8\xbb &7{RANK} &efor &7${MONEY}"
# current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%" # current: "&c{OLD_RANK} &e\xbb &c{RANK} &efor &a${MONEY} &e{PERCENT_DONE money}%"
# incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}" # incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &efor &a${MONEY}"
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
# an empty string disables the header/footer # an empty string disables the header/footer
header: "" header: ""
footer: "" footer: ""
# sent when a player tries to rankup when they are on cooldown # sent when a player tries to rankup when they are on cooldown
cooldown: cooldown:
singular: "&c你必须等候 {SECONDS_LEFT} 才能够再次升级!" singular: "&c你必须等候 {SECONDS_LEFT} 才能够再次升级!"
plural: "&c你必须等候 {SECONDS_LEFT} 才能够再次升级!" plural: "&c你必须等候 {SECONDS_LEFT} 才能够再次升级!"
# prestige messages can also be customised # prestige messages can also be customised
prestige: prestige:
requirements-not-met: "&cYou need {MONEY} money to prestige." requirements-not-met: "&cYou need {MONEY} money to prestige."
no-prestige: "&eYou are at the highest prestige." no-prestige: "&eYou are at the highest prestige."
success-public: "&a{PLAYER} &ehas prestiged to: &d{RANK}" success-public: "&a{PLAYER} &ehas prestiged to: &d{RANK}"
success-private: "&aYou have prestiged to: &d{RANK}" success-private: "&aYou have prestiged to: &d{RANK}"
confirmation: |- confirmation: |-
&eAre you sure you want to prestige to &a{RANK}&e? &eAre you sure you want to prestige to &a{RANK}&e?
&eType &c/prestige &eagain to confirm. &eType &c/prestige &eagain to confirm.
title: "Prestige to {RANK}" title: "Prestige to {RANK}"
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK}" complete: "&7{OLD_RANK} &8\xbb &7{RANK}"
current: "&c{OLD_RANK} &e\xbb &c{RANK}" current: "&c{OLD_RANK} &e\xbb &c{RANK}"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK}"
header: "" header: ""
footer: "" footer: ""
cooldown: cooldown:
singular: "&cYou must wait {SECONDS_LEFT} second to prestige again." singular: "&cYou must wait {SECONDS_LEFT} second to prestige again."
plural: "&cYou must wait {SECONDS_LEFT} more seconds to prestige again." plural: "&cYou must wait {SECONDS_LEFT} more seconds to prestige again."
not-high-enough: "&cYou cannot prestige at your rank!" not-high-enough: "&cYou cannot prestige at your rank!"
not-in-ladder: "&cSorry, but we could not find any rankups for the group(s) you are in. 使用 /ranks 指令去查看所有等级的列表。" not-in-ladder: "&cSorry, but we could not find any rankups for the group(s) you are in. 使用 /ranks 指令去查看所有等级的列表。"
invalid-rankup: "&c配置中定义的等级无效,请联系管理员检查后台。" invalid-rankup: "&c配置中定义的等级无效,请联系管理员检查后台。"
+64 -64
View File
@@ -1,65 +1,65 @@
name: Rankup name: Rankup
version: ${version} version: ${version}
main: sh.okx.rankup.RankupPlugin main: sh.okx.rankup.RankupPlugin
author: Okx author: Okx
depend: [Vault] depend: [Vault]
softdepend: [PlaceholderAPI, mcMMO, AdvancedAchievements, Towny] softdepend: [PlaceholderAPI, mcMMO, AdvancedAchievements, Towny]
api-version: 1.13 api-version: 1.13
commands: commands:
rankup: rankup:
permission: rankup.rankup permission: rankup.rankup
description: Rankup. description: Rankup.
rankup3: rankup3:
permission: rankup3.info permission: rankup3.info
description: View Rankup version and perform some administrative commands. description: View Rankup version and perform some administrative commands.
# support the old command # support the old command
aliases: [pru] aliases: [pru]
ranks: ranks:
permission: rankup.ranks permission: rankup.ranks
description: List all the ranks. description: List all the ranks.
prestige: prestige:
permission: rankup.prestige permission: rankup.prestige
description: Prestige. description: Prestige.
prestiges: prestiges:
permission: rankup.prestiges permission: rankup.prestiges
description: List all the prestiges. description: List all the prestiges.
maxrankup: maxrankup:
permission: rankup.maxrankup permission: rankup.maxrankup
description: Rankup as much as possible. description: Rankup as much as possible.
permissions: permissions:
rankup.*: rankup.*:
children: children:
rankup.info: true rankup.info: true
rankup.rankup: true rankup.rankup: true
rankup.admin: true rankup.admin: true
rankup.ranks: true rankup.ranks: true
rankup.prestige: true rankup.prestige: true
rankup.prestiges: true rankup.prestiges: true
rankup.auto: true rankup.auto: true
rankup.maxrankup: true rankup.maxrankup: true
rankup.admin: rankup.admin:
children: children:
# if a player can see if the plugin needs updating when they run /pru # if a player can see if the plugin needs updating when they run /pru
rankup.checkversion: true rankup.checkversion: true
# if a player can run /pru reload # if a player can run /pru reload
rankup.reload: true rankup.reload: true
# if a player can force rankup or prestige someone # if a player can force rankup or prestige someone
rankup.force: true rankup.force: true
# if a player receives notifications to update rankup when they log in. # if a player receives notifications to update rankup when they log in.
rankup.notify: true rankup.notify: true
default: op default: op
rankup.info: rankup.info:
default: true default: true
rankup.rankup: rankup.rankup:
default: true default: true
rankup.ranks: rankup.ranks:
default: true default: true
rankup.prestige: rankup.prestige:
default: true default: true
rankup.prestiges: rankup.prestiges:
default: true default: true
rankup.auto: rankup.auto:
default: true default: true
rankup.maxrankup: rankup.maxrankup:
default: true default: true
+18 -18
View File
@@ -1,19 +1,19 @@
first: first:
# the rank people must be to use this prestige # the rank people must be to use this prestige
from: 'D' from: 'D'
# the rank to change it to # the rank to change it to
to: 'A' to: 'A'
next: 'P1' next: 'P1'
# see rankups.yml for more information on requirements, commands, and messages # see rankups.yml for more information on requirements, commands, and messages
requirements: requirements:
- 'money 10000' - 'money 10000'
P1example: P1example:
from: 'D' from: 'D'
to: 'A' to: 'A'
# the rank added to indicate this prestige # the rank added to indicate this prestige
rank: 'P1' rank: 'P1'
next: 'P2' next: 'P2'
requirements: requirements:
- 'money 20000' - 'money 20000'
- 'xp-level 5' - 'xp-level 5'
+43 -43
View File
@@ -1,44 +1,44 @@
# #
# If you are adding your own ranks, make sure to delete the example ranks! # If you are adding your own ranks, make sure to delete the example ranks!
# Need help setting the plugin up? # Need help setting the plugin up?
# Read an example: https://github.com/okx-code/Rankup3/wiki/Configuration-Example # Read an example: https://github.com/okx-code/Rankup3/wiki/Configuration-Example
# Join the discord server for live support: https://discord.gg/maB4382 (buyers only) # Join the discord server for live support: https://discord.gg/maB4382 (buyers only)
# #
# this name doesn't matter # this name doesn't matter
Aexample: Aexample:
# the name of the group # the name of the group
# players have to be in this rank to rankup # players have to be in this rank to rankup
rank: 'A' rank: 'A'
# the name of the rank a player can rankup to # the name of the rank a player can rankup to
next: 'B' next: 'B'
# List of requirements to go to the next rank # List of requirements to go to the next rank
# This example will charge 1000 money to rankup from A to B. # This example will charge 1000 money to rankup from A to B.
# https://github.com/okx-code/Rankup3/wiki/Requirements # https://github.com/okx-code/Rankup3/wiki/Requirements
# custom requirements can also be added by other plugins. # custom requirements can also be added by other plugins.
requirements: requirements:
- 'money 1000' - 'money 1000'
# the console will run these commands when a player ranks up # the console will run these commands when a player ranks up
# nb: groups are automatically changed with vault # nb: groups are automatically changed with vault
#commands: #commands:
# this will run when a player ranks up from A to B. # this will run when a player ranks up from A to B.
#- 'say {PLAYER} well done for ranking up from {OLD_RANK} to {RANK}!' #- 'say {PLAYER} well done for ranking up from {OLD_RANK} to {RANK}!'
Bexample: Bexample:
rank: 'B' rank: 'B'
next: 'C' next: 'C'
requirements: requirements:
- 'money 2500' - 'money 2500'
Cexample: Cexample:
rank: 'C' rank: 'C'
next: 'D' next: 'D'
requirements: requirements:
- 'money 5000' - 'money 5000'
- 'xp-level 2' - 'xp-level 2'
# you can have a custom messages for each rank # you can have a custom messages for each rank
# the paths of these messages are the same as in the messages for your locale # the paths of these messages are the same as in the messages for your locale
rankup: rankup:
requirements-not-met: '&cYou need 5000 money and 2 levels of XP to rankup to D.' requirements-not-met: '&cYou need 5000 money and 2 levels of XP to rankup to D.'
list: list:
complete: "&7{OLD_RANK} &8\xbb &7{RANK} &e(5000 money, 2 XP levels)" complete: "&7{OLD_RANK} &8\xbb &7{RANK} &e(5000 money, 2 XP levels)"
current: "&c{OLD_RANK} &e\xbb &c{RANK} &e(5000 money, 2 XP levels)" current: "&c{OLD_RANK} &e\xbb &c{RANK} &e(5000 money, 2 XP levels)"
incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &e(5000 money, 2 XP levels)" incomplete: "&r{OLD_RANK} &e\xbb &r{RANK} &e(5000 money, 2 XP levels)"
@@ -1,14 +1,14 @@
package sh.okx.rankup.messages; package sh.okx.rankup.messages;
import org.junit.Test; import org.junit.Test;
import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.instanceOf;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThat;
public class MessageBuilderTest { public class MessageBuilderTest {
@Test @Test
public void testFailIfEmpty() { public void testFailIfEmpty() {
assertThat(new MessageBuilder("").failIfEmpty(), instanceOf(NullMessageBuilder.class)); assertThat(new MessageBuilder("").failIfEmpty(), instanceOf(NullMessageBuilder.class));
} }
} }