initial commit

2025-12-22 20:29:34 +03:00 · 2025-12-22 20:29:34 +03:00 · 2625155037
commit 2625155037
26 changed files with 2034 additions and 0 deletions
--- a/.gitea/workflows/release.yml
+++ 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
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,9 @@
+.gradle/
+build/
+.idea/
+*.iml
+*.ipr
+*.iws
+out/
+run/
+logs/
--- a/README.md
+++ 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` для настройки:
+- Дистанции для команд
+- Скорости движения в наручниках
+- Сообщений
+- Параметров тюрьмы
--- a/build.gradle.kts
+++ 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")
+    }
+}
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ 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
--- a/248
+++ b/248
@ -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" "$@"
--- a/gradlew.bat
+++ 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
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@ -0,0 +1,8 @@
+rootProject.name = "jail-plugin"
+
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        maven("https://repo.papermc.io/repository/maven-public/")
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/JailPlugin.java
+++ 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<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;
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/CuffCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/JailCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/LeadCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/SetJailCommand.java
+++ 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;
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/UncuffCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/UnjailCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/commands/UnleadCommand.java
+++ 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<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<>();
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/listeners/CuffListener.java
+++ 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);
+            }
+        }
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/listeners/JailListener.java
+++ 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();
+        }
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/listeners/LeadListener.java
+++ 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);
+        }
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/managers/CuffManager.java
+++ 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<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);
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/managers/JailManager.java
+++ 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<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;
+        }
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/managers/LeadManager.java
+++ 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<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();
+        }
+    }
+}
--- a/src/main/java/com/rpserver/jailplugin/managers/MessageManager.java
+++ 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;
+    }
+}
--- a/src/main/resources/config.yml
+++ 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Вы освобождены из тюрьмы!"
--- a/src/main/resources/plugin.yml
+++ 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 <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