├── .gitignore ├── build.gradle.kts ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── readme.md ├── settings.gradle.kts └── src └── main ├── java └── miyukisystem │ ├── commands │ └── impl │ │ ├── ActionBarCommand.java │ │ ├── AlertCommand.java │ │ ├── AnvilCommand.java │ │ ├── BackCommand.java │ │ ├── CartographyTableCommand.java │ │ ├── CheckIPCommand.java │ │ ├── ClearChatCommand.java │ │ ├── ClearCommand.java │ │ ├── ColorsCommand.java │ │ ├── EditItemCommand.java │ │ ├── EnchantCommand.java │ │ ├── EnchantingTableCommand.java │ │ ├── EnderChestCommand.java │ │ ├── ExecuteSoundCommand.java │ │ ├── FeedCommand.java │ │ ├── FlashLightCommand.java │ │ ├── FlyCommand.java │ │ ├── GamemodeCommand.java │ │ ├── GodCommand.java │ │ ├── GrindstoneCommand.java │ │ ├── HatCommand.java │ │ ├── HealCommand.java │ │ ├── InvSeeCommand.java │ │ ├── KickAllCommand.java │ │ ├── LoomCommand.java │ │ ├── OnlineCommand.java │ │ ├── PingCommand.java │ │ ├── RepairCommand.java │ │ ├── SetSpawnCommand.java │ │ ├── SkullCommand.java │ │ ├── SmithingTableCommand.java │ │ ├── SpawnCommand.java │ │ ├── SpeedCommand.java │ │ ├── StonecutterCommand.java │ │ ├── SudoCommand.java │ │ ├── TeleportCommand.java │ │ ├── TitleCommand.java │ │ ├── TpAcceptCommand.java │ │ ├── TpAllCommand.java │ │ ├── TpDenyCommand.java │ │ ├── TpHereCommand.java │ │ ├── TpaCommand.java │ │ ├── TpaToggleCommand.java │ │ ├── TrashCommand.java │ │ ├── VanishCommand.java │ │ ├── WhitelistCommand.java │ │ ├── WorkbenchCommand.java │ │ └── subcommands │ │ └── whitelist │ │ ├── WhitelistAddSubCommand.java │ │ ├── WhitelistFalseSubCommand.java │ │ ├── WhitelistPermissionSubCommand.java │ │ ├── WhitelistReloadSubCommand.java │ │ ├── WhitelistRemoveSubCommand.java │ │ └── WhitelistTrueSubCommand.java │ └── listener │ └── impl │ ├── DropPlayerHeadOnDeath.java │ ├── GodModeDamage.java │ ├── KeepEXP.java │ ├── KickPlayerOnWhitelist.java │ ├── Motd.java │ ├── TeleportToSpawn.java │ ├── VanishNewPlayers.java │ └── blockers │ ├── BlockAnvilDecay.java │ ├── BlockCommand.java │ ├── BlockDeathMessage.java │ ├── BlockFallIntoVoid.java │ ├── BlockFeed.java │ ├── BlockFreezeWater.java │ ├── BlockGetIntoVehicles.java │ ├── BlockImproperNicks.java │ ├── BlockItemExplosion.java │ ├── BlockLeaveDecay.java │ ├── BlockMelt.java │ ├── BlockMobCatchFire.java │ ├── BlockPortalCreation.java │ ├── BlockPortalTeleport.java │ ├── BlockRain.java │ └── BlockSleep.java ├── kotlin └── miyukisystem │ ├── Main.kt │ ├── commands │ ├── CommandService.kt │ └── SubCommand.kt │ ├── database │ ├── Database.kt │ ├── adapter │ │ └── LocationAdapter.kt │ ├── datasource │ │ ├── DataSource.kt │ │ └── impl │ │ │ ├── H2.kt │ │ │ ├── MySQL.kt │ │ │ └── SQLite.kt │ └── tables │ │ ├── Table.kt │ │ └── impl │ │ └── Users.kt │ ├── hook │ └── Vault.kt │ ├── listener │ └── ListenerRegistry.kt │ ├── manager │ ├── Cacheable.kt │ ├── CachedDataService.kt │ ├── DataService.kt │ ├── ManagerService.kt │ └── impl │ │ ├── ConfigManager.kt │ │ ├── LocationManager.kt │ │ ├── MessageManager.kt │ │ ├── PlayerManager.kt │ │ ├── TpaManager.kt │ │ ├── UserManager.kt │ │ ├── WarpsManager.kt │ │ └── WhitelistManager.kt │ ├── model │ ├── CachedLocation.kt │ ├── TPA.kt │ ├── User.kt │ ├── Warp.kt │ └── WhitelistPlayer.kt │ └── util │ ├── AsyncUtil.kt │ ├── Config.kt │ ├── JsonFile.kt │ ├── LocationUtil.kt │ └── NBTUtil.kt └── resources ├── ajuda.yml ├── commands.yml ├── config.yml ├── data.yml ├── messages.yml ├── plugin.yml └── subcommands.yml /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by https://www.toptal.com/developers/gitignore/api/java,kotlin,gradle,intellij+all 2 | # Edit at https://www.toptal.com/developers/gitignore?templates=java,kotlin,gradle,intellij+all 3 | 4 | ### Intellij+all ### 5 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 6 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 7 | 8 | # User-specific stuff 9 | .idea/**/workspace.xml 10 | .idea/**/tasks.xml 11 | .idea/**/usage.statistics.xml 12 | .idea/**/dictionaries 13 | .idea/**/shelf 14 | 15 | # AWS User-specific 16 | .idea/**/aws.xml 17 | 18 | # Generated files 19 | .idea/**/contentModel.xml 20 | 21 | # Sensitive or high-churn files 22 | .idea/**/dataSources/ 23 | .idea/**/dataSources.ids 24 | .idea/**/dataSources.local.xml 25 | .idea/**/sqlDataSources.xml 26 | .idea/**/dynamic.xml 27 | .idea/**/uiDesigner.xml 28 | .idea/**/dbnavigator.xml 29 | 30 | # Gradle 31 | .idea/**/gradle.xml 32 | .idea/**/libraries 33 | 34 | # Gradle and Maven with auto-import 35 | # When using Gradle or Maven with auto-import, you should exclude module files, 36 | # since they will be recreated, and may cause churn. Uncomment if using 37 | # auto-import. 38 | # .idea/artifacts 39 | # .idea/compiler.xml 40 | # .idea/jarRepositories.xml 41 | # .idea/modules.xml 42 | # .idea/*.iml 43 | # .idea/modules 44 | # *.iml 45 | # *.ipr 46 | 47 | # CMake 48 | cmake-build-*/ 49 | 50 | # Mongo Explorer plugin 51 | .idea/**/mongoSettings.xml 52 | 53 | # File-based project format 54 | *.iws 55 | 56 | # IntelliJ 57 | out/ 58 | 59 | # mpeltonen/sbt-idea plugin 60 | .idea_modules/ 61 | 62 | # JIRA plugin 63 | atlassian-ide-plugin.xml 64 | 65 | # Cursive Clojure plugin 66 | .idea/replstate.xml 67 | 68 | # Crashlytics plugin (for Android Studio and IntelliJ) 69 | com_crashlytics_export_strings.xml 70 | crashlytics.properties 71 | crashlytics-build.properties 72 | fabric.properties 73 | 74 | # Editor-based Rest Client 75 | .idea/httpRequests 76 | 77 | # Android studio 3.1+ serialized cache file 78 | .idea/caches/build_file_checksums.ser 79 | 80 | ### Intellij+all Patch ### 81 | # Ignores the whole .idea folder and all .iml files 82 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360 83 | 84 | .idea/ 85 | 86 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023 87 | 88 | *.iml 89 | modules.xml 90 | .idea/misc.xml 91 | *.ipr 92 | 93 | # Sonarlint plugin 94 | .idea/sonarlint 95 | 96 | ### Java ### 97 | # Compiled class file 98 | *.class 99 | 100 | # Log file 101 | *.log 102 | 103 | # BlueJ files 104 | *.ctxt 105 | 106 | # Mobile Tools for Java (J2ME) 107 | .mtj.tmp/ 108 | 109 | # Package Files # 110 | *.jar 111 | *.war 112 | *.nar 113 | *.ear 114 | *.zip 115 | *.tar.gz 116 | *.rar 117 | 118 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 119 | hs_err_pid* 120 | 121 | ### Kotlin ### 122 | # Compiled class file 123 | 124 | # Log file 125 | 126 | # BlueJ files 127 | 128 | # Mobile Tools for Java (J2ME) 129 | 130 | # Package Files # 131 | 132 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 133 | 134 | ### Gradle ### 135 | .gradle 136 | build/ 137 | 138 | # Ignore Gradle GUI config 139 | gradle-app.setting 140 | 141 | # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) 142 | !gradle-wrapper.jar 143 | 144 | # Cache of project 145 | .gradletasknamecache 146 | 147 | # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898 148 | # gradle/wrapper/gradle-wrapper.properties 149 | 150 | ### Gradle Patch ### 151 | **/build/ 152 | 153 | # End of https://www.toptal.com/developers/gitignore/api/java,kotlin,gradle,intellij+all -------------------------------------------------------------------------------- /build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | kotlin("jvm") version "1.5.21" 3 | `java-library` 4 | id("com.github.johnrengelman.shadow") version "6.1.0" 5 | id("io.github.slimjar") version "1.2.1" 6 | } 7 | 8 | group = "miyukisystem" 9 | version = "1.0-SNAPSHOT" 10 | 11 | 12 | repositories { 13 | google() 14 | jcenter() 15 | mavenCentral() 16 | maven("https://jitpack.io") 17 | maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") 18 | maven("https://oss.sonatype.org/content/repositories/snapshots/") 19 | maven("https://libraries.minecraft.net/") 20 | maven("https://papermc.io/repo/repository/maven-public/") 21 | maven("https://repo.codemc.io/repository/maven-snapshots/") 22 | maven("https://repo.codemc.org/repository/maven-public/") 23 | flatDir { 24 | dirs("libs", "implementation") 25 | } 26 | } 27 | 28 | dependencies { 29 | slim(kotlin("stdlib-jdk8")) 30 | compileOnly(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar")))) 31 | implementation(fileTree(mapOf("dir" to "implementation", "include" to listOf("*.jar")))) 32 | compileOnly("com.destroystokyo.paper:paper-api:1.16.5-R0.1-SNAPSHOT") 33 | compileOnly("com.mojang:authlib:1.5.21") 34 | compileOnly("com.github.MilkBowl:VaultAPI:1.7") 35 | compileOnly("org.projectlombok:lombok:1.18.20") 36 | annotationProcessor("org.projectlombok:lombok:1.18.20") 37 | implementation("com.zaxxer:HikariCP:3.4.5") 38 | implementation("org.slf4j:slf4j-api:1.7.30") 39 | implementation("org.slf4j:slf4j-simple:1.7.30") 40 | implementation("io.github.bananapuncher714:nbteditor:7.17.0") 41 | slim("com.github.cryptomorin:XSeries:8.2.0") 42 | slim("com.h2database:h2:1.4.200") 43 | slim("org.mariadb.jdbc:mariadb-java-client:2.7.3") 44 | } 45 | 46 | tasks { 47 | withType { 48 | kotlinOptions.jvmTarget = "1.8" 49 | } 50 | withType { 51 | options.encoding = "UTF-8" 52 | } 53 | slimJar { 54 | relocate("com.zaxxer", "miyukisystem.database") 55 | relocate("kotlin", "miyukisystem.kotlin") 56 | relocate("com.cryptomorin.xseries", "miyukisystem.util.xseries") 57 | relocate("org.h2", "miyukisystem.database.h2") 58 | relocate("org.mariadb", "miyukisystem.database.mariadb") 59 | relocate("org.intellij.lang.annotations", "miyukisystem.util.annotations") 60 | relocate("org.jetbrains.annotations", "miyukisystem.util.annotations") 61 | relocate("com.google.protobuf", "miyukisystem.util.google.protobuf") 62 | } 63 | shadowJar { 64 | relocate("io.github.bananapuncher714.nbteditor", "miyukisystem.util") 65 | relocate("io.github.slimjar", "miyukisystem.util.slimjar") 66 | relocate("net.wesjd.anvilgui", "miyukisystem.util.anvil") 67 | relocate("org.slf4j", "miyukisystem.util.slf4j") 68 | classifier = null 69 | } 70 | } -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | slimjar.version = 1.2.4 -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SOekd/MiyukiSystem/da693432cb907a5b552ed7e8cf96b1f1b67adb4c/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | # 4 | # Copyright 2015 the original author or authors. 5 | # 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 7 | # you may not use this file except in compliance with the License. 8 | # You may obtain a copy of the License at 9 | # 10 | # https://www.apache.org/licenses/LICENSE-2.0 11 | # 12 | # Unless required by applicable law or agreed to in writing, software 13 | # distributed under the License is distributed on an "AS IS" BASIS, 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | # See the License for the specific language governing permissions and 16 | # limitations under the License. 17 | # 18 | 19 | ############################################################################## 20 | ## 21 | ## Gradle start up script for UN*X 22 | ## 23 | ############################################################################## 24 | 25 | # Attempt to set APP_HOME 26 | # Resolve links: $0 may be a link 27 | PRG="$0" 28 | # Need this for relative symlinks. 29 | while [ -h "$PRG" ] ; do 30 | ls=`ls -ld "$PRG"` 31 | link=`expr "$ls" : '.*-> \(.*\)$'` 32 | if expr "$link" : '/.*' > /dev/null; then 33 | PRG="$link" 34 | else 35 | PRG=`dirname "$PRG"`"/$link" 36 | fi 37 | done 38 | SAVED="`pwd`" 39 | cd "`dirname \"$PRG\"`/" >/dev/null 40 | APP_HOME="`pwd -P`" 41 | cd "$SAVED" >/dev/null 42 | 43 | APP_NAME="Gradle" 44 | APP_BASE_NAME=`basename "$0"` 45 | 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' 48 | 49 | # Use the maximum available, or set MAX_FD != -1 to use that value. 50 | MAX_FD="maximum" 51 | 52 | warn () { 53 | echo "$*" 54 | } 55 | 56 | die () { 57 | echo 58 | echo "$*" 59 | echo 60 | exit 1 61 | } 62 | 63 | # OS specific support (must be 'true' or 'false'). 64 | cygwin=false 65 | msys=false 66 | darwin=false 67 | nonstop=false 68 | case "`uname`" in 69 | CYGWIN* ) 70 | cygwin=true 71 | ;; 72 | Darwin* ) 73 | darwin=true 74 | ;; 75 | MINGW* ) 76 | msys=true 77 | ;; 78 | NONSTOP* ) 79 | nonstop=true 80 | ;; 81 | esac 82 | 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 84 | 85 | 86 | # Determine the Java command to use to start the JVM. 87 | if [ -n "$JAVA_HOME" ] ; then 88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 89 | # IBM's JDK on AIX uses strange locations for the executables 90 | JAVACMD="$JAVA_HOME/jre/sh/java" 91 | else 92 | JAVACMD="$JAVA_HOME/bin/java" 93 | fi 94 | if [ ! -x "$JAVACMD" ] ; then 95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 96 | 97 | Please set the JAVA_HOME variable in your environment to match the 98 | location of your Java installation." 99 | fi 100 | else 101 | JAVACMD="java" 102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 103 | 104 | Please set the JAVA_HOME variable in your environment to match the 105 | location of your Java installation." 106 | fi 107 | 108 | # Increase the maximum file descriptors if we can. 109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then 110 | MAX_FD_LIMIT=`ulimit -H -n` 111 | if [ $? -eq 0 ] ; then 112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 113 | MAX_FD="$MAX_FD_LIMIT" 114 | fi 115 | ulimit -n $MAX_FD 116 | if [ $? -ne 0 ] ; then 117 | warn "Could not set maximum file descriptor limit: $MAX_FD" 118 | fi 119 | else 120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 121 | fi 122 | fi 123 | 124 | # For Darwin, add options to specify how the application appears in the dock 125 | if $darwin; then 126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 127 | fi 128 | 129 | # For Cygwin or MSYS, switch paths to Windows format before running java 130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then 131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 133 | 134 | JAVACMD=`cygpath --unix "$JAVACMD"` 135 | 136 | # We build the pattern for arguments to be converted via cygpath 137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 138 | SEP="" 139 | for dir in $ROOTDIRSRAW ; do 140 | ROOTDIRS="$ROOTDIRS$SEP$dir" 141 | SEP="|" 142 | done 143 | OURCYGPATTERN="(^($ROOTDIRS))" 144 | # Add a user-defined pattern to the cygpath arguments 145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 147 | fi 148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 149 | i=0 150 | for arg in "$@" ; do 151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 153 | 154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 156 | else 157 | eval `echo args$i`="\"$arg\"" 158 | fi 159 | i=`expr $i + 1` 160 | done 161 | case $i in 162 | 0) set -- ;; 163 | 1) set -- "$args0" ;; 164 | 2) set -- "$args0" "$args1" ;; 165 | 3) set -- "$args0" "$args1" "$args2" ;; 166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 172 | esac 173 | fi 174 | 175 | # Escape application args 176 | save () { 177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done 178 | echo " " 179 | } 180 | APP_ARGS=`save "$@"` 181 | 182 | # Collect all arguments for the java command, following the shell quoting and substitution rules 183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" 184 | 185 | exec "$JAVACMD" "$@" 186 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%" == "" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%" == "" set DIRNAME=. 29 | set APP_BASE_NAME=%~n0 30 | set APP_HOME=%DIRNAME% 31 | 32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 34 | 35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 37 | 38 | @rem Find java.exe 39 | if defined JAVA_HOME goto findJavaFromJavaHome 40 | 41 | set JAVA_EXE=java.exe 42 | %JAVA_EXE% -version >NUL 2>&1 43 | if "%ERRORLEVEL%" == "0" goto execute 44 | 45 | echo. 46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 47 | echo. 48 | echo Please set the JAVA_HOME variable in your environment to match the 49 | echo location of your Java installation. 50 | 51 | goto fail 52 | 53 | :findJavaFromJavaHome 54 | set JAVA_HOME=%JAVA_HOME:"=% 55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 56 | 57 | if exist "%JAVA_EXE%" goto execute 58 | 59 | echo. 60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 61 | echo. 62 | echo Please set the JAVA_HOME variable in your environment to match the 63 | echo location of your Java installation. 64 | 65 | goto fail 66 | 67 | :execute 68 | @rem Setup the command line 69 | 70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 71 | 72 | 73 | @rem Execute Gradle 74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 75 | 76 | :end 77 | @rem End local scope for the variables with windows NT shell 78 | if "%ERRORLEVEL%"=="0" goto mainEnd 79 | 80 | :fail 81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 82 | rem the _cmd.exe /c_ return code! 83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 84 | exit /b 1 85 | 86 | :mainEnd 87 | if "%OS%"=="Windows_NT" endlocal 88 | 89 | :omega 90 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # MiyukiSystem [Em breve] 2 | 3 | Uma espécie de **fork** do famoso [system](https://github.com/eduardo-mior/System). 4 | 5 | ![](https://media.giphy.com/media/WbanOzR9wjAjddGtLf/giphy.gif) 6 | 7 | # Por quê usar MiyukiSystem? 8 | 9 | * Uma [wiki](https://github.com/SOekd/MiyukiSystem/wiki) completa para você. 10 | * Código aberto a toda comunidade. 11 | * Código super otimizado. 12 | * Atualizado constantemente. 13 | * Thread-safe. 14 | * Suporte a cores RGB (1.16+). 15 | * Suporte a materiais das novas versões. 16 | * Tab-complete em comandos compatíveis. 17 | * Entre muitos outros. 18 | 19 | # Usando o plugin: 20 | 21 | * Baixe o plugin na versão mais recente clicando [aqui](https://github.com/SOekd/MiyukiSystem/releases/latest). (Em breve) 22 | * O plugin suporta as versões: 1.8.8 ~ 1.17. 23 | * Para mudar qualquer nome de comando, aliases, clique [aqui](https://github.com/SOekd/MiyukiSystem/blob/master/src/main/resources/commands.yml). 24 | * Caso tenha algum problema, sugestões abrir uma issue clicando [aqui](https://github.com/SOekd/MiyukiSystem/issues). 25 | 26 | 27 | Está com alguma dúvida na instalação? Verifique nosso tópico na [wiki](https://github.com/SOekd/MiyukiSystem/wiki/%5BMiyukiSystem%5D-Introdu%C3%A7%C3%A3o). 28 | 29 | ## Wiki: 30 | 31 | * [Tópico I - Instalando o plugin](https://bit.ly/3evgm0K) - Tópico para a instalação do plugin. 32 | * [Tópico II - Comandos e Permissões](https://bit.ly/2UUBVka) - Tópico para mostrar todos comandos e permissões que estão dísponiveís. 33 | * [Tópico III - Bloqueadores](https://bit.ly/3eruYhK) - Tópico para mostrar os bloqueadores de eventos e afins que estão dísponiveis. 34 | * [Tópico IV - Diversos](https://bit.ly/3wHx03z) - Tudo o que você não encontrou nos tópicos acima, provavelmente irá achar aqui. 35 | 36 | 37 | 38 | [Wiki](https://github.com/SOekd/MiyukiSystem/wiki) constantemente atualizada. 39 | 40 | Acha que devemos adicionar algo em nossa [wiki](https://github.com/SOekd/MiyukiSystem/wiki)? abra um [issue](https://github.com/SOekd/MiyukiSystem/issues) :D. 41 | 42 | ## Desenvolvedores: 43 | 44 | [SOekd](https://github.com/SOekd) [mattnicee7](https://github.com/mattnicee7) [Kroxyyy](https://github.com/kroxyyy) 45 | 46 | ## Contribuidores: 47 | 48 | Contribuidores, seja com ideias, ajuda em alguma parte do código, etc. 49 | 50 | * [Nevisk, Alexandre] 51 | 52 | 53 | Obrigado a todos. =) -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name = "MiyukiSystem" 2 | 3 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/ActionBarCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.PlayerManagerKt; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.jetbrains.annotations.NotNull; 10 | 11 | import java.util.Arrays; 12 | import java.util.Collections; 13 | import java.util.List; 14 | 15 | public class ActionBarCommand extends CommandService { 16 | 17 | public ActionBarCommand() { 18 | super("ActionBar", "miyukisystem.actionbar", false); 19 | } 20 | 21 | @Override 22 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 23 | 24 | if (args.length < 1) { 25 | MessageManagerKt.sendCustomMessage(sender, "IncorrectActionBarCommand"); 26 | return false; 27 | } 28 | 29 | val player = Bukkit.getPlayer(args[0]); 30 | 31 | val array = Arrays.copyOfRange(args, 1, args.length); 32 | val message = MessageManagerKt.translateColorCodes(String.join(" ", array)); 33 | 34 | if (player == null) { 35 | 36 | if (args[0].equalsIgnoreCase("*")) { 37 | 38 | Bukkit.getOnlinePlayers().forEach(it -> PlayerManagerKt.sendActionBar(it, message)); 39 | 40 | return false; 41 | } 42 | 43 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 44 | return false; 45 | } 46 | 47 | PlayerManagerKt.sendActionBar(player, message); 48 | MessageManagerKt.sendCustomMessage(sender, "ActionBarSent"); 49 | 50 | return false; 51 | } 52 | 53 | @NotNull 54 | @Override 55 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 56 | return Collections.emptyList(); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/AlertCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.HashMap; 12 | import java.util.List; 13 | 14 | public class AlertCommand extends CommandService { 15 | 16 | public AlertCommand() { 17 | super("Alert", "miyukisystem.alert", false); 18 | } 19 | 20 | @Override 21 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 22 | 23 | if (args.length < 1) { 24 | MessageManagerKt.sendCustomMessage(sender, "IncorrectAlertCommand"); 25 | return false; 26 | } 27 | 28 | String warn = String.join(" ", args).replace('&', '§'); 29 | 30 | val placeHolders = new HashMap(); 31 | placeHolders.put("{alert}", warn); 32 | 33 | Bukkit.getOnlinePlayers().forEach(it -> MessageManagerKt.sendCustomMessage(it, "Alert", placeHolders)); 34 | MessageManagerKt.sendCustomMessage(sender, "AlertSent"); 35 | 36 | return true; 37 | } 38 | 39 | @NotNull 40 | @Override 41 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 42 | return Collections.emptyList(); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/AnvilCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import net.wesjd.anvilgui.version.VersionMatcher; 7 | import net.wesjd.anvilgui.version.VersionWrapper; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.Player; 10 | import org.jetbrains.annotations.NotNull; 11 | 12 | import java.util.Collections; 13 | import java.util.List; 14 | 15 | public class AnvilCommand extends CommandService { 16 | 17 | public AnvilCommand() { 18 | super("Anvil", "miyukisystem.anvil", false); 19 | } 20 | 21 | private final VersionWrapper WRAPPER = new VersionMatcher().match(); 22 | 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | if (!(sender instanceof Player)) { 27 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 28 | return false; 29 | } 30 | val player = (Player) sender; 31 | 32 | player.closeInventory(); 33 | 34 | WRAPPER.handleInventoryCloseEvent(player); 35 | WRAPPER.setActiveContainerDefault(player); 36 | 37 | val title = " "; 38 | final Object container = WRAPPER.newContainerAnvil(player, title); 39 | 40 | val containerId = WRAPPER.getNextContainerId(player, container); 41 | WRAPPER.sendPacketOpenWindow(player, containerId, title); 42 | WRAPPER.setActiveContainer(player, container); 43 | WRAPPER.setActiveContainerId(container, containerId); 44 | WRAPPER.addActiveContainerSlotListener(container, player); 45 | return false; 46 | } 47 | 48 | @NotNull 49 | @Override 50 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 51 | return Collections.emptyList(); 52 | } 53 | 54 | 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/BackCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import org.bukkit.command.CommandSender; 6 | import org.bukkit.entity.Player; 7 | import org.jetbrains.annotations.NotNull; 8 | 9 | import java.util.List; 10 | 11 | public class BackCommand extends CommandService { 12 | 13 | public BackCommand() { 14 | super("Back", "miyukisystem.back", false); 15 | } 16 | 17 | @Override 18 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 19 | 20 | if (!(sender instanceof Player)) { 21 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 22 | } 23 | 24 | return false; 25 | } 26 | 27 | @NotNull 28 | @Override 29 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 30 | return null; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/CartographyTableCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class CartographyTableCommand extends CommandService { 14 | 15 | public CartographyTableCommand() { 16 | super("CartographyTable", "miyukisystem.cartographytable", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | 29 | player.closeInventory(); 30 | 31 | try { 32 | player.openCartographyTable(player.getLocation(), true); 33 | } catch (Exception exception) { 34 | MessageManagerKt.sendCustomMessage(sender, "UnavailableCommand"); 35 | } 36 | 37 | return true; 38 | } 39 | 40 | @NotNull 41 | @Override 42 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 43 | return Collections.emptyList(); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/CheckIPCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.HashMap; 11 | import java.util.List; 12 | 13 | public class CheckIPCommand extends CommandService { 14 | 15 | 16 | public CheckIPCommand() { 17 | super("CheckIP", "miyukisystem.checkip", false); 18 | } 19 | 20 | @Override 21 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 22 | 23 | if (args.length != 1) { 24 | MessageManagerKt.sendCustomMessage(sender, "IncorrectCheckIPCommand"); 25 | return false; 26 | } 27 | 28 | val target = Bukkit.getPlayer(args[0]); 29 | 30 | if (target == null) { 31 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 32 | return false; 33 | } 34 | 35 | val placeHolders = new HashMap(); 36 | placeHolders.put("{target}", target.getName()); 37 | placeHolders.put("{ip}", String.valueOf(target.getAddress())); 38 | 39 | MessageManagerKt.sendCustomMessage(sender, "CheckingIP", placeHolders); 40 | 41 | return false; 42 | } 43 | 44 | // colocar tab complete 45 | @NotNull 46 | @Override 47 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 48 | return null; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/ClearChatCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.jetbrains.annotations.NotNull; 10 | 11 | import java.util.Collections; 12 | import java.util.List; 13 | 14 | public class ClearChatCommand extends CommandService { 15 | 16 | public ClearChatCommand() { 17 | super("ClearChat", "miyukisystem.clearchat", false); 18 | } 19 | 20 | // Comando 100% feito. 21 | 22 | @Override 23 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 24 | 25 | val players = Bukkit.getOnlinePlayers(); 26 | players.forEach(it -> it.sendMessage(StringUtils.repeat(" \n", 100))); 27 | players.forEach(it -> MessageManagerKt.sendCustomMessage(it, "ClearedChat")); 28 | 29 | return false; 30 | } 31 | 32 | 33 | @NotNull 34 | @Override 35 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 36 | return Collections.emptyList(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/ClearCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.PlayerManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.HashMap; 16 | import java.util.List; 17 | import java.util.stream.Collectors; 18 | 19 | public class ClearCommand extends CommandService { 20 | 21 | public ClearCommand() { 22 | super("Clear", "miyukisystem.clear", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (args.length > 0) { 29 | 30 | if (!(sender.hasPermission("miyukisystem.clear.other"))) { 31 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 32 | return false; 33 | } 34 | 35 | val target = Bukkit.getPlayer(args[0]); 36 | 37 | if (target == null) { 38 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 39 | return false; 40 | } 41 | 42 | val placeHolders = new HashMap(); 43 | placeHolders.put("{player}", target.getName()); 44 | 45 | if (PlayerManagerKt.isInventoryEmpty(target, false)) { 46 | MessageManagerKt.sendCustomMessage(sender, "AlreadyTargetCleared", placeHolders); 47 | } else { 48 | PlayerManagerKt.clearInventory(target); 49 | MessageManagerKt.sendCustomMessage(sender, "TargetCleared", placeHolders); 50 | } 51 | 52 | return false; 53 | } 54 | 55 | if (!(sender instanceof Player)) { 56 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 57 | return false; 58 | } 59 | 60 | val player = (Player) sender; 61 | 62 | if (!PlayerManagerKt.isInventoryEmpty(player, true)) { 63 | PlayerManagerKt.clearInventory(player); 64 | MessageManagerKt.sendCustomMessage(sender, "Cleared"); 65 | } else { 66 | MessageManagerKt.sendCustomMessage(sender, "AlreadyCleared"); 67 | } 68 | return false; 69 | } 70 | 71 | @NotNull 72 | @Override 73 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 74 | val player = sender instanceof Player ? (Player) sender : null; 75 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.clear.other")) return Collections.emptyList(); 76 | val lastWord = args[args.length - 1]; 77 | return Bukkit.getOnlinePlayers().stream() 78 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 79 | .map(HumanEntity::getName) 80 | .sorted() 81 | .collect(Collectors.toList()); 82 | } 83 | } -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/ColorsCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import org.bukkit.command.CommandSender; 6 | import org.jetbrains.annotations.NotNull; 7 | 8 | import java.util.Collections; 9 | import java.util.List; 10 | 11 | public class ColorsCommand extends CommandService { 12 | 13 | public ColorsCommand() { 14 | super("Colors", "miyukisystem.colors", false); 15 | } 16 | 17 | @Override 18 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 19 | 20 | MessageManagerKt.sendCustomMessage(sender, "Colors"); 21 | 22 | return true; 23 | } 24 | 25 | @NotNull 26 | @Override 27 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 28 | return Collections.emptyList(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/EditItemCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import org.bukkit.command.CommandSender; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.inventory.ItemStack; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class EditItemCommand extends CommandService { 14 | 15 | public EditItemCommand() { 16 | super("EditItem", "miyukisystem.edititem", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | Player player = (Player) sender; 28 | ItemStack itemHand = player.getItemInHand(); 29 | 30 | /* 31 | * 32 | * 33 | * 34 | * 35 | * */ 36 | 37 | return false; 38 | } 39 | 40 | @NotNull 41 | @Override 42 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 43 | return Collections.emptyList(); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/EnchantCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import com.cryptomorin.xseries.XEnchantment; 4 | import com.cryptomorin.xseries.XMaterial; 5 | import lombok.val; 6 | import miyukisystem.commands.CommandService; 7 | import miyukisystem.manager.impl.MessageManagerKt; 8 | import org.bukkit.Material; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class EnchantCommand extends CommandService { 17 | 18 | public EnchantCommand() { 19 | super("Enchant", "miyukisystem.enchant", false); 20 | } 21 | 22 | @SuppressWarnings("all") 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | if (!(sender instanceof Player)) { 27 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 28 | return false; 29 | } 30 | 31 | if (args.length != 2) { 32 | MessageManagerKt.sendCustomMessage(sender, "IncorrectEnchantCommand"); 33 | } 34 | 35 | val player = (Player) sender; 36 | val itemInHand = player.getItemInHand(); 37 | 38 | if (XMaterial.matchXMaterial(itemInHand.getType()).parseMaterial() == XMaterial.AIR.parseMaterial()) { 39 | MessageManagerKt.sendCustomMessage(sender, "PutAItemInHand"); 40 | return false; 41 | } 42 | 43 | val enchant = XEnchantment.matchXEnchantment(args[0].toUpperCase()); 44 | 45 | 46 | return false; 47 | } 48 | 49 | @NotNull 50 | @Override 51 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 52 | return Collections.emptyList(); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/EnchantingTableCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class EnchantingTableCommand extends CommandService { 14 | 15 | public EnchantingTableCommand() { 16 | super("EnchantingTable", "miyukisystem.enchantingtable", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | player.closeInventory(); 29 | player.openEnchanting(player.getLocation(), true); 30 | 31 | return true; 32 | } 33 | 34 | @NotNull 35 | @Override 36 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 37 | return Collections.emptyList(); 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/EnderChestCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.HumanEntity; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.inventory.Inventory; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.List; 16 | import java.util.stream.Collectors; 17 | 18 | public class EnderChestCommand extends CommandService { 19 | 20 | public EnderChestCommand() { 21 | super("EnderChest", "miyukisystem.enderchest", false); 22 | } 23 | 24 | @Override 25 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 26 | 27 | if (!(sender instanceof Player)) { 28 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 29 | return false; 30 | } 31 | 32 | val player = (Player) sender; 33 | 34 | Inventory enderChest; 35 | 36 | if (args.length > 0) { 37 | 38 | if (!(sender.hasPermission("miyukisystem.enderchest.other"))) { 39 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 40 | return false; 41 | } 42 | 43 | val target = Bukkit.getPlayer(args[0]); 44 | 45 | if (target == null) { 46 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 47 | return false; 48 | } 49 | 50 | enderChest = target.getEnderChest(); 51 | } else { 52 | enderChest = player.getEnderChest(); 53 | } 54 | 55 | player.openInventory(enderChest); 56 | 57 | return true; 58 | } 59 | 60 | @NotNull 61 | @Override 62 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 63 | val player = sender instanceof Player ? (Player) sender : null; 64 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.enderchest.other")) return Collections.emptyList(); 65 | val lastWord = args[args.length - 1]; 66 | return Bukkit.getOnlinePlayers().stream() 67 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 68 | .map(HumanEntity::getName) 69 | .sorted() 70 | .collect(Collectors.toList()); 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/ExecuteSoundCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import com.cryptomorin.xseries.XSound; 4 | import lombok.val; 5 | import miyukisystem.commands.CommandService; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.Sound; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Arrays; 15 | import java.util.Collections; 16 | import java.util.HashMap; 17 | import java.util.List; 18 | import java.util.stream.Collectors; 19 | 20 | public class ExecuteSoundCommand extends CommandService { 21 | 22 | public ExecuteSoundCommand() { 23 | super("ExecuteSound", "miyukisystem.executesound", false); 24 | } 25 | 26 | @Override 27 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 28 | 29 | if (args.length != 2) { 30 | MessageManagerKt.sendCustomMessage(sender, "IncorrectExecuteSoundCommand"); 31 | return false; 32 | } 33 | 34 | val target = Bukkit.getPlayer(args[0]); 35 | val sound = XSound.matchXSound(args[1].toUpperCase()); 36 | 37 | if (!sound.isPresent()) { 38 | MessageManagerKt.sendCustomMessage(sender, "SoundNotFound"); 39 | return false; 40 | } 41 | 42 | if (target == null) { 43 | 44 | if (args[0].equalsIgnoreCase("*")) { 45 | 46 | Bukkit.getOnlinePlayers().forEach( 47 | it -> it.playSound(it.getLocation(), sound.get().parseSound(), 1.0f, 1.0f) 48 | ); 49 | 50 | MessageManagerKt.sendCustomMessage(sender, "SoundSent"); 51 | return false; 52 | } 53 | 54 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 55 | return false; 56 | } 57 | 58 | target.playSound(target.getLocation(), sound.get().parseSound(), 1.0f, 1.0f); 59 | 60 | val placeHolders = new HashMap(); 61 | placeHolders.put("{player}", target.getName()); 62 | 63 | MessageManagerKt.sendCustomMessage(sender, "SoundSentTarget", placeHolders); 64 | 65 | return false; 66 | } 67 | 68 | @NotNull 69 | @Override 70 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 71 | val player = sender instanceof Player ? (Player) sender : null; 72 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.executesound")) return Collections.emptyList(); 73 | val lastWord = args[args.length - 1]; 74 | if (lastWord.length() <= 0) return Collections.emptyList(); 75 | return Arrays.stream(Sound.values()) 76 | .map(Sound::name) 77 | .filter(it -> StringUtils.startsWithIgnoreCase(it, lastWord)) 78 | .sorted() 79 | .collect(Collectors.toList()); 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/FeedCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.HumanEntity; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.HashMap; 15 | import java.util.List; 16 | import java.util.stream.Collectors; 17 | 18 | public class FeedCommand extends CommandService { 19 | 20 | public FeedCommand() { 21 | super("Feed", "miyukisystem.feed", false); 22 | } 23 | 24 | @Override 25 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 26 | 27 | if (!(sender instanceof Player) && args.length != 1) { 28 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 29 | return false; 30 | } 31 | 32 | Player player; 33 | if (args.length > 0) { 34 | 35 | if (!(sender.hasPermission("miyukisystem.feed.other"))) { 36 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 37 | return false; 38 | } 39 | 40 | player = Bukkit.getPlayer(args[0]); 41 | 42 | if (player == null) { 43 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 44 | return false; 45 | } 46 | 47 | if (player.getFoodLevel() >= 20) { 48 | MessageManagerKt.sendCustomMessage(sender, "FullFoodPlayer"); 49 | return false; 50 | } 51 | 52 | val placeHolders = new HashMap(); 53 | placeHolders.put("{player}", player.getName()); 54 | MessageManagerKt.sendCustomMessage(sender, "FeededPlayer", placeHolders); 55 | } else { 56 | 57 | player = (Player) sender; 58 | 59 | if (player.getFoodLevel() >= 20) { 60 | MessageManagerKt.sendCustomMessage(player, "FullFood"); 61 | return false; 62 | } 63 | 64 | MessageManagerKt.sendCustomMessage(player, "Feeded"); 65 | 66 | } 67 | 68 | player.setFoodLevel(20); 69 | player.setSaturation(10); 70 | player.setExhaustion(0F); 71 | 72 | return true; 73 | } 74 | 75 | @NotNull 76 | @Override 77 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 78 | val player = sender instanceof Player ? (Player) sender : null; 79 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.feed.other")) return Collections.emptyList(); 80 | val lastWord = args[args.length - 1]; 81 | return Bukkit.getOnlinePlayers().stream() 82 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 83 | .map(HumanEntity::getName) 84 | .sorted() 85 | .collect(Collectors.toList()); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/FlashLightCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.bukkit.potion.PotionEffect; 9 | import org.bukkit.potion.PotionEffectType; 10 | import org.jetbrains.annotations.NotNull; 11 | 12 | import java.util.Collections; 13 | import java.util.List; 14 | 15 | public class FlashLightCommand extends CommandService { 16 | 17 | public FlashLightCommand() { 18 | super("FlashLight", "miyukisystem.flashlight", false); 19 | } 20 | 21 | @Override 22 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 23 | 24 | if (!(sender instanceof Player)) { 25 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 26 | return false; 27 | } 28 | 29 | val player = (Player) sender; 30 | 31 | if (player.hasPotionEffect(PotionEffectType.NIGHT_VISION)) { 32 | player.removePotionEffect(PotionEffectType.NIGHT_VISION); 33 | MessageManagerKt.sendCustomMessage(player, "FlashLightDisabled"); 34 | } else { 35 | player.addPotionEffect(new PotionEffect(PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, 50)); 36 | MessageManagerKt.sendCustomMessage(player, "FlashLightActivated"); 37 | } 38 | 39 | return true; 40 | } 41 | 42 | @NotNull 43 | @Override 44 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 45 | return Collections.emptyList(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/FlyCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.HumanEntity; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.HashMap; 15 | import java.util.List; 16 | import java.util.stream.Collectors; 17 | 18 | public class FlyCommand extends CommandService { 19 | 20 | public FlyCommand() { 21 | super("Fly", "miyukisystem.fly", false); 22 | } 23 | 24 | @Override 25 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 26 | 27 | if (!(sender instanceof Player) && args.length != 1) { 28 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 29 | return false; 30 | } 31 | 32 | if (args.length > 0) { 33 | 34 | if (!(sender.hasPermission("miyukisystem.fly.other"))) { 35 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 36 | return false; 37 | } 38 | 39 | val target = Bukkit.getPlayer(args[0]); 40 | 41 | if (target == null) { 42 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 43 | return false; 44 | } 45 | 46 | val placeHolders = new HashMap(); 47 | placeHolders.put("{player}", target.getName()); 48 | target.setAllowFlight(!target.getAllowFlight()); 49 | 50 | MessageManagerKt.sendCustomMessage(sender, target.getAllowFlight() ? "FlyTargetActivated" : "FlyTargetDisabled", placeHolders); 51 | 52 | return true; 53 | } 54 | 55 | Player player = (Player) sender; 56 | player.setAllowFlight(!player.getAllowFlight()); 57 | MessageManagerKt.sendCustomMessage(player, player.getAllowFlight() ? "FlyActivated" : "FlyDisabled"); 58 | 59 | return true; 60 | } 61 | 62 | @NotNull 63 | @Override 64 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 65 | val player = sender instanceof Player ? (Player) sender : null; 66 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.fly.other")) return Collections.emptyList(); 67 | val lastWord = args[args.length - 1]; 68 | return Bukkit.getOnlinePlayers().stream() 69 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 70 | .map(HumanEntity::getName) 71 | .sorted() 72 | .collect(Collectors.toList()); 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/GamemodeCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManager; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.GameMode; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.HumanEntity; 12 | import org.bukkit.entity.Player; 13 | import org.jetbrains.annotations.NotNull; 14 | 15 | import java.util.*; 16 | import java.util.stream.Collectors; 17 | 18 | public class GamemodeCommand extends CommandService { 19 | 20 | public GamemodeCommand() { 21 | super("Gamemode", "miyukisystem.gamemode", false); 22 | } 23 | 24 | @Override 25 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 26 | 27 | if (args.length < 1 || args.length > 2) { 28 | MessageManagerKt.sendCustomMessage(sender, "IncorrectGameModeCommand"); 29 | return false; 30 | } 31 | 32 | val gameMode = matchGamemode(args[0]); 33 | 34 | if (gameMode == null) { 35 | MessageManagerKt.sendCustomMessage(sender, "GameModeNull"); 36 | return false; 37 | } 38 | 39 | if (args.length == 2) { 40 | 41 | val target = Bukkit.getPlayer(args[1]); 42 | 43 | if (target == null) { 44 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 45 | return false; 46 | } 47 | 48 | val placeHolders = new HashMap(); 49 | placeHolders.put("{gamemode}", getName(gameMode)); 50 | placeHolders.put("{player}", target.getName()); 51 | 52 | if (!(sender.hasPermission("miyukisystem.gamemode." + gameMode.name().toLowerCase()))) { 53 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 54 | return false; 55 | } 56 | 57 | target.setGameMode(gameMode); 58 | MessageManagerKt.sendCustomMessage(sender, "GameModeTargetChanged", placeHolders); 59 | 60 | return true; 61 | } 62 | 63 | if (!(sender instanceof Player)) { 64 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 65 | return false; 66 | } 67 | 68 | val player = (Player) sender; 69 | val placeHolders = new HashMap(); 70 | placeHolders.put("{gamemode}", getName(gameMode)); 71 | 72 | if (!(sender.hasPermission("miyukisystem.gamemode." + gameMode.name().toLowerCase()))) { 73 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 74 | return false; 75 | } 76 | 77 | player.setGameMode(gameMode); 78 | MessageManagerKt.sendCustomMessage(sender, "GameModeChanged", placeHolders); 79 | 80 | return true; 81 | } 82 | 83 | private GameMode matchGamemode(String gameMode) { 84 | gameMode = gameMode.toLowerCase(); 85 | if (gameMode.startsWith("su") || gameMode.startsWith("so") || gameMode.equals("0")) { 86 | return GameMode.SURVIVAL; 87 | } else if (gameMode.startsWith("cr") || gameMode.equals("1")) { 88 | return GameMode.CREATIVE; 89 | } else if (gameMode.startsWith("a") || gameMode.equals("2")) { 90 | return GameMode.ADVENTURE; 91 | } else if (gameMode.startsWith("sp") || gameMode.equals("3")) { 92 | return GameMode.SPECTATOR; 93 | } else { 94 | return null; 95 | } 96 | } 97 | 98 | private String getName(GameMode gameMode) { 99 | switch (gameMode) { 100 | case SURVIVAL: 101 | return MessageManager.Companion.getMessage("Survival")[0]; 102 | case CREATIVE: 103 | return MessageManager.Companion.getMessage("Creative")[0]; 104 | case SPECTATOR: 105 | return MessageManager.Companion.getMessage("Spectator")[0]; 106 | case ADVENTURE: 107 | return MessageManager.Companion.getMessage("Adventure")[0]; 108 | default: 109 | return ""; 110 | } 111 | } 112 | 113 | @NotNull 114 | @Override 115 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 116 | val player = sender instanceof Player ? (Player) sender : null; 117 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.gamemode")) 118 | return Collections.emptyList(); 119 | val lastWord = args[args.length - 1]; 120 | if (args.length == 1) { 121 | val modes = Arrays.asList("Survival", "Creative", "Adventure", "Spectator"); 122 | return modes.stream() 123 | .filter(it -> StringUtils.startsWithIgnoreCase(it, lastWord)) 124 | .collect(Collectors.toList()); 125 | } else { 126 | if (!player.hasPermission("miyukisystem.gamemode.other")) return Collections.emptyList(); 127 | return Bukkit.getOnlinePlayers().stream() 128 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 129 | .map(HumanEntity::getName) 130 | .sorted() 131 | .collect(Collectors.toList()); 132 | } 133 | } 134 | } 135 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/GodCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.Main; 5 | import miyukisystem.commands.CommandService; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.metadata.FixedMetadataValue; 13 | import org.jetbrains.annotations.NotNull; 14 | 15 | import java.util.Collections; 16 | import java.util.HashMap; 17 | import java.util.List; 18 | import java.util.stream.Collectors; 19 | 20 | public class GodCommand extends CommandService { 21 | 22 | // Em desenvolvimento pode ocorrer bugs 23 | 24 | public GodCommand() { 25 | super("God", "miyukisystem.god", false); 26 | } 27 | 28 | @Override 29 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 30 | 31 | val plugin = Main.Companion.getInstance(); 32 | 33 | if (args.length == 0) { 34 | if (!(sender instanceof Player)) { 35 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 36 | return false; 37 | } 38 | 39 | val player = (Player) sender; 40 | 41 | if (player.hasMetadata("miyukisystem_god")) { 42 | player.removeMetadata("miyukisystem_god", plugin); 43 | MessageManagerKt.sendCustomMessage(player, "DisabledGodMode"); 44 | } else { 45 | player.setMetadata("miyukisystem_god", new FixedMetadataValue(Main.Companion.getInstance(), "meta")); 46 | MessageManagerKt.sendCustomMessage(player, "EnabledGodMode"); 47 | } 48 | return true; 49 | } 50 | 51 | 52 | if (!(sender.hasPermission("miyukisystem.god.other"))) { 53 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 54 | return false; 55 | } 56 | 57 | val target = Bukkit.getPlayer(args[0]); 58 | 59 | if (target == null) { 60 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 61 | return false; 62 | } 63 | 64 | val placeHolders = new HashMap(); 65 | placeHolders.put("{target}", target.getName()); 66 | 67 | if (target.hasMetadata("miyukisystem_god")) { 68 | target.removeMetadata("miyukisystem_god", plugin); 69 | MessageManagerKt.sendCustomMessage(sender, "DisabledGodModeOther", placeHolders); 70 | } else { 71 | target.setMetadata("miyukisystem_god", new FixedMetadataValue(Main.Companion.getInstance(), "meta")); 72 | MessageManagerKt.sendCustomMessage(sender, "EnabledGodModeOther", placeHolders); 73 | } 74 | return true; 75 | } 76 | 77 | @NotNull 78 | @Override 79 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 80 | val player = sender instanceof Player ? (Player) sender : null; 81 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.god.other")) 82 | return Collections.emptyList(); 83 | val lastWord = args[args.length - 1]; 84 | return Bukkit.getOnlinePlayers().stream() 85 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 86 | .map(HumanEntity::getName) 87 | .sorted() 88 | .collect(Collectors.toList()); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/GrindstoneCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class GrindstoneCommand extends CommandService { 14 | 15 | public GrindstoneCommand() { 16 | super("Grindstone", "miyukisystem.grindstone", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | 29 | player.closeInventory(); 30 | 31 | try { 32 | player.openGrindstone(player.getLocation(), true); 33 | } catch (Exception exception) { 34 | MessageManagerKt.sendCustomMessage(sender, "UnavailableCommand"); 35 | } 36 | 37 | return true; 38 | 39 | } 40 | 41 | @NotNull 42 | @Override 43 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 44 | return Collections.emptyList(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/HatCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import org.bukkit.Material; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.bukkit.inventory.ItemStack; 9 | import org.bukkit.inventory.PlayerInventory; 10 | import org.jetbrains.annotations.NotNull; 11 | 12 | import java.util.Collections; 13 | import java.util.List; 14 | 15 | public class HatCommand extends CommandService { 16 | 17 | public HatCommand() { 18 | super("Hat", "miyukisystem.hat", false); 19 | } 20 | 21 | @Override 22 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 23 | 24 | if (!(sender instanceof Player)) { 25 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 26 | return false; 27 | } 28 | 29 | Player player = (Player) sender; 30 | PlayerInventory playerInventory = player.getInventory(); 31 | ItemStack itemInHand = player.getItemInHand(); 32 | 33 | if (itemInHand.getType().name().contains("HELMET") || itemInHand.getType() != Material.AIR && itemInHand.getType().getMaxDurability() == 0) { 34 | ItemStack helmet = playerInventory.getHelmet(); 35 | playerInventory.setHelmet(itemInHand); 36 | player.setItemInHand(helmet); 37 | MessageManagerKt.sendCustomMessage(player, "HatPlaced"); 38 | } else { 39 | MessageManagerKt.sendCustomMessage(player, "InvalidHat"); 40 | } 41 | 42 | return false; 43 | } 44 | 45 | @NotNull 46 | @Override 47 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 48 | return Collections.emptyList(); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/HealCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.HumanEntity; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.HashMap; 15 | import java.util.List; 16 | import java.util.stream.Collectors; 17 | 18 | public class HealCommand extends CommandService { 19 | 20 | public HealCommand() { 21 | super("Heal", "miyukisystem.heal", false); 22 | } 23 | 24 | @Override 25 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 26 | 27 | if (!(sender instanceof Player) && args.length != 1) { 28 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 29 | return false; 30 | } 31 | 32 | Player player; 33 | 34 | if (args.length > 0) { 35 | 36 | if (!(sender.hasPermission("miyukisystem.heal.other"))) { 37 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 38 | return false; 39 | } 40 | 41 | player = Bukkit.getPlayer(args[0]); 42 | 43 | if (player == null) { 44 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 45 | return false; 46 | } 47 | 48 | if (player.getHealth() >= 20.0) { 49 | MessageManagerKt.sendCustomMessage(sender, "FullLifePlayer"); 50 | return false; 51 | } 52 | 53 | val placeHolders = new HashMap(); 54 | placeHolders.put("{player}", player.getName()); 55 | MessageManagerKt.sendCustomMessage(sender, "HealedPlayer", placeHolders); 56 | } else { 57 | 58 | player = (Player) sender; 59 | 60 | if (player.getHealth() >= 20.0) { 61 | MessageManagerKt.sendCustomMessage(player, "FullLife"); 62 | return false; 63 | } 64 | 65 | MessageManagerKt.sendCustomMessage(player, "Healed"); 66 | } 67 | 68 | player.setHealth(20.0); 69 | 70 | return false; 71 | } 72 | 73 | @NotNull 74 | @Override 75 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 76 | val player = sender instanceof Player ? (Player) sender : null; 77 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.heal.other")) return Collections.emptyList(); 78 | val lastWord = args[args.length - 1]; 79 | return Bukkit.getOnlinePlayers().stream() 80 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 81 | .map(HumanEntity::getName) 82 | .sorted() 83 | .collect(Collectors.toList()); 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/InvSeeCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.PlayerManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.inventory.Inventory; 13 | import org.jetbrains.annotations.NotNull; 14 | 15 | import java.util.Collections; 16 | import java.util.HashMap; 17 | import java.util.List; 18 | import java.util.stream.Collectors; 19 | 20 | public class InvSeeCommand extends CommandService { 21 | 22 | public InvSeeCommand() { 23 | super("InvSee", "miyukisystem.invsee", false); 24 | } 25 | 26 | // adicionar para aparecer a armadura 27 | 28 | @Override 29 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 30 | 31 | if (!(sender instanceof Player)) { 32 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 33 | return false; 34 | } 35 | 36 | if (args.length != 1) { 37 | MessageManagerKt.sendCustomMessage(sender, "IncorrectInvSeeCommand"); 38 | return false; 39 | } 40 | 41 | val player = (Player) sender; 42 | val target = Bukkit.getPlayer(args[0]); 43 | 44 | if (target == null) { 45 | MessageManagerKt.sendCustomMessage(sender, "Offline"); 46 | return false; 47 | } 48 | 49 | if (target == player) { 50 | MessageManagerKt.sendCustomMessage(sender, ""); 51 | return false; 52 | } 53 | 54 | val placeHolders = new HashMap(); 55 | placeHolders.put("{player}", target.getName()); 56 | 57 | Inventory targetInventory = target.getInventory(); 58 | PlayerManagerKt.sendActionBar(target, "OpeningInventory"); // path do messages.yml. {player} retorna target.getName(); 59 | player.openInventory(targetInventory); 60 | 61 | return false; 62 | } 63 | 64 | @NotNull 65 | @Override 66 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 67 | val player = sender instanceof Player ? (Player) sender : null; 68 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.invsee")) return Collections.emptyList(); 69 | val lastWord = args[args.length - 1]; 70 | return Bukkit.getOnlinePlayers().stream() 71 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 72 | .map(HumanEntity::getName) 73 | .sorted() 74 | .collect(Collectors.toList()); 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/KickAllCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.ConfigManager; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.ChatColor; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.Player; 10 | import org.jetbrains.annotations.NotNull; 11 | 12 | import java.util.Collections; 13 | import java.util.List; 14 | 15 | public class KickAllCommand extends CommandService { 16 | 17 | public KickAllCommand() { 18 | super("KickAll", "miyukisystem.kickall", false); 19 | } 20 | 21 | 22 | @Override 23 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 24 | 25 | val config = ConfigManager.Companion.getConfig().config; 26 | 27 | val kickMessage = ChatColor.translateAlternateColorCodes('&', config.getString("KickAllMessage")); 28 | val kickSuccess = ChatColor.translateAlternateColorCodes('&', config.getString("KickAllSuccess")); 29 | 30 | for (Player player : Bukkit.getOnlinePlayers()) { 31 | 32 | if (player != sender) { 33 | player.kickPlayer(kickMessage); 34 | } 35 | 36 | } 37 | 38 | sender.sendMessage(config.getString(kickSuccess)); 39 | return false; 40 | } 41 | 42 | @NotNull 43 | @Override 44 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 45 | return Collections.emptyList(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/LoomCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class LoomCommand extends CommandService { 14 | 15 | public LoomCommand() { 16 | super("Loom", "miyukisystem.loom", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | 29 | player.closeInventory(); 30 | 31 | try { 32 | player.openLoom(player.getLocation(), true); 33 | } catch (Exception exception) { 34 | MessageManagerKt.sendCustomMessage(sender, "UnavailableCommand"); 35 | } 36 | 37 | return true; 38 | } 39 | 40 | @NotNull 41 | @Override 42 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 43 | return Collections.emptyList(); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/OnlineCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.HashMap; 12 | import java.util.List; 13 | 14 | public class OnlineCommand extends CommandService { 15 | 16 | public OnlineCommand() { 17 | super("Online", "miyukisystem.online", false); 18 | } 19 | 20 | @Override 21 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 22 | 23 | val placeHolders = new HashMap(); 24 | placeHolders.put("{online}", String.valueOf(Bukkit.getOnlinePlayers().size())); 25 | 26 | MessageManagerKt.sendCustomMessage(sender, "OnlinePlayers", placeHolders); 27 | 28 | return false; 29 | } 30 | 31 | @NotNull 32 | @Override 33 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 34 | return Collections.emptyList(); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/PingCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.PlayerManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.HashMap; 16 | import java.util.List; 17 | import java.util.stream.Collectors; 18 | 19 | public class PingCommand extends CommandService { 20 | 21 | public PingCommand() { 22 | super("Ping", "miyukisystem.ping", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (args.length > 0) { 29 | 30 | if (!(sender.hasPermission("miyukisystem.ping.other"))) { 31 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 32 | return false; 33 | } 34 | 35 | val target = Bukkit.getPlayer(args[0]); 36 | 37 | if (target == null) { 38 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 39 | return false; 40 | } 41 | 42 | val placeHolders = new HashMap(); 43 | placeHolders.put("{player}", target.getName()); 44 | placeHolders.put("{ping}", String.valueOf(PlayerManagerKt.getServerPing(target))); 45 | 46 | MessageManagerKt.sendCustomMessage(sender, "PingTarget", placeHolders); 47 | 48 | return true; 49 | } 50 | 51 | if (!(sender instanceof Player)) { 52 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 53 | return false; 54 | } 55 | 56 | val player = (Player) sender; 57 | val placeHolders = new HashMap(); 58 | placeHolders.put("{ping}", String.valueOf(PlayerManagerKt.getServerPing(player))); 59 | MessageManagerKt.sendCustomMessage(player, "Ping", placeHolders); 60 | return true; 61 | } 62 | 63 | @NotNull 64 | @Override 65 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 66 | Player player = sender instanceof Player ? (Player) sender : null; 67 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.ping.other")) return Collections.emptyList(); 68 | val lastWord = args[args.length - 1]; 69 | return Bukkit.getOnlinePlayers().stream() 70 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 71 | .map(HumanEntity::getName) 72 | .sorted() 73 | .collect(Collectors.toList()); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/RepairCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import com.cryptomorin.xseries.XMaterial; 4 | import lombok.val; 5 | import miyukisystem.commands.CommandService; 6 | import miyukisystem.manager.impl.ConfigManager; 7 | import miyukisystem.manager.impl.MessageManagerKt; 8 | import miyukisystem.util.NBTUtilKt; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | import java.util.Optional; 16 | 17 | public class RepairCommand extends CommandService { 18 | 19 | public RepairCommand() { 20 | super("Repair", "miyukisystem.repair", false); 21 | } 22 | 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | val config = ConfigManager.Companion.getConfig().config; 27 | 28 | if (!(sender instanceof Player)) { 29 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 30 | return false; 31 | } 32 | 33 | val player = (Player) sender; 34 | val itemInHand = player.getInventory().getItemInHand(); 35 | 36 | if (XMaterial.matchXMaterial(itemInHand.getType()).parseMaterial() == XMaterial.AIR.parseMaterial() || itemInHand.getType().getMaxDurability() == 0) { 37 | MessageManagerKt.sendCustomMessage(player, "NoReparable"); 38 | return false; 39 | } 40 | 41 | if (itemInHand.getDurability() == 0) { 42 | MessageManagerKt.sendCustomMessage(player, "MaxDurability"); 43 | return false; 44 | } 45 | 46 | if (config.getStringList("RepairBlockedNBTs").stream().anyMatch(it -> NBTUtilKt.containsNBT(itemInHand, it))) { 47 | MessageManagerKt.sendCustomMessage(player, "BlockedRepairItem"); 48 | return false; 49 | } 50 | 51 | val items = config.getStringList("RepairBlockedItems").stream().map(XMaterial::matchXMaterial).filter(Optional::isPresent).map(Optional::get); 52 | val hand = XMaterial.matchXMaterial(itemInHand); 53 | if (items.anyMatch(it -> it == hand)) { 54 | MessageManagerKt.sendCustomMessage(player, "BlockedRepairItem"); 55 | return false; 56 | } 57 | itemInHand.setDurability((short) 0); 58 | MessageManagerKt.sendCustomMessage(player, "SuccessRepair"); 59 | 60 | return true; 61 | } 62 | 63 | @NotNull 64 | @Override 65 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 66 | return Collections.emptyList(); 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SetSpawnCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.ConfigManager; 6 | import miyukisystem.manager.impl.LocationManager; 7 | import miyukisystem.manager.impl.MessageManagerKt; 8 | import miyukisystem.model.CachedLocation; 9 | import miyukisystem.util.LocationUtilKt; 10 | import org.bukkit.Location; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.configuration.file.YamlConfiguration; 13 | import org.bukkit.entity.Player; 14 | import org.jetbrains.annotations.NotNull; 15 | 16 | import java.util.Collections; 17 | import java.util.List; 18 | 19 | public class SetSpawnCommand extends CommandService { 20 | 21 | public SetSpawnCommand() { 22 | super("SetSpawn", "miyukisystem.setspawn", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (!(sender instanceof Player)) { 29 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 30 | return false; 31 | } 32 | 33 | val player = (Player) sender; 34 | 35 | val spawn = player.getLocation(); 36 | LocationManager.Companion.set(new CachedLocation("Spawn", spawn)); 37 | MessageManagerKt.sendCustomMessage(player, "SettedSpawnSuccess"); 38 | 39 | return false; 40 | } 41 | 42 | @NotNull 43 | @Override 44 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 45 | return Collections.emptyList(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SkullCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import com.cryptomorin.xseries.SkullUtils; 4 | import io.github.bananapuncher714.nbteditor.NBTEditor; 5 | import lombok.val; 6 | import miyukisystem.commands.CommandService; 7 | import miyukisystem.manager.impl.MessageManagerKt; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class SkullCommand extends CommandService { 17 | 18 | public SkullCommand() { 19 | super("Skull", "miyukisystem.skull", false); 20 | } 21 | 22 | @Override 23 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 24 | 25 | if (!(sender instanceof Player)) { 26 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 27 | return false; 28 | } 29 | 30 | val player = (Player) sender; 31 | 32 | if (args[0].contains("http") || args[0].contains("texture") || args[0].length() > 64) { 33 | MessageManagerKt.sendCustomMessage(player, "InvalidSkullFormat"); 34 | return false; 35 | } 36 | 37 | player.getInventory().addItem(args[0].length() > 16 ? NBTEditor.getHead("http://textures.minecraft.net/texture/" + args[0]) : SkullUtils.getSkull(Bukkit.getOfflinePlayer(args[0]).getUniqueId())); 38 | MessageManagerKt.sendCustomMessage(sender, "SuccessGiveSkull"); 39 | return true; 40 | } 41 | 42 | @NotNull 43 | @Override 44 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 45 | return Collections.emptyList(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SmithingTableCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class SmithingTableCommand extends CommandService { 14 | 15 | public SmithingTableCommand() { 16 | super("SmithingTable", "miyukisystem.smithingtable", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | 29 | player.closeInventory(); 30 | 31 | try { 32 | player.openSmithingTable(player.getLocation(), true); 33 | } catch (Exception exception) { 34 | MessageManagerKt.sendCustomMessage(sender, "UnavailableCommand"); 35 | } 36 | 37 | return true; 38 | 39 | } 40 | 41 | @NotNull 42 | @Override 43 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 44 | return Collections.emptyList(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SpawnCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.PlayerManagerKt; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.Sound; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.HumanEntity; 12 | import org.bukkit.entity.Player; 13 | import org.jetbrains.annotations.NotNull; 14 | 15 | import java.util.Collections; 16 | import java.util.HashMap; 17 | import java.util.List; 18 | import java.util.stream.Collectors; 19 | 20 | public class SpawnCommand extends CommandService { 21 | 22 | public SpawnCommand() { 23 | super("Spawn", "", false); 24 | } 25 | 26 | @Override 27 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 28 | 29 | if (args.length == 0) { 30 | 31 | if (!(sender instanceof Player)) { 32 | MessageManagerKt.sendCustomMessage(sender, "IncorrectSpawnAdminCommand"); 33 | return false; 34 | } 35 | 36 | val player = (Player) sender; 37 | 38 | PlayerManagerKt.toSpawn(player); 39 | 40 | MessageManagerKt.sendCustomMessage(player, "TeleportedSpawnSuccess"); 41 | player.playSound(player.getLocation(), Sound.valueOf("LEVEL_UP"), 1.0f, 1.0f); 42 | return true; 43 | } 44 | 45 | if (!(sender.hasPermission("miyukisystem.spawn.other"))) { 46 | MessageManagerKt.sendCustomMessage(sender, "NoPermission"); 47 | return false; 48 | } 49 | 50 | val target = Bukkit.getPlayer(args[0]); 51 | 52 | if (target == null) { 53 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 54 | return false; 55 | } 56 | 57 | val placeHolders = new HashMap(); 58 | placeHolders.put("{player}", target.getName()); 59 | 60 | PlayerManagerKt.toSpawn(target); 61 | MessageManagerKt.sendCustomMessage(sender, "SentToSpawn", placeHolders); 62 | MessageManagerKt.sendCustomMessage(sender, "ForcedTeleportSpawn"); 63 | 64 | return false; 65 | } 66 | 67 | @NotNull 68 | @Override 69 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 70 | val player = sender instanceof Player ? (Player) sender : null; 71 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.spawn.other")) return Collections.emptyList(); 72 | val lastWord = args[args.length - 1]; 73 | return Bukkit.getOnlinePlayers().stream() 74 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 75 | .map(HumanEntity::getName) 76 | .sorted() 77 | .collect(Collectors.toList()); 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SpeedCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import org.bukkit.command.CommandSender; 6 | import org.bukkit.entity.Player; 7 | import org.jetbrains.annotations.NotNull; 8 | 9 | import java.util.Collections; 10 | import java.util.List; 11 | 12 | public class SpeedCommand extends CommandService { 13 | 14 | public SpeedCommand() { 15 | super("Speed", "miyukisystem.speed", false); 16 | } 17 | 18 | @Override 19 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 20 | 21 | if (!(sender instanceof Player) && args.length != 2) { 22 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 23 | return false; 24 | } 25 | 26 | return false; 27 | } 28 | 29 | @NotNull 30 | @Override 31 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 32 | return Collections.emptyList(); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/StonecutterCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class StonecutterCommand extends CommandService { 14 | 15 | public StonecutterCommand() { 16 | super("Stonecutter", "miyukisystem.stonecutter", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | 29 | player.closeInventory(); 30 | 31 | try { 32 | player.openStonecutter(player.getLocation(), true); 33 | } catch (Exception exception) { 34 | MessageManagerKt.sendCustomMessage(sender, "UnavailableCommand"); 35 | } 36 | 37 | return true; 38 | 39 | } 40 | 41 | @NotNull 42 | @Override 43 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 44 | return Collections.emptyList(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/SudoCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.HumanEntity; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | import java.util.stream.Collectors; 16 | 17 | public class SudoCommand extends CommandService { 18 | 19 | public SudoCommand() { 20 | super("Sudo", "miyukisystem.sudo", false); 21 | } 22 | 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | if (args.length < 2) { 27 | MessageManagerKt.sendCustomMessage(sender, "IncorrectSudoCommand"); 28 | return false; 29 | } 30 | 31 | val target = Bukkit.getPlayer(args[0]); 32 | 33 | if (target == null) { 34 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 35 | return false; 36 | } 37 | 38 | val message = String.join(" ", args); 39 | target.performCommand(message); 40 | 41 | return false; 42 | } 43 | 44 | @NotNull 45 | @Override 46 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 47 | val player = sender instanceof Player ? (Player) sender : null; 48 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.sudo")) return Collections.emptyList(); 49 | val lastWord = args[args.length - 1]; 50 | return Bukkit.getOnlinePlayers().stream() 51 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 52 | .map(HumanEntity::getName) 53 | .sorted() 54 | .collect(Collectors.toList()); 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TeleportCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.HashMap; 16 | import java.util.List; 17 | import java.util.stream.Collectors; 18 | 19 | public class TeleportCommand extends CommandService { 20 | 21 | public TeleportCommand() { 22 | super("Teleport", "miyukisystem.teleport", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (args.length < 1 || args.length > 4) { 29 | MessageManagerKt.sendCustomMessage(sender, "IncorrectTeleportCommand"); 30 | return false; 31 | } 32 | 33 | if (args.length == 1) { 34 | 35 | if (!(sender instanceof Player)) { 36 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 37 | return false; 38 | } 39 | 40 | Player target = Bukkit.getPlayer(args[0]); 41 | 42 | if (target == null) { 43 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 44 | return false; 45 | } 46 | 47 | if (target.getName().equals(sender.getName())) { 48 | MessageManagerKt.sendCustomMessage(sender, "TeleportedToYourself"); 49 | return false; 50 | } 51 | 52 | val placeHolders = new HashMap(); 53 | placeHolders.put("{player}", target.getName()); 54 | 55 | Player player = (Player) sender; 56 | player.teleport(target.getLocation()); 57 | MessageManagerKt.sendCustomMessage(player, "TeleportedSuccess", placeHolders); 58 | return false; 59 | } 60 | 61 | if (args.length == 2) { 62 | 63 | Player player = Bukkit.getPlayer(args[0]); 64 | 65 | if (player == null) { 66 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 67 | return false; 68 | } 69 | 70 | Player target = Bukkit.getPlayer(args[1]); 71 | 72 | if (target == null) { 73 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 74 | return false; 75 | } 76 | 77 | if (player.getName().equals(target.getName())) { 78 | sender.sendMessage(""); 79 | return false; 80 | } 81 | 82 | player.teleport(target); 83 | 84 | } 85 | 86 | double x, y, z; 87 | 88 | if (args.length == 3) { 89 | 90 | if (!(sender instanceof Player)) { 91 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 92 | return false; 93 | } 94 | 95 | try { 96 | x = Double.parseDouble(args[0]); 97 | y = Double.parseDouble(args[1]); 98 | z = Double.parseDouble(args[2]); 99 | } catch (NumberFormatException exception) { 100 | MessageManagerKt.sendCustomMessage(sender, "InvalidCoords"); 101 | return false; 102 | } 103 | 104 | Player player = (Player) sender; 105 | Location locationTarget = new Location(player.getWorld(), x, y, z); 106 | player.teleport(locationTarget); 107 | MessageManagerKt.sendCustomMessage(player, "TeleportedSuccessWithCoords"); 108 | } 109 | 110 | if (args.length == 4) { 111 | 112 | Player target = Bukkit.getPlayer(args[0]); 113 | 114 | if (target == null) { 115 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 116 | return false; 117 | } 118 | 119 | try { 120 | x = Double.parseDouble(args[1]); 121 | y = Double.parseDouble(args[2]); 122 | z = Double.parseDouble(args[3]); 123 | } catch (NumberFormatException exception) { 124 | MessageManagerKt.sendCustomMessage(sender, "InvalidCoords"); 125 | return false; 126 | } 127 | 128 | val placeHolders = new HashMap(); 129 | placeHolders.put("{player}", target.getName()); 130 | 131 | Location locationTarget = new Location(target.getWorld(), x, y, z); 132 | target.teleport(locationTarget); 133 | MessageManagerKt.sendCustomMessage(sender, "PlayerTeleportedSuccessWithCoords", placeHolders); 134 | } 135 | 136 | return false; 137 | } 138 | 139 | @NotNull 140 | @Override 141 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 142 | val player = sender instanceof Player ? (Player) sender : null; 143 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.teleport")) return Collections.emptyList(); 144 | val lastWord = args[args.length - 1]; 145 | return Bukkit.getOnlinePlayers().stream() 146 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 147 | .map(HumanEntity::getName) 148 | .sorted() 149 | .collect(Collectors.toList()); 150 | } 151 | } 152 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TitleCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import miyukisystem.commands.CommandService; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import miyukisystem.manager.impl.PlayerManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class TitleCommand extends CommandService { 14 | 15 | public TitleCommand() { 16 | super("Title", "miyukisystem.title", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (args.length == 0) { 23 | MessageManagerKt.sendCustomMessage(sender, "IncorrectTitleCommand"); 24 | return false; 25 | } 26 | 27 | String message = String.join(" ", args).replace('&', '§'); 28 | 29 | String[] title = message.split("\\|"); 30 | 31 | if (title.length == 1) 32 | Bukkit.getOnlinePlayers().forEach(it -> PlayerManagerKt.title(it, title[0], "")); 33 | else 34 | Bukkit.getOnlinePlayers().forEach(it -> PlayerManagerKt.title(it, title[0], title[1])); 35 | 36 | MessageManagerKt.sendCustomMessage(sender, "TitleSent"); 37 | 38 | return false; 39 | } 40 | 41 | @NotNull 42 | @Override 43 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 44 | return Collections.emptyList(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpAcceptCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.TpaManager; 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.HumanEntity; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.HashMap; 16 | import java.util.List; 17 | import java.util.stream.Collectors; 18 | 19 | public class TpAcceptCommand extends CommandService { 20 | 21 | public TpAcceptCommand() { 22 | super("TpAccept", "miyukisystem.tpa", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (!(sender instanceof Player)) { 29 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 30 | return false; 31 | } 32 | 33 | val player = (Player) sender; 34 | 35 | if (args.length < 1) { 36 | 37 | val targetTPA = TpaManager.Companion.lastReceived(player.getName()); 38 | 39 | if (targetTPA == null) { 40 | MessageManagerKt.sendCustomMessage(sender, "NoHaveRequests"); 41 | return false; 42 | } 43 | 44 | val targetName = targetTPA.getFrom(); 45 | val target = Bukkit.getPlayer(targetName); 46 | 47 | if (target == null) { 48 | MessageManagerKt.sendCustomMessage(sender, "ExpiredTpa"); 49 | return false; 50 | } 51 | 52 | TpaManager.Companion.remove(target.getName()); 53 | 54 | val placeHolders = new HashMap(); 55 | placeHolders.put("{target}", player.getName()); // Lembrando que aqui é o contrário. 56 | placeHolders.put("{player}", target.getName()); 57 | 58 | MessageManagerKt.sendCustomMessage(target, "AcceptTpaPlayer", placeHolders); 59 | MessageManagerKt.sendCustomMessage(player, "AcceptTpaOther", placeHolders); 60 | target.teleport(player.getLocation()); 61 | 62 | } else { 63 | 64 | Player target = Bukkit.getPlayer(args[0]); 65 | 66 | if (target == null) { 67 | MessageManagerKt.sendCustomMessage(player, "PlayerOffline"); 68 | return false; 69 | } 70 | 71 | if (target.equals(player)) { 72 | MessageManagerKt.sendCustomMessage(player, "TpAcceptYourself"); 73 | return false; 74 | } 75 | 76 | if (!TpaManager.Companion.has(target.getName())) { 77 | MessageManagerKt.sendCustomMessage(player, "NoHaveRequests"); 78 | return false; 79 | } 80 | 81 | TpaManager.Companion.remove(target.getName()); 82 | 83 | val placeHolders = new HashMap(); 84 | placeHolders.put("{target}", player.getName()); // Lembrando que aqui é o contrário. 85 | placeHolders.put("{player}", target.getName()); 86 | 87 | MessageManagerKt.sendCustomMessage(player, "AcceptTpaOther", placeHolders); 88 | MessageManagerKt.sendCustomMessage(target, "AcceptTpaPlayer", placeHolders); 89 | target.teleport(player.getLocation()); 90 | 91 | } 92 | 93 | return true; 94 | } 95 | 96 | @NotNull 97 | @Override 98 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 99 | val player = sender instanceof Player ? (Player) sender : null; 100 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.tpaccept")) 101 | return Collections.emptyList(); 102 | val lastWord = args[args.length - 1]; 103 | return Bukkit.getOnlinePlayers().stream() 104 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 105 | .map(HumanEntity::getName) 106 | .sorted() 107 | .collect(Collectors.toList()); 108 | } 109 | } 110 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpAllCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.bukkit.entity.Player; 9 | import org.jetbrains.annotations.NotNull; 10 | 11 | import java.util.Collections; 12 | import java.util.HashMap; 13 | import java.util.List; 14 | 15 | public class TpAllCommand extends CommandService { 16 | 17 | public TpAllCommand() { 18 | super("TpAll", "miyukisystem.tpall", false); 19 | } 20 | 21 | @Override 22 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 23 | 24 | if (args.length > 1) { 25 | MessageManagerKt.sendCustomMessage(sender, "IncorrectTpAllCommand"); 26 | return false; 27 | } 28 | 29 | if (args.length == 1) { 30 | 31 | Player target = Bukkit.getPlayer(args[0]); 32 | 33 | if (target == null) { 34 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 35 | return false; 36 | } 37 | 38 | Bukkit.getOnlinePlayers().forEach(it -> { 39 | if (it != target) 40 | it.teleport(target); 41 | }); 42 | 43 | val placeHolders = new HashMap(); 44 | placeHolders.put("{player}", target.getName()); 45 | 46 | MessageManagerKt.sendCustomMessage(target, "AllPlayersTeleportedToYou"); 47 | MessageManagerKt.sendCustomMessage(sender, "ForcedTpAll", placeHolders); 48 | } 49 | 50 | if (args.length == 0) { 51 | 52 | Player p = (Player) sender; 53 | 54 | Bukkit.getOnlinePlayers().forEach(it -> { 55 | if (it != p) 56 | it.teleport(p); 57 | }); 58 | } 59 | 60 | return false; 61 | } 62 | 63 | @NotNull 64 | @Override 65 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 66 | return Collections.emptyList(); 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpDenyCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.TpaManager; 7 | import miyukisystem.model.TPA; 8 | import org.apache.commons.lang.StringUtils; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | import java.util.Collections; 15 | import java.util.HashMap; 16 | import java.util.List; 17 | import java.util.stream.Collectors; 18 | 19 | public class TpDenyCommand extends CommandService { 20 | 21 | public TpDenyCommand() { 22 | super("TpDeny", "miyukisystem.tpa", false); 23 | } 24 | 25 | @Override 26 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 27 | 28 | if (!(sender instanceof Player)) { 29 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 30 | return false; 31 | } 32 | 33 | Player player = (Player) sender; 34 | 35 | if(args.length < 1) { 36 | 37 | val targetTPA = TpaManager.Companion.lastReceived(player.getName()); 38 | 39 | if (targetTPA == null) { 40 | MessageManagerKt.sendCustomMessage(player, "NoHaveRequests"); 41 | return false; 42 | } 43 | 44 | val targetName = targetTPA.getFrom(); 45 | val target = Bukkit.getPlayer(targetName); 46 | 47 | TpaManager.Companion.remove(targetName); 48 | 49 | val placeHolders = new HashMap(); 50 | placeHolders.put("{target}", player.getName()); // Lembrando que aqui é o contrário. 51 | placeHolders.put("{player}", targetName); 52 | 53 | MessageManagerKt.sendCustomMessage(player, "DenyTpaOther", placeHolders); 54 | 55 | if (target!= null) { 56 | MessageManagerKt.sendCustomMessage(target, "DenyTpaPlayer", placeHolders); 57 | } 58 | } else { 59 | 60 | val target = Bukkit.getPlayer(args[0]); 61 | 62 | if(target == null) { 63 | MessageManagerKt.sendCustomMessage(player, "PlayerOffline"); 64 | return false; 65 | } 66 | 67 | if(target.equals(player)) { 68 | MessageManagerKt.sendCustomMessage(player, "TpDenyYourself"); 69 | return false; 70 | } 71 | 72 | if (TpaManager.Companion.getAll().stream().noneMatch(it -> it.getFrom().equals(target.getName()))) { 73 | MessageManagerKt.sendCustomMessage(player, "NoHaveRequests"); 74 | return false; 75 | } 76 | 77 | TpaManager.Companion.remove(target.getName()); 78 | 79 | val placeHolders = new HashMap(); 80 | placeHolders.put("{target}", player.getName()); // Lembrando que aqui é o contrário. 81 | placeHolders.put("{player}", target.getName()); 82 | 83 | MessageManagerKt.sendCustomMessage(player, "DenyTpaOther", placeHolders); 84 | MessageManagerKt.sendCustomMessage(target, "DenyTpaPlayer", placeHolders); 85 | 86 | } 87 | return true; 88 | } 89 | 90 | @NotNull 91 | @Override 92 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 93 | val player = sender instanceof Player ? (Player) sender : null; 94 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.tpa")) return Collections.emptyList(); 95 | val lastWord = args[args.length - 1]; 96 | return TpaManager.Companion.getAll().stream() 97 | .filter(it -> it.getTo().equalsIgnoreCase(player.getName()) && StringUtils.startsWithIgnoreCase(it.getFrom(), lastWord)) 98 | .map(TPA::getFrom) 99 | .sorted() 100 | .collect(Collectors.toList()); 101 | } 102 | } 103 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpHereCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.command.CommandSender; 8 | import org.bukkit.entity.Player; 9 | import org.jetbrains.annotations.NotNull; 10 | 11 | import java.util.Collections; 12 | import java.util.HashMap; 13 | import java.util.List; 14 | 15 | public class TpHereCommand extends CommandService { 16 | 17 | public TpHereCommand() { 18 | super("TpHere", "miyukisystem.tphere", false); 19 | } 20 | 21 | // Comando 100% feito. 22 | 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | if (!(sender instanceof Player)) { 27 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 28 | return false; 29 | } 30 | 31 | if (args.length != 1) { 32 | MessageManagerKt.sendCustomMessage(sender, "IncorrectTpHereCommand"); 33 | return false; 34 | } 35 | 36 | Player player = (Player) sender; 37 | Player target = Bukkit.getPlayer(args[0]); 38 | 39 | if (target == null) { 40 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 41 | return false; 42 | } 43 | 44 | target.teleport(player.getLocation()); 45 | 46 | val placeHolders = new HashMap(); 47 | placeHolders.put("{player}", target.getName()); 48 | 49 | MessageManagerKt.sendCustomMessage(sender, "TpHereSuccess", placeHolders); 50 | 51 | return false; 52 | } 53 | 54 | // fazer o tab complete 55 | @NotNull 56 | @Override 57 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 58 | return Collections.emptyList(); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpaCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.TpaManager; 7 | import miyukisystem.manager.impl.UserManager; 8 | import miyukisystem.model.TPA; 9 | import org.apache.commons.lang.StringUtils; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.entity.HumanEntity; 13 | import org.bukkit.entity.Player; 14 | import org.jetbrains.annotations.NotNull; 15 | 16 | import java.util.Collections; 17 | import java.util.HashMap; 18 | import java.util.List; 19 | import java.util.stream.Collectors; 20 | 21 | public class TpaCommand extends CommandService { 22 | 23 | public static HashMap> tps = new HashMap<>(); 24 | 25 | public TpaCommand() { 26 | super("Tpa", "miyukisystem.tpa", false); 27 | } 28 | 29 | @Override 30 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 31 | 32 | if (!(sender instanceof Player)) { 33 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 34 | return false; 35 | } 36 | 37 | val player = (Player) sender; 38 | val playerUser = UserManager.Companion.get(player.getName()); 39 | 40 | if (args.length != 1) { 41 | MessageManagerKt.sendCustomMessage(player, "IncorrectTpaCommand"); 42 | return false; 43 | } 44 | 45 | if(!playerUser.getTpaEnabled()) { 46 | MessageManagerKt.sendCustomMessage(player, "YourTpaIsDisabled"); 47 | return false; 48 | } 49 | 50 | val target = Bukkit.getPlayer(args[0]); 51 | 52 | if (target == null) { 53 | MessageManagerKt.sendCustomMessage(player, "PlayerOffline"); 54 | return false; 55 | } 56 | 57 | if (target == player) { 58 | MessageManagerKt.sendCustomMessage(player, "TpaYourself"); 59 | return false; 60 | } 61 | 62 | val targetUser = UserManager.Companion.get(target.getName()); 63 | 64 | if(!targetUser.getTpaEnabled()) { 65 | MessageManagerKt.sendCustomMessage(player, "TargetTpaIsDisabled"); 66 | return false; 67 | } 68 | 69 | val tpa = new TPA(player.getName(), target.getName()); 70 | val placeHolders = new HashMap(); 71 | placeHolders.put("{player}", player.getName()); 72 | placeHolders.put("{target}", target.getName()); 73 | 74 | TpaManager.Companion.set(tpa); 75 | MessageManagerKt.sendCustomMessage(target, "TpaOther", placeHolders); 76 | MessageManagerKt.sendCustomMessage(player, "TpaPlayer", placeHolders); 77 | 78 | return true; 79 | } 80 | 81 | @NotNull 82 | @Override 83 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 84 | val player = sender instanceof Player ? (Player) sender : null; 85 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.tpa")) return Collections.emptyList(); 86 | val lastWord = args[args.length - 1]; 87 | return Bukkit.getOnlinePlayers().stream() 88 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 89 | .map(HumanEntity::getName) 90 | .sorted() 91 | .collect(Collectors.toList()); 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TpaToggleCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.UserManager; 7 | import org.bukkit.command.CommandSender; 8 | import org.bukkit.entity.Player; 9 | import org.jetbrains.annotations.NotNull; 10 | 11 | import java.util.Collections; 12 | import java.util.List; 13 | 14 | public class TpaToggleCommand extends CommandService { 15 | 16 | public TpaToggleCommand() { 17 | super("TpaToggle", "miyukisystem.tpatoggle", false); 18 | } 19 | 20 | @Override 21 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 22 | 23 | if (!(sender instanceof Player)) { 24 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 25 | return false; 26 | } 27 | 28 | val player = (Player) sender; 29 | 30 | val user = UserManager.Companion.get(player.getName()); 31 | 32 | user.setTpaEnabled(!user.getTpaEnabled()); 33 | user.save(); 34 | MessageManagerKt.sendCustomMessage(player, !user.getTpaEnabled() ? "TpaDisabled" : "TpaEnabled"); 35 | 36 | return true; 37 | } 38 | 39 | @NotNull 40 | @Override 41 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 42 | return Collections.emptyList(); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/TrashCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.Main; 5 | import miyukisystem.commands.CommandService; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.inventory.Inventory; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class TrashCommand extends CommandService { 17 | 18 | public TrashCommand() { 19 | super("Trash", "miyukisystem.trash", false); 20 | } 21 | 22 | @Override 23 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 24 | 25 | if (!(sender instanceof Player)) { 26 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 27 | return false; 28 | } 29 | 30 | val player = (Player) sender; 31 | 32 | val titleMenu = Main.instance.getConfig().getString("TrashTitleMenu"); 33 | val sizeMenu = Main.instance.getConfig().getInt("TrashSize"); 34 | 35 | Inventory trash = Bukkit.createInventory(null, sizeMenu, titleMenu); 36 | 37 | player.openInventory(trash); 38 | return false; 39 | } 40 | 41 | @NotNull 42 | @Override 43 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 44 | return Collections.emptyList(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/VanishCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.Main; 5 | import miyukisystem.commands.CommandService; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.metadata.FixedMetadataValue; 11 | import org.jetbrains.annotations.NotNull; 12 | 13 | import java.util.Collections; 14 | import java.util.HashMap; 15 | import java.util.List; 16 | 17 | public class VanishCommand extends CommandService { 18 | 19 | public VanishCommand() { 20 | super("Vanish", "miyukisystem.vanish", false); 21 | } 22 | 23 | @Override 24 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 25 | 26 | val plugin = Main.Companion.getInstance(); 27 | 28 | if(args.length == 0) { 29 | 30 | if (!(sender instanceof Player)) { 31 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 32 | return false; 33 | } 34 | 35 | val player = (Player) sender; 36 | val players = Bukkit.getOnlinePlayers(); 37 | 38 | if(!player.hasMetadata("miyukisystem_vanish")) { 39 | player.setMetadata("miyukisystem_vanish", new FixedMetadataValue(plugin, "meta")); 40 | players.forEach(it -> { 41 | if(!it.hasPermission("miyukisystem.bypass.vanish")) 42 | it.hidePlayer(player); 43 | }); 44 | MessageManagerKt.sendCustomMessage(player, "VanishJoined"); 45 | } else { 46 | player.removeMetadata("miyukisystem_vanish", plugin); 47 | players.forEach(it -> it.showPlayer(player)); 48 | MessageManagerKt.sendCustomMessage(player, "VanishLeaved"); 49 | } 50 | return true; 51 | } 52 | 53 | val player = (Player) sender; 54 | val players = Bukkit.getOnlinePlayers(); 55 | val target = Bukkit.getPlayer(args[0]); 56 | 57 | if(target == null) { 58 | MessageManagerKt.sendCustomMessage(player, "PlayerOffline"); 59 | return false; 60 | } 61 | 62 | val placeHolders = new HashMap(); 63 | placeHolders.put("{target}", target.getName()); 64 | 65 | if (!target.hasMetadata("miyukisystem_vanish")) { 66 | target.setMetadata("miyukisystem_vanish", new FixedMetadataValue(plugin, "meta")); 67 | players.forEach(it -> it.hidePlayer(target)); 68 | MessageManagerKt.sendCustomMessage(player, "VanishJoinedOther", placeHolders); 69 | } else { 70 | target.removeMetadata("miyukisystem_vanish", plugin); 71 | players.forEach(it -> it.showPlayer(target)); 72 | MessageManagerKt.sendCustomMessage(player, "VanishLeavedOther", placeHolders); 73 | } 74 | 75 | return true; 76 | } 77 | 78 | @NotNull 79 | @Override 80 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 81 | return Collections.emptyList(); 82 | } 83 | } 84 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/WhitelistCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.commands.SubCommand; 6 | import miyukisystem.commands.impl.subcommands.whitelist.*; 7 | import miyukisystem.manager.impl.MessageManagerKt; 8 | import org.apache.commons.lang.StringUtils; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.HumanEntity; 12 | import org.bukkit.entity.Player; 13 | import org.jetbrains.annotations.NotNull; 14 | 15 | import java.util.ArrayList; 16 | import java.util.Collections; 17 | import java.util.List; 18 | import java.util.Optional; 19 | import java.util.stream.Collectors; 20 | 21 | public class WhitelistCommand extends CommandService { 22 | 23 | List subCommands = new ArrayList<>(); 24 | 25 | public WhitelistCommand() { 26 | super("Whitelist", "miyukisystem.whitelist", false); 27 | subCommands.add(new WhitelistAddSubCommand()); 28 | subCommands.add(new WhitelistRemoveSubCommand()); 29 | subCommands.add(new WhitelistPermissionSubCommand()); 30 | subCommands.add(new WhitelistReloadSubCommand()); 31 | subCommands.add(new WhitelistTrueSubCommand()); 32 | subCommands.add(new WhitelistFalseSubCommand()); 33 | } 34 | 35 | @Override 36 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 37 | 38 | if(args.length > 0) { 39 | for(SubCommand subCommand : subCommands) { 40 | List aliases = subCommand.getAliases(); 41 | if(aliases.contains(args[0].toLowerCase())) { 42 | return subCommand.execute(sender, args); 43 | } 44 | } 45 | } 46 | 47 | MessageManagerKt.sendCustomMessage(sender, "WhitelistHelp"); 48 | 49 | return true; 50 | } 51 | 52 | @NotNull 53 | @Override 54 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 55 | val player = sender instanceof Player ? (Player) sender : null; 56 | if (args.length == 0 || player == null || !player.hasPermission("miyukisystem.whitelist")) return Collections.emptyList(); 57 | val lastWord = args[args.length - 1]; 58 | if (args.length == 1) { 59 | return subCommands.stream() 60 | .map(it -> it.getAliases().stream().findFirst()) 61 | .filter(Optional::isPresent) 62 | .map(Optional::get) 63 | .filter(it -> StringUtils.startsWithIgnoreCase(it, lastWord)) 64 | .sorted() 65 | .collect(Collectors.toList()); 66 | } 67 | else if (args.length == 3) { 68 | List aliases = new ArrayList<>(); 69 | subCommands.forEach(it -> { 70 | if (it instanceof WhitelistPermissionSubCommand) { 71 | ((WhitelistPermissionSubCommand) it).subCommands.stream() 72 | .map(subCommand -> subCommand.getAliases().stream().findFirst()) 73 | .filter(Optional::isPresent) 74 | .map(Optional::get) 75 | .forEach(aliases::add); 76 | } 77 | }); 78 | return aliases; 79 | } else { 80 | return Bukkit.getOnlinePlayers().stream() 81 | .filter(it -> player.canSee(it) && StringUtils.startsWithIgnoreCase(it.getName(), lastWord)) 82 | .map(HumanEntity::getName) 83 | .sorted() 84 | .collect(Collectors.toList()); 85 | } 86 | } 87 | 88 | } 89 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/WorkbenchCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.CommandService; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import org.bukkit.command.CommandSender; 7 | import org.bukkit.entity.Player; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.Collections; 11 | import java.util.List; 12 | 13 | public class WorkbenchCommand extends CommandService { 14 | 15 | public WorkbenchCommand() { 16 | super("Workbench", "miyukisystem.workbench", false); 17 | } 18 | 19 | @Override 20 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args) { 21 | 22 | if (!(sender instanceof Player)) { 23 | MessageManagerKt.sendCustomMessage(sender, "NoConsole"); 24 | return false; 25 | } 26 | 27 | val player = (Player) sender; 28 | player.closeInventory(); 29 | player.openWorkbench(player.getLocation(), true); 30 | return false; 31 | } 32 | 33 | @NotNull 34 | @Override 35 | public List onTabComplete(@NotNull CommandSender sender, @NotNull String[] args) { 36 | return Collections.emptyList(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistAddSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.SubCommand; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import miyukisystem.model.WhitelistPlayer; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.command.CommandSender; 10 | import org.jetbrains.annotations.NotNull; 11 | 12 | public class WhitelistAddSubCommand extends SubCommand { 13 | 14 | public WhitelistAddSubCommand() { 15 | super("WhitelistAdd"); 16 | } 17 | 18 | @Override 19 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 20 | 21 | val manager = WhitelistManager.Companion; 22 | 23 | if(args.length < 1) { 24 | MessageManagerKt.sendCustomMessage(sender, "IncorrectWhitelistAddSubCommand"); 25 | return false; 26 | } 27 | 28 | val target = Bukkit.getPlayer(args[0]); 29 | 30 | if(target == null) { 31 | MessageManagerKt.sendCustomMessage(sender, "PlayerOffline"); 32 | return false; 33 | } 34 | 35 | if(manager.has(target.getName())) { 36 | MessageManagerKt.sendCustomMessage(sender, "PlayerAlreadyOnTheWhitelist"); 37 | return false; 38 | } 39 | 40 | WhitelistPlayer whitelistPlayer = new WhitelistPlayer("target", false, false, false); 41 | whitelistPlayer.save(); 42 | manager.set(whitelistPlayer); 43 | MessageManagerKt.sendCustomMessage(sender, "AddedThePlayerFromTheWhitelist"); 44 | 45 | return true; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistFalseSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.SubCommand; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | public class WhitelistFalseSubCommand extends SubCommand { 11 | 12 | public WhitelistFalseSubCommand() { 13 | super("WhitelistFalse"); 14 | } 15 | 16 | @Override 17 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 18 | 19 | val manager = WhitelistManager.Companion; 20 | 21 | if(!manager.getState()) { 22 | MessageManagerKt.sendCustomMessage(sender, "WhitelistAlreadyFalse"); 23 | return false; 24 | } 25 | 26 | manager.setState(false); 27 | MessageManagerKt.sendCustomMessage(sender, "WhitelistFalse"); 28 | 29 | return true; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistPermissionSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.SubCommand; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | import java.util.ArrayList; 11 | import java.util.List; 12 | 13 | public class WhitelistPermissionSubCommand extends SubCommand { 14 | 15 | public List subCommands = new ArrayList<>(); 16 | 17 | public WhitelistPermissionSubCommand() { 18 | super("WhitelistPermission"); 19 | 20 | subCommands.add(new SubCommand("WhitelistPermissionBreakBlock") { 21 | @Override 22 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 23 | 24 | val target = WhitelistManager.Companion.get(args[0]); 25 | 26 | if(target.getCanBreak()) { 27 | target.setCanBreak(false); 28 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionCanBreakFalse"); 29 | } else { 30 | target.setCanBreak(true); 31 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionCanBreakTrue"); 32 | } 33 | return true; 34 | } 35 | }); 36 | 37 | subCommands.add(new SubCommand("WhitelistPermissionExecuteCommands") { 38 | @Override 39 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 40 | 41 | val target = WhitelistManager.Companion.get(args[0]); 42 | 43 | if(target.getCanExecuteCommands()) { 44 | target.setCanExecuteCommands(false); 45 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionExecuteCommandsFalse"); 46 | } else { 47 | target.setCanExecuteCommands(true); 48 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionExecuteCommandsTrue"); 49 | } 50 | return true; 51 | } 52 | }); 53 | 54 | subCommands.add(new SubCommand("WhitelistPermissionPlaceBlocks") { 55 | @Override 56 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 57 | 58 | val target = WhitelistManager.Companion.get(args[0]); 59 | 60 | if(target.getCanPlace()) { 61 | target.setCanPlace(false); 62 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionCanPlaceFalse"); 63 | } else { 64 | target.setCanPlace(true); 65 | MessageManagerKt.sendCustomMessage(sender, "WhitelistPermissionCanPlaceTrue"); 66 | } 67 | return true; 68 | } 69 | }); 70 | 71 | } 72 | 73 | @Override 74 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 75 | 76 | if(args.length != 2) { 77 | MessageManagerKt.sendCustomMessage(sender, "IncorrectWhitelistPermissionSubCommand"); 78 | return false; 79 | } 80 | 81 | if(!WhitelistManager.Companion.has(args[0])) { 82 | MessageManagerKt.sendCustomMessage(sender, "PlayerNotOnTheWhitelist"); 83 | return false; 84 | } 85 | 86 | for (SubCommand subCommand : subCommands) { 87 | 88 | if (subCommand.getAliases().contains(args[1].toLowerCase())) { 89 | val arg = new String[] { "", args[0], args[1] }; 90 | return subCommand.execute(sender, arg); 91 | } 92 | 93 | } 94 | 95 | MessageManagerKt.sendCustomMessage(sender, "WhitelistHelp"); 96 | 97 | return true; 98 | } 99 | } 100 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistReloadSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import miyukisystem.commands.SubCommand; 4 | import miyukisystem.manager.impl.MessageManagerKt; 5 | import miyukisystem.manager.impl.WhitelistManager; 6 | import org.bukkit.command.CommandSender; 7 | import org.jetbrains.annotations.NotNull; 8 | 9 | public class WhitelistReloadSubCommand extends SubCommand { 10 | 11 | public WhitelistReloadSubCommand() { 12 | super("WhitelistReload"); 13 | } 14 | 15 | @Override 16 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 17 | 18 | WhitelistManager.Companion.reload(); 19 | MessageManagerKt.sendCustomMessage(sender, "WhitelistReloaded"); 20 | 21 | return true; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistRemoveSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.SubCommand; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | public class WhitelistRemoveSubCommand extends SubCommand { 11 | 12 | public WhitelistRemoveSubCommand() { 13 | super("WhitelistRemove"); 14 | } 15 | 16 | @Override 17 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 18 | 19 | if(args.length < 1) { 20 | MessageManagerKt.sendCustomMessage(sender, "IncorrectWhitelistRemoveSubCommand"); 21 | return false; 22 | } 23 | 24 | if(!WhitelistManager.Companion.has(args[0])) { 25 | MessageManagerKt.sendCustomMessage(sender, "PlayerNotOnTheWhitelist"); 26 | return false; 27 | } 28 | 29 | val target = WhitelistManager.Companion.get(args[0]); 30 | val targetName = target.getPlayerName(); 31 | 32 | WhitelistManager.Companion.remove(targetName); 33 | MessageManagerKt.sendCustomMessage(sender, "RemovedThePlayerFromTheWhitelist"); 34 | 35 | return true; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/commands/impl/subcommands/whitelist/WhitelistTrueSubCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands.impl.subcommands.whitelist; 2 | 3 | import lombok.val; 4 | import miyukisystem.commands.SubCommand; 5 | import miyukisystem.manager.impl.MessageManagerKt; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import org.bukkit.command.CommandSender; 8 | import org.jetbrains.annotations.NotNull; 9 | 10 | public class WhitelistTrueSubCommand extends SubCommand { 11 | 12 | public WhitelistTrueSubCommand() { 13 | super("WhitelistTrue"); 14 | } 15 | 16 | @Override 17 | public boolean execute(@NotNull CommandSender sender, @NotNull String[] args, @NotNull String command) { 18 | 19 | val manager = WhitelistManager.Companion; 20 | 21 | if(manager.getState()) { 22 | MessageManagerKt.sendCustomMessage(sender, "WhitelistAlreadyTrue"); 23 | return false; 24 | } 25 | 26 | manager.setState(true); 27 | MessageManagerKt.sendCustomMessage(sender, "WhitelistTrue"); 28 | 29 | return true; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/DropPlayerHeadOnDeath.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import com.cryptomorin.xseries.SkullUtils; 4 | import kotlin.random.Random; 5 | import miyukisystem.manager.impl.ConfigManager; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.entity.PlayerDeathEvent; 9 | 10 | public class DropPlayerHeadOnDeath implements Listener { 11 | 12 | @EventHandler 13 | public void onPlayerDeath(PlayerDeathEvent event) { 14 | if (!ConfigManager.Companion.getConfig().config.getBoolean("DropPlayerHeadOnDeath")) return; 15 | if (ConfigManager.Companion.getConfig().config.getInt("DropPlayerHeadChance") > Random.Default.nextInt(1, 100)) return; 16 | event.getEntity().getInventory().addItem(SkullUtils.getSkull(event.getEntity().getUniqueId())); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/GodModeDamage.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import lombok.val; 4 | import org.bukkit.entity.Player; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.entity.EntityDamageEvent; 8 | 9 | public class GodModeDamage implements Listener { 10 | 11 | @EventHandler 12 | public void onEntityDamage(EntityDamageEvent e) { 13 | 14 | if (!(e.getEntity() instanceof Player)) { 15 | return; 16 | } 17 | 18 | val player = (Player) e.getEntity(); 19 | 20 | if (player.hasMetadata("miyukisystem_god")) { 21 | e.setCancelled(true); 22 | } 23 | 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/KeepEXP.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.entity.PlayerDeathEvent; 7 | 8 | public class KeepEXP implements Listener { 9 | 10 | @EventHandler 11 | public void onPlayerDeath(PlayerDeathEvent event) { 12 | 13 | Player player = event.getEntity(); 14 | 15 | if (!(player.hasPermission("miyukisystem.keepxp"))) return; 16 | 17 | event.setKeepLevel(true); 18 | event.setDroppedExp(0); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/KickPlayerOnWhitelist.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.manager.impl.ConfigManager; 5 | import miyukisystem.manager.impl.MessageManager; 6 | import miyukisystem.manager.impl.WhitelistManager; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.Listener; 9 | import org.bukkit.event.player.PlayerJoinEvent; 10 | 11 | public class KickPlayerOnWhitelist implements Listener { 12 | 13 | @EventHandler 14 | public void onPlayerJoin(PlayerJoinEvent e) { 15 | 16 | val config = ConfigManager.Companion.getData().config; 17 | val player = e.getPlayer(); 18 | val manager = WhitelistManager.Companion; 19 | 20 | if (!manager.getState()) return; 21 | 22 | if (config.getBoolean("WhitelistState")) { 23 | if (!manager.has(player.getName())) { 24 | player.kickPlayer(String.join("\n", MessageManager.Companion.getMessage("WhitelistOnKick"))); 25 | } 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/Motd.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import lombok.val; 4 | import miyukisystem.manager.impl.ConfigManager; 5 | import miyukisystem.manager.impl.WhitelistManager; 6 | import org.apache.commons.lang.StringUtils; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.event.EventHandler; 9 | import org.bukkit.event.Listener; 10 | import org.bukkit.event.server.ServerListPingEvent; 11 | 12 | public class Motd implements Listener { 13 | 14 | @EventHandler 15 | public void onServerListPing(ServerListPingEvent e) { 16 | 17 | val config = ConfigManager.Companion.getConfig().config; 18 | 19 | if(StringUtils.isEmpty(config.getString("Motd.WhitelistMotd")) || StringUtils.isEmpty(config.getString("Motd.NormalMotd"))) return; 20 | 21 | if (Bukkit.hasWhitelist() || WhitelistManager.Companion.getState()) { 22 | e.setMotd(config.getString("Motd.WhitelistMotd")); 23 | e.setMaxPlayers(config.getInt("Motd.WhitelistMaxPlayers")); 24 | } else { 25 | e.setMotd(config.getString("Motd.NormalMotd")); 26 | e.setMaxPlayers(config.getInt("Motd.NormalMaxPlayers")); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/TeleportToSpawn.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import miyukisystem.manager.impl.PlayerManagerKt; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.player.PlayerJoinEvent; 8 | 9 | public class TeleportToSpawn implements Listener { 10 | 11 | @EventHandler 12 | public void onJoin(PlayerJoinEvent event) { 13 | 14 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Spawn")) return; 15 | 16 | PlayerManagerKt.toSpawn(event.getPlayer()); 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/VanishNewPlayers.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl; 2 | 3 | import lombok.val; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.player.PlayerJoinEvent; 8 | 9 | public class VanishNewPlayers implements Listener { 10 | 11 | @EventHandler 12 | public void onPlayerJoin(PlayerJoinEvent e) { 13 | val player = e.getPlayer(); 14 | 15 | Bukkit.getOnlinePlayers().forEach(it -> { 16 | if (!it.hasPermission("miyukisystem.bypass.vanish") && it.hasMetadata("miyukisystem_vanish")) { 17 | player.hidePlayer(it); 18 | } 19 | }); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockAnvilDecay.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.Material; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.entity.EntityChangeBlockEvent; 9 | 10 | public class BlockAnvilDecay implements Listener { 11 | 12 | @EventHandler(ignoreCancelled = true) 13 | public void onEntityChangeBlock(EntityChangeBlockEvent event) { 14 | 15 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.AnvilDecay")) return; 16 | 17 | if (event.getEntityType() == EntityType.FALLING_BLOCK && event.getTo() == Material.AIR) { 18 | if (event.getBlock().getType() == Material.ANVIL) { 19 | event.setCancelled(true); 20 | event.getBlock().getState().update(false, false); 21 | } 22 | } 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockCommand.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import lombok.val; 4 | import miyukisystem.manager.impl.ConfigManager; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.player.PlayerCommandPreprocessEvent; 8 | 9 | import java.util.stream.Collectors; 10 | 11 | public class BlockCommand implements Listener { 12 | 13 | @EventHandler 14 | public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent e) { 15 | val player = e.getPlayer(); 16 | 17 | if (player.hasPermission("miyukisystem.bypass.blockedcommands")) return; 18 | 19 | val command = e.getMessage().split(" ")[0].toLowerCase(); 20 | 21 | val blockedCommands = ConfigManager.Companion.getCommands().config.getStringList("BlockedCommands").stream() 22 | .map(String::toLowerCase) 23 | .collect(Collectors.toList()); 24 | 25 | if (blockedCommands.contains(command)) { 26 | player.sendMessage("BlockedCommand"); 27 | e.setCancelled(true); 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockDeathMessage.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.entity.PlayerDeathEvent; 7 | 8 | public class BlockDeathMessage implements Listener { 9 | 10 | @EventHandler 11 | public void onDeath(PlayerDeathEvent event) { 12 | 13 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.DeathMessage")) return; 14 | 15 | event.setDeathMessage(null); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockFallIntoVoid.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import miyukisystem.manager.impl.PlayerManagerKt; 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.entity.EntityDamageEvent; 9 | import org.bukkit.event.entity.EntityDamageEvent.DamageCause; 10 | 11 | public class BlockFallIntoVoid implements Listener { 12 | 13 | @EventHandler 14 | public void onFallVoid(EntityDamageEvent event) { 15 | 16 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.FallIntoVoid")) return; 17 | 18 | if (event.getCause() == DamageCause.VOID && event.getEntity() instanceof Player) { 19 | Player player = (Player) event.getEntity(); 20 | if (player.getLocation().getBlockY() < 0) { 21 | event.setCancelled(true); 22 | player.setFallDistance(1); 23 | PlayerManagerKt.toSpawn(player); 24 | } 25 | } 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockFeed.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.entity.FoodLevelChangeEvent; 7 | 8 | public class BlockFeed implements Listener { 9 | 10 | @EventHandler 11 | public void onChangeFoodLevel(FoodLevelChangeEvent event) { 12 | 13 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.Feed")) return; 14 | 15 | event.setCancelled(true); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockFreezeWater.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.Material; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.EventPriority; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.block.BlockFormEvent; 9 | 10 | public class BlockFreezeWater implements Listener { 11 | 12 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 13 | public void onFreeze(BlockFormEvent event) { 14 | 15 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.FreezeWater")) return; 16 | 17 | if (event.getBlock().getType() == Material.WATER) { 18 | event.setCancelled(true); 19 | } 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockGetIntoVehicles.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import lombok.val; 4 | import miyukisystem.manager.impl.ConfigManager; 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.vehicle.VehicleEnterEvent; 9 | 10 | public class BlockGetIntoVehicles implements Listener { 11 | 12 | @EventHandler 13 | public void onVehicleEnterEvent(VehicleEnterEvent e) { 14 | 15 | val entity = e.getEntered(); 16 | val config = ConfigManager.Companion.getConfig().config; 17 | 18 | if(!(entity instanceof Player)) { 19 | if (config.getBoolean("Blockers.EntityGetIntoVehicles")) e.setCancelled(true); 20 | } else { 21 | if (config.getBoolean("Blockers.PlayerGetIntoVehicles")) e.setCancelled(true); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockImproperNicks.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import lombok.val; 4 | import miyukisystem.manager.impl.ConfigManager; 5 | import miyukisystem.manager.impl.MessageManager; 6 | import miyukisystem.manager.impl.MessageManagerKt; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.configuration.file.YamlConfiguration; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.Listener; 11 | import org.bukkit.event.player.PlayerJoinEvent; 12 | 13 | import java.util.HashMap; 14 | 15 | public class BlockImproperNicks implements Listener { 16 | 17 | private final YamlConfiguration config = ConfigManager.Companion.getConfig().config; 18 | 19 | @EventHandler 20 | public void onJoin(PlayerJoinEvent event) { 21 | 22 | for (String nickName : config.getStringList("BlockedNicks")) { 23 | if (nickName.equals(event.getPlayer().getName())) { 24 | val message = MessageManager.Companion.getMessage("ImproperNick"); 25 | val kickMessage = String.join(" \n", message); 26 | event.getPlayer().kickPlayer(kickMessage); 27 | 28 | val placeHolders = new HashMap(); 29 | placeHolders.put("{player}", event.getPlayer().getName()); 30 | placeHolders.put("{ip}", String.valueOf(event.getPlayer().getAddress())); 31 | 32 | MessageManagerKt.sendCustomMessage(Bukkit.getConsoleSender(), "ImproperNickLogged", placeHolders); 33 | } 34 | } 35 | 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockItemExplosion.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.entity.Item; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.entity.EntityDamageByEntityEvent; 8 | 9 | public class BlockItemExplosion implements Listener { 10 | 11 | @EventHandler 12 | public void onExplode(EntityDamageByEntityEvent event) { 13 | 14 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.ItemExplosion")) return; 15 | 16 | if (event.getEntity() instanceof Item) event.setCancelled(true); 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockLeaveDecay.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.block.LeavesDecayEvent; 7 | 8 | public class BlockLeaveDecay implements Listener { 9 | 10 | @EventHandler 11 | public void onLeavesDecay(LeavesDecayEvent event) { 12 | 13 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.LeavesDecay")) return; 14 | 15 | event.setCancelled(true); 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockMelt.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.Material; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.block.BlockFadeEvent; 8 | 9 | public class BlockMelt implements Listener { 10 | 11 | @EventHandler 12 | public void onMelt(BlockFadeEvent event) { 13 | 14 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.Melt")) return; 15 | 16 | if (event.getBlock().getType() == Material.ICE || event.getBlock().getType() == Material.SNOW) event.setCancelled(true); 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockMobCatchFire.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.entity.EntityCombustByBlockEvent; 7 | import org.bukkit.event.entity.EntityCombustByEntityEvent; 8 | import org.bukkit.event.entity.EntityCombustEvent; 9 | 10 | public class BlockMobCatchFire implements Listener { 11 | 12 | @EventHandler 13 | public void onEntityCombust(EntityCombustEvent event) { 14 | 15 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.MobsCatchFire")) return; 16 | 17 | if (!(event instanceof EntityCombustByEntityEvent) && !(event instanceof EntityCombustByBlockEvent)) { 18 | event.setCancelled(true); 19 | } 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockPortalCreation.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.EventPriority; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.world.PortalCreateEvent; 8 | 9 | public class BlockPortalCreation implements Listener { 10 | 11 | @EventHandler 12 | public void onPortalCreate(PortalCreateEvent event) { 13 | 14 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.CreatePortal")) return; 15 | 16 | event.setCancelled(true); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockPortalTeleport.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.configuration.file.YamlConfiguration; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.Listener; 7 | import org.bukkit.event.player.PlayerPortalEvent; 8 | import org.bukkit.event.player.PlayerTeleportEvent; 9 | 10 | public class BlockPortalTeleport implements Listener { 11 | 12 | YamlConfiguration config = ConfigManager.Companion.getConfig().config; 13 | 14 | @EventHandler 15 | public void onTeleport(PlayerPortalEvent event) { 16 | 17 | if (event.getCause() == PlayerTeleportEvent.TeleportCause.NETHER_PORTAL && config.getBoolean("Blockers.Portal.Nether")) { 18 | event.setCancelled(true); 19 | } 20 | 21 | if (event.getCause() == PlayerTeleportEvent.TeleportCause.END_PORTAL && config.getBoolean("Blockers.Portal.End")) { 22 | event.setCancelled(true); 23 | } 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockRain.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.weather.WeatherChangeEvent; 7 | 8 | public class BlockRain implements Listener { 9 | 10 | @EventHandler(ignoreCancelled = true) 11 | public void onWeatherChange(WeatherChangeEvent event) { 12 | 13 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.RainCancel")) return; 14 | 15 | if (event.toWeatherState()) { 16 | event.setCancelled(true); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/miyukisystem/listener/impl/blockers/BlockSleep.java: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener.impl.blockers; 2 | 3 | import miyukisystem.manager.impl.ConfigManager; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.event.player.PlayerBedEnterEvent; 7 | 8 | public class BlockSleep implements Listener { 9 | 10 | @EventHandler 11 | public void onSleep(PlayerBedEnterEvent event) { 12 | 13 | if (!ConfigManager.Companion.getConfig().config.getBoolean("Blockers.Sleep")) return; 14 | 15 | event.setCancelled(true); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/Main.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem 2 | 3 | import io.github.slimjar.app.builder.ApplicationBuilder 4 | import miyukisystem.commands.CommandService 5 | import miyukisystem.database.Database 6 | import miyukisystem.hook.Vault 7 | import miyukisystem.listener.ListenerRegistry 8 | import miyukisystem.manager.ManagerService 9 | import miyukisystem.manager.impl.ConfigManager 10 | import org.bukkit.Bukkit 11 | import org.bukkit.plugin.java.JavaPlugin 12 | import java.io.File 13 | import java.nio.file.Paths 14 | 15 | class Main : JavaPlugin() { 16 | 17 | companion object { 18 | 19 | lateinit var instance: Main 20 | 21 | } 22 | 23 | 24 | override fun onLoad() { 25 | 26 | Bukkit.getConsoleSender().sendMessage("§9§lMiyukiSystem §cCarregando/Baixando as bibliotecas do plugin...") 27 | Bukkit.getConsoleSender().sendMessage("§9§lMiyukiSystem §cEsta acao pode levar um tempo, aguarde.") 28 | ApplicationBuilder 29 | .appending("MiyukiSystem") 30 | .downloadDirectoryPath(Paths.get(File(dataFolder, "libs").absolutePath)) 31 | .build() 32 | "§9§lMiyukiSystem §aTodas as bibliotecas foram baixadas e carregadas com sucesso.".sendToConsole() 33 | } 34 | 35 | override fun onEnable() { 36 | instance = this 37 | 38 | if (!Vault.setupEconomy()) { 39 | "§9§lMiyukiSystem §cO vault nao foi encontrado no servidor.".sendToConsole() 40 | Bukkit.getPluginManager().disablePlugin(this) 41 | return 42 | } 43 | 44 | ConfigManager.load() 45 | CommandService.CommandRegistry.load() 46 | ListenerRegistry.load() 47 | ManagerService.load() 48 | Database.dataSource 49 | 50 | } 51 | 52 | override fun onDisable() { 53 | try { 54 | Database.dataSource.closeConnection() 55 | } catch (ignored: Exception) { } 56 | } 57 | 58 | 59 | } 60 | 61 | fun String?.sendToConsole() { 62 | if (this == null || this == "") return 63 | Bukkit.getConsoleSender().sendMessage(this) 64 | } 65 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/commands/CommandService.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands 2 | 3 | import com.google.common.reflect.ClassPath 4 | import miyukisystem.Main 5 | import miyukisystem.manager.ManagerService 6 | import miyukisystem.manager.impl.ConfigManager 7 | import miyukisystem.manager.impl.sendCustomMessage 8 | import miyukisystem.sendToConsole 9 | import miyukisystem.util.async 10 | import org.bukkit.Bukkit 11 | import org.bukkit.command.Command 12 | import org.bukkit.command.CommandMap 13 | import org.bukkit.command.CommandSender 14 | 15 | 16 | abstract class CommandService( 17 | name: String, 18 | private val perm: String, 19 | private val async: Boolean = true 20 | ) : Command(name) { 21 | 22 | object CommandRegistry : ManagerService { 23 | 24 | override fun load() { 25 | val classPath = ClassPath.from(Main.instance.javaClass.classLoader) 26 | var i = 0 27 | classPath.getTopLevelClassesRecursive("miyukisystem.commands.impl").forEach { classInfo -> 28 | try { 29 | val command = classInfo.load().newInstance() 30 | if (command is CommandService && command.canRegister()) { 31 | val field = Bukkit.getPluginManager().javaClass.getDeclaredField("commandMap") 32 | field.isAccessible = true 33 | val commandMap = field.get(Bukkit.getPluginManager()) as CommandMap 34 | commandMap.register("miyukisystem", command) 35 | i++ 36 | } 37 | } catch (exception: Exception) { 38 | exception.printStackTrace() 39 | } 40 | } 41 | "§9§lMiyukiSystem §aForam registrados §7$i §acomandos.".sendToConsole() 42 | } 43 | 44 | override fun reload() { } 45 | 46 | 47 | } 48 | 49 | private val commandConfig = ConfigManager.commands.config 50 | 51 | private val enabled: Boolean 52 | private val commandName: String 53 | private val commandDescription: String 54 | 55 | init { 56 | val section = commandConfig.getConfigurationSection(name)!! 57 | enabled = section.getBoolean("Enabled") 58 | commandName = section.getString("Command")!! 59 | commandDescription = section.getString("Description")!! 60 | } 61 | 62 | fun canRegister() : Boolean { 63 | if (!enabled) return false 64 | val commands: Array = 65 | if(commandName.contains("|")) 66 | commandName.split("|").toTypedArray() 67 | else 68 | arrayOf(commandName) 69 | if (commands.isNullOrEmpty()) return false; 70 | setDescription(description) 71 | val register = setName(commands[0]) 72 | aliases = commands.drop(1) 73 | return register 74 | } 75 | 76 | abstract fun execute(sender: CommandSender, args: Array): Boolean 77 | 78 | abstract fun onTabComplete(sender: CommandSender, args: Array): List 79 | 80 | override fun tabComplete(sender: CommandSender, alias: String, args: Array): MutableList { 81 | return onTabComplete(sender, args).toMutableList(); 82 | } 83 | 84 | override fun execute(sender: CommandSender, commandLabel: String, args: Array): Boolean { 85 | if (!sender.hasPermission(perm)) { 86 | sender.sendCustomMessage("NoPermission") 87 | return false 88 | } 89 | return try { 90 | if (async) { 91 | async { 92 | execute(sender, args) 93 | } 94 | return true 95 | } 96 | else execute(sender, args) 97 | } catch (exception: Exception) { 98 | exception.printStackTrace() 99 | sender.sendMessage("§9MiyukiSystem §cOcorreu um erro ao tentar executar o comando. Contate o administrador.") 100 | false; 101 | } 102 | 103 | } 104 | 105 | 106 | 107 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/commands/SubCommand.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.commands 2 | 3 | import miyukisystem.manager.impl.ConfigManager 4 | import org.bukkit.command.CommandSender 5 | 6 | abstract class SubCommand(val name: String) { 7 | 8 | val aliases: List 9 | val enabled : Boolean 10 | 11 | init { 12 | val section = ConfigManager.subCommands.config.getConfigurationSection(name)!! 13 | 14 | aliases = section.getString("Aliases")!!.split("|") 15 | enabled = section.getBoolean("Enabled") 16 | } 17 | 18 | fun execute(sender: CommandSender, args: Array): Boolean { 19 | val command = args[0] 20 | val correctArgs = args.sliceArray(1 until args.size) 21 | return execute(sender, correctArgs, command) 22 | } 23 | 24 | abstract fun execute(sender: CommandSender, args: Array, command: String): Boolean 25 | 26 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/Database.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database 2 | 3 | import miyukisystem.database.datasource.DataSource 4 | import miyukisystem.database.datasource.impl.H2 5 | import miyukisystem.database.datasource.impl.MySQL 6 | import miyukisystem.database.datasource.impl.SQLite 7 | import miyukisystem.database.tables.Table 8 | import miyukisystem.database.tables.impl.Users 9 | import miyukisystem.manager.impl.ConfigManager 10 | import miyukisystem.model.User 11 | import miyukisystem.sendToConsole 12 | 13 | 14 | class Database { 15 | 16 | companion object { 17 | 18 | lateinit var dataSource: DataSource 19 | 20 | lateinit var USERS: Table 21 | 22 | init { 23 | 24 | "§9§lMiyukiSystem §cConectando ao banco de dados.".sendToConsole() 25 | try { 26 | dataSource = when (ConfigManager.config.config.getString("Database.Mode")!!.uppercase()) { 27 | "MYSQL", "MARIADB" -> MySQL() 28 | "SQLITE" -> SQLite() 29 | else -> H2() 30 | } 31 | 32 | dataSource.getConnection() 33 | 34 | USERS = Users() 35 | 36 | "§9§lMiyukiSystem §aA conexao com o banco de dados foi estabelecida com sucesso.".sendToConsole() 37 | } catch (exception: Exception) { 38 | exception.printStackTrace() 39 | "§9§lMiyukiSystem §cOcorreu um erro ao tentar estabelecer uma conexao com o banco de dados.".sendToConsole() 40 | } 41 | 42 | } 43 | 44 | 45 | 46 | 47 | } 48 | 49 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/adapter/LocationAdapter.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.adapter 2 | 3 | import com.google.gson.TypeAdapter 4 | import com.google.gson.stream.JsonReader 5 | import com.google.gson.stream.JsonWriter 6 | import miyukisystem.util.toCustomString 7 | import miyukisystem.util.toLocation 8 | import org.bukkit.Bukkit 9 | import org.bukkit.Location 10 | 11 | class LocationAdapter : TypeAdapter() { 12 | 13 | override fun write(out: JsonWriter, value: Location) { 14 | out.beginObject() 15 | out.name("loc").value(value.toCustomString()) 16 | out.endObject() 17 | } 18 | 19 | override fun read(`in`: JsonReader): Location { 20 | `in`.beginObject() 21 | var loc: Location? = null 22 | while (`in`.hasNext()) { 23 | if (`in`.nextName() == "loc") { 24 | loc = `in`.nextString().toLocation() 25 | } 26 | } 27 | `in`.endObject() 28 | return loc!! 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/datasource/DataSource.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.datasource 2 | 3 | import java.sql.Connection 4 | 5 | interface DataSource { 6 | 7 | fun getConnection(): Connection 8 | 9 | fun closeConnection() 10 | 11 | 12 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/datasource/impl/H2.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.datasource.impl 2 | 3 | import miyukisystem.Main 4 | import miyukisystem.database.datasource.DataSource 5 | import java.io.File 6 | import java.sql.Connection 7 | import java.sql.DriverManager 8 | 9 | class H2 : DataSource { 10 | 11 | private val url: String = "jdbc:h2:./${File(Main.instance.dataFolder, "database")}" 12 | 13 | init { 14 | Class.forName("org.h2.Driver") 15 | } 16 | 17 | override fun getConnection(): Connection = DriverManager.getConnection(url) 18 | 19 | override fun closeConnection() { } 20 | 21 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/datasource/impl/MySQL.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.datasource.impl 2 | 3 | import com.zaxxer.hikari.HikariConfig 4 | import com.zaxxer.hikari.HikariDataSource 5 | import miyukisystem.database.datasource.DataSource 6 | import miyukisystem.manager.impl.ConfigManager 7 | import java.lang.Exception 8 | import java.sql.Connection 9 | 10 | class MySQL : DataSource { 11 | 12 | private val connection: HikariDataSource 13 | 14 | init { 15 | 16 | val config = ConfigManager.config.config 17 | var section = config.getConfigurationSection("Database")!! 18 | 19 | val mode = section.getString("Mode")!!.lowercase() 20 | 21 | val hikariConfig = HikariConfig().apply { 22 | jdbcUrl = 23 | "jdbc:$mode://${section.getString("Host")}:${section.getString("Port")}/${section.getString("Database")}" 24 | username = section.getString("Username") 25 | password = section.getString("Password") 26 | 27 | driverClassName = if (mode == "mysql") { 28 | try { 29 | Class.forName("com.mysql.cj.jdbc.Driver") 30 | "com.mysql.cj.jdbc.Driver" 31 | } catch (exception: Exception) { 32 | "com.mysql.jdbc.Driver" 33 | } 34 | } else 35 | "org.mariadb.jdbc.Driver" 36 | 37 | section = section.getConfigurationSection("MySQLConfiguration")!! 38 | 39 | poolName = section.getString("PoolName") 40 | minimumIdle = section.getInt("MiniumIdle") 41 | maximumPoolSize = section.getInt("MaximumPoolSize") 42 | connectionTimeout = section.getLong("ConnectionTimeout") 43 | addDataSourceProperty("cachePrepStmts", section.getBoolean("CachePrepStmts")) 44 | addDataSourceProperty("prepStmtCacheSize", section.getInt("PrepStmtCacheSize")) 45 | addDataSourceProperty("prepStmtCacheSqlLimit", section.getInt("PrepStmtCacheSqlLimit")) 46 | addDataSourceProperty("useServerPrepStmts", section.getBoolean("UseServerPrepStmts")) 47 | addDataSourceProperty("useLocalSessionState", section.getBoolean("UseLocalSessionState")) 48 | addDataSourceProperty("rewriteBatchedStatements", section.getBoolean("RewriteBatchedStatements")) 49 | addDataSourceProperty("cacheResultSetMetadata", section.getBoolean("CacheResultSetMetadata")) 50 | addDataSourceProperty("cacheServerConfiguration", section.getBoolean("CacheServerConfiguration")) 51 | addDataSourceProperty("elideSetAutoCommits", section.getBoolean("ElideSetAutoCommits")) 52 | addDataSourceProperty("maintainTimeStats", section.getBoolean("MaintainTimeStats")) 53 | } 54 | 55 | connection = HikariDataSource(hikariConfig) 56 | 57 | } 58 | 59 | override fun getConnection(): Connection = connection.connection 60 | 61 | override fun closeConnection() { 62 | if (!connection.isClosed) { 63 | connection.close() 64 | } 65 | } 66 | 67 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/datasource/impl/SQLite.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.datasource.impl 2 | 3 | import miyukisystem.Main 4 | import miyukisystem.database.datasource.DataSource 5 | import java.io.File 6 | import java.sql.Connection 7 | import java.sql.DriverManager 8 | 9 | class SQLite : DataSource { 10 | 11 | private val url: String = "jdbc:sqlite:${File(Main.instance.dataFolder, "database.sqlite.db")}" 12 | 13 | init { 14 | Class.forName("org.sqlite.JDBC") 15 | } 16 | 17 | override fun getConnection(): Connection = DriverManager.getConnection(url) 18 | 19 | override fun closeConnection() { } 20 | 21 | 22 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/tables/Table.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.tables 2 | 3 | import java.util.concurrent.CompletableFuture 4 | 5 | interface Table { 6 | 7 | fun createTable() 8 | 9 | fun has(key: String): CompletableFuture 10 | 11 | fun insert(value: T) 12 | 13 | fun update(value: T) 14 | 15 | fun get(key: String): CompletableFuture 16 | 17 | fun getAll(): CompletableFuture> 18 | 19 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/database/tables/impl/Users.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.database.tables.impl 2 | 3 | import com.google.gson.GsonBuilder 4 | import miyukisystem.database.Database 5 | import miyukisystem.database.adapter.LocationAdapter 6 | import miyukisystem.database.tables.Table 7 | import miyukisystem.model.User 8 | import org.bukkit.Location 9 | import java.util.concurrent.CompletableFuture 10 | 11 | class Users : Table { 12 | 13 | private val gson = GsonBuilder() 14 | .disableHtmlEscaping() 15 | .enableComplexMapKeySerialization() 16 | .registerTypeAdapter(Location::class.java, LocationAdapter()) 17 | .create() 18 | 19 | override fun createTable() { 20 | Database.dataSource.getConnection().use { conn -> 21 | conn.prepareStatement(""" 22 | CREATE TABLE `miyukisystem_users` ( 23 | `id` INT NOT NULL AUTO_INCREMENT, 24 | `name` VARCHAR(40) NOT NULL, 25 | `playername` VARCHAR(40) NOT NULL, 26 | `tpaEnabled` TINYINT(1) NOT NULL, 27 | `homes` TEXT NOT NULL, 28 | `kits` TEXT NOT NULL, 29 | PRIMARY KEY (`id`) 30 | ) 31 | """.trimIndent()).use { it.executeUpdate() } 32 | } 33 | } 34 | 35 | override fun has(key: String): CompletableFuture = CompletableFuture.supplyAsync { 36 | Database.dataSource.getConnection().use { conn -> 37 | conn.prepareStatement("SELECT * FROM `miyukisystem_users` WHERE `name` = ?") 38 | .use { stm -> 39 | stm.setString(1, key.lowercase()) 40 | stm.executeQuery().use { it.next() } 41 | } 42 | } 43 | } 44 | 45 | override fun insert(value: User) { 46 | CompletableFuture.runAsync { 47 | Database.dataSource.getConnection().use { conn -> 48 | conn.prepareStatement("INSERT INTO `miyukisystem_users` (`name`,`playername`,`tpaEnabled`, `homes`,`kits`) VALUES (?,?,?,?,?)") 49 | .use { 50 | it.setString(1, value.playerName.lowercase()) 51 | it.setString(2, value.playerName) 52 | it.setInt(3, if (value.tpaEnabled) 1 else 0) 53 | it.setString(4, gson.toJson(value.homes)) 54 | it.setString(5, gson.toJson(value.kits)) 55 | it.executeUpdate() 56 | } 57 | } 58 | } 59 | } 60 | 61 | override fun update(value: User) { 62 | CompletableFuture.runAsync { 63 | Database.dataSource.getConnection().use { conn -> 64 | conn.prepareStatement(""" 65 | UPDATE `miyukisystem_users` SET 66 | `tpaEnabled` = ?, 67 | `homes` = ?, 68 | `kits` = ?, 69 | WHERE `name` = ? 70 | """.trimIndent()) 71 | .use { 72 | it.setInt(1, if (value.tpaEnabled) 1 else 0) 73 | it.setString(2, gson.toJson(value.homes)) 74 | it.setString(3, gson.toJson(value.kits)) 75 | it.setString(4, value.playerName.lowercase()) 76 | it.executeUpdate() 77 | } 78 | } 79 | } 80 | } 81 | 82 | override fun get(key: String): CompletableFuture = CompletableFuture.supplyAsync { 83 | Database.dataSource.getConnection().use { conn -> 84 | conn.prepareStatement("SELECT * FROM `miyukisystem_users` WHERE `name` = ?") 85 | .use { stm -> 86 | stm.setString(1, key.lowercase()) 87 | stm.executeQuery().use { 88 | if (it.next()) { 89 | val homesMap = mutableMapOf().javaClass 90 | val kitsMap = mutableMapOf().javaClass 91 | 92 | User( 93 | it.getString("playername"), 94 | it.getInt("tpaEnabled") == 1, 95 | gson.fromJson(it.getString("homes"), homesMap), 96 | gson.fromJson(it.getString("kits"), kitsMap) 97 | ) 98 | } 99 | else 100 | null 101 | } 102 | } 103 | } 104 | } 105 | 106 | 107 | override fun getAll(): CompletableFuture> = CompletableFuture.supplyAsync { 108 | val users = mutableListOf() 109 | 110 | val homesMap = mutableMapOf().javaClass 111 | val kitsMap = mutableMapOf().javaClass 112 | 113 | Database.dataSource.getConnection().use { conn -> 114 | conn.prepareStatement("SELECT * FROM `miyukisystem_users`") 115 | .use { stm -> 116 | stm.executeQuery().use { 117 | while (it.next()) { 118 | users.add( 119 | User( 120 | it.getString("playername"), 121 | it.getInt("tpaEnabled") == 1, 122 | gson.fromJson(it.getString("homes"), homesMap), 123 | gson.fromJson(it.getString("kits"), kitsMap) 124 | ) 125 | ) 126 | } 127 | } 128 | } 129 | } 130 | users 131 | } 132 | 133 | 134 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/hook/Vault.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.hook 2 | 3 | import net.milkbowl.vault.economy.Economy 4 | import org.bukkit.Bukkit.getServer 5 | 6 | 7 | class Vault { 8 | 9 | companion object { 10 | 11 | lateinit var economy: Economy 12 | 13 | fun setupEconomy(): Boolean { 14 | if (getServer().pluginManager.getPlugin("Vault") == null) 15 | return false 16 | val rsp = getServer().servicesManager.getRegistration(Economy::class.java) ?: return false 17 | economy = rsp.provider 18 | return true 19 | } 20 | 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/listener/ListenerRegistry.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.listener 2 | 3 | import com.google.common.reflect.ClassPath 4 | import miyukisystem.Main 5 | import miyukisystem.manager.ManagerService 6 | import miyukisystem.sendToConsole 7 | import org.bukkit.Bukkit 8 | import org.bukkit.event.Listener 9 | 10 | class ListenerRegistry { 11 | 12 | companion object : ManagerService { 13 | 14 | override fun load() { 15 | val classPath = ClassPath.from(Main.instance.javaClass.classLoader) 16 | var i = 0 17 | classPath.getTopLevelClassesRecursive("miyukisystem.listener.impl").forEach { classInfo -> 18 | try { 19 | val listener = classInfo.load().newInstance() 20 | if (listener is Listener) { 21 | Bukkit.getPluginManager().registerEvents(listener, Main.instance) 22 | i++ 23 | } 24 | } catch (exception: Exception) { } 25 | } 26 | "§9§lMiyukiSystem §aForam registrados §7$i §aeventos.".sendToConsole() 27 | } 28 | 29 | override fun reload() { } 30 | 31 | } 32 | 33 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/Cacheable.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager 2 | 3 | interface Cacheable { 4 | 5 | fun getKey(): String 6 | 7 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/CachedDataService.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager 2 | 3 | abstract class CachedDataService : DataService { 4 | 5 | open val cached = mutableMapOf() 6 | 7 | override fun has(key: String): Boolean = cached.containsKey(key.lowercase()) 8 | 9 | override fun get(key: String): V = cached[key.lowercase()]!! 10 | 11 | override fun set(value: V) { 12 | cached[value.getKey()] = value 13 | } 14 | 15 | override fun set(vararg value: V) { 16 | value.forEach { cached[it.getKey()] = it } 17 | } 18 | 19 | override fun remove(key: String) { 20 | cached.remove(key.lowercase()) 21 | } 22 | 23 | override fun getAll(): List = cached.values.toList() 24 | 25 | fun clear() { 26 | cached.clear() 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/DataService.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager 2 | 3 | interface DataService { 4 | 5 | fun has(key: String): Boolean 6 | 7 | fun get(key: String): V 8 | 9 | fun set(value: V) 10 | 11 | fun set(vararg value: V) 12 | 13 | fun remove(key: String) 14 | 15 | fun getAll(): List 16 | 17 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/ManagerService.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager 2 | 3 | import com.google.common.reflect.ClassPath 4 | import miyukisystem.Main 5 | import miyukisystem.sendToConsole 6 | 7 | interface ManagerService { 8 | 9 | companion object : ManagerService { 10 | 11 | 12 | override fun load() { 13 | val classPath = ClassPath.from(Main.instance.javaClass.classLoader) 14 | var i = 0 15 | classPath.getTopLevelClassesRecursive("miyukisystem.manager.impl").forEach { classInfo -> 16 | try { 17 | val manager = Class.forName(classInfo.name).getDeclaredField("Companion").get(null) 18 | if (manager is ManagerService) { 19 | manager.load() 20 | i++ 21 | } 22 | } catch (exception: Exception) { } 23 | } 24 | "§9§lMiyukiSystem §aForam carregados §7$i §amodulos.".sendToConsole() 25 | } 26 | 27 | override fun reload() { } 28 | 29 | 30 | } 31 | 32 | fun load() 33 | 34 | fun reload() 35 | 36 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/ConfigManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import miyukisystem.Main 4 | import miyukisystem.manager.ManagerService 5 | import miyukisystem.util.Config 6 | import java.io.File 7 | 8 | class ConfigManager { 9 | 10 | companion object : ManagerService { 11 | 12 | val config = Config("config.yml") 13 | val messages = Config("messages.yml") 14 | val commands = Config("commands.yml") 15 | val subCommands = Config("subcommands.yml") 16 | val data = Config("data.yml") 17 | 18 | override fun load() { 19 | if (File(Main.instance.dataFolder, "ajuda.yml").exists()) 20 | Main.instance.saveResource("ajuda.yml", false) 21 | 22 | config.saveDefaultConfig() 23 | messages.saveDefaultConfig() 24 | commands.saveDefaultConfig() 25 | data.saveDefaultConfig() 26 | subCommands.saveDefaultConfig() 27 | reload() 28 | } 29 | 30 | override fun reload() { 31 | config.reloadConfig() 32 | messages.reloadConfig() 33 | commands.reloadConfig() 34 | data.reloadConfig() 35 | subCommands.reloadConfig() 36 | } 37 | 38 | } 39 | 40 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/LocationManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import miyukisystem.manager.DataService 4 | import miyukisystem.manager.ManagerService 5 | import miyukisystem.model.CachedLocation 6 | import miyukisystem.util.toCustomString 7 | import miyukisystem.util.toLocation 8 | import java.util.* 9 | 10 | class LocationManager { 11 | 12 | companion object: DataService, ManagerService { 13 | 14 | 15 | override fun has(key: String): Boolean = ConfigManager.data.config.contains("Locations.$key") 16 | 17 | override fun get(key: String): CachedLocation = CachedLocation("Locations.$key", ConfigManager.data.config.getString(key).toLocation()) 18 | 19 | override fun set(value: CachedLocation) { 20 | ConfigManager.data.config.set("Locations.${value.getKey()}", value.location.toCustomString()) 21 | save() 22 | } 23 | 24 | override fun set(vararg value: CachedLocation) { 25 | value.forEach { set(it) } 26 | } 27 | 28 | override fun remove(key: String) { 29 | ConfigManager.data.config.set("Locations.$key", null) 30 | save() 31 | } 32 | 33 | 34 | override fun getAll(): List { 35 | val config = ConfigManager.data.config 36 | if (!config.isConfigurationSection("Locations")) return Collections.emptyList() 37 | return config.getConfigurationSection("Locations")!!.getKeys(false).map { get(it) } 38 | } 39 | 40 | private fun save() { 41 | ConfigManager.data.saveConfig() 42 | } 43 | 44 | override fun load() { 45 | val config = ConfigManager.data 46 | config.saveDefaultConfig() 47 | config.reloadConfig() 48 | } 49 | 50 | override fun reload() { 51 | load() 52 | } 53 | 54 | } 55 | 56 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/PlayerManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import com.cryptomorin.xseries.ReflectionUtils 4 | import com.cryptomorin.xseries.messages.ActionBar 5 | import com.cryptomorin.xseries.messages.Titles 6 | import org.bukkit.Bukkit 7 | import org.bukkit.Material 8 | import org.bukkit.entity.Player 9 | import java.lang.reflect.Field 10 | 11 | fun Player.isInventoryEmpty(checkScroll: Boolean = false): Boolean { 12 | return when { 13 | inventory.contents.any { it != null && it.type != Material.AIR } -> false 14 | inventory.armorContents.any { it != null && it.type != Material.AIR } -> false 15 | checkScroll -> itemOnCursor == null || itemOnCursor.type == Material.AIR 16 | else -> true 17 | } 18 | } 19 | 20 | fun Player.toSpawn() { 21 | val location = 22 | if (LocationManager.has("Spawn") && LocationManager.get("Spawn").location != null) 23 | LocationManager.get("Spawn").location!! 24 | else Bukkit.getWorlds()[0].spawnLocation 25 | teleport(location) 26 | } 27 | 28 | fun Player.clearInventory() { 29 | inventory.boots = null 30 | inventory.helmet = null 31 | inventory.chestplate = null 32 | inventory.leggings = null 33 | setItemOnCursor(null) 34 | inventory.clear() 35 | } 36 | 37 | private object PingReflection { 38 | var pingField: Field? = null 39 | } 40 | 41 | fun Player.getServerPing(): Int { 42 | return try { 43 | val entityPlayer = ReflectionUtils.getHandle(this)!! 44 | if (PingReflection.pingField == null) { 45 | val field = entityPlayer.javaClass.getDeclaredField("ping") 46 | field.isAccessible = true 47 | PingReflection.pingField = field 48 | } 49 | val ping = PingReflection.pingField!!.getInt(entityPlayer) 50 | if (ping > 0) ping else 0 51 | } catch (exception: Exception) { 52 | 0 53 | } 54 | } 55 | 56 | fun Player.clearPotionEffects() { 57 | activePotionEffects.forEach { removePotionEffect(it.type) } 58 | } 59 | 60 | fun Player.title(title: String, subtitle: String) { 61 | Titles.sendTitle(this, title, subtitle) 62 | } 63 | 64 | fun Player.title(title: String, subtitle: String, fadeIn: Int, stay: Int, fadeOut: Int) { 65 | Titles.sendTitle(this, fadeIn, stay, fadeOut, title, subtitle) 66 | } 67 | 68 | fun Player.clearTitle() { 69 | Titles.clearTitle(this) 70 | } 71 | 72 | fun Player.sendActionBar(message: String) { 73 | ActionBar.sendActionBar(this, message) 74 | } 75 | 76 | fun Player.sendActionBar(message: String, placeholder: MutableMap) { 77 | var msg = message 78 | placeholder.forEach { (placeholder, value) -> msg = msg.replace(placeholder, value) } 79 | ActionBar.sendActionBar(this, msg) 80 | } 81 | 82 | fun Player.clearActionBar() { 83 | ActionBar.clearActionBar(this) 84 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/TpaManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import com.google.common.cache.Cache 4 | import com.google.common.cache.CacheBuilder 5 | import miyukisystem.manager.DataService 6 | import miyukisystem.manager.ManagerService 7 | import miyukisystem.model.TPA 8 | import java.util.concurrent.TimeUnit 9 | 10 | class TpaManager { 11 | 12 | companion object : DataService, ManagerService { 13 | 14 | private lateinit var cached: Cache 15 | 16 | override fun has(key: String): Boolean = cached.asMap().containsKey(key) 17 | 18 | override fun get(key: String): TPA = cached.asMap()[key]!! 19 | 20 | override fun set(value: TPA) { 21 | cached.put(value.getKey(), value) 22 | } 23 | 24 | override fun set(vararg value: TPA) { 25 | value.forEach { cached.put(it.getKey(), it) } 26 | } 27 | 28 | override fun getAll(): List = cached.asMap().values.toList() 29 | 30 | override fun remove(key: String) { 31 | cached.invalidate(key) 32 | } 33 | 34 | fun lastReceived(key: String): TPA? { 35 | return try { 36 | cached.asMap().values.last { it.to.equals(key, ignoreCase = true) } 37 | } catch (exception: NoSuchElementException) { 38 | null 39 | } 40 | } 41 | 42 | override fun load() { 43 | val expireTime = ConfigManager.config.config.getLong("TpaExpire") 44 | cached = CacheBuilder.newBuilder() 45 | .expireAfterWrite(expireTime, TimeUnit.SECONDS) 46 | .build() 47 | } 48 | 49 | override fun reload() { 50 | load() 51 | } 52 | 53 | 54 | } 55 | 56 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/UserManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import miyukisystem.Main 4 | import miyukisystem.database.Database 5 | import miyukisystem.manager.CachedDataService 6 | import miyukisystem.manager.ManagerService 7 | import miyukisystem.model.User 8 | import org.bukkit.Bukkit 9 | import org.bukkit.event.EventHandler 10 | import org.bukkit.event.Listener 11 | import org.bukkit.event.player.PlayerJoinEvent 12 | import org.bukkit.event.player.PlayerQuitEvent 13 | 14 | class UserManager { 15 | 16 | companion object : CachedDataService(), ManagerService { 17 | 18 | 19 | override fun load() { 20 | Bukkit.getPluginManager().registerEvents(object : Listener { 21 | 22 | @EventHandler 23 | fun onPlayerJoin(event: PlayerJoinEvent) { 24 | val player = event.player 25 | 26 | Database.USERS.has(player.name).thenAccept { hasUser -> 27 | if (hasUser) { 28 | Database.USERS.get(player.name).thenAccept { set(it) } 29 | } else { 30 | val user = User( 31 | player.name, 32 | true, 33 | HashMap(), 34 | HashMap() 35 | ) 36 | set(user) 37 | } 38 | } 39 | } 40 | 41 | @EventHandler 42 | fun onPlayerQuit(event: PlayerQuitEvent) { 43 | val player = event.player 44 | if (has(player.name)) 45 | remove(player.name) 46 | } 47 | 48 | }, Main.instance) 49 | } 50 | 51 | override fun reload() { } 52 | 53 | } 54 | 55 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/WarpsManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import miyukisystem.Main 4 | import miyukisystem.manager.CachedDataService 5 | import miyukisystem.manager.ManagerService 6 | import miyukisystem.model.Warp 7 | import miyukisystem.util.Config 8 | import miyukisystem.util.toCustomString 9 | import miyukisystem.util.toLocation 10 | import java.io.File 11 | 12 | class WarpsManager { 13 | 14 | companion object : CachedDataService(), ManagerService { 15 | 16 | fun saveFile(warp: Warp) { 17 | val warpConfig = Config("warps${File.separator}${warp.name}.yml") 18 | warpConfig.saveDefaultConfig() 19 | val config = warpConfig.config 20 | config.set("Name", warp.name) 21 | config.set("Permission", warp.permission) 22 | config.set("Location", warp.location.toCustomString()) 23 | config.set("Title.Title", warp.title?.first) 24 | config.set("Title.Subtitle", warp.title?.second) 25 | config.set("ActionBar", warp.actionBar) 26 | if (warp.message.size == 1) 27 | config.set("Message", warp.message[0]) 28 | else 29 | config.set("Message", warp.message.toList()) 30 | warpConfig.saveConfig() 31 | } 32 | 33 | override fun load() { 34 | val warps = File(Main.instance.dataFolder, "warps").listFiles() 35 | if (warps.isNullOrEmpty()) return 36 | for (warpName in warps.map { it.nameWithoutExtension }) { 37 | val warpConfig = Config("warps${File.separator}$warpName.yml") 38 | warpConfig.saveDefaultConfig() 39 | val config = warpConfig.config 40 | set( 41 | Warp( 42 | config.getString("Name")!!, 43 | config.getString("Location").toLocation()!!, 44 | config.getString("Permission")!!, 45 | if (config.contains("Title")) 46 | Pair(config.getString("Title.Title")!!, config.getString("Title.Subtitle")!!) 47 | else null, 48 | if (config.contains("ActionBar")) config.getString("ActionBar")!! else null, 49 | if (config.isString("Message")) 50 | arrayOf(config.getString("Message")!!) 51 | else 52 | config.getStringList("Message").toTypedArray() 53 | ) 54 | ) 55 | 56 | 57 | } 58 | } 59 | 60 | override fun reload() { 61 | clear() 62 | load() 63 | } 64 | 65 | } 66 | 67 | } 68 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/manager/impl/WhitelistManager.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.manager.impl 2 | 3 | import miyukisystem.manager.DataService 4 | import miyukisystem.manager.ManagerService 5 | import miyukisystem.model.WhitelistPlayer 6 | import java.util.* 7 | 8 | class WhitelistManager { 9 | 10 | companion object : DataService, ManagerService { 11 | 12 | override fun has(key: String): Boolean = ConfigManager.data.config.contains("Whitelist.${key.lowercase()}") 13 | 14 | override fun get(key: String): WhitelistPlayer { 15 | val section = "Whitelist.${key.lowercase()}" 16 | val config = ConfigManager.data.config 17 | return WhitelistPlayer( 18 | config.getString("$section.Name")!!, 19 | config.getBoolean("$section.CanBreak"), 20 | config.getBoolean("$section.CanPlace"), 21 | config.getBoolean("$section.CanExecuteCommands") 22 | ) 23 | } 24 | 25 | override fun set(value: WhitelistPlayer) { 26 | val section = "Whitelist.${value.getKey().lowercase()}" 27 | val config = ConfigManager.data.config 28 | config.set("$section.Name", value.playerName) 29 | config.set("$section.CanBreak", value.canBreak) 30 | config.set("$section.CanPlace", value.canPlace) 31 | config.set("$section.CanExecuteCommands", value.canExecuteCommands) 32 | save() 33 | } 34 | 35 | override fun set(vararg value: WhitelistPlayer) { 36 | value.forEach { set(it) } 37 | } 38 | 39 | override fun remove(key: String) { 40 | ConfigManager.data.config.set("Whitelist.$key", null) 41 | save() 42 | } 43 | 44 | override fun getAll(): List { 45 | val config = ConfigManager.data.config 46 | if (!config.isConfigurationSection("Whitelist")) return Collections.emptyList() 47 | return config.getConfigurationSection("Whitelist")!!.getKeys(false).map { get(it) } 48 | } 49 | 50 | fun getState(): Boolean = ConfigManager.data.config.getBoolean("WhitelistState") 51 | 52 | fun setState(state: Boolean) { 53 | ConfigManager.data.config.set("WhitelistState", state) 54 | save() 55 | } 56 | 57 | private fun save() { 58 | ConfigManager.data.saveConfig() 59 | } 60 | 61 | override fun load() { 62 | val config = ConfigManager.data 63 | config.saveDefaultConfig() 64 | config.reloadConfig() 65 | } 66 | 67 | override fun reload() { 68 | load() 69 | } 70 | 71 | } 72 | 73 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/model/CachedLocation.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.model 2 | 3 | import miyukisystem.manager.Cacheable 4 | import org.bukkit.Location 5 | 6 | data class CachedLocation(val path: String, val location: Location?) : Cacheable { 7 | 8 | override fun getKey(): String = path 9 | 10 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/model/TPA.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.model 2 | 3 | import miyukisystem.manager.Cacheable 4 | 5 | data class TPA(val from: String, val to: String) : Cacheable { 6 | 7 | override fun getKey(): String = from 8 | 9 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/model/User.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.model 2 | 3 | import miyukisystem.database.Database 4 | import miyukisystem.manager.Cacheable 5 | import miyukisystem.manager.impl.UserManager 6 | import org.bukkit.Location 7 | 8 | class User( 9 | val playerName: String, 10 | var tpaEnabled: Boolean, 11 | val homes: MutableMap, 12 | val kits: MutableMap 13 | ) : Cacheable { 14 | 15 | fun save() { 16 | UserManager.set(this) 17 | 18 | Database.USERS.update(this) 19 | } 20 | 21 | override fun getKey(): String = playerName.lowercase() 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/model/Warp.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.model 2 | 3 | import com.cryptomorin.xseries.messages.ActionBar 4 | import miyukisystem.manager.Cacheable 5 | import miyukisystem.manager.impl.title 6 | import org.bukkit.Location 7 | import org.bukkit.entity.Player 8 | 9 | class Warp( 10 | val name: String, 11 | var location: Location, 12 | var permission: String, 13 | val title: Pair?, 14 | val actionBar: String?, 15 | val message: Array 16 | ) : Cacheable { 17 | 18 | fun teleport(player: Player) { 19 | player.teleport(location) 20 | if (title != null) { 21 | player.title(title.first, title.second) 22 | } 23 | if (actionBar != null) 24 | ActionBar.sendActionBar(player, actionBar) 25 | if (message.isNotEmpty()) 26 | player.sendMessage(message) 27 | } 28 | 29 | override fun getKey(): String = name.lowercase() 30 | 31 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/model/WhitelistPlayer.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.model 2 | 3 | import miyukisystem.manager.Cacheable 4 | import miyukisystem.manager.impl.WhitelistManager 5 | 6 | data class WhitelistPlayer( 7 | var playerName: String, 8 | var canBreak: Boolean = false, 9 | var canPlace: Boolean = false, 10 | var canExecuteCommands: Boolean = false 11 | ) : Cacheable { 12 | 13 | override fun getKey(): String = playerName.toLowerCase() 14 | 15 | fun save() { 16 | WhitelistManager.set(this) 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/util/AsyncUtil.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.util 2 | 3 | import miyukisystem.Main 4 | import org.bukkit.Bukkit 5 | 6 | class AsyncUtil { 7 | 8 | companion object { 9 | 10 | fun runAsync(run: Runnable) { 11 | Bukkit.getScheduler().runTaskAsynchronously(Main.instance, run) 12 | } 13 | 14 | fun runAsyncLater(delay: Long, run: Runnable) { 15 | Bukkit.getScheduler().runTaskLaterAsynchronously(Main.instance, run, delay) 16 | } 17 | 18 | fun runAsyncTimer(delay: Long, period: Long, run: Runnable) { 19 | Bukkit.getScheduler().runTaskTimerAsynchronously(Main.instance, run, delay, period) 20 | } 21 | 22 | fun runSync(run: Runnable) { 23 | Bukkit.getScheduler().runTask(Main.instance, run) 24 | } 25 | 26 | fun runSyncLater(delay: Long, run: Runnable) { 27 | Bukkit.getScheduler().runTaskLater(Main.instance, run, delay) 28 | } 29 | 30 | fun runSyncTimer(delay: Long, period: Long, run: Runnable) { 31 | Bukkit.getScheduler().runTaskTimer(Main.instance, run, delay, period) 32 | } 33 | } 34 | 35 | } 36 | 37 | fun Any.sync(run: () -> Unit) { 38 | Bukkit.getScheduler().runTask(Main.instance, run) 39 | } 40 | 41 | fun Any.syncLater(delay: Long, run: () -> Unit) { 42 | Bukkit.getScheduler().runTaskLater(Main.instance, run, delay) 43 | } 44 | 45 | fun Any.syncTimer(delay: Long, period: Long, run: () -> Unit) { 46 | Bukkit.getScheduler().runTaskTimer(Main.instance, run, delay, period) 47 | } 48 | 49 | fun Any.async(run: () -> Unit) { 50 | Bukkit.getScheduler().runTaskAsynchronously(Main.instance, run) 51 | } 52 | 53 | fun Any.asyncLater(delay: Long, run: () -> Unit) { 54 | Bukkit.getScheduler().runTaskLaterAsynchronously(Main.instance, run, delay) 55 | } 56 | 57 | fun Any.asyncTimer(delay: Long, period: Long, run: () -> Unit) { 58 | Bukkit.getScheduler().runTaskTimerAsynchronously(Main.instance, run, delay, period) 59 | } 60 | -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/util/Config.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.util 2 | 3 | import miyukisystem.Main 4 | import org.bukkit.configuration.file.YamlConfiguration 5 | import java.io.File 6 | 7 | class Config(private val path: String) { 8 | 9 | lateinit var config: YamlConfiguration 10 | 11 | private val file = File(Main.instance.dataFolder, path) 12 | 13 | init { 14 | saveDefaultConfig() 15 | reloadConfig() 16 | } 17 | 18 | fun saveConfig() { 19 | config.save(file) 20 | } 21 | 22 | fun saveDefaultConfig() { 23 | val file = File(Main.instance.dataFolder, path) 24 | if (!file.exists()) { 25 | if (Main.instance.getResource(path) == null) { 26 | file.parentFile.mkdirs() 27 | file.createNewFile() 28 | } else 29 | Main.instance.saveResource(path, false) 30 | reloadConfig() 31 | } 32 | } 33 | 34 | fun reloadConfig() { 35 | config = YamlConfiguration.loadConfiguration(file) 36 | } 37 | 38 | 39 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/util/JsonFile.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.util 2 | 3 | import java.io.File 4 | import java.io.FileWriter 5 | import java.io.IOException 6 | import java.net.URI 7 | import java.nio.file.Files 8 | 9 | 10 | class JsonFile : File { 11 | 12 | private var parent: JsonFile? = null 13 | 14 | companion object { 15 | private const val seriaalVersionUID = 1L 16 | } 17 | 18 | constructor(pathname: String) : super(pathname) { 19 | if (getParent() != null) { 20 | parent = JsonFile(getParent()) 21 | } 22 | } 23 | 24 | constructor(parent: String, child: String) : super(parent, child) { 25 | if (getParent() != null) { 26 | this.parent = JsonFile(getParent()) 27 | } 28 | } 29 | 30 | constructor(parent: File, child: String) : super(parent, child) { 31 | if (getParent() != null) { 32 | this.parent = JsonFile(getParent()) 33 | } 34 | } 35 | 36 | constructor(uri: URI) : super(uri) { 37 | if (getParent() != null) { 38 | parent = JsonFile(getParent()) 39 | } 40 | } 41 | 42 | override fun getParentFile(): JsonFile { 43 | return parent!! 44 | } 45 | 46 | fun getFileInDir(name: String, create: Boolean, dir: Boolean): JsonFile? { 47 | return if (this.isDirectory) { 48 | val file = JsonFile(this, name) 49 | if (create && !file.exists()) { 50 | if (dir) { 51 | file.mkdirs() 52 | } else { 53 | if (file.parentFile.exists()) { 54 | file.parentFile.mkdirs() 55 | } 56 | try { 57 | file.createNewFile() 58 | } catch (var6: IOException) { 59 | var6.printStackTrace() 60 | } 61 | } 62 | } 63 | file 64 | } else { 65 | null 66 | } 67 | } 68 | 69 | fun readerToString(defaultString: String): String { 70 | return try { 71 | String(Files.readAllBytes(toPath())) 72 | } catch (var3: IOException) { 73 | defaultString 74 | } 75 | } 76 | 77 | fun whiter(result: String) { 78 | try { 79 | if (!exists()) { 80 | createNewFile() 81 | } 82 | val fw = FileWriter(this) 83 | fw.write(result) 84 | fw.close() 85 | } catch (var3: IOException) { 86 | } 87 | } 88 | 89 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/util/LocationUtil.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.util 2 | 3 | import org.bukkit.Bukkit 4 | import org.bukkit.Location 5 | 6 | fun Location?.toCustomString(): String? { 7 | if (this == null) return null 8 | if (world == null) return null 9 | return "${world?.name};${x};${y};${z};${yaw};${pitch}" 10 | } 11 | 12 | fun String?.toLocation(): Location? { 13 | if (this == null) return null 14 | val locSplit = split(";") 15 | if (locSplit.size != 6) return null 16 | return Location( 17 | Bukkit.getWorld(locSplit[0]), 18 | locSplit[1].toDouble(), 19 | locSplit[2].toDouble(), 20 | locSplit[3].toDouble(), 21 | locSplit[4].toFloat(), 22 | locSplit[5].toFloat() 23 | ) 24 | } -------------------------------------------------------------------------------- /src/main/kotlin/miyukisystem/util/NBTUtil.kt: -------------------------------------------------------------------------------- 1 | package miyukisystem.util 2 | 3 | import io.github.bananapuncher714.nbteditor.NBTEditor 4 | import org.bukkit.inventory.ItemStack 5 | 6 | fun ItemStack.containsNBT(tag: String): Boolean = NBTEditor.contains(this, tag) 7 | 8 | fun ItemStack.getNBT(tag: String): String? = NBTEditor.getString(this, tag) 9 | 10 | fun ItemStack.setNBT(tag: String, value: String): ItemStack = NBTEditor.set(this.clone(), value, tag) -------------------------------------------------------------------------------- /src/main/resources/ajuda.yml: -------------------------------------------------------------------------------- 1 | # Permiss�es do plugin: 2 | 3 | # Comandos 4 | 5 | # ------------------------------------------------------------------------------------------------ 6 | 7 | # miyukisystem.commands.* -> Permiss�o para usar todos comandos. 8 | 9 | # miyukisystem.alert -> Permiss�o para usar o comando /alerta. 10 | 11 | # miyukisystem.feed -> Permiss�o para usar o comando /feed. 12 | # miyukisystem.feed.other -> Permiss�o para usar o /feed em jogadores. 13 | 14 | # miyukisystem.heal -> Permiss�o para usar o comando /heal. 15 | # miyukisystem.heal.other -> Permiss�o para usar o comando /heal em jogadores. 16 | 17 | # miyukisystem.flashlight -> Permiss�o para usar o comando /luz. 18 | # miyukisystem.gamemode -> permiss�o para usar o comando /gamemode. 19 | # miyukisystem.teleport -> permiss�o para usar o comando /teleport. 20 | # miyukisystem.hat -> permiss�o para usar o comando /hat. 21 | 22 | # miyukisystem.fly -> permiss�o para usar o comando /fly. 23 | # miyukisystem.fly.other -> permiss�o para usar o comando /fly em outros jogadores. 24 | 25 | # miyukisystem.clearchat -> permiss�o para usar o comando /clearchat. 26 | # miyukisystem.vanish -> permiss�o para usar o comando /vanish. 27 | # miyukisystem.ping -> permiss�o para usar o comando /ping. 28 | # miyukisystem.trash -> permiss�o para usar o comando /trash. 29 | 30 | # miyukisystem.enderchest -> permiss�o para usar o comando /enderchest. 31 | # miyukisystem.enderchest.other -> permiss�o para ver ender chest de outros players. 32 | 33 | # miyukisystem.invsee -> permiss�o para usar o comando /invsee. 34 | # miyukisystem.tpall -> permiss�o para usar o comando /tpall. 35 | # miyukisystem.workbench -> permiss�o para usar o comando /workbench. 36 | # miyukisystem.setspawn -> permiss�o para usar o comando /setspawn. 37 | 38 | # miyukisystem.spawn.other -> permissão para usar o comando /spawn . 39 | 40 | # miyukisystem.edititem -> permissão para usar o comando /edititem. 41 | 42 | # miyukisystem.clear -> permissão para usar o comando /clear. 43 | # miyukisystem.clear.other -> permissão para usar o comando /clear em outras pessoas. 44 | 45 | # miyukisystem.title -> permissão para usar o comando /title. 46 | # miyukisystem.repair -> permissão para usar o comando /repair. 47 | # miyukisystem.speed -> permissão para usar o comando /speed. 48 | # miyukisystem.back -> permissão para usar o comando /back. 49 | 50 | # miyukisystem.executesound -> permissão para usar o comando /executesound 51 | # miyukisystem.online -> permissão para usar o comando /online. 52 | 53 | # miyukisystem.kickall -> permissão para usar o comando /kickall 54 | 55 | # ------------------------------------------------------------------------------------------------ 56 | 57 | # Gerais 58 | 59 | # miyukisystem.keepxp -> permissão para manter o xp quando morrer. -------------------------------------------------------------------------------- /src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # 2 | # Lista de materiais: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/Material.html 3 | # 4 | # true -> sim 5 | # false -> não 6 | # 7 | # Para pesquisar, veja aqui na lista abaixo os bloqueadores e de um CTRL+F para pesquisar. 8 | # Exemplo: CTRL + F, LeavesDecay 9 | 10 | Database: 11 | # Modos disponíveis: H2, MARIADB, MYSQL e SQLITE. 12 | Mode: H2 13 | Host: localhost 14 | Port: 3306 15 | Database: MiyukiSystem 16 | Username: 'Username' 17 | Password: 'Password' 18 | MySQLConfiguration: 19 | PoolName: 'MiyukiSystemPool' 20 | MiniumIdle: 10 21 | MaximumPoolSize: 10 22 | ConnectionTimeout: 30000 23 | CachePrepStmts: true 24 | PrepStmtCacheSize: 250 25 | PrepStmtCacheSqlLimit: 2048 26 | UseServerPrepStmts: true 27 | UseLocalSessionState: true 28 | RewriteBatchedStatements: true 29 | CacheResultSetMetadata: true 30 | CacheServerConfiguration: true 31 | ElideSetAutoCommits: true 32 | MaintainTimeStats: false 33 | 34 | # Se deixar true, toda vez que o player entrar, ele vai ser teleportado pro spawn invez de 35 | # sua ultima localização. 36 | TeleportSpawn: true 37 | 38 | # Tempo para expirar o TPA (em segundos) 39 | TpaExpire: 30 40 | 41 | # Lixeiro 42 | 43 | TrashSize: 54 44 | TrashTitleMenu: 'Lixeiro' 45 | 46 | # Dropar cabeças ao matar jogadores 47 | 48 | DropPlayerHeadOnDeath: true 49 | # Use chances entre 1 e 100 50 | DropPlayerHeadChance: 20 51 | Blockers: 52 | # Bloqueia de transformar a água em gelo. 53 | FreezeWater: true 54 | # Bloqueia de cair no void (teleporta pro spawn). 55 | FallIntoVoid: true 56 | # Bloqueia de criar portal do nether. 57 | CreatePortal: true 58 | # Bloqueia dos mobs pegarem fogo para o sol. 59 | MobsCatchFire: true 60 | # Bloqueia das folhas cairem. 61 | LeavesDecay: true 62 | # Bloqueia das bigornas cairem. 63 | AnvilDecay: true 64 | # Cancela a chuva quando comecar. 65 | RainCancel: true 66 | # Cancela o player de entrar na cama. 67 | Sleep: true 68 | # Cancela de derreter o gelo e a neve. 69 | Melt: true 70 | # Cancela a explosão dos itens. 71 | ItemExplosion: true 72 | # Cancela de entrar em portais. Se tiver true = bloqueia. 73 | Portal: 74 | Nether: true 75 | End: true 76 | # Cancela a fome. Se tiver true = não tem mais fome. 77 | Feed: true 78 | # Cancela a mensagem de morte. 79 | DeathMessage: true 80 | # Bloqueia do jogador entrar em veículos. 81 | PlayerGetIntoVehicles: false 82 | # Bloqueia de entidades (MOBS) entrarem em veículos. 83 | EntityGetIntoVehicles: true 84 | 85 | # Reparar 86 | 87 | RepairBlockedNBTs: # Deixe com "[]" para não bloquear nenhum. 88 | - 'NBT1' 89 | - 'NBT2' 90 | RepairBlockedItems: # Deixe com "[]" para não bloquear nenhum. 91 | - 'DIAMOND_PICKAXE' 92 | 93 | Motd: # Lembrando que se deixar vazio ele fica o default da server.properties. (Ignora o MaxPlayers também!) 94 | # Motd quando está em WHITELIST (Use \n para pular linha) 95 | WhitelistMotd: '' 96 | # Jogadores máximos quando está em WHITELIST. (Apenas estático) 97 | WhitelistMaxPlayers: 1 98 | # Motd normal (Use \n para pular linha); 99 | NormalMotd: '' 100 | # Jogadores máximos com a motd normal. (Apenas estático) 101 | NormalMaxPlayers: 200 102 | 103 | BlockedNicks: 104 | - 'teste1' 105 | - 'teste2' 106 | 107 | BlockedCommands: # Use "/". 108 | - '/teste1' 109 | - '/teste2' 110 | 111 | BlockedCrafts: [] 112 | 113 | 114 | -------------------------------------------------------------------------------- /src/main/resources/data.yml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SOekd/MiyukiSystem/da693432cb907a5b552ed7e8cf96b1f1b67adb4c/src/main/resources/data.yml -------------------------------------------------------------------------------- /src/main/resources/plugin.yml: -------------------------------------------------------------------------------- 1 | main: miyukisystem.Main 2 | version: 1.0.0-SNAPSHOT 3 | name: MiyukiSystem 4 | load: POSTWORLD 5 | authors: [RUSH, SOekd, mattnicee7, Kroxy_] 6 | website: github.com/SOekd/MiyukiSystem 7 | softdepend: [Legendchat, mcMMO, MassiveCore, Factions, Vault] 8 | -------------------------------------------------------------------------------- /src/main/resources/subcommands.yml: -------------------------------------------------------------------------------- 1 | WhitelistTrue: 2 | Enabled: true 3 | Aliases: 'true|ligar|on' 4 | 5 | WhitelistFalse: 6 | Enabled: true 7 | Aliases: 'false|desligar|off' 8 | 9 | WhitelistAdd: 10 | Enabled: true 11 | Aliases: 'add|adicionar' 12 | 13 | WhitelistRemove: 14 | Enabled: true 15 | Aliases: 'remove|remover' 16 | 17 | WhitelistPermission: 18 | Enabled: true 19 | Aliases: 'permission|permissions|permissões|permissão|permissao|permissoes|perm|perms' 20 | 21 | WhitelistReload: 22 | Enabled: true 23 | Aliases: 'reload|recarregar' 24 | 25 | WhitelistPermissionBreakBlock: 26 | Enabled: true 27 | Aliases: 'break|breakblocks|quebrar|quebrarblocos' 28 | 29 | WhitelistPermissionExecuteCommands: 30 | Enabled: true 31 | Aliases: 'commands|executarcomandos|comandos|executecommands' 32 | 33 | WhitelistPermissionPlaceBlocks: 34 | Enabled: true 35 | Aliases: 'place|placeblocks|colocar|colocarblocos' --------------------------------------------------------------------------------