commit 2625155037016e0d91f98742bc11780810cd8d3e Author: Илья Глазунов Date: Mon Dec 22 20:29:34 2025 +0300 initial commit diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml new file mode 100644 index 0000000..4acca4e --- /dev/null +++ b/.gitea/workflows/release.yml @@ -0,0 +1,70 @@ +name: Build and Release + +on: + push: + tags: + - 'v*' + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Set up JDK 21 + uses: actions/setup-java@v4 + with: + java-version: '21' + distribution: 'temurin' + + - name: Grant execute permission for gradlew + run: chmod +x gradlew + + - name: Build with Gradle + run: ./gradlew build + + - name: Get version from tag + id: get_version + run: echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT + + - name: Create Release + uses: actions/forgejo-release@v2 + with: + direction: upload + url: ${{ github.server_url }} + token: ${{ secrets.RELEASE_TOKEN }} + release-dir: build/libs + release-notes: | + ## Release ${{ steps.get_version.outputs.VERSION }} + + ### What's New + - Feature 1 + - Feature 2 + + ### Bug Fixes + - Fix 1 + - Fix 2 + + ### Changes + - Change 1 + - Change 2 + + ### Breaking Changes + - None + + ### Installation + 1. Download the JAR file from the assets below + 2. Place it in your server's `plugins` folder + 3. Restart the server + + ### Requirements + - Minecraft Server with PaperMC: 1.21.11 + - Java: 21+ + + --- + **Full Changelog**: Compare with previous version + tag: ${{ steps.get_version.outputs.VERSION }} + title: Release ${{ steps.get_version.outputs.VERSION }} + prerelease: false + draft: true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..55692b2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +.gradle/ +build/ +.idea/ +*.iml +*.ipr +*.iws +out/ +run/ +logs/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..df548b2 --- /dev/null +++ b/README.md @@ -0,0 +1,84 @@ +# JailPlugin - PaperMC 1.21.11 РП Плагин + +Простой плагин для РП серверов Minecraft с функциями наручников, тюрьмы и конвоирования. + +## История создания + +Всё началось с того, что мы с друзьями подняли свой сервер и решили добавить немного ролевого отыгрыша — устраивать настоящие суды над нарушителями. Представьте: задержание, конвоирование в зал суда, вынесение приговора и отправка в тюрьму. Звучит круто, правда? + +Но возник вопрос: **как усмирить нарушителя?** Без наручников он просто убежит. Без возможности вести его за собой — суд превращается в хаос. + +Я перерыл кучу плагинов в поисках нужного функционала, но ничего адекватного так и не нашёл — либо заброшенные проекты, либо переусложнённые комбайны с тонной лишнего. Поэтому решил: **напишу сам** — простой, лёгкий и с тем функционалом, который реально нужен для РП. +А потом подумал: если я столкнулся с этой проблемой, наверняка кто-то ещё ищет такое решение. Так что выкладываю в открытый доступ — пользуйтесь на здоровье! +Так появился **JailPlugin** для PaperMC 1.21.11 — минималистичный, но функциональный плагин для ролевых серверов Minecraft. + +## Функции + +- **Наручники (Cuff)** - Надевайте наручники на игроков, ограничивая их действия +- **Тюрьма (Jail)** - Сажайте нарушителей в тюрьму на определённое время +- **Конвоирование (Lead)** - Ведите игроков в наручниках за собой + +## Зависимости + +- PaperMC 1.21.11+ +- LuckPerms + +## Команды + +| Команда | Описание | Право | +|---------|----------|-------| +| `/cuff <игрок>` | Надеть наручники | `jailplugin.cuff` | +| `/uncuff <игрок>` | Снять наручники | `jailplugin.uncuff` | +| `/jail <игрок> <время> [причина]` | Посадить в тюрьму | `jailplugin.jail` | +| `/unjail <игрок>` | Выпустить из тюрьмы | `jailplugin.unjail` | +| `/setjail` | Установить точку тюрьмы | `jailplugin.setjail` | +| `/lead <игрок>` | Вести игрока в наручниках | `jailplugin.lead` | +| `/unlead <игрок>` | Отпустить ведомого игрока | `jailplugin.unlead` | + +## Права (LuckPerms) + +- `jailplugin.cuff` - Надевать наручники +- `jailplugin.uncuff` - Снимать наручники +- `jailplugin.jail` - Сажать в тюрьму +- `jailplugin.unjail` - Выпускать из тюрьмы +- `jailplugin.setjail` - Устанавливать точку тюрьмы +- `jailplugin.lead` - Конвоировать игроков +- `jailplugin.unlead` - Отпускать ведомых +- `jailplugin.admin` - Все права плагина + +## Настройка прав в LuckPerms + +```bash +# Дать право полицейским +/lp group police permission set jailplugin.cuff true +/lp group police permission set jailplugin.uncuff true +/lp group police permission set jailplugin.lead true +/lp group police permission set jailplugin.unlead true + +# Дать все права администраторам +/lp group admin permission set jailplugin.admin true +``` + +## Сборка + +```bash +./gradlew build +``` + +Собранный JAR будет в `build/libs/` + +## Установка + +1. Скопируйте JAR в папку `plugins/` вашего сервера +2. Убедитесь что установлен LuckPerms +3. Перезапустите сервер +4. Настройте `config.yml` по необходимости +5. Установите точку тюрьмы: `/setjail` + +## Конфигурация + +Смотрите `config.yml` для настройки: +- Дистанции для команд +- Скорости движения в наручниках +- Сообщений +- Параметров тюрьмы diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..44f159e --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,47 @@ +plugins { + java + id("io.papermc.paperweight.userdev") version "2.0.0-beta.19" + id("xyz.jpenilla.run-paper") version "2.3.0" +} + +group = "com.rpserver" +version = "1.0.0-alpha" + +java { + toolchain.languageVersion.set(JavaLanguageVersion.of(21)) +} + +repositories { + mavenCentral() + maven("https://repo.papermc.io/repository/maven-public/") +} + +dependencies { + paperweight.paperDevBundle("1.21.11-R0.1-SNAPSHOT") + compileOnly("net.luckperms:api:5.4") +} + +tasks { + compileJava { + options.encoding = Charsets.UTF_8.name() + options.release.set(21) + } + + processResources { + filteringCharset = Charsets.UTF_8.name() + val props = mapOf( + "name" to project.name, + "version" to project.version, + "description" to "RPServer Jail & Cuff Plugin", + "apiVersion" to "1.21" + ) + inputs.properties(props) + filesMatching("plugin.yml") { + expand(props) + } + } + + runServer { + minecraftVersion("1.21.11") + } +} diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..f8e1ee3 Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..23449a2 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100755 index 0000000..adff685 --- /dev/null +++ b/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..e509b2d --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,93 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..eba448e --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,8 @@ +rootProject.name = "jail-plugin" + +pluginManagement { + repositories { + gradlePluginPortal() + maven("https://repo.papermc.io/repository/maven-public/") + } +} diff --git a/src/main/java/com/rpserver/jailplugin/JailPlugin.java b/src/main/java/com/rpserver/jailplugin/JailPlugin.java new file mode 100644 index 0000000..aa9961f --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/JailPlugin.java @@ -0,0 +1,106 @@ +package com.rpserver.jailplugin; + +import com.rpserver.jailplugin.commands.*; +import com.rpserver.jailplugin.listeners.CuffListener; +import com.rpserver.jailplugin.listeners.JailListener; +import com.rpserver.jailplugin.listeners.LeadListener; +import com.rpserver.jailplugin.managers.CuffManager; +import com.rpserver.jailplugin.managers.JailManager; +import com.rpserver.jailplugin.managers.LeadManager; +import com.rpserver.jailplugin.managers.MessageManager; +import net.luckperms.api.LuckPerms; +import org.bukkit.Bukkit; +import org.bukkit.plugin.RegisteredServiceProvider; +import org.bukkit.plugin.java.JavaPlugin; + +public class JailPlugin extends JavaPlugin { + + private static JailPlugin instance; + private LuckPerms luckPerms; + + private CuffManager cuffManager; + private JailManager jailManager; + private LeadManager leadManager; + private MessageManager messageManager; + + @Override + public void onEnable() { + instance = this; + + saveDefaultConfig(); + + if (!setupLuckPerms()) { + getLogger().severe("LuckPerms не найден! Плагин отключён."); + getServer().getPluginManager().disablePlugin(this); + return; + } + + messageManager = new MessageManager(this); + cuffManager = new CuffManager(this); + jailManager = new JailManager(this); + leadManager = new LeadManager(this); + + registerCommands(); + + registerListeners(); + + getLogger().info("JailPlugin успешно загружен!"); + } + + @Override + public void onDisable() { + if (jailManager != null) { + jailManager.saveData(); + } + getLogger().info("JailPlugin отключён!"); + } + + private boolean setupLuckPerms() { + RegisteredServiceProvider provider = Bukkit.getServicesManager().getRegistration(LuckPerms.class); + if (provider != null) { + luckPerms = provider.getProvider(); + return true; + } + return false; + } + + private void registerCommands() { + getCommand("cuff").setExecutor(new CuffCommand(this)); + getCommand("uncuff").setExecutor(new UncuffCommand(this)); + getCommand("jail").setExecutor(new JailCommand(this)); + getCommand("unjail").setExecutor(new UnjailCommand(this)); + getCommand("setjail").setExecutor(new SetJailCommand(this)); + getCommand("lead").setExecutor(new LeadCommand(this)); + getCommand("unlead").setExecutor(new UnleadCommand(this)); + } + + private void registerListeners() { + getServer().getPluginManager().registerEvents(new CuffListener(this), this); + getServer().getPluginManager().registerEvents(new JailListener(this), this); + getServer().getPluginManager().registerEvents(new LeadListener(this), this); + } + + public static JailPlugin getInstance() { + return instance; + } + + public LuckPerms getLuckPerms() { + return luckPerms; + } + + public CuffManager getCuffManager() { + return cuffManager; + } + + public JailManager getJailManager() { + return jailManager; + } + + public LeadManager getLeadManager() { + return leadManager; + } + + public MessageManager getMessageManager() { + return messageManager; + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/CuffCommand.java b/src/main/java/com/rpserver/jailplugin/commands/CuffCommand.java new file mode 100644 index 0000000..6abc006 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/CuffCommand.java @@ -0,0 +1,83 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class CuffCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public CuffCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("cuff").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.cuff")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 1) { + player.sendMessage("§cИспользование: /cuff <игрок>"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (target.equals(player)) { + player.sendMessage("§cВы не можете надеть наручники на себя!"); + return true; + } + + if (plugin.getCuffManager().isCuffed(target)) { + plugin.getMessageManager().send(player, "cuff-already"); + return true; + } + + double distance = player.getLocation().distance(target.getLocation()); + if (distance > plugin.getCuffManager().getCuffDistance()) { + plugin.getMessageManager().send(player, "cuff-too-far"); + return true; + } + + plugin.getCuffManager().cuff(target); + plugin.getMessageManager().send(player, "cuff-success", "%player%", target.getName()); + plugin.getMessageManager().send(target, "cuff-target"); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> !plugin.getCuffManager().isCuffed(p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/JailCommand.java b/src/main/java/com/rpserver/jailplugin/commands/JailCommand.java new file mode 100644 index 0000000..f199516 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/JailCommand.java @@ -0,0 +1,103 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +public class JailCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public JailCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("jail").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.jail")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 2) { + player.sendMessage("§cИспользование: /jail <игрок> <время_в_секундах> [причина]"); + return true; + } + + if (!plugin.getJailManager().isJailSet()) { + plugin.getMessageManager().send(player, "jail-not-set"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (plugin.getJailManager().isJailed(target)) { + plugin.getMessageManager().send(player, "jail-already"); + return true; + } + + int time; + try { + time = Integer.parseInt(args[1]); + if (time <= 0) { + player.sendMessage("§cВремя должно быть положительным числом!"); + return true; + } + } catch (NumberFormatException e) { + player.sendMessage("§cНеверный формат времени!"); + return true; + } + + int maxTime = plugin.getConfig().getInt("jail.max-time", 0); + if (maxTime > 0 && time > maxTime) { + time = maxTime; + } + + String reason = args.length > 2 + ? String.join(" ", Arrays.copyOfRange(args, 2, args.length)) + : "Не указана"; + + plugin.getJailManager().jail(target, time, reason); + plugin.getMessageManager().send(player, "jail-success", "%player%", target.getName(), "%time%", String.valueOf(time)); + plugin.getMessageManager().send(target, "jail-target", "%time%", String.valueOf(time), "%reason%", reason); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> !plugin.getJailManager().isJailed(p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } else if (args.length == 2) { + return Arrays.asList("60", "300", "600", "1800", "3600"); + } else if (args.length == 3) { + return Arrays.asList("Нарушение", "РДМ", "ВДМ", "Гриферство"); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/LeadCommand.java b/src/main/java/com/rpserver/jailplugin/commands/LeadCommand.java new file mode 100644 index 0000000..9d72a37 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/LeadCommand.java @@ -0,0 +1,89 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class LeadCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public LeadCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("lead").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.lead")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 1) { + player.sendMessage("§cИспользование: /lead <игрок>"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (target.equals(player)) { + player.sendMessage("§cВы не можете вести себя!"); + return true; + } + + if (!plugin.getCuffManager().isCuffed(target)) { + plugin.getMessageManager().send(player, "lead-not-cuffed"); + return true; + } + + if (plugin.getLeadManager().isLeading(player, target)) { + plugin.getMessageManager().send(player, "lead-already"); + return true; + } + + double distance = player.getLocation().distance(target.getLocation()); + if (distance > plugin.getCuffManager().getCuffDistance()) { + plugin.getMessageManager().send(player, "cuff-too-far"); + return true; + } + + plugin.getLeadManager().lead(player, target); + plugin.getMessageManager().send(player, "lead-success", "%player%", target.getName()); + plugin.getMessageManager().send(target, "lead-target"); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> plugin.getCuffManager().isCuffed(p)) + .filter(p -> !plugin.getLeadManager().isBeingLed(p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/SetJailCommand.java b/src/main/java/com/rpserver/jailplugin/commands/SetJailCommand.java new file mode 100644 index 0000000..abd0a17 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/SetJailCommand.java @@ -0,0 +1,35 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; + +public class SetJailCommand implements CommandExecutor { + + private final JailPlugin plugin; + + public SetJailCommand(JailPlugin plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.setjail")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + plugin.getJailManager().setJailLocation(player.getLocation()); + plugin.getMessageManager().send(player, "setjail-success"); + + return true; + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/UncuffCommand.java b/src/main/java/com/rpserver/jailplugin/commands/UncuffCommand.java new file mode 100644 index 0000000..3d44826 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/UncuffCommand.java @@ -0,0 +1,72 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class UncuffCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public UncuffCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("uncuff").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.uncuff")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 1) { + player.sendMessage("§cИспользование: /uncuff <игрок>"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (!plugin.getCuffManager().isCuffed(target)) { + plugin.getMessageManager().send(player, "uncuff-not-cuffed"); + return true; + } + + plugin.getCuffManager().uncuff(target); + plugin.getMessageManager().send(player, "uncuff-success", "%player%", target.getName()); + plugin.getMessageManager().send(target, "uncuff-target"); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> plugin.getCuffManager().isCuffed(p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/UnjailCommand.java b/src/main/java/com/rpserver/jailplugin/commands/UnjailCommand.java new file mode 100644 index 0000000..fa0064d --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/UnjailCommand.java @@ -0,0 +1,72 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class UnjailCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public UnjailCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("unjail").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.unjail")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 1) { + player.sendMessage("§cИспользование: /unjail <игрок>"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (!plugin.getJailManager().isJailed(target)) { + plugin.getMessageManager().send(player, "unjail-not-jailed"); + return true; + } + + plugin.getJailManager().unjail(target); + plugin.getMessageManager().send(player, "unjail-success", "%player%", target.getName()); + plugin.getMessageManager().send(target, "unjail-target"); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> plugin.getJailManager().isJailed(p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/commands/UnleadCommand.java b/src/main/java/com/rpserver/jailplugin/commands/UnleadCommand.java new file mode 100644 index 0000000..fcf5d82 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/commands/UnleadCommand.java @@ -0,0 +1,72 @@ +package com.rpserver.jailplugin.commands; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class UnleadCommand implements CommandExecutor, TabCompleter { + + private final JailPlugin plugin; + + public UnleadCommand(JailPlugin plugin) { + this.plugin = plugin; + plugin.getCommand("unlead").setTabCompleter(this); + } + + @Override + public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { + if (!(sender instanceof Player player)) { + sender.sendMessage("Эта команда только для игроков!"); + return true; + } + + if (!player.hasPermission("jailplugin.unlead")) { + plugin.getMessageManager().send(player, "no-permission"); + return true; + } + + if (args.length < 1) { + player.sendMessage("§cИспользование: /unlead <игрок>"); + return true; + } + + Player target = Bukkit.getPlayer(args[0]); + if (target == null) { + plugin.getMessageManager().send(player, "player-not-online"); + return true; + } + + if (!plugin.getLeadManager().isLeading(player, target)) { + plugin.getMessageManager().send(player, "unlead-not-leading"); + return true; + } + + plugin.getLeadManager().unlead(target); + plugin.getMessageManager().send(player, "unlead-success", "%player%", target.getName()); + plugin.getMessageManager().send(target, "unlead-target"); + + return true; + } + + @Override + public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) { + if (args.length == 1 && sender instanceof Player player) { + return Bukkit.getOnlinePlayers().stream() + .filter(p -> plugin.getLeadManager().isLeading(player, p)) + .map(Player::getName) + .filter(name -> name.toLowerCase().startsWith(args[0].toLowerCase())) + .collect(Collectors.toList()); + } + return new ArrayList<>(); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/listeners/CuffListener.java b/src/main/java/com/rpserver/jailplugin/listeners/CuffListener.java new file mode 100644 index 0000000..59a151c --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/listeners/CuffListener.java @@ -0,0 +1,77 @@ +package com.rpserver.jailplugin.listeners; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.event.player.PlayerDropItemEvent; +import org.bukkit.event.inventory.InventoryOpenEvent; + +public class CuffListener implements Listener { + + private final JailPlugin plugin; + + public CuffListener(JailPlugin plugin) { + this.plugin = plugin; + } + + @EventHandler(priority = EventPriority.HIGHEST) + public void onPlayerCommand(PlayerCommandPreprocessEvent event) { + Player player = event.getPlayer(); + + if (plugin.getCuffManager().isCuffed(player)) { + String command = event.getMessage(); + if (plugin.getCuffManager().isCommandBlocked(command)) { + event.setCancelled(true); + plugin.getMessageManager().send(player, "cuff-command-blocked"); + } + } + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent event) { + Player player = event.getPlayer(); + + // Снимаем наручники при выходе + if (plugin.getCuffManager().isCuffed(player)) { + plugin.getCuffManager().uncuff(player); + } + + // Разрываем связь конвоирования + plugin.getLeadManager().unlead(player); + plugin.getLeadManager().unleadByLeader(player); + } + + @EventHandler + public void onPlayerDropItem(PlayerDropItemEvent event) { + Player player = event.getPlayer(); + + if (plugin.getCuffManager().isCuffed(player)) { + event.setCancelled(true); + } + } + + @EventHandler + public void onInventoryOpen(InventoryOpenEvent event) { + if (!(event.getPlayer() instanceof Player player)) return; + + if (plugin.getCuffManager().isCuffed(player)) { + event.setCancelled(true); + } + } + + @EventHandler + public void onPlayerInteract(PlayerInteractEvent event) { + Player player = event.getPlayer(); + + if (plugin.getCuffManager().isCuffed(player)) { + if (event.getClickedBlock() != null) { + event.setCancelled(true); + } + } + } +} diff --git a/src/main/java/com/rpserver/jailplugin/listeners/JailListener.java b/src/main/java/com/rpserver/jailplugin/listeners/JailListener.java new file mode 100644 index 0000000..bf05172 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/listeners/JailListener.java @@ -0,0 +1,73 @@ +package com.rpserver.jailplugin.listeners; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerMoveEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.event.player.PlayerTeleportEvent; + +public class JailListener implements Listener { + + private final JailPlugin plugin; + + public JailListener(JailPlugin plugin) { + this.plugin = plugin; + } + + @EventHandler + public void onPlayerJoin(PlayerJoinEvent event) { + Player player = event.getPlayer(); + + if (plugin.getJailManager().isJailed(player)) { + if (plugin.getJailManager().getJailLocation() != null) { + player.teleport(plugin.getJailManager().getJailLocation()); + + long remaining = plugin.getJailManager().getRemainingTime(player); + if (remaining > 0) { + plugin.getMessageManager().send(player, "jail-time-left", "%time%", String.valueOf(remaining)); + } else { + plugin.getJailManager().unjail(player); + plugin.getMessageManager().send(player, "jail-released"); + } + } + } + } + + @EventHandler(priority = EventPriority.HIGHEST) + public void onPlayerMove(PlayerMoveEvent event) { + Player player = event.getPlayer(); + + if (!plugin.getJailManager().isJailed(player)) return; + if (plugin.getJailManager().getJailLocation() == null) return; + + double distance = event.getTo().distance(plugin.getJailManager().getJailLocation()); + if (distance > 20) { + event.setCancelled(true); + player.teleport(plugin.getJailManager().getJailLocation()); + } + } + + @EventHandler(priority = EventPriority.HIGHEST) + public void onPlayerTeleport(PlayerTeleportEvent event) { + Player player = event.getPlayer(); + + if (!plugin.getJailManager().isJailed(player)) return; + + if (event.getCause() != PlayerTeleportEvent.TeleportCause.PLUGIN) { + event.setCancelled(true); + } + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent event) { + Player player = event.getPlayer(); + + if (plugin.getJailManager().isJailed(player)) { + plugin.getJailManager().saveData(); + } + } +} diff --git a/src/main/java/com/rpserver/jailplugin/listeners/LeadListener.java b/src/main/java/com/rpserver/jailplugin/listeners/LeadListener.java new file mode 100644 index 0000000..5c6b32c --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/listeners/LeadListener.java @@ -0,0 +1,41 @@ +package com.rpserver.jailplugin.listeners; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.event.player.PlayerTeleportEvent; + +public class LeadListener implements Listener { + + private final JailPlugin plugin; + + public LeadListener(JailPlugin plugin) { + this.plugin = plugin; + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent event) { + Player player = event.getPlayer(); + + if (plugin.getLeadManager().isBeingLed(player)) { + Player leader = plugin.getLeadManager().getLeader(player); + plugin.getLeadManager().unlead(player); + if (leader != null && leader.isOnline()) { + plugin.getMessageManager().send(leader, "lead-broken"); + } + } + + plugin.getLeadManager().unleadByLeader(player); + } + + @EventHandler + public void onPlayerTeleport(PlayerTeleportEvent event) { + Player player = event.getPlayer(); + + if (event.getCause() != PlayerTeleportEvent.TeleportCause.PLUGIN) { + plugin.getLeadManager().unleadByLeader(player); + } + } +} diff --git a/src/main/java/com/rpserver/jailplugin/managers/CuffManager.java b/src/main/java/com/rpserver/jailplugin/managers/CuffManager.java new file mode 100644 index 0000000..cd7152a --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/managers/CuffManager.java @@ -0,0 +1,81 @@ +package com.rpserver.jailplugin.managers; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.entity.Player; +import org.bukkit.potion.PotionEffect; +import org.bukkit.potion.PotionEffectType; + +import java.util.HashSet; +import java.util.Set; +import java.util.UUID; + +public class CuffManager { + + private final JailPlugin plugin; + private final Set cuffedPlayers; + + public CuffManager(JailPlugin plugin) { + this.plugin = plugin; + this.cuffedPlayers = new HashSet<>(); + } + + public boolean isCuffed(Player player) { + return cuffedPlayers.contains(player.getUniqueId()); + } + + public boolean isCuffed(UUID uuid) { + return cuffedPlayers.contains(uuid); + } + + public void cuff(Player player) { + cuffedPlayers.add(player.getUniqueId()); + applySlowEffect(player); + } + + public void uncuff(Player player) { + cuffedPlayers.remove(player.getUniqueId()); + removeSlowEffect(player); + + plugin.getLeadManager().unlead(player); + } + + private void applySlowEffect(Player player) { + double speedModifier = plugin.getConfig().getDouble("cuff.speed-modifier", 0.5); + int amplifier = (int) ((1.0 - speedModifier) * 4); // 0.5 speed = Slowness 2 + + player.addPotionEffect(new PotionEffect( + PotionEffectType.SLOWNESS, + Integer.MAX_VALUE, + amplifier, + false, + false, + true + )); + } + + private void removeSlowEffect(Player player) { + player.removePotionEffect(PotionEffectType.SLOWNESS); + } + + public boolean isCommandBlocked(String command) { + if (!plugin.getConfig().getBoolean("cuff.block-commands", true)) { + return false; + } + + String cmd = command.toLowerCase().split(" ")[0]; + for (String allowed : plugin.getConfig().getStringList("cuff.allowed-commands")) { + if (cmd.equalsIgnoreCase(allowed) || cmd.equalsIgnoreCase(allowed.substring(1))) { + return false; + } + } + return true; + } + + public double getCuffDistance() { + return plugin.getConfig().getDouble("cuff.distance", 5.0); + } + + public Set getCuffedPlayers() { + return new HashSet<>(cuffedPlayers); + } +} diff --git a/src/main/java/com/rpserver/jailplugin/managers/JailManager.java b/src/main/java/com/rpserver/jailplugin/managers/JailManager.java new file mode 100644 index 0000000..08fd8b7 --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/managers/JailManager.java @@ -0,0 +1,242 @@ +package com.rpserver.jailplugin.managers; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scheduler.BukkitTask; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +public class JailManager { + + private final JailPlugin plugin; + private final Map jailedPlayers; + private Location jailLocation; + private File dataFile; + private FileConfiguration dataConfig; + private BukkitTask jailTask; + + public JailManager(JailPlugin plugin) { + this.plugin = plugin; + this.jailedPlayers = new HashMap<>(); + loadData(); + startJailTimer(); + } + + public boolean isJailed(Player player) { + return jailedPlayers.containsKey(player.getUniqueId()); + } + + public boolean isJailed(UUID uuid) { + return jailedPlayers.containsKey(uuid); + } + + public void jail(Player player, int seconds, String reason) { + if (jailLocation == null) { + return; + } + + JailData data = new JailData( + player.getLocation().clone(), + System.currentTimeMillis() + (seconds * 1000L), + reason + ); + + jailedPlayers.put(player.getUniqueId(), data); + + plugin.getCuffManager().uncuff(player); + + player.teleport(jailLocation); + + saveData(); + } + + public void unjail(Player player) { + JailData data = jailedPlayers.remove(player.getUniqueId()); + + if (data != null && plugin.getConfig().getBoolean("jail.teleport-on-release", true)) { + player.teleport(data.getPreviousLocation()); + } + + saveData(); + } + + public void setJailLocation(Location location) { + this.jailLocation = location.clone(); + saveData(); + } + + public Location getJailLocation() { + return jailLocation; + } + + public boolean isJailSet() { + return jailLocation != null; + } + + public long getRemainingTime(Player player) { + JailData data = jailedPlayers.get(player.getUniqueId()); + if (data == null) return 0; + + long remaining = data.getReleaseTime() - System.currentTimeMillis(); + return Math.max(0, remaining / 1000); + } + + public String getJailReason(Player player) { + JailData data = jailedPlayers.get(player.getUniqueId()); + return data != null ? data.getReason() : ""; + } + + private void startJailTimer() { + jailTask = new BukkitRunnable() { + @Override + public void run() { + long currentTime = System.currentTimeMillis(); + + for (Map.Entry entry : new HashMap<>(jailedPlayers).entrySet()) { + if (currentTime >= entry.getValue().getReleaseTime()) { + Player player = Bukkit.getPlayer(entry.getKey()); + if (player != null && player.isOnline()) { + unjail(player); + plugin.getMessageManager().send(player, "jail-released"); + } else { + jailedPlayers.remove(entry.getKey()); + } + } + } + } + }.runTaskTimer(plugin, 20L, 20L); // Каждую секунду + } + + public void loadData() { + dataFile = new File(plugin.getDataFolder(), "data.yml"); + + if (!dataFile.exists()) { + try { + plugin.getDataFolder().mkdirs(); + dataFile.createNewFile(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + dataConfig = YamlConfiguration.loadConfiguration(dataFile); + + if (dataConfig.contains("jail-location")) { + String worldName = dataConfig.getString("jail-location.world"); + World world = Bukkit.getWorld(worldName); + if (world != null) { + jailLocation = new Location( + world, + dataConfig.getDouble("jail-location.x"), + dataConfig.getDouble("jail-location.y"), + dataConfig.getDouble("jail-location.z"), + (float) dataConfig.getDouble("jail-location.yaw"), + (float) dataConfig.getDouble("jail-location.pitch") + ); + } + } + + if (dataConfig.contains("jailed-players")) { + for (String uuidString : dataConfig.getConfigurationSection("jailed-players").getKeys(false)) { + try { + UUID uuid = UUID.fromString(uuidString); + String path = "jailed-players." + uuidString; + + String prevWorldName = dataConfig.getString(path + ".previous-location.world"); + World prevWorld = Bukkit.getWorld(prevWorldName); + + if (prevWorld != null) { + Location prevLoc = new Location( + prevWorld, + dataConfig.getDouble(path + ".previous-location.x"), + dataConfig.getDouble(path + ".previous-location.y"), + dataConfig.getDouble(path + ".previous-location.z"), + (float) dataConfig.getDouble(path + ".previous-location.yaw"), + (float) dataConfig.getDouble(path + ".previous-location.pitch") + ); + + long releaseTime = dataConfig.getLong(path + ".release-time"); + String reason = dataConfig.getString(path + ".reason", ""); + + jailedPlayers.put(uuid, new JailData(prevLoc, releaseTime, reason)); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + } + + public void saveData() { + if (jailLocation != null) { + dataConfig.set("jail-location.world", jailLocation.getWorld().getName()); + dataConfig.set("jail-location.x", jailLocation.getX()); + dataConfig.set("jail-location.y", jailLocation.getY()); + dataConfig.set("jail-location.z", jailLocation.getZ()); + dataConfig.set("jail-location.yaw", jailLocation.getYaw()); + dataConfig.set("jail-location.pitch", jailLocation.getPitch()); + } + + dataConfig.set("jailed-players", null); + for (Map.Entry entry : jailedPlayers.entrySet()) { + String path = "jailed-players." + entry.getKey().toString(); + JailData data = entry.getValue(); + + dataConfig.set(path + ".previous-location.world", data.getPreviousLocation().getWorld().getName()); + dataConfig.set(path + ".previous-location.x", data.getPreviousLocation().getX()); + dataConfig.set(path + ".previous-location.y", data.getPreviousLocation().getY()); + dataConfig.set(path + ".previous-location.z", data.getPreviousLocation().getZ()); + dataConfig.set(path + ".previous-location.yaw", data.getPreviousLocation().getYaw()); + dataConfig.set(path + ".previous-location.pitch", data.getPreviousLocation().getPitch()); + dataConfig.set(path + ".release-time", data.getReleaseTime()); + dataConfig.set(path + ".reason", data.getReason()); + } + + try { + dataConfig.save(dataFile); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public void shutdown() { + if (jailTask != null) { + jailTask.cancel(); + } + saveData(); + } + + public static class JailData { + private final Location previousLocation; + private final long releaseTime; + private final String reason; + + public JailData(Location previousLocation, long releaseTime, String reason) { + this.previousLocation = previousLocation; + this.releaseTime = releaseTime; + this.reason = reason; + } + + public Location getPreviousLocation() { + return previousLocation; + } + + public long getReleaseTime() { + return releaseTime; + } + + public String getReason() { + return reason; + } + } +} diff --git a/src/main/java/com/rpserver/jailplugin/managers/LeadManager.java b/src/main/java/com/rpserver/jailplugin/managers/LeadManager.java new file mode 100644 index 0000000..e1d274b --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/managers/LeadManager.java @@ -0,0 +1,129 @@ +package com.rpserver.jailplugin.managers; + +import com.rpserver.jailplugin.JailPlugin; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scheduler.BukkitTask; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +public class LeadManager { + + private final JailPlugin plugin; + private final Map leadingMap; // led player -> leader + private BukkitTask followTask; + + public LeadManager(JailPlugin plugin) { + this.plugin = plugin; + this.leadingMap = new HashMap<>(); + startFollowTask(); + } + + public boolean isBeingLed(Player player) { + return leadingMap.containsKey(player.getUniqueId()); + } + + public boolean isBeingLed(UUID uuid) { + return leadingMap.containsKey(uuid); + } + + public boolean isLeading(Player leader, Player target) { + UUID ledBy = leadingMap.get(target.getUniqueId()); + return ledBy != null && ledBy.equals(leader.getUniqueId()); + } + + public Player getLeader(Player player) { + UUID leaderUuid = leadingMap.get(player.getUniqueId()); + if (leaderUuid != null) { + return Bukkit.getPlayer(leaderUuid); + } + return null; + } + + public void lead(Player leader, Player target) { + leadingMap.put(target.getUniqueId(), leader.getUniqueId()); + } + + public void unlead(Player target) { + leadingMap.remove(target.getUniqueId()); + } + + public void unleadByLeader(Player leader) { + leadingMap.entrySet().removeIf(entry -> entry.getValue().equals(leader.getUniqueId())); + } + + private void startFollowTask() { + double maxDistance = plugin.getConfig().getDouble("lead.max-distance", 10.0); + double followDistance = plugin.getConfig().getDouble("lead.follow-distance", 2.0); + boolean teleportOnExceed = plugin.getConfig().getBoolean("lead.teleport-on-exceed", true); + + followTask = new BukkitRunnable() { + @Override + public void run() { + for (Map.Entry entry : new HashMap<>(leadingMap).entrySet()) { + Player target = Bukkit.getPlayer(entry.getKey()); + Player leader = Bukkit.getPlayer(entry.getValue()); + + if (target == null || leader == null || !target.isOnline() || !leader.isOnline()) { + leadingMap.remove(entry.getKey()); + continue; + } + + if (!target.getWorld().equals(leader.getWorld())) { + breakLead(target, leader); + continue; + } + + double distance = target.getLocation().distance(leader.getLocation()); + + if (distance > maxDistance) { + if (teleportOnExceed) { + teleportBehindLeader(target, leader, followDistance); + } else { + breakLead(target, leader); + } + } else if (distance > followDistance + 1) { + pullTowardsLeader(target, leader, followDistance); + } + } + } + }.runTaskTimer(plugin, 10L, 10L); // Каждые полсекунды + } + + private void teleportBehindLeader(Player target, Player leader, double distance) { + Location leaderLoc = leader.getLocation(); + Location behind = leaderLoc.clone().add(leaderLoc.getDirection().multiply(-distance)); + behind.setY(leaderLoc.getY()); + behind.setPitch(target.getLocation().getPitch()); + behind.setYaw(leaderLoc.getYaw()); + target.teleport(behind); + } + + private void pullTowardsLeader(Player target, Player leader, double followDistance) { + Location targetLoc = target.getLocation(); + Location leaderLoc = leader.getLocation(); + + org.bukkit.util.Vector direction = leaderLoc.toVector().subtract(targetLoc.toVector()).normalize(); + + double currentDistance = targetLoc.distance(leaderLoc); + double pullStrength = Math.min(0.3, (currentDistance - followDistance) * 0.1); + + target.setVelocity(direction.multiply(pullStrength)); + } + + private void breakLead(Player target, Player leader) { + leadingMap.remove(target.getUniqueId()); + plugin.getMessageManager().send(leader, "lead-broken"); + plugin.getMessageManager().send(target, "lead-broken-target"); + } + + public void shutdown() { + if (followTask != null) { + followTask.cancel(); + } + } +} diff --git a/src/main/java/com/rpserver/jailplugin/managers/MessageManager.java b/src/main/java/com/rpserver/jailplugin/managers/MessageManager.java new file mode 100644 index 0000000..b92773a --- /dev/null +++ b/src/main/java/com/rpserver/jailplugin/managers/MessageManager.java @@ -0,0 +1,48 @@ +package com.rpserver.jailplugin.managers; + +import com.rpserver.jailplugin.JailPlugin; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class MessageManager { + + private final JailPlugin plugin; + private final String prefix; + + public MessageManager(JailPlugin plugin) { + this.plugin = plugin; + this.prefix = plugin.getConfig().getString("messages.prefix", "&8[&cJail&8] &r"); + } + + public void send(CommandSender sender, String key) { + send(sender, key, new String[0]); + } + + public void send(CommandSender sender, String key, String... replacements) { + String message = plugin.getConfig().getString("messages." + key, key); + + for (int i = 0; i < replacements.length; i += 2) { + if (i + 1 < replacements.length) { + message = message.replace(replacements[i], replacements[i + 1]); + } + } + + Component component = LegacyComponentSerializer.legacyAmpersand().deserialize(prefix + message); + sender.sendMessage(component); + } + + public void sendRaw(CommandSender sender, String message) { + Component component = LegacyComponentSerializer.legacyAmpersand().deserialize(prefix + message); + sender.sendMessage(component); + } + + public String getMessage(String key) { + return plugin.getConfig().getString("messages." + key, key); + } + + public String getPrefix() { + return prefix; + } +} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..d3bb7a2 --- /dev/null +++ b/src/main/resources/config.yml @@ -0,0 +1,73 @@ +# JailPlugin Configuration + +# Настройки наручников +cuff: + # Дистанция для надевания наручников (в блоках) + distance: 5.0 + # Запретить игроку в наручниках использовать команды + block-commands: true + # Разрешённые команды для игроков в наручниках + allowed-commands: + - "/msg" + - "/r" + - "/me" + # Замедление игрока в наручниках (0.0 - 1.0, где 1.0 = нормальная скорость) + speed-modifier: 0.5 + +# Настройки конвоирования (lead) +lead: + # Максимальная дистанция конвоирования (после этого связь разрывается) + max-distance: 10.0 + # Дистанция следования за конвоиром + follow-distance: 2.0 + # Телепортировать если дистанция превышена + teleport-on-exceed: true + +# Настройки тюрьмы +jail: + # Телепортировать игрока в точку спавна после выхода из тюрьмы + teleport-on-release: true + # Максимальное время заключения в секундах (0 = без ограничений) + max-time: 0 + # Запретить выход из игры в тюрьме (время продолжает идти) + prevent-logout: false + +# Сообщения +messages: + prefix: "&8[&cJail&8] &r" + no-permission: "&cУ вас нет прав для выполнения этой команды!" + player-not-found: "&cИгрок не найден!" + player-not-online: "&cИгрок не в сети!" + + # Наручники + cuff-success: "&aВы надели наручники на игрока &e%player%&a!" + cuff-target: "&cНа вас надели наручники!" + cuff-already: "&cИгрок уже в наручниках!" + uncuff-success: "&aВы сняли наручники с игрока &e%player%&a!" + uncuff-target: "&aС вас сняли наручники!" + uncuff-not-cuffed: "&cИгрок не в наручниках!" + cuff-too-far: "&cИгрок слишком далеко!" + cuff-command-blocked: "&cВы не можете использовать команды в наручниках!" + + # Конвоирование + lead-success: "&aВы ведёте игрока &e%player%&a!" + lead-target: "&cВас ведут!" + lead-not-cuffed: "&cИгрок должен быть в наручниках!" + lead-already: "&cВы уже ведёте этого игрока!" + unlead-success: "&aВы отпустили игрока &e%player%&a!" + unlead-target: "&aВас отпустили!" + unlead-not-leading: "&cВы не ведёте этого игрока!" + lead-broken: "&eСвязь с конвоируемым разорвана!" + lead-broken-target: "&eВас отпустили!" + + # Тюрьма + jail-success: "&aИгрок &e%player% &aпосажен в тюрьму на &e%time% &aсекунд!" + jail-target: "&cВы посажены в тюрьму на &e%time% &cсекунд! Причина: &e%reason%" + jail-already: "&cИгрок уже в тюрьме!" + jail-not-set: "&cТочка тюрьмы не установлена!" + unjail-success: "&aИгрок &e%player% &aвыпущен из тюрьмы!" + unjail-target: "&aВы выпущены из тюрьмы!" + unjail-not-jailed: "&cИгрок не в тюрьме!" + setjail-success: "&aТочка тюрьмы установлена!" + jail-time-left: "&eДо освобождения: &c%time% &eсекунд" + jail-released: "&aВы освобождены из тюрьмы!" diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..0c60243 --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,72 @@ +name: ${name} +version: ${version} +main: com.rpserver.jailplugin.JailPlugin +api-version: ${apiVersion} +description: ${description} +author: RPServer +depend: + - LuckPerms + +commands: + cuff: + description: Надеть наручники на игрока + usage: /cuff + permission: jailplugin.cuff + uncuff: + description: Снять наручники с игрока + usage: /uncuff + permission: jailplugin.uncuff + jail: + description: Посадить игрока в тюрьму + usage: /jail