Shifty/jail-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

initial commit
Some checks failed
Build and Release / build (push) Failing after 3s
Details

Browse Source
This commit is contained in:
Илья Глазунов 2025-12-22 20:29:34 +03:00
commit 2625155037
26 changed files with 2034 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
.gitea/workflows/release.yml Normal file
View File

@ -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

9
.gitignore vendored Normal file
View File

@ -0,0 +1,9 @@
.gradle/
build/
.idea/
*.iml
*.ipr
*.iws
out/
run/
logs/

84
README.md Normal file
View File

@ -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` для настройки:
- Дистанции для команд
- Скорости движения в наручниках
- Сообщений
- Параметров тюрьмы

47
build.gradle.kts Normal file
View File

@ -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")
}
}

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

7
gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@ -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

248
gradlew vendored Executable file
View File

@ -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" "$@"

93
gradlew.bat vendored Normal file
View File

@ -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

8
settings.gradle.kts Normal file
View File

@ -0,0 +1,8 @@
rootProject.name = "jail-plugin"
pluginManagement {
repositories {
gradlePluginPortal()
maven("https://repo.papermc.io/repository/maven-public/")
}
}

106
src/main/java/com/rpserver/jailplugin/JailPlugin.java Normal file
View File

@ -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<LuckPerms> 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;
}
}

83
src/main/java/com/rpserver/jailplugin/commands/CuffCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

103
src/main/java/com/rpserver/jailplugin/commands/JailCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

89
src/main/java/com/rpserver/jailplugin/commands/LeadCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

35
src/main/java/com/rpserver/jailplugin/commands/SetJailCommand.java Normal file
View File

@ -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;
}
}

72
src/main/java/com/rpserver/jailplugin/commands/UncuffCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

72
src/main/java/com/rpserver/jailplugin/commands/UnjailCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

72
src/main/java/com/rpserver/jailplugin/commands/UnleadCommand.java Normal file
View File

@ -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<String> 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<>();
}
}

77
src/main/java/com/rpserver/jailplugin/listeners/CuffListener.java Normal file
View File

@ -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);
}
}
}
}

73
src/main/java/com/rpserver/jailplugin/listeners/JailListener.java Normal file
View File

@ -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();
}
}
}

41
src/main/java/com/rpserver/jailplugin/listeners/LeadListener.java Normal file
View File

@ -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);
}
}
}

81
src/main/java/com/rpserver/jailplugin/managers/CuffManager.java Normal file
View File

@ -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<UUID> 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<UUID> getCuffedPlayers() {
return new HashSet<>(cuffedPlayers);
}
}

242
src/main/java/com/rpserver/jailplugin/managers/JailManager.java Normal file
View File

@ -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<UUID, JailData> 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<UUID, JailData> 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<UUID, JailData> 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;
}
}
}

129
src/main/java/com/rpserver/jailplugin/managers/LeadManager.java Normal file
View File

@ -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<UUID, UUID> 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<UUID, UUID> 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();
}
}
}

48
src/main/java/com/rpserver/jailplugin/managers/MessageManager.java Normal file
View File

@ -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;
}
}

73
src/main/resources/config.yml Normal file
View File

@ -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Вы освобождены из тюрьмы!"

72
src/main/resources/plugin.yml Normal file
View File

@ -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 <player>
permission: jailplugin.cuff
uncuff:
description: Снять наручники с игрока
usage: /uncuff <player>
permission: jailplugin.uncuff
jail:
description: Посадить игрока в тюрьму
usage: /jail <player> <time> [reason]
permission: jailplugin.jail
unjail:
description: Выпустить игрока из тюрьмы
usage: /unjail <player>
permission: jailplugin.unjail
setjail:
description: Установить точку тюрьмы
usage: /setjail
permission: jailplugin.setjail
lead:
description: Вести за собой игрока в наручниках
usage: /lead <player>
permission: jailplugin.lead
unlead:
description: Отпустить ведомого игрока
usage: /unlead <player>
permission: jailplugin.unlead
permissions:
jailplugin.cuff:
description: Разрешает надевать наручники
default: op
jailplugin.uncuff:
description: Разрешает снимать наручники
default: op
jailplugin.jail:
description: Разрешает сажать в тюрьму
default: op
jailplugin.unjail:
description: Разрешает выпускать из тюрьмы
default: op
jailplugin.setjail:
description: Разрешает устанавливать точку тюрьмы
default: op
jailplugin.lead:
description: Разрешает вести игроков в наручниках
default: op
jailplugin.unlead:
description: Разрешает отпускать ведомых игроков
default: op
jailplugin.admin:
description: Все права плагина
default: op
children:
jailplugin.cuff: true
jailplugin.uncuff: true
jailplugin.jail: true
jailplugin.unjail: true
jailplugin.setjail: true
jailplugin.lead: true
jailplugin.unlead: true