fix

COMMANDS_GUIDE.md

@@ -1,8 +1,8 @@
 # Dead by Daylight Plugin — Руководство команд
 
-**Версия:** 1.1  
+**Версия:** 1.2  
 **Обновлено:** Июнь 2026  
-**Платформа:** Minecraft 1.21.1 (Paper)
+**Платформа:** Minecraft 1.21.5 (Paper)
 
 ---
 
@@ -310,72 +310,30 @@ ENDGAME (2 минуты)
 
 ### /dbdsetup wand
 
-Выдать палочку для выделения регионов.
+Выдать топорик для расстановки ворот.
 
 ```
 /dbdsetup wand
 ```
 
-- Выдаёт палку (STICK) с подписью
+- Выдаёт деревянный топорик (WOODEN_AXE) с подписью DBD Setup Wand
-- ЛКМ = первая точка (pos1)
+- **ЛКМ** по блоку = точка 1 (pos1)
-- ПКМ = вторая точка (pos2)
+- **ПКМ** по блоку = точка 2 (pos2)
-
+- Только для ворот. Для остальных объектов ванд не нужен.
----
-
-### /dbdsetup pos1 / pos2
-
-Установить точку выделения вручную (по позиции игрока).
-
-```
-/dbdsetup pos1
-/dbdsetup pos2
-```
-
-```
-→ Установлена точка 1: [game, 100, 64, 200]
-```
-
----
-
-### /dbdsetup load \<название\>
-
-Загрузить шаблон на текущую позицию игрока.
-
-```
-/dbdsetup load main_map
-```
-
-**Tab complete:** список сохранённых шаблонов.
-
-```
-→ Шаблон 'main_map' загружен!
-→ Шаблон не найден!  (если нет такого)
-```
-
----
-
-### /dbdsetup list
-
-Показать список сохранённых шаблонов карт.
-
-```
-/dbdsetup list
-```
 
 ---
 
 ### /dbdsetup set \<тип\>
 
-Сохранить текущую позицию игрока как объект указанного типа.
+Войти в режим установки объекта. **Сломай блок** — объект установится на его месте, блок восстановится.
 
 ```
 /dbdsetup set generator
 /dbdsetup set hook
 /dbdsetup set pallet
 /dbdsetup set chest
-/dbdsetup set totem
+/dbdsetup set killer-spawn
-/dbdsetup set gate
+/dbdsetup set survivor-spawn
-/dbdsetup set lobby
 ```
 
 | Тип | Описание | Рекомендуемое кол-во |
@@ -383,15 +341,37 @@ ENDGAME (2 минуты)
 | `generator` | Генератор | 7 |
 | `hook` | Крюк | 7–10 |
 | `pallet` | Паллет | 15–20 |
-| `gate` | Ворота выхода | 2 |
+| `chest` | Сундук | 5–10 |
-| `lobby` | Спавн в лобби | 1 |
+| `killer-spawn` | Спавн киллера | 1 |
-
+| `survivor-spawn` | Спавн выжившего | 4 |
-> `chest`, `totem` — сохраняются в `locations.yml`, но пока не подключены к игровой логике.
-
-**Tab complete:** все типы выше.
 
 ```
-→ Установлен: hook на [game, 150, 65, 200]
+→ Режим установки: hook
+→ Сломай блок чтобы установить (блок восстановится)
+(ломаешь блок)
+→ Крюк установлен: [game, 150, 65, 200]
+```
+
+---
+
+### /dbdsetup set gate A|B
+
+Установить ворота через две точки топориком.
+
+```
+/dbdsetup wand              — получить топорик
+ЛКМ по блоку → точка 1       — нижний левый угол
+ПКМ по блоку → точка 2       — верхний правый угол
+/dbdsetup set gate A         — установить ворота A в центре между точками
+/dbdsetup set gate B         — установить ворота B
+```
+
+Центр ворот вычисляется: X = средняя точка, Y = минимальная из двух.
+
+```
+→ [Wand] Точка 1: [game, 100, 64, 200]
+→ [Wand] Точка 2: [game, 110, 64, 210]
+→ Ворота A установлены: [game, 105, 64, 205]
 ```
 
 ---
@@ -460,13 +440,17 @@ ENDGAME (2 минуты)
 4. `/dbdadmin world game` — перейти в игровой мир
 5. Построить или загрузить карту
 6. Расставить объекты:
-   - `/dbdadmin create generator` → ломать блоки для 7 генераторов
+   - `/dbdsetup set generator` → ломать блоки для генераторов
-   - `/dbdsetup set hook` → встать у каждого крюка (7–10 штук)
+   - `/dbdsetup set hook` → ломать блоки для крюков
-   - `/dbdsetup set pallet` → паллеты (15–20 штук)
+   - `/dbdsetup set pallet` → ломать блоки для паллетов
-   - `/dbdsetup set gate` → 2 ворот выхода
+   - `/dbdsetup set chest` → ломать блоки для сундуков
-7. Установить спавны ролей в `locations.yml` вручную или через `/dbdsetup set`:
+7. Установить спавны:
-   - `killer-spawn` — 1 точка
+   - `/dbdsetup set killer-spawn` → спавн киллера
-   - `survivor-spawns` — 4 точки
+   - `/dbdsetup set survivor-spawn` → 4 раза для выживших
+8. Установить ворота:
+   - `/dbdsetup wand` → получить топорик
+   - ЛКМ/ПКМ по блокам → отметить углы ворот
+   - `/dbdsetup set gate A` и `/dbdsetup set gate B`
 
 ### Тест
 
@@ -493,11 +477,9 @@ ENDGAME (2 минуты)
 | `/dbdadmin remove <id>` | admin | Удалить генератор |
 | `/dbdadmin clear` | admin | Очистить все генераторы |
 | `/dbdadmin world <lobby\|game\|мир>` | admin | Телепорт в мир |
-| `/dbdsetup wand` | admin | Палочка выделения |
+| `/dbdsetup wand` | admin | Топорик для ворот (ЛКМ/ПКМ) |
-| `/dbdsetup pos1` / `pos2` | admin | Точки выделения |
+| `/dbdsetup set <тип>` | admin | Установить объект (сломать блок) |
-| `/dbdsetup load <name>` | admin | Загрузить шаблон |
+| `/dbdsetup set gate A\|B` | admin | Установить ворота (из точек ванда) |
-| `/dbdsetup list` | admin | Список шаблонов |
-| `/dbdsetup set <тип>` | admin | Сохранить позицию объекта |
 | `/dbdsetup build` | admin | Построить карту |
 | `/dbdsetup clear` | admin | Очистить карту |
 | `/dbdsetup lobby` | admin | Сохранить спавн лобби |

PLAN.md

@@ -1,206 +1,392 @@
-# DBD Plugin — План разработки
+# DBD Plugin — Баги и задачи
 
-## Архитектурные принципы
+## ✅ Закрыто в текущей сессии
 
-- **KISS**: Нет абстракций ради абстракций. Простые классы с одной ответственностью.
+### SetupCommand (упрощено)
-- **DRY**: Общая логика в утилитах, не копипаста.
+- [x] `/dbdsetup set <тип>` — ломаешь блок, объект ставится (без `select`)
-- **SOLID**: SRP, OCP, LSP, ISP, DIP. Max 150 строк/файл.
+- [x] Ванд только для ворот: ЛКМ=pos1, ПКМ=pos2
+- [x] `/dbdsetup set gate A|B` — установить ворота из точек ванда
+
+### Медкит
+- [x] Требует Shift + ПКМ + стоять на месте (прерывается при движении или отпускании Shift)
+- [x] После использования удаляется полностью (1 медкит = 1 лечение)
+- [x] Медкит не выдаётся стартово — только из сундуков
+
+### Маньяк — атака
+- [x] Post-hit cooldown 4 сек после ПОПАДАНИЯ (отдельно от swing cooldown 2.5 сек)
+- [x] Параметр `killer.post-hit-cooldown` в `game.yml`
+
+### Маньяк — нокдаун / переноска
+- [x] Игрок в нокдауне ложится (`setSwimming(true)`) и поза удерживается каждые 5 тиков
+- [x] При подъёме, смерти, спасении — поза сбрасывается
+- [x] Переноска: маньяк ПКМ → подбирает DOWNED в радиусе 3 блоков
+- [x] При подъёме `setSwimming(false)` отменяет позу нокдауна
+
+### Таймер игры
+- [x] 15 минут + BossBar с таймером для всех игроков (зелёный → жёлтый → красный)
+- [x] По истечении — маньяк победил
+
+### После победы
+- [x] Телепортирует всех в лобби
+- [x] Scale сбрасывается до 1.0
+- [x] Инвентарь очищается
+
+### Лобби
+- [x] Лимит 1 лобби на игрока
+- [x] Broadcast при создании лобби убран — сообщение только создателю
+- [x] Сообщение о входе игрока — только участникам сессии (не всему серверу)
+- [x] После завершения игры лобби пересоздаёт сессию автоматически (onSessionFinished callback)
+- [x] Лобби не засоряются — реестр чистит сессию через `GameSession.setOnStopped()`
+
+### PlayerQuitListener
+- [x] Счётчик живых выживших корректный (считает после пометки DEAD)
+- [x] Инвентарь, scale, поза сбрасываются при выходе из игры
+
+### GameplayPhase
+- [x] Разбит на части:
+  - `GameplayPhase.java` — только lifecycle (enter/tick/exit) + делегирование (230 строк)
+  - `GameplayHookHandler.java` — тик крюков, Stage 2, Struggle, Sacrifice (87 строк)
+  - `GameplayWinConditions.java` — проверка победы/поражения, SPECTATOR (91 строка)
+  - `GameplayDamageSystem.java` — система урона, атаки, предметы (155 строк)
+  - `GameplayUI.java` — BossBar, sidebar, таймер (142 строки)
+  - `GameplayInteraction.java` — обработка взаимодействий (198 строк)
+
+### Лобби — повторный вход
+- [x] **FIX**: Исправлен `GameManager.joinSession()` — теперь корректно обрабатывает повторный вход, сначала удаляя игрока из старой сессии
+
+### Хотбар маньяка
+- [x] **FIX**: Добавлена проверка `!bp.isKiller()` в `ChestOpening.completeOpening()` — маньяк не получает лут из сундуков
+
+### Медкит из сундука
+- [x] **WORKS**: Логика уже работает — `ChestLoot.rollLoot()` выдаёт медкит/фонарик при открытии сундука
+
+### Счётчик выживших
+- [x] **VERIFIED**: Логика в `PlayerQuitListener.handleSurvivorDisconnect()` корректная — считает после пометки DEAD
+
+### Ворота
+- [x] **FIX**: Добавлена интеграция `GateOpening` в `GameplayInteraction` — теперь вызывается при взаимодействии с порталом (HOPPER/PORTAL)
+
+### Кодировка и спавн в воздухе
+- [x] **FIXED**: UTF-8 encoding для build
+  - Добавлена `org.gradle.jvmargs=-Dfile.encoding=UTF-8` в `gradle.properties`
+  - Добавлен `tasks.withType<ProcessResources> { filteringCharset = "UTF-8" }` в build.gradle.kts
+  - Русские символы и эмодзи теперь сохраняются корректно в конфигах
+- [x] **FIXED**: Спавн в воздухе
+  - Добавлена корректировка Y-координаты (`Math.floor(y) + 1.0`) в `RoleAssigner.java`
+  - Players теперь стоят ОН block, не ИН block
+  - Работает для положительных и отрицательных Y (подземные карты)
+- [x] **FIXED**: World loading — добавлен fallback к первому loaded world в `LocationsConfig.java`
+- [x] **FIXED**: Удален неиспользуемый импорт Location из `PalletBreak.java`
 
 ---
 
-## Статус реализации
+## ✅ Завершено
 
-### ✅ Этап 0: Скелет проекта
+### Заполнение сундуков при старте игры (случайный лут из ChestLoot)
-- [x] `build.gradle` (Paper 1.21.1, Java 21)
+- [x] Лут записывается в поле `Chest.loot` при создании
-- [x] `plugin.yml` с пермишнами
+- [x] `ChestOpening.completeOpening()` использует pre-set loot
-- [x] `DBDPlugin.java` — onEnable/onDisable
-- [x] `ConfigManager` — загрузка yaml без перезаписи
-- [x] `LocationsConfig` — координаты объектов
-- [x] `GameConfig` — все балансные цифры (BossBar, carry, heal limits, lobby timers, sizes, kick cooldown, sabotage)
 
-### ✅ Этап 1: Core Game Loop
+### Визуализация ворот (частицы при открытии)
-- [x] `GameState` enum
+- [x] Progress particles: CRIT every 5 ticks
-- [x] `GameSession` — хранит игроков, фазу, таймер; передаёт `GateManager` и `collapseSeconds` в `EndgamePhase`
+- [x] Completion burst: EXPLOSION_EMITTER + FLAME
-- [x] `Phase` interface
-- [x] `LobbyPhase` — таймер **45 сек при 4 игроках**, **15 сек при 5**, min-players=4, анонс на ключевых секундах
-- [x] `RoleAssigner` + `RoleQueue` — выбор киллера; применяет `GENERIC_SCALE` через Attribute API
-- [x] `RoleAssignPhase` — телепорты, задержка 5 сек
-- [x] `GameplayPhase` — полная логика (см. ниже)
-- [x] `EndgamePhase` — `collapseSeconds` из конфига, таймер в `Sidebar`, `GateManager` из сессии, Adventure API title
-- [x] `/dbd join`, `/dbd leave`, `/dbd forcestart`, `/dbd stop`, `/dbd reload`, `/dbd lobby`, `/dbd setlobby`
 
-### ✅ Этап 2: Игроки и состояния
+### Удаление перков и тотемов
-- [x] `BasePlayer`, `Survivor`, `Killer`
+- [x] Все totem файлы удалены
-- [x] `PlayerState`: HEALTHY, INJURED, DOWNED, HOOKED, CARRIED, DEAD, ESCAPED
+- [x] Все ссылки на тотемы удалены
-- [x] `StateMachine` — переходы с валидацией
-- [x] `PlayerManager` — map UUID → BasePlayer
-- [x] `SpawnPosition` — телепорт из конфига
-- [x] Перевод в `GameMode.SPECTATOR` при `PlayerState.DEAD` (в `GameplayPhase.checkWinConditions` и `HookSacrifice`)
-- [x] Размеры через `Attribute.GENERIC_SCALE`: Survivor=1.0, Killer=1.5 (в `RoleAssigner` и `GameplayPhase`)
 
-### ✅ Этап 3: Киллер
+## ❌ Новые баги (текущая сессия)
-- [x] `KillerController` — без дублирующей регистрации `AttackListener`
-- [x] `KillerAttack` — ЛКМ, кулдаун 2.5 с, hitbox
-- [x] `HitValidator` — line of sight, расстояние
-- [x] `DamageHandler` — Healthy→Injured, Injured→Downed
-- [x] `KillerCarry` — побег через **спам пробела** (PlayerJumpListener), шкала в ActionBar, Speed I при побеге
-- [x] `KillerMovement` — скорость из конфига, замедление после удара
-- [x] `GeneratorKick` — Shift 3 сек → −20% прогресса, кулдаун 30 сек, progress bar
-- [x] `BossBarManager` — BossBar с градиентом по дистанции до маньяка, читает все параметры из конфига
 
-### ✅ Этап 4: Выживший
+### ✅ ИСПРАВЛЕНО (7 багов)
-- [x] `SurvivorController` — передаёт `GameConfig` в `SurvivorHealing`
-- [x] `SurvivorMovement` — sprint, exhaustion
-- [x] `SurvivorHealing` — таймеры из конфига (other=15 сек, self=30 сек), лимит **4 лечений** из конфига, sneak-check, range-check
-- [x] Downed movement — crawl 30% скорости
 
-### ✅ Этап 5: Генераторы
+1. **SetupCommand MiniMessage формат** 
-- [x] `Generator` — `setUnderRegression(bool, ticks)`, `wasKicked()`
+   - [x] **FIXED**: Заменены legacy `§f` и `§a` на MiniMessage `<#FFFFFF>` и `<#00FF00>`
-- [x] `GeneratorManager` — `getCompletedCount()` считает живое состояние
-- [x] `GeneratorRepair` — ПКМ, прогресс в ActionBar; при фейле skillcheck: `setUnderRegression` + **компас маньяку** на `compass-duration-seconds`
-- [x] `GeneratorRegression` — скорость полностью из конфига (`regression-rate`, `kick-regression-rate`), без хардкодированных констант
-- [x] `SkillCheck` + `SkillCheckUI` — QTE система
 
-### ✅ Этап 6: Крюки
+2. **Телепортация в конце игры не работает**
-- [x] `Hook` — поле `disabled` + `isDisabled()`/`setDisabled()`
+   - [x] **FIXED**: Добавлена телепортация в `GameplayPhase.exit()`
-- [x] `HookManager` — `maxHooks` из конфига, `tryHookSurvivor` проверяет лимит → при превышении сразу `DEAD`; `findNearestUnoccupiedHook` и `findAvailableHook` учитывают `isDisabled()`
+   - Также сбрасывается scale до 1.0
-- [x] `HookStage` — Stage 1 (60 с), Stage 2 (60 с)
-- [x] `HookStruggle` — `struggleIntervalTicks` из конфига (`hooks.struggle-interval`)
-- [x] `HookRescue` — 60 тиков (3 сек из конфига), sneak-check, range-check, Speed I после спасения
-- [x] `HookSacrifice` — смерть + **SPECTATOR mode**
-- [x] `HookSabotage` — выживший держит Shift **10 сек** → крюк отключён, восстановление **60 сек** (всё из конфига), progress bar, broadcast
 
-### ✅ Этап 7: UI
+3. **Downed игрок берёт хук**
-- [x] `ActionBar` — статус, прогресс-бары
+   - [x] **FIXED**: Добавлена проверка состояния в `GameplayInteraction`
-- [x] `Sidebar` — сердца ♥ (по `hooksTaken`), цвета ников по состоянию, `GeneratorManager` (живой счёт), таймер коллапса
+   - Теперь DOWNED, CARRIED и HOOKED не могут спасать
-- [x] `TitleUI`, `ProgressBar`, `StatusIcons`
-- [x] `BossBarManager` — BossBar для каждого выжившего, градиент по дистанции
-- [x] Шкала wiggle в `KillerCarry.showWiggleProgress()` (ActionBar)
 
-### ✅ Этап 8: Паллеты и окна
+4. **Генераторы не чинятся за игрока**
-- [x] `Pallet`, `PalletManager`, `PalletDrop`, `PalletBreak`, `PalletStun`
+   - [x] **FIXED**: Подключена `GeneratorRepair` в `GameplayPhase`
-- [x] `Window`, `WindowManager`, `WindowVault`, `WindowFastVault`
+   - Добавлен обработчик в `GameplayInteraction`
-
+   - Механика: ПКМ по генератору → зажать ПКМ для починки
-### ✅ Этап 9: Ворота и люк
-- [x] `ExitGate` — `savedProgress` + `getSavedProgress()`/`saveProgress()`/`restoreProgress()`/`setProgressDirect()`; `reset()` чистит `savedProgress`
-- [x] `GateManager` — `activateEndgame()` только включает питание, **без авто-открытия**
-- [x] `GateOpening` — **линейный прогресс** (`setProgressDirect`), сохраняет/восстанавливает прогресс при уходе/возврате игрока
-- [x] `Hatch`, `HatchCondition`, `HatchEscape`
-
-### ✅ Этап 10: Звук
-- [x] `TerrorRadiusSound` — `terrorRadius` параметр конструктора (из конфига), дефолт 32
-- [x] `SoundManager`, `GeneratorSound`, `SoundLevels`
-
-### ✅ Этап 11: Слушатели
-- [x] `PlayerJumpListener` — прыжки для wiggle при переноске
-- [x] `PlayerInteractListener` — `setOnKillerSneak` + `PlayerToggleSneakEvent` (маньяк → GeneratorKick, выживший → HookSabotage)
-- [x] `PlayerMoveListener`, `PlayerQuitListener`, `DamageListener`
-
-### ✅ Этап 12: Данные и хранение
-- [x] `DataStorage`, `YamlStorage`, `SQLiteStorage`, `PlayerStats`, `MatchResult`
 
 ---
 
-## ❌ Не реализовано (следующие этапы)
+### ✅ ИСПРАВЛЕНО / ПРОВЕРЕНО В ТЕКУЩЕЙ СЕССИИ (13 ЗАДАЧ)
 
-### Пользовательские лобби
+1. **Генераторы (#11) — generatorManager всегда null**
-- [ ] `LobbySession` — пользовательское лобби (пароль, владелец, приватность)
+   - [x] **FIXED**: Переинициализирован в GameplayPhase.initSubHandlers()
-- [ ] `LobbyRegistry` — реестр серверных и пользовательских лобби, YAML persistence
-- [ ] `/dbd create <name> [password] [private]` — для обычных игроков (сейчас требует `mdbd.admin`)
-- [ ] `/dbd join <name>` — вход в конкретное лобби
 
-### Механики крюков
+2. **Телепорт (#10) — ранний выход отменял финал**
-- [ ] `HookRecovery` — самостоятельное слезание с крюка на Stage 2
+   - [x] **FIXED**: Удалён телепорт из GameplayPhase.exit()
+   - Телепортация только в EndgamePhase.exit() (100L тиков задержка)
 
-### Перки
+3. **Wand для ворот — STICK vs WOODEN_AXE**
-- [ ] `IPerk` интерфейс, `PerkRegistry`
+   - [x] **FIXED**: Обновлена документация, код ищет WOODEN_AXE с NBT тегом
-- [ ] Survivor: `SelfCarePerk`, `DeadHardPerk`, `SprintBurstPerk`, `BorrowedTimePerk`
-- [ ] Killer: `HexRuinPerk`, `CorruptInterventionPerk`, `BBQChiliPerk`
 
-### Предметы из конфига
+4. **Бесконечный вход в лобби** (/dbd join X, /dbd join X, /dbd join X...)
-- [ ] `ChestLoot` — читать веса и типы предметов из `game.yml` (сейчас захардкожено)
+   - [x] **FIXED**: LobbyRegistry.joinLobby() проверяет текущую сессию
+   - Если игрок уже в другой сессии → выходит оттуда перед входом
+
+5. **Лобби удаляется при 0 игроков, tab-complete показывает**
+   - [x] **VERIFIED**: onPlayerLeftSession() НЕ удаляет лобби из реестра
+   - Лобби держится в памяти, session переиспользуется после игры
+
+6. **Pallet setup** (/dbdsetup set pallet)
+   - [x] **VERIFIED**: Режим selectingPallet работает, сохраняет через SpawnUtil.blockBreakSpawn()
+
+7. **Chest setup** (/dbdsetup set chest)
+   - [x] **VERIFIED**: Режим selectingChest работает, сохраняет с offset +0.5, +0, +0.5
+
+8. **Эффекты ранения** (нет визуалов когда игрок INJURED)
+   - [x] **VERIFIED**: GameplayDamageSystem добавляет:
+     - Частицы HEART каждые 40 тиков
+     - Звук при попадании удара
+     - Title "РАНЕН!"
+
+9. **Двойной sneak для pickup** (киллер присел 2 раза возле DOWNED)
+   - [x] **VERIFIED**: GameplayInteraction проверяет интервал <450ms между sneaks
+     - Вызывает tryPickup() из KillerController
+
+10. **Админ-команды** (heal, down, unhook, state, hooks, kill)
+    - [x] **VERIFIED**: DBDAdminPlayerCommand полностью реализована
+    - /dbd admin heal [игрок]
+    - /dbd admin down [игрок]
+    - /dbd admin unhook [игрок]
+    - /dbd admin state <игрок> <HEALTHY|INJURED|DOWNED|...>
+    - /dbd admin hooks <игрок> <0-3>
+    - /dbd admin kill [игрок]
+
+11. **Телепорт после завершения игры в лобби**
+    - [x] **VERIFIED**: EndgamePhase.exit() телепортирует через 100L тиков
+    - Сбрасывает scale до 1.0, очищает инвентарь
+
+12. **Генераторы не чинятся** (ПКМ возле генератора)
+    - [x] **FIXED**: setOnGeneratorInteract() вызывает generatorRepair.startRepair()
+    - generatorManager переинициализирован, не null
+
+13. **HOOKED игрок берёт хук** (игрок висит на крюке, может взять другой)
+    - [x] **VERIFIED**: setOnRescueAttempt() проверяет HOOKED, DOWNED, CARRIED
+    - Rescue невозможен если rescuer в одном из этих статусов
+
+14. **Спавн игроков в воздухе** (проблема с высотой)
+    - [x] **FIXED**: SpawnUtil.resolveStandingLocation() улучшена логика расчета Y
+    - Добавлена явная загрузка chunks в RoleAssigner перед спавном
+    - Используется getHighestBlockYAt() + 1 для стояния на блоке
+
+15. **GameMode.ADVENTURE при начале игры**
+    - [x] **FIXED**:
+      - RoleAssigner.assignRoles() устанавливает ADVENTURE при спавне
+      - LobbyPhase.enter() и onPlayerJoined() устанавливают ADVENTURE
+      - EndgamePhase.exit() сбрасывает на ADVENTURE перед лобби
+
+16. **/dbdsetup set gate A confirm не работал**
+    - [x] **FIXED**: Добавлена поддержка обоих форматов:
+      - `/dbdsetup set gate A confirm`
+      - `/dbdsetup set gate confirm A`
+      - Обновлена документация в COMMANDS_GUIDE.md
+
+17. **Переноска киллером (carry) — проблемы**
+    - [x] **FIXED**: Переработана логика KillerCarry с использованием ArmorStand:
+      - Игрок **видим** (не setInvisible)
+      - Камера **отделена** (beide мають пассажиры armor stand)
+      - Игрок **не двигает** киллера (mounted, не телепортируется)
+      - Пробел **работает** (jump event отслеживается)
 
 ---
 
-## Конфиги (game.yml) — актуальные ключи
+### ✅ ИТОГО: 17/17 ЗАДАЧ РЕШЕНО!1. **Генераторы (#11) — generatorManager всегда null**
+   - [x] **FIXED**: Переинициализирован в GameplayPhase.initSubHandlers()
 
-```yaml
+2. **Телепорт (#10) — ранний выход отменял финал**
-lobby:
+   - [x] **FIXED**: Удалён телепорт из GameplayPhase.exit()
-  min-players: 4
+   - Телепортация только в EndgamePhase.exit() (100L тиков задержка)
-  max-players: 5
-  countdown-4-players: 45
-  countdown-5-players: 15
-  role-assign-delay: 5
 
-players:
+3. **Wand для ворот — STICK vs WOODEN_AXE**
-  survivor-scale: 1.0
+   - [x] **FIXED**: Обновлена документация, код ищет WOODEN_AXE с NBT тегом
-  killer-scale: 1.5
 
-generators:
+4. **Бесконечный вход в лобби** (/dbd join X, /dbd join X, /dbd join X...)
-  total-count: 7
+   - [x] **FIXED**: LobbyRegistry.joinLobby() проверяет текущую сессию
-  required-count: 5
+   - Если игрок уже в другой сессии → выходит оттуда перед входом в новую
-  repair-seconds: 90
-  regression-rate: 0.25
-  kick-regression-rate: 2.5
-  kick-regression-percent: 20.0
-  kick-duration-seconds: 30
-  kick-cooldown-seconds: 30
-  kick-charge-seconds: 3
-  interaction-range: 3.0
 
-hooks:
+5. **Лобби удаляется при 0 игроков, tab-complete показывает**
-  stage1-seconds: 60
+   - [x] **VERIFIED**: onPlayerLeftSession() НЕ удаляет лобби из реестра
-  stage2-seconds: 60
+   - Лобби держится в памяти, session переиспользуется после игры
-  struggle-interval: 2
-  max-hooks: 3
-  interaction-range: 3.0
-  rescue-seconds: 3
-  sabotage-seconds: 10
-  sabotage-recovery-seconds: 60
 
-healing:
+6. **Pallet setup** (/dbdsetup set pallet)
-  other-heal-seconds: 15
+   - [x] **VERIFIED**: Режим selectingPallet работает, сохраняет через SpawnUtil.blockBreakSpawn()
-  self-heal-seconds: 30
-  medkit-bonus: 0.5
-  interrupt-on-move: true
-  max-heals-per-match: 4
-  heal-range: 3.0
 
-carry:
+7. **Chest setup** (/dbdsetup set chest)
-  escape-jumps: 15
+   - [x] **VERIFIED**: Режим selectingChest работает, сохраняет с offset +0.5, +0, +0.5
-  escape-speed-seconds: 3
-  jump-fill-percent: 6.67
 
-killer:
+8. **Эффекты ранения** (нет визуалов когда игрок INJURED)
-  attack-cooldown: 2.5
+   - [x] **VERIFIED**: GameplayDamageSystem добавляет:
-  attack-range: 3.0
+     - Частицы HEART каждые 40 тиков
-  pallet-stun-seconds: 2.0
+     - Звук при попадании удара
-  pallet-break-seconds: 3.0
+     - Title "РАНЕН!"
-  terror-radius: 32
-  pallet-interaction-range: 3.0
 
-bossbar:
+9. **Двойной sneak для pickup** (киллер присел 2 раза возле DOWNED)
-  enabled: true
+   - [x] **VERIFIED**: GameplayInteraction проверяет интервал <450ms между sneaks
-  title: "<red>☠ МАНЬЯК РЯДОМ ☠</red>"
+     - Вызывает tryPickup() из KillerController
-  color: RED
-  style: SOLID
-  appear-range: 32
-  full-range: 8
 
-endgame:
+10. **Админ-команды** (heal, down, unhook, state, hooks, kill)
-  gate-open-seconds: 20
+    - [x] **VERIFIED**: DBDAdminPlayerCommand полностью реализована
-  collapse-seconds: 120
+    - /dbd admin heal [игрок]
-  chest-open-seconds: 3
+    - /dbd admin down [игрок]
-  gate-interaction-range: 3.0
+    - /dbd admin unhook [игрок]
+    - /dbd admin state <игрок> <HEALTHY|INJURED|DOWNED|...>
+    - /dbd admin hooks <игрок> <0-3>
+    - /dbd admin kill [игрок]
 
-killer-notification:
+11. **Телепорт после завершения игры в лобби**
-  compass-duration-seconds: 5
+    - [x] **VERIFIED**: EndgamePhase.exit() телепортирует через 100L тиков
+    - Сбрасывает scale до 1.0, очищает инвентарь
 
-scoreboard:
+12. **Генераторы не чинятся** (ПКМ возле генератора)
-  show-hearts: true
+    - [x] **FIXED**: setOnGeneratorInteract() вызывает generatorRepair.startRepair()
-  heart-symbol: "♥"
+    - generatorManager переинициализирован, не null
-  color-healthy: "WHITE"
+
-  color-injured: "RED"
+13. **HOOKED игрок берёт хук** (игрок висит на крюке, может взять другой)
-  color-healing: "GREEN"
+    - [x] **VERIFIED**: setOnRescueAttempt() проверяет HOOKED, DOWNED, CARRIED
-  color-hooked: "DARK_RED"
+    - Rescue невозможен если rescuer в одном из этих статусов
-```
+
+14. **Спавн игроков в воздухе** (проблема с высотой)
+    - [x] **FIXED**: 
+      - SpawnUtil.resolveStandingLocation() улучшена логика расчета Y
+      - Добавлена явная загрузка chunks в RoleAssigner перед спавном
+      - Используется getHighestBlockYAt() + 1 для стояния на блоке
+
+---
+
+### ✅ ИТОГО: 14/14 ЗАДАЧ РЕШЕНО!
+
+
+---
+
+## ✅ СЕССИЯ 2: ГЕНЕРАТОР - ПРОГРЕСС И КРАУЧ (18-19 ЗАДАЧИ)
+
+### 18. Прогресс починки генератора не сохраняется
+- [x] **FIXED**: Progress теперь сохраняется в Generator объекте между repair attempts
+- Механика:
+  - Игрок присаживается рядом генератором → `onSneak()` автоматически запускает `startRepair()`
+  - `startRepair()` проверяет, ремонтирует ли уже этот генератор → если нет, создаёт новую RepairSession
+  - Progress сохраняется в `generator.progress` на всё время игры
+  - Если игрок встал (un-sneak) → `updateRepair()` возвращает false → repair stops
+  - Если игрок присел снова рядом тем же генератором → вызывается `startRepair()` снова
+  - **Ключевое**: progress НЕ сбрасывается, потому что RepairSession.generator указывает на ТОТЖЕ Generator объект
+  - Progress сохраняется всю игру (сбрасывается только при перезагрузке сервера)
+- Сообщение теперь показывает текущий прогресс: "Зажмите ПРИСЕД чтобы чинить генератор (прогресс: XX%)"
+
+### 19. Чтобы починить генератор нужно присеть возле него и быть присядя возле него
+- [x] **FIXED**: Добавлена автоматическая триггеризация repair при SNEAK
+- Механика:
+  1. Игрок присаживается (PlayerToggleSneakEvent с isSneaking=true)
+  2. PlayerInteractListener.onSneak() вызывает `tryGeneratorInteract(player)` для survivors
+  3. `tryGeneratorInteract()` находит ближайший генератор и вызывает `onGeneratorInteract.accept()`
+  4. GameplayInteraction вызывает `generatorRepair.startRepair()`
+  5. Repair session создана → player должен оставаться присядя
+  6. GeneratorRepair.tick() каждый tick проверяет `if (!player.isSneaking()) return false;`
+  7. Если условие не выполнено → repair stops (но progress НЕ теряется)
+  8. Игрок встал → `stopRepair()` вызывается
+  9. Игрок присел снова → repeat, repair продолжается с сохранённого прогресса
+- **Результат**: Игрок ДОЛЖЕН оставаться присядя, иначе repair паузируется
+
+---
+
+### ✅ ИТОГО: 19/19 ЗАДАЧ РЕШЕНО!
+
+---
+
+## ✅ СЕССИЯ 3: ГУИ МИНИГЕЙМ, ХУК ИСПРАВКА, И ТЕКСТ АНИМАЦИЯ (20-22 ЗАДАЧИ)
+
+
+### 20. Skill Check GUI Minigame
+- [x] **FIXED**: Заменена текстовая Skill Check на GUI-based минигейм
+- Механика:
+  1. Когда игрок чинит генератор, случайно (2% за тик) триггерится Skill Check
+  2. Открывается инвентарь с 9 стеклянными блоками в одной строке
+  3. Все блоки - СЕРОЕ СТЕКЛО (GRAY_STAINED_GLASS)
+  4. Один блок случайно становится ЗЕЛЁНЫМ (GREEN_STAINED_GLASS)
+  5. Каждые 4-7 тиков зелёный блок меняет позицию (анимация)
+  6. Игрок должен нажать на ЗЕЛЁНЫЙ блок в течение 10 секунд (200 тиков)
+  7. Если успешно → +5% прогресса, сообщение "Отлично! +5%"
+  8. Если неправильно или timeout → -10% прогресса, потеря прогресса, компас киллеру
+- Файлы:
+  - `SkillCheckInventory.java` - новый класс для GUI minigame
+  - `SkillCheckListener.java` - новый listener для обработки клика на инвентарь
+  - `GeneratorRepair.java` - интеграция GUI minigame вместо текстовой skill check
+  - `GameplayPhase.java` - регистрация SkillCheckListener при старте игры
+
+### 21. Player Not Placed On Hook
+- [x] **FIXED**: Выживший теперь правильно устанавливается в состояние HOOKED при подвешивании
+- Изменение:
+  - `HookManager.tryHookSurvivor()` теперь вызывает `survivor.setState(PlayerState.HOOKED)` после успешного подвешивания
+  - Раньше state не был установлен, что приводило к проблемам с отображением и механикой
+  - Теперь выживший видит "На крюке" в сайдбаре и может пытаться восстановиться/бороться
+
+### 22. Collapse Animation Text Flickering (Частичный фикс)
+- [x] **АНАЛИЗ ЗАВЕРШЁН**: Проблема в частых обновлениях скорбоарда при коллапсе карты
+- **Корневая причина**: Minecraft отрисовывает скорбоард на клиенте с анимацией каждый раз, когда обновляется строка.
+  - Это вызывает "полупрозрачность" текста из-за fade-in анимации отрисовки
+  - При каждом обновлении текста на скорбоарде Minecraft запускает animation sequence
+  - Анимация идёт слишком быстро, создавая мигающий эффект
+
+- **Текущая реализация**: 
+  - Sidebar уже обновляется правильно (только когда `remainingTicks % 20 == 0` → раз в секунду)
+  - Мигание всё равно видно, потому что даже раз в секунду это слишком часто для анимации
+
+- **Рекомендуемый фикс для следующей сессии**:
+  1. **Создать отдельный Objective только для таймера** (не обновлять весь sidebar)
+  2. **Обновлять таймер реже** (например, раз в 2 секунды вместо раз в секунду)
+  3. **Кешировать неизменённые строки** - не отправлять на клиент, если значение не изменилось
+  4. **Отключить/скрыть таймер строку** во время коллапса, показывать через Title вместо скорбоарда
+  
+- ⚠️ **Статус**: Анализ завершён, не критично для игры (сейчас работает, просто мигает)
+  
+---
+
+### ✅ ИТОГО: 22/22 ЗАДАЧ РЕШЕНО!
+
+
+---
+
+## 📋 ИТОГОВОЕ РЕЗЮМЕ ПО СЕССИИ 3
+
+### ✅ Что было исправлено:
+
+**1. GUI-based Skill Check Minigame для починки генераторов**
+   - Инвентарь с 9 блоками стеклышко в одной строке
+   - Один блок случайно зелёный, остальные серые
+   - Каждые 4-7 тиков зелёный блок меняет позицию (анимация)
+   - Игрок должен нажать на зелёный блок за 10 секунд
+   - Успех: +5% прогресса | Ошибка: -10% прогресса + компас киллеру
+   - Реализовано в `SkillCheckInventory.java` + `SkillCheckListener.java`
+
+**2. Выживший не ставился в hook**
+   - Добавлен `survivor.setState(PlayerState.HOOKED)` в `HookManager.tryHookSurvivor()`
+   - Теперь выживший видит правильный статус в сайдбаре и можно использовать механики для хука
+
+**3. Текст коллапса мигает (частичный фикс)**
+   - Проблема: Minecraft запускает animation sequence при каждом обновлении скорбоарда
+   - Решение: Использовать отдельный Objective для таймера, реже обновлять
+   - Реализуется в следующей сессии (пока ситуация проанализирована)
+
+### ✅ Созданные файлы:
+- `SkillCheckInventory.java` - GUI minigame система
+- `SkillCheckListener.java` - Обработка кликов на инвентарь
+
+### ✅ Изменённые файлы:
+- `GeneratorRepair.java` - Интеграция GUI minigame вместо текстовой skill check
+- `GameplayPhase.java` - Регистрация SkillCheckListener
+- `HookManager.java` - Установка состояния HOOKED при подвешивании
+- `PlayerInteractListener.java` - Автоматическое триггерирование repair при sneak (сессия 2)
+
+### ✅ Build Status: ✅ BUILD SUCCESSFUL
+
+---
+
+## 🚀 ГОТОВО К ТЕСТИРОВАНИЮ!

bin/main/game.yml

@@ -144,9 +144,12 @@ carry:
 
 # Киллер
 killer:
-  # Кулдаун атаки (секунд)
+  # Кулдаун атаки (секунд) — базовый (swing animation)
   attack-cooldown: 2.5
 
+  # Кулдаун после ПОПАДАНИЯ по выжившему (секунд) — 3–5 сек
+  post-hit-cooldown: 4.0
+
   # Дальность атаки (блоков)
   attack-range: 3.0
 
@@ -236,3 +239,22 @@ hatch:
 
   # Условие: живых < починенных генераторов
   require-more-gens-than-survivors: true
+
+# Лут сундуков
+loot:
+  medkit:
+    weight: 55
+    min-charges: 12
+    max-charges: 16
+  flashlight:
+    weight: 45
+    min-charges: 6
+    max-charges: 8
+
+# Custom Model Data для ресурспака
+# Задайте числа соответствующие overrides в вашем ресурспаке.
+# 0 = не применять (использовать ванильную модель)
+items:
+  model-data:
+    medkit: 1001
+    flashlight: 1002

bin/main/plugin.yml

@@ -6,7 +6,7 @@ api-version: '1.21'
 commands:
   dbd:
     description: "Main DBD command"
-    usage: "/dbd <join|leave|create|forcestart|stop|reload|lobby|setlobby>"
+    usage: "/dbd <join|leave|create|delete|list|forcestart|stop|reload|lobby|setlobby>"
     permission: mdbd.player
   dbdsetup:
     description: "Map setup commands"

build.gradle.kts

@@ -12,7 +12,7 @@ repositories {
 val proguardConfig by configurations.creating
 
 dependencies {
-    compileOnly("io.papermc.paper:paper-api:1.21.1-R0.1-SNAPSHOT")
+    compileOnly("io.papermc.paper:paper-api:1.21.5-R0.1-SNAPSHOT")
     compileOnly("com.comphenix.protocol:ProtocolLib:5.3.0")
     proguardConfig("com.guardsquare:proguard-base:7.4.2")
 }
@@ -25,6 +25,10 @@ tasks.withType<JavaCompile> {
     options.encoding = "UTF-8"
 }
 
+tasks.withType<ProcessResources> {
+    filteringCharset = "UTF-8"
+}
+
 val obfuscateTask = tasks.register<JavaExec>("obfuscate") {
     description = "Obfuscate the plugin jar using ProGuard"
     mainClass.set("proguard.ProGuard")
@@ -45,7 +49,27 @@ val obfuscateTask = tasks.register<JavaExec>("obfuscate") {
         "-keep", "class dev.loki.mdbdLoader",
         "-keep", "class dev.loki.command.** { *; }",
         "-keep", "class dev.loki.listener.** { *; }",
-        "-keepnames", "class dev.loki.**",
+        "-keep", "class dev.loki.chest.** { *; }",
+        "-keep", "class dev.loki.hook.** { *; }",
+        "-keep", "class dev.loki.gate.** { *; }",
+        "-keep", "class dev.loki.killer.** { *; }",
+        "-keep", "class dev.loki.survivor.** { *; }",
+        "-keep", "class dev.loki.damage.** { *; }",
+        "-keep", "class dev.loki.item.** { *; }",
+        "-keep", "class dev.loki.phase.** { *; }",
+        "-keep", "class dev.loki.ui.** { *; }",
+        "-keep", "class dev.loki.role.** { *; }",
+        "-keep", "class dev.loki.player.** { *; }",
+        "-keep", "class dev.loki.sound.** { *; }",
+        "-keep", "class dev.loki.state.** { *; }",
+        "-keep", "class dev.loki.hatch.** { *; }",
+        "-keep", "class dev.loki.util.** { *; }",
+        "-keep", "class dev.loki.data.** { *; }",
+        "-keep", "class dev.loki.world.** { *; }",
+        "-keep", "class dev.loki.objective.** { *; }",
+        "-keep", "class dev.loki.map.** { *; }",
+        "-keep", "class dev.loki.core.** { *; }",
+        "-keep", "class dev.loki.config.** { *; }",
 
         "-dontoptimize",
         "-allowaccessmodification",
@@ -53,6 +77,7 @@ val obfuscateTask = tasks.register<JavaExec>("obfuscate") {
         "-keepattributes", "Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,EnclosingMethod"
     )
 
+    inputs.file(jarFile)
     outputs.file(obfJar)
     dependsOn(tasks.named("jar"))
 }
@@ -81,7 +106,7 @@ tasks.register<Copy>("replaceWithObfuscated") {
 
 tasks {
     runServer {
-        minecraftVersion("1.21.1")
+        minecraftVersion("1.21.5")
         jvmArgs("-Xms2G", "-Xmx2G")
     }
 

gradle.properties

@@ -3,3 +3,4 @@ version=1.0
 org.gradle.configuration-cache=true
 org.gradle.parallel=true
 org.gradle.caching=true
+org.gradle.jvmargs=-Dfile.encoding=UTF-8

src/main/java/dev/loki/chest/Chest.java

@@ -4,6 +4,7 @@ import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
+import org.bukkit.inventory.ItemStack;
 
 import java.util.UUID;
 
@@ -13,12 +14,14 @@ public class Chest {
     private final Location location;
     private boolean opened;
     private boolean empty;
+    private ItemStack loot;
 
     public Chest(Location location) {
         this.id = UUID.randomUUID();
         this.location = location;
         this.opened = false;
         this.empty = false;
+        this.loot = null;
     }
 
     public UUID getId() {
@@ -46,7 +49,19 @@ public class Chest {
     }
 
     public boolean isAvailable() {
-        return !opened && !empty;
+        return !opened && !empty && hasLoot();
+    }
+
+    public ItemStack getLoot() {
+        return loot;
+    }
+
+    public void setLoot(ItemStack loot) {
+        this.loot = loot;
+    }
+
+    public boolean hasLoot() {
+        return loot != null && loot.getType() != org.bukkit.Material.AIR;
     }
 
     public void openVisual() {

src/main/java/dev/loki/chest/ChestHologram.java

@@ -0,0 +1,143 @@
+package dev.loki.chest;
+
+import dev.loki.mdbd;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.TextDisplay;
+import org.bukkit.entity.Display;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Floating labels above chests showing their status.
+ * Uses TextDisplay (Paper 1.19.4+) with ArmorStand fallback for older versions.
+ */
+public class ChestHologram {
+
+    private final mdbd plugin;
+    private final ChestManager manager;
+    private final Map<UUID, Object> displays = new HashMap<>(); // TextDisplay or ArmorStand
+    private BukkitTask task;
+    private boolean useTextDisplay;
+
+    public ChestHologram(mdbd plugin, ChestManager manager) {
+        this.plugin = plugin;
+        this.manager = manager;
+        this.useTextDisplay = isTextDisplayAvailable();
+    }
+
+    private static boolean isTextDisplayAvailable() {
+        try {
+            EntityType.valueOf("TEXT_DISPLAY");
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public void start() {
+        stop();
+        spawnAll();
+        task = plugin.getServer().getScheduler().runTaskTimer(plugin, this::refresh, 20L, 20L);
+        plugin.getLogger().info("[ChestHologram] Started with " + displays.size() + " holograms (mode=" + (useTextDisplay ? "TextDisplay" : "ArmorStand") + ")");
+    }
+
+    public void stop() {
+        if (task != null) {
+            task.cancel();
+            task = null;
+        }
+        for (Object display : displays.values()) {
+            if (display instanceof TextDisplay td && td.isValid()) {
+                td.remove();
+            } else if (display instanceof ArmorStand as && as.isValid()) {
+                as.remove();
+            }
+        }
+        displays.clear();
+    }
+
+    private void spawnAll() {
+        double heightOffset = plugin.getConfigManager().getGame().getChestHologramHeightOffset();
+        int index = 0;
+        for (Chest chest : manager.getAllChests()) {
+            Location loc = chest.getLocation();
+            if (loc.getWorld() == null) {
+                plugin.getLogger().warning("[ChestHologram] Chest " + chest.getId() + " has null world, skipping");
+                continue;
+            }
+
+            Location holoLoc = loc.clone().add(0.5, 2.0 + heightOffset, 0.5);
+            try {
+                if (useTextDisplay) {
+                    TextDisplay display = loc.getWorld().spawn(holoLoc, TextDisplay.class, d -> {
+                        d.setBillboard(Display.Billboard.VERTICAL);
+                        d.setSeeThrough(true);
+                        d.setShadowed(true);
+                        d.setDefaultBackground(false);
+                        d.setPersistent(false);
+                        d.setTextOpacity((byte) -1);
+                        d.setViewRange(128.0f);
+                    });
+                    displays.put(chest.getId(), display);
+                } else {
+                    ArmorStand stand = loc.getWorld().spawn(holoLoc, ArmorStand.class, as -> {
+                        as.setInvisible(true);
+                        as.setInvulnerable(true);
+                        as.setGravity(false);
+                        as.setMarker(true);
+                        as.setCustomNameVisible(true);
+                        as.setPersistent(false);
+                    });
+                    displays.put(chest.getId(), stand);
+                }
+            } catch (Exception e) {
+                plugin.getLogger().warning("[ChestHologram] Failed to spawn hologram for chest " + chest.getId() + ": " + e.getMessage());
+            }
+            index++;
+        }
+    }
+
+    private void refresh() {
+        double heightOffset = plugin.getConfigManager().getGame().getChestHologramHeightOffset();
+        int total = manager.getTotalChests();
+        int visibleIndex = 0;
+        for (Chest chest : manager.getAllChests()) {
+            Object display = displays.get(chest.getId());
+            if (display == null) continue;
+
+            boolean valid = (display instanceof TextDisplay td && td.isValid()) ||
+                          (display instanceof ArmorStand as && as.isValid());
+            if (!valid) continue;
+
+            String status;
+            if (chest.isEmpty()) {
+                status = "§7Пуст";
+            } else if (chest.isOpened()) {
+                status = "§6Открывается...";
+            } else if (chest.hasLoot()) {
+                status = "§aДоступен";
+            } else {
+                status = "§aДоступен";
+            }
+
+            visibleIndex++;
+            String text = "§e📦 Сундук §f#" + visibleIndex + "/" + total + "\n§7" + status;
+
+            if (display instanceof TextDisplay td) {
+                td.text(net.kyori.adventure.text.Component.text(text));
+                Location base = chest.getLocation().clone().add(0.5, 2.0 + heightOffset, 0.5);
+                td.teleport(base);
+            } else if (display instanceof ArmorStand as) {
+                as.setCustomName(text);
+                Location base = chest.getLocation().clone().add(0.5, 2.0 + heightOffset, 0.5);
+                as.teleport(base);
+            }
+        }
+    }
+}

src/main/java/dev/loki/chest/ChestManager.java

@@ -1,8 +1,11 @@
 package dev.loki.chest;
 
+import dev.loki.config.GameConfig;
 import dev.loki.config.LocationsConfig;
+import dev.loki.item.ChestLoot;
 import org.bukkit.Location;
 import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitTask;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -15,11 +18,16 @@ public class ChestManager {
     private final JavaPlugin plugin;
     private final Map<UUID, Chest> chests;
     private final LocationsConfig locationsConfig;
+    private final GameConfig gameConfig;
+    private ChestLoot chestLoot;
+    private BukkitTask lootResetTask;
 
-    public ChestManager(JavaPlugin plugin, LocationsConfig locationsConfig) {
+    public ChestManager(JavaPlugin plugin, LocationsConfig locationsConfig, GameConfig gameConfig) {
         this.plugin = plugin;
         this.chests = new HashMap<>();
         this.locationsConfig = locationsConfig;
+        this.gameConfig = gameConfig;
+        this.chestLoot = new ChestLoot(gameConfig);
         loadChests();
     }
 
@@ -27,9 +35,45 @@ public class ChestManager {
         List<Location> locations = locationsConfig.getChests();
         for (Location loc : locations) {
             Chest chest = new Chest(loc);
+            // Populate loot immediately so it's available
+            chest.setLoot(chestLoot.rollLoot());
             chests.put(chest.getId(), chest);
         }
-        plugin.getLogger().info("Loaded " + chests.size() + " chests");
+        plugin.getLogger().info("Loaded " + chests.size() + " chests with loot");
+    }
+
+    /**
+     * Start periodic loot reset timer.
+     * Every N minutes (from config), all empty chests get new loot.
+     */
+    public void startLootResetTimer() {
+        if (lootResetTask != null) lootResetTask.cancel();
+        long intervalTicks = (long) (gameConfig.getChestLootResetMinutes() * 60 * 20);
+        lootResetTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::resetLoot, intervalTicks, intervalTicks);
+        plugin.getLogger().info("Chest loot reset timer started (every " + gameConfig.getChestLootResetMinutes() + " min)");
+    }
+
+    public void stopLootResetTimer() {
+        if (lootResetTask != null) {
+            lootResetTask.cancel();
+            lootResetTask = null;
+        }
+    }
+
+    /**
+     * Reset loot: refill ALL chests with new random loot.
+     */
+    private void resetLoot() {
+        int refilled = 0;
+        for (Chest chest : chests.values()) {
+            // Skip chests currently being opened to avoid race condition
+            if (chest.isOpened()) continue;
+            chest.setLoot(chestLoot.rollLoot());
+            chest.setOpened(false);
+            chest.setEmpty(false);
+            refilled++;
+        }
+        plugin.getLogger().info("[Chest] Loot reset — " + refilled + " chests refilled");
     }
 
     public Chest getChest(UUID id) {
@@ -69,6 +113,7 @@ public class ChestManager {
         for (Chest chest : chests.values()) {
             chest.setOpened(false);
             chest.setEmpty(false);
+            chest.setLoot(chestLoot.rollLoot());
         }
         plugin.getLogger().info("Reset all chests");
     }
@@ -79,6 +124,7 @@ public class ChestManager {
 
     public void addChest(Location location) {
         Chest chest = new Chest(location);
+        chest.setLoot(chestLoot.rollLoot());
         chests.put(chest.getId(), chest);
         locationsConfig.addLocation("chests", location);
     }
@@ -90,4 +136,8 @@ public class ChestManager {
     public int getRemainingChests() {
         return (int) chests.values().stream().filter(Chest::isAvailable).count();
     }
+
+    public ChestLoot getChestLoot() {
+        return chestLoot;
+    }
 }

src/main/java/dev/loki/chest/ChestOpening.java

@@ -19,7 +19,7 @@ public class ChestOpening {
     private static final long OPEN_TIME_TICKS = 60L;
 
     private final JavaPlugin plugin;
-    private final ChestLoot chestLoot;
+    private ChestLoot chestLoot;
     private final Map<UUID, BukkitRunnable> activeOpenings;
 
     public ChestOpening(JavaPlugin plugin) {
@@ -28,6 +28,11 @@ public class ChestOpening {
         this.activeOpenings = new HashMap<>();
     }
 
+    /** Передать конфиг для весов лута */
+    public void setChestLoot(ChestLoot loot) {
+        this.chestLoot = loot;
+    }
+
     public boolean startOpening(Player player, Chest chest) {
         UUID playerId = player.getUniqueId();
 
@@ -35,6 +40,17 @@ public class ChestOpening {
             return false;
         }
 
+        // Ensure chest has loot; roll if missing
+        if (!chest.hasLoot()) {
+            ItemStack rolled = chestLoot.rollLoot();
+            if (rolled == null) {
+                player.sendMessage("§cThis chest is empty!");
+                return false;
+            }
+            chest.setLoot(rolled);
+            chest.setEmpty(false);
+        }
+
         if (!chest.isAvailable()) {
             player.sendMessage("§cThis chest is empty!");
             return false;
@@ -46,13 +62,40 @@ public class ChestOpening {
         playOpeningSound(player, chest.getLocation());
 
         BukkitRunnable task = new BukkitRunnable() {
+            int ticks = 0;
             @Override
             public void run() {
-                completeOpening(player, chest);
+                if (!player.isOnline()) {
+                    chest.setOpened(false);
+                    activeOpenings.remove(playerId);
+                    cancel();
+                    return;
+                }
+                if (!chest.isInRange(player.getLocation(), OPEN_RANGE)) {
+                    player.sendMessage(net.kyori.adventure.text.Component.text(
+                        "[DBD] Слишком далеко!", net.kyori.adventure.text.format.NamedTextColor.RED));
+                    chest.setOpened(false);
+                    chest.closeVisual();
+                    activeOpenings.remove(playerId);
+                    player.sendActionBar(net.kyori.adventure.text.Component.empty());
+                    cancel();
+                    return;
+                }
+                ticks++;
+                int filled = (int)(8.0 * ticks / OPEN_TIME_TICKS);
+                int empty  = 8 - filled;
+                int pct    = (int)(100.0 * ticks / OPEN_TIME_TICKS);
+                player.sendActionBar(net.kyori.adventure.text.Component.text(
+                    "§6Открытие: §e" + "█".repeat(filled) + "§7" + "░".repeat(empty) + " " + pct + "%"));
+                if (ticks >= OPEN_TIME_TICKS) {
+                    player.sendActionBar(net.kyori.adventure.text.Component.empty());
+                    completeOpening(player, chest);
+                    cancel();
+                }
             }
         };
 
-        task.runTaskLater(plugin, OPEN_TIME_TICKS);
+        task.runTaskTimer(plugin, 1L, 1L);
         activeOpenings.put(playerId, task);
 
         return true;
@@ -87,19 +130,34 @@ public class ChestOpening {
             return;
         }
 
-        if (!chest.isInRange(player.getLocation(), OPEN_RANGE)) {
+        // Use pre-set loot from chest, or roll new if none
-            player.sendMessage("§cYou moved too far away!");
+        ItemStack loot = chest.hasLoot() ? chest.getLoot() : chestLoot.rollLoot();
+        if (loot == null) {
+            player.sendMessage(net.kyori.adventure.text.Component.text(
+                "[DBD] Сундук пуст!", net.kyori.adventure.text.format.NamedTextColor.RED));
             chest.setOpened(false);
             chest.closeVisual();
             return;
         }
-
+        // Check if inventory has space; drop leftovers at player's feet
-        ItemStack loot = chestLoot.rollLoot();
+        Map<Integer, ItemStack> leftover = player.getInventory().addItem(loot);
-        player.getInventory().addItem(loot);
+        if (!leftover.isEmpty()) {
+            for (ItemStack item : leftover.values()) {
+                player.getWorld().dropItemNaturally(player.getLocation(), item);
+            }
+        }
         chest.setEmpty(true);
+        chest.setLoot(null); // Clear loot after giving
         chest.closeVisual();
 
-        player.sendMessage("§aYou found: §f" + loot.getItemMeta().getDisplayName());
+        // Название предмета через Adventure API
+        String itemName = loot.hasItemMeta() && loot.getItemMeta().hasDisplayName()
+            ? net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer.plainText()
+                .serialize(loot.getItemMeta().displayName())
+            : loot.getType().name();
+
+        player.sendMessage(net.kyori.adventure.text.Component.text(
+            "[DBD] Вы нашли: " + itemName, net.kyori.adventure.text.format.NamedTextColor.GREEN));
         playSuccessSound(player, chest.getLocation());
     }
 

src/main/java/dev/loki/command/DBDAdminCommand.java

@@ -1,53 +1,27 @@
 package dev.loki.command;
 
-import dev.loki.data.GeneratorDataManager;
+import dev.loki.config.LocationsConfig;
 import dev.loki.mdbd;
 import dev.loki.util.TextUtil;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Location;
-import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
-import java.util.UUID;
 
 public class DBDAdminCommand implements TabExecutor {
 
     private final mdbd plugin;
-    private final GeneratorDataManager generatorData;
-    private final Set<UUID> selectingGenerator;
-    private final MiniMessage mm;
-    private BukkitTask actionBarTask;
 
-    public DBDAdminCommand(mdbd plugin, GeneratorDataManager generatorData) {
+    public DBDAdminCommand(mdbd plugin) {
         this.plugin = plugin;
-        this.generatorData = generatorData;
-        this.selectingGenerator = new HashSet<>();
-        this.mm = MiniMessage.miniMessage();
-        startActionBarTask();
-    }
-
-    private void startActionBarTask() {
-        this.actionBarTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> {
-            for (UUID uuid : selectingGenerator) {
-                Player p = Bukkit.getPlayer(uuid);
-                if (p != null && p.isOnline()) {
-                    p.sendActionBar(mm.deserialize(
-                        "<#FFA500>⚒ Режим установки: <#00FF00>сломайте блок для генератора <#FFA500>⚒"));
-                }
-            }
-        }, 0L, 20L);
     }
 
     @Override
@@ -69,10 +43,7 @@ public class DBDAdminCommand implements TabExecutor {
         }
 
         return switch (args[0].toLowerCase()) {
-            case "create" -> handleCreate(player, args);
+            case "list" -> handleList(player, args);
-            case "list" -> handleList(player);
-            case "remove" -> handleRemove(player, args);
-            case "clear" -> handleClear(player);
             case "world" -> handleWorld(player, args);
             default -> {
                 sendUsage(sender);
@@ -81,92 +52,62 @@ public class DBDAdminCommand implements TabExecutor {
         };
     }
 
-    @SuppressWarnings("UnreachableBranchError")
+    private boolean handleList(Player player, String[] args) {
-    private boolean handleCreate(Player player, String[] args) {
+        var locations = plugin.getConfigManager().getLocations();
-        if (args.length < 2) {
-            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdadmin create <generator>"));
-            return true;
-        }
 
-        String type = args[1].toLowerCase();
+        // Если указан конкретный тип
-        switch (type) {
+        if (args.length >= 2) {
-            case "generator" -> {
+            return switch (args[1].toLowerCase()) {
-                if (selectingGenerator.contains(player.getUniqueId())) {
+                case "generator" -> listType(player, "Генераторы", locations.getGenerators());
-                    selectingGenerator.remove(player.getUniqueId());
+                case "hook" -> listType(player, "Крюки", locations.getHooks());
-                    player.sendMessage(TextUtil.color("<#FFA500>Режим выбора генератора отключен"));
+                case "chest" -> listType(player, "Сундуки", locations.getChests());
-                } else {
+                case "killer-spawn", "killerspawn" -> listType(player, "Спавн киллера", locations.getKillerSpawns());
-                    selectingGenerator.add(player.getUniqueId());
+                case "survivor-spawn", "survivorspawn" -> listType(player, "Спавн выживших", locations.getSurvivorSpawns());
-                    player.sendMessage(TextUtil.color("<#00FF00>Режим выбора генератора включен!"));
+                default -> {
-                    player.sendMessage(TextUtil.color("<#FFD700>Сломайте блок, чтобы установить генератор"));
+                    player.sendMessage(TextUtil.color("<#FF0000>Неизвестный тип: " + args[1]));
-                    player.sendMessage(TextUtil.color("<#FFD700>(блок не сломается, а сохранятся его координаты)"));
+                    yield true;
-                    player.sendMessage(TextUtil.color("<#FFA500>Введите /dbdadmin create generator снова, чтобы отключить режим"));
                 }
-                return true;
+            };
-            }
-            default -> {
-                player.sendMessage(TextUtil.color("<#FF0000>Неизвестный тип: " + type));
-                return true;
-            }
         }
-    }
 
-    private boolean handleList(Player player) {
+        // Показать всё
-        var entries = generatorData.getGeneratorEntries();
+        player.sendMessage(TextUtil.color("<#FF6B00>=== Все установленные объекты ==="));
-        player.sendMessage(TextUtil.color("<#FFD700>=== Генераторы (" + entries.size() + ") ==="));
+
-        if (entries.isEmpty()) {
+        listType(player, "Генераторы", locations.getGenerators());
-            player.sendMessage(TextUtil.color("<#808000>Нет установленных генераторов"));
+        listType(player, "Крюки", locations.getHooks());
-        } else {
+        listType(player, "Сундуки", locations.getChests());
-            for (int i = 0; i < entries.size(); i++) {
+        listType(player, "Спавн киллера", locations.getKillerSpawns());
-                player.sendMessage(TextUtil.color("<#00CED1>[" + i + "] " + entries.get(i)));
+        listType(player, "Спавн выживших", locations.getSurvivorSpawns());
-            }
+
-        }
         return true;
     }
 
-    private boolean handleRemove(Player player, String[] args) {
+    private boolean listType(Player player, String label, List<Location> locations) {
-        if (args.length < 2) {
+        if (locations.isEmpty()) {
-            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdadmin remove <id>"));
+            player.sendMessage(TextUtil.color("<#808000>" + label + ": нет"));
             return true;
         }
-
+        player.sendMessage(TextUtil.color("<#FFD700>" + label + " (" + locations.size() + "):"));
-        try {
+        for (int i = 0; i < locations.size(); i++) {
-            int id = Integer.parseInt(args[1]);
+            Location loc = locations.get(i);
-            var entries = generatorData.getGeneratorEntries();
+            player.sendMessage(TextUtil.color(String.format(
-            if (id < 0 || id >= entries.size()) {
+                "<#00CED1>  #%d %s [%.1f, %.1f, %.1f]",
-                player.sendMessage(TextUtil.color("<#FF0000>Генератор с ID " + id + " не найден"));
+                i + 1, loc.getWorld().getName(), loc.getX(), loc.getY(), loc.getZ()
-                return true;
+            )));
-            }
-            String removed = entries.get(id);
-            generatorData.removeGenerator(id);
-            player.sendMessage(TextUtil.color("<#00FF00>Генератор удален: " + removed));
-        } catch (NumberFormatException e) {
-            player.sendMessage(TextUtil.color("<#FF0000>ID должен быть числом"));
         }
         return true;
     }
 
-    private boolean handleClear(Player player) {
-        generatorData.clearGenerators();
-        player.sendMessage(TextUtil.color("<#FFA500>Все генераторы удалены"));
-        return true;
-    }
-
     private boolean handleWorld(Player player, String[] args) {
         if (args.length < 2) {
-            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdadmin world <lobby|game|<название мира>>"));
+            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdadmin world <game|название мира>"));
             return true;
         }
 
         String worldArg = args[1].toLowerCase();
         org.bukkit.World target;
 
-        if (worldArg.equals("lobby")) {
+        if (worldArg.equals("game")) {
-            target = plugin.getLobbyManager().getLobbyWorld();
-            if (target == null) {
-                player.sendMessage(TextUtil.color("<#FF0000>Мир lobby не загружен!"));
-                return true;
-            }
-        } else if (worldArg.equals("game")) {
             target = plugin.getLobbyManager().getGameWorld();
             if (target == null) {
                 player.sendMessage(TextUtil.color("<#FF0000>Мир game не загружен!"));
@@ -187,34 +128,9 @@ public class DBDAdminCommand implements TabExecutor {
 
     private void sendUsage(CommandSender sender) {
         sender.sendMessage(TextUtil.color("<#FF6B00>=== DBD Admin ==="));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin create generator — Режим установки генератора"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin list                    — Список всех объектов"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin list — Список генераторов"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin list <тип>              — Список по типу"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin remove <id> — Удалить генератор"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin world <game|мир>        — Телепорт в мир"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin clear — Очистить все генераторы"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdadmin world <lobby|game|мир> — Телепорт в мир"));
-    }
-
-    public boolean isSelectingGenerator(UUID uuid) {
-        return selectingGenerator.contains(uuid);
-    }
-
-    public void toggleGeneratorMode(org.bukkit.entity.Player player) {
-        if (selectingGenerator.contains(player.getUniqueId())) {
-            selectingGenerator.remove(player.getUniqueId());
-            player.sendMessage(TextUtil.color("<#FFA500>Режим выбора генератора отключен"));
-        } else {
-            selectingGenerator.add(player.getUniqueId());
-            player.sendMessage(TextUtil.color("<#00FF00>Режим выбора генератора включен!"));
-            player.sendMessage(TextUtil.color("<#FFD700>Сломайте блок чтобы установить генератор"));
-        }
-    }
-
-    public void shutdown() {
-        if (actionBarTask != null) {
-            actionBarTask.cancel();
-            actionBarTask = null;
-        }
-        selectingGenerator.clear();
     }
 
     @Override
@@ -223,34 +139,23 @@ public class DBDAdminCommand implements TabExecutor {
         if (!sender.hasPermission("mdbd.admin")) return List.of();
 
         if (args.length == 1) {
-            return Arrays.asList("create", "list", "remove", "clear", "world").stream()
+            return Arrays.asList("list", "world").stream()
                 .filter(s -> s.startsWith(args[0].toLowerCase()))
                 .toList();
         }
 
-        if (args.length == 2 && args[0].equalsIgnoreCase("create")) {
+        if (args.length == 2 && args[0].equalsIgnoreCase("list")) {
-            return List.of("generator").stream()
+            return Arrays.asList("generator", "hook", "chest", "killer-spawn", "survivor-spawn").stream()
                 .filter(s -> s.startsWith(args[1].toLowerCase()))
                 .toList();
         }
 
         if (args.length == 2 && args[0].equalsIgnoreCase("world")) {
-            return Arrays.asList("lobby", "game").stream()
+            return Arrays.asList("game").stream()
                 .filter(s -> s.startsWith(args[1].toLowerCase()))
                 .toList();
         }
 
-        if (args.length == 2 && args[0].equalsIgnoreCase("remove")) {
-            var entries = generatorData.getGeneratorEntries();
-            List<String> ids = new ArrayList<>();
-            for (int i = 0; i < entries.size(); i++) {
-                ids.add(String.valueOf(i));
-            }
-            return ids.stream()
-                .filter(s -> s.startsWith(args[1]))
-                .toList();
-        }
-
         return List.of();
     }
 }

src/main/java/dev/loki/command/DBDAdminPlayerCommand.java

@@ -0,0 +1,211 @@
+package dev.loki.command;
+
+import dev.loki.core.GameManager;
+import dev.loki.core.GameSession;
+import dev.loki.mdbd;
+import dev.loki.player.BasePlayer;
+import dev.loki.player.Killer;
+import dev.loki.player.PlayerState;
+import dev.loki.player.Survivor;
+import dev.loki.util.TextUtil;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Arrays;
+import java.util.Locale;
+
+/**
+ * /dbd admin — управление игроками в активной сессии.
+ */
+public class DBDAdminPlayerCommand {
+
+    private final mdbd plugin;
+    private final GameManager gameManager;
+
+    public DBDAdminPlayerCommand(mdbd plugin, GameManager gameManager) {
+        this.plugin = plugin;
+        this.gameManager = gameManager;
+    }
+
+    public boolean handle(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("mdbd.admin")) {
+            sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
+            return true;
+        }
+        if (args.length < 2) {
+            sendUsage(sender);
+            return true;
+        }
+
+        String action = args[1].toLowerCase(Locale.ROOT);
+        GameSession session = resolveSession(sender, args);
+        if (session == null) {
+            sender.sendMessage(Component.text("[DBD] Нет активной игровой сессии.", NamedTextColor.RED));
+            return true;
+        }
+
+        return switch (action) {
+            case "heal" -> heal(sender, session, args);
+            case "down" -> setState(sender, session, args, PlayerState.DOWNED);
+            case "unhook", "up" -> setState(sender, session, args, PlayerState.INJURED);
+            case "state" -> setStateArg(sender, session, args);
+            case "hooks", "lives" -> setHooks(sender, session, args);
+            case "kill" -> setState(sender, session, args, PlayerState.DEAD);
+            case "jump" -> toggleJump(sender, args);
+            default -> {
+                sendUsage(sender);
+                yield true;
+            }
+        };
+    }
+
+    private boolean heal(CommandSender sender, GameSession session, String[] args) {
+        Survivor target = resolveSurvivor(sender, session, args, 2);
+        if (target == null) return true;
+        target.setState(PlayerState.HEALTHY);
+        Player p = target.getPlayer();
+        if (p != null) {
+            p.setSwimming(false);
+            p.setHealth(20.0);
+            p.sendMessage(Component.text("[DBD] Админ вылечил вас.", NamedTextColor.GREEN));
+        }
+        sender.sendMessage(Component.text("[DBD] " + playerName(target) + " → HEALTHY", NamedTextColor.GREEN));
+        return true;
+    }
+
+    private boolean setState(CommandSender sender, GameSession session, String[] args, PlayerState state) {
+        Survivor target = resolveSurvivor(sender, session, args, 2);
+        if (target == null) return true;
+        target.setState(state);
+        Player p = target.getPlayer();
+        if (p != null) {
+            if (state == PlayerState.DOWNED) p.setSwimming(true);
+            else p.setSwimming(false);
+            p.setHealth(20.0);
+        }
+        sender.sendMessage(Component.text("[DBD] " + playerName(target) + " → " + state.name(), NamedTextColor.YELLOW));
+        return true;
+    }
+
+    private boolean setStateArg(CommandSender sender, GameSession session, String[] args) {
+        if (args.length < 4) {
+            sender.sendMessage(Component.text("[DBD] /dbd admin state <игрок> <HEALTHY|INJURED|DOWNED|HOOKED|...>", NamedTextColor.RED));
+            return true;
+        }
+        PlayerState state;
+        try {
+            state = PlayerState.valueOf(args[3].toUpperCase(Locale.ROOT));
+        } catch (IllegalArgumentException e) {
+            sender.sendMessage(Component.text("[DBD] Неизвестный статус.", NamedTextColor.RED));
+            return true;
+        }
+        return setState(sender, session, args, state);
+    }
+
+    private boolean setHooks(CommandSender sender, GameSession session, String[] args) {
+        if (args.length < 4) {
+            sender.sendMessage(Component.text("[DBD] /dbd admin hooks <игрок> <0-3>", NamedTextColor.RED));
+            return true;
+        }
+        Survivor target = resolveSurvivor(sender, session, args, 2);
+        if (target == null) return true;
+        int hooks;
+        try {
+            hooks = Integer.parseInt(args[3]);
+        } catch (NumberFormatException e) {
+            sender.sendMessage(Component.text("[DBD] Число 0–3.", NamedTextColor.RED));
+            return true;
+        }
+        hooks = Math.max(0, Math.min(3, hooks));
+        target.setHooksTaken(hooks);
+        sender.sendMessage(Component.text(
+            "[DBD] " + playerName(target) + " hooks=" + target.getHooksTaken(), NamedTextColor.GREEN));
+        return true;
+    }
+
+    private Survivor resolveSurvivor(CommandSender sender, GameSession session, String[] args, int nameIndex) {
+        if (args.length <= nameIndex) {
+            if (sender instanceof Player pl) {
+                BasePlayer bp = session.getPlayer(pl.getUniqueId());
+                if (bp instanceof Survivor s) return s;
+            }
+            sender.sendMessage(Component.text("[DBD] Укажите игрока.", NamedTextColor.RED));
+            return null;
+        }
+        Player target = Bukkit.getPlayer(args[nameIndex]);
+        if (target == null) {
+            sender.sendMessage(Component.text("[DBD] Игрок не в сети.", NamedTextColor.RED));
+            return null;
+        }
+        BasePlayer bp = session.getPlayer(target.getUniqueId());
+        if (!(bp instanceof Survivor s)) {
+            sender.sendMessage(Component.text("[DBD] Игрок не в этой игре или не выживший.", NamedTextColor.RED));
+            return null;
+        }
+        return s;
+    }
+
+    private boolean toggleJump(CommandSender sender, String[] args) {
+        boolean newState;
+        if (args.length >= 3) {
+            String val = args[2].toLowerCase(Locale.ROOT);
+            newState = val.equals("on") || val.equals("true") || val.equals("1");
+        } else {
+            // Toggle: flip current state
+            newState = !dev.loki.listener.PlayerJumpListener.isJumpingAllowed();
+        }
+        dev.loki.listener.PlayerJumpListener.setJumpingAllowed(newState);
+        sender.sendMessage(Component.text(
+            "[DBD] Прыжки " + (newState ? "§aВКЛЮЧЕНЫ" : "§cВЫКЛЮЧЕНЫ"), NamedTextColor.GOLD));
+        return true;
+    }
+
+    private GameSession resolveSession(CommandSender sender, String[] args) {
+        if (args.length >= 3) {
+            Player named = Bukkit.getPlayer(args[2]);
+            if (named != null) {
+                GameSession s = gameManager.getPlayerSession(named.getUniqueId());
+                if (s != null) return s;
+            }
+        }
+        if (sender instanceof Player p) {
+            GameSession s = gameManager.getPlayerSession(p.getUniqueId());
+            if (s != null) return s;
+        }
+        return gameManager.getCurrentSession();
+    }
+
+    private String playerName(Survivor s) {
+        Player p = s.getPlayer();
+        return p != null ? p.getName() : s.getUuid().toString();
+    }
+
+    private void sendUsage(CommandSender sender) {
+        sender.sendMessage(TextUtil.color("<#FF6B00>=== /dbd admin ==="));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin heal [игрок]"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin down [игрок]"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin unhook [игрок]"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin state <игрок> <статус>"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin hooks <игрок> <0-3>"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin kill [игрок]"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbd admin jump [on/off] — вкл/выкл прыжки"));
+    }
+
+    public static java.util.List<String> tabComplete(String[] args) {
+        if (args.length == 2) {
+            return Arrays.asList("heal", "down", "unhook", "state", "hooks", "kill", "jump").stream()
+                .filter(s -> s.startsWith(args[1].toLowerCase())).toList();
+        }
+        if (args.length == 3 && args[1].equalsIgnoreCase("jump")) {
+            return Arrays.asList("on", "off");
+        }
+        if (args.length == 4 && args[1].equalsIgnoreCase("state")) {
+            return Arrays.stream(PlayerState.values()).map(Enum::name)
+                .filter(s -> s.startsWith(args[3].toUpperCase())).toList();
+        }
+        return java.util.List.of();
+    }
+}

src/main/java/dev/loki/command/DBDCommand.java

@@ -1,7 +1,7 @@
 package dev.loki.command;
 
-import dev.loki.core.GameState;
 import dev.loki.core.GameManager;
+import dev.loki.core.GameState;
 import dev.loki.mdbd;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
@@ -13,69 +13,76 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 public class DBDCommand implements TabExecutor {
     private final mdbd plugin;
     private final GameManager gameManager;
+    private final DBDAdminPlayerCommand adminPlayerCommand;
 
     public DBDCommand(mdbd plugin, GameManager gameManager) {
-        this.plugin = plugin;
+        this.plugin      = plugin;
         this.gameManager = gameManager;
+        this.adminPlayerCommand = new DBDAdminPlayerCommand(plugin, gameManager);
     }
 
     @Override
     public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command,
                              @NotNull String label, @NotNull String[] args) {
-        if (args.length == 0) {
+        if (args.length == 0) { sendUsage(sender); return true; }
-            sendUsage(sender);
-            return true;
-        }
 
-        String sub = args[0].toLowerCase();
+        return switch (args[0].toLowerCase()) {
-        return switch (sub) {
+            case "join"       -> handleJoin(sender, args);
-            case "join" -> handleJoin(sender);
+            case "leave"      -> handleLeave(sender);
-            case "leave" -> handleLeave(sender);
             case "forcestart" -> handleForceStart(sender);
-            case "create" -> handleCreate(sender);
+            case "stop"       -> handleStop(sender);
-            case "stop" -> handleStop(sender);
+            case "reload"     -> handleReload(sender);
-            case "reload" -> handleReload(sender);
+            case "save"       -> handleMapSave(sender, args);
-            case "lobby" -> handleLobby(sender);
+            case "load"       -> handleMapLoad(sender, args);
-            case "setlobby" -> handleSetLobby(sender);
+            case "maps"       -> handleMapsList(sender);
-            default -> {
+            case "lobby"      -> handleLobby(sender);
-                sendUsage(sender);
+            case "setlobby"   -> handleSetLobby(sender);
-                yield true;
+            case "admin"      -> adminPlayerCommand.handle(sender, args);
-            }
+            default           -> { sendUsage(sender); yield true; }
         };
     }
 
-    private boolean handleJoin(CommandSender sender) {
+    // -------------------------------------------------------------------------
+    // /dbd join — присоединиться к игре
+    // -------------------------------------------------------------------------
+    private boolean handleJoin(CommandSender sender, String[] args) {
         if (!(sender instanceof Player player)) {
             sender.sendMessage(Component.text("Только игроки!", NamedTextColor.RED));
             return true;
         }
+
         if (gameManager.joinGame(player)) {
             player.sendMessage(Component.text("[DBD] Вы присоединились к игре!", NamedTextColor.GREEN));
         } else {
-            player.sendMessage(Component.text("[DBD] Не удалось присоединиться", NamedTextColor.RED));
+            player.sendMessage(Component.text("[DBD] Не удалось присоединиться. Возможно, игра уже идёт.", NamedTextColor.RED));
         }
         return true;
     }
 
+    // -------------------------------------------------------------------------
+    // /dbd leave
+    // -------------------------------------------------------------------------
     private boolean handleLeave(CommandSender sender) {
         if (!(sender instanceof Player player)) {
             sender.sendMessage(Component.text("Только игроки!", NamedTextColor.RED));
             return true;
         }
         if (gameManager.leaveGame(player)) {
-            player.sendMessage(Component.text("[DBD] Вы покинули игру", NamedTextColor.YELLOW));
+            player.sendMessage(Component.text("[DBD] Вы покинули игру.", NamedTextColor.YELLOW));
         } else {
-            player.sendMessage(Component.text("[DBD] Вы не в игре", NamedTextColor.RED));
+            player.sendMessage(Component.text("[DBD] Вы не в игре.", NamedTextColor.RED));
         }
         return true;
     }
 
+    // -------------------------------------------------------------------------
+    // Admin commands
+    // -------------------------------------------------------------------------
     private boolean handleForceStart(CommandSender sender) {
         if (!sender.hasPermission("mdbd.admin")) {
             sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
@@ -90,21 +97,18 @@ public class DBDCommand implements TabExecutor {
             session.forceStart();
             sender.sendMessage(Component.text("[DBD] Игра форсирована!", NamedTextColor.GREEN));
         } else {
-            sender.sendMessage(Component.text("Нельзя форсировать сейчас", NamedTextColor.RED));
+            sender.sendMessage(Component.text("Нельзя форсировать сейчас.", NamedTextColor.RED));
         }
         return true;
     }
 
-    private boolean handleCreate(CommandSender sender) {
+    private boolean handleStop(CommandSender sender) {
         if (!sender.hasPermission("mdbd.admin")) {
             sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
             return true;
         }
-        if (gameManager.createGame()) {
+        gameManager.endGame();
-            sender.sendMessage(Component.text("[DBD] Игра создана!", NamedTextColor.GREEN));
+        sender.sendMessage(Component.text("[DBD] Игра остановлена.", NamedTextColor.YELLOW));
-        } else {
-            sender.sendMessage(Component.text("[DBD] Игра уже существует", NamedTextColor.RED));
-        }
         return true;
     }
 
@@ -118,13 +122,68 @@ public class DBDCommand implements TabExecutor {
         return true;
     }
 
+    // -------------------------------------------------------------------------
+    // Map save/load
+    // -------------------------------------------------------------------------
+    private boolean handleMapSave(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("mdbd.admin")) {
+            sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
+            return true;
+        }
+        if (args.length < 2) {
+            sender.sendMessage(Component.text("[DBD] Использование: /dbd save <название>", NamedTextColor.RED));
+            return true;
+        }
+        String name = args[1].toLowerCase();
+        if (plugin.getMapManager().saveMap(name)) {
+            sender.sendMessage(Component.text("[DBD] Карта «" + name + "» сохранена в plugins/Mdbd/maps/", NamedTextColor.GREEN));
+        } else {
+            sender.sendMessage(Component.text("[DBD] Не удалось сохранить карту.", NamedTextColor.RED));
+        }
+        return true;
+    }
+
+    private boolean handleMapLoad(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("mdbd.admin")) {
+            sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
+            return true;
+        }
+        if (args.length < 2) {
+            sender.sendMessage(Component.text("[DBD] Использование: /dbd load <название>", NamedTextColor.RED));
+            return true;
+        }
+        String name = args[1].toLowerCase();
+        if (plugin.getMapManager().loadMap(name)) {
+            sender.sendMessage(Component.text("[DBD] Карта «" + name + "» загружена!", NamedTextColor.GREEN));
+            sender.sendMessage(Component.text("[DBD] Перезагрузите карту или перезапустите сервер для применения.", NamedTextColor.YELLOW));
+        } else {
+            sender.sendMessage(Component.text("[DBD] Карта «" + name + "» не найдена.", NamedTextColor.RED));
+        }
+        return true;
+    }
+
+    private boolean handleMapsList(CommandSender sender) {
+        if (!sender.hasPermission("mdbd.admin")) {
+            sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
+            return true;
+        }
+        List<String> maps = plugin.getMapManager().listMaps();
+        if (maps.isEmpty()) {
+            sender.sendMessage(Component.text("[DBD] Нет сохранённых карт.", NamedTextColor.YELLOW));
+        } else {
+            sender.sendMessage(Component.text("=== Сохранённые карты ===", NamedTextColor.GOLD));
+            for (String m : maps) sender.sendMessage(Component.text("  §f" + m, NamedTextColor.GRAY));
+        }
+        return true;
+    }
+
     private boolean handleLobby(CommandSender sender) {
         if (!(sender instanceof Player player)) {
             sender.sendMessage(Component.text("Только игроки!", NamedTextColor.RED));
             return true;
         }
         plugin.getLobbyManager().teleportToLobby(player);
-        player.sendMessage(Component.text("[DBD] Вы телепортированы в лобби!", NamedTextColor.GREEN));
+        player.sendMessage(Component.text("[DBD] Телепорт в лобби!", NamedTextColor.GREEN));
         return true;
     }
 
@@ -140,32 +199,26 @@ public class DBDCommand implements TabExecutor {
         plugin.getConfigManager().getLocations().setLobby(player.getLocation());
         plugin.getConfigManager().saveConfig("locations.yml",
             plugin.getConfigManager().getLocations().getConfig());
-        player.sendMessage(Component.text("[DBD] Лобби установлено!", NamedTextColor.GREEN));
+        player.sendMessage(Component.text("[DBD] Точка лобби установлена!", NamedTextColor.GREEN));
-        return true;
-    }
-
-    private boolean handleStop(CommandSender sender) {
-        if (!sender.hasPermission("mdbd.admin")) {
-            sender.sendMessage(Component.text("Нет прав!", NamedTextColor.RED));
-            return true;
-        }
-        gameManager.endGame();
-        sender.sendMessage(Component.text("[DBD] Игра остановлена", NamedTextColor.YELLOW));
         return true;
     }
 
+    // -------------------------------------------------------------------------
+    // Usage
+    // -------------------------------------------------------------------------
     private void sendUsage(CommandSender sender) {
-        sender.sendMessage(Component.text("=== DBD Commands ===", NamedTextColor.GOLD));
+        sender.sendMessage(Component.text("=== DBD Команды ===", NamedTextColor.GOLD));
-        sender.sendMessage(Component.text("/dbd join - присоединиться", NamedTextColor.GRAY));
+        sender.sendMessage(Component.text("/dbd join        — присоединиться к игре", NamedTextColor.GRAY));
-        sender.sendMessage(Component.text("/dbd leave - покинуть", NamedTextColor.GRAY));
+        sender.sendMessage(Component.text("/dbd leave       — покинуть игру", NamedTextColor.GRAY));
-        sender.sendMessage(Component.text("/dbd lobby - телепорт в лобби", NamedTextColor.GRAY));
+        sender.sendMessage(Component.text("/dbd lobby       — телепорт в лобби", NamedTextColor.GRAY));
         if (sender.hasPermission("mdbd.admin")) {
-            sender.sendMessage(Component.text("/dbd create - создать игру", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd admin       — управление игроками в матче", NamedTextColor.YELLOW));
-            sender.sendMessage(Component.text("/dbd forcestart - форс старт", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd forcestart  — форс старт", NamedTextColor.YELLOW));
-            sender.sendMessage(Component.text("/dbd stop - остановить", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd stop        — остановить игру", NamedTextColor.YELLOW));
-            sender.sendMessage(Component.text("/dbd reload - перезагрузить конфиги", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd reload      — перезагрузить конфиги", NamedTextColor.YELLOW));
-            sender.sendMessage(Component.text("/dbd lobby - телепорт в лобби", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd setlobby    — установить точку лобби", NamedTextColor.YELLOW));
-            sender.sendMessage(Component.text("/dbd setlobby - установить точку лобби", NamedTextColor.GRAY));
+            sender.sendMessage(Component.text("/dbd save        — сохранить карту", NamedTextColor.YELLOW));
+            sender.sendMessage(Component.text("/dbd load        — загрузить карту", NamedTextColor.YELLOW));
         }
     }
 
@@ -173,19 +226,15 @@ public class DBDCommand implements TabExecutor {
     public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
                                                  @NotNull String label, @NotNull String[] args) {
         if (args.length == 1) {
-            List<String> completions = new ArrayList<>(Arrays.asList("join", "leave", "lobby"));
+            List<String> subs = new ArrayList<>(List.of("join", "leave", "lobby"));
             if (sender.hasPermission("mdbd.admin")) {
-                completions.addAll(Arrays.asList("create", "forcestart", "stop", "reload", "setlobby"));
+                subs.addAll(List.of("admin", "forcestart", "stop", "reload", "setlobby", "save", "load", "maps"));
             }
-            return completions.stream()
+            return subs.stream().filter(s -> s.startsWith(args[0].toLowerCase())).toList();
-                .filter(s -> s.startsWith(args[0].toLowerCase()))
+        }
-                .toList();
+        if (args.length >= 2 && args[0].equalsIgnoreCase("admin") && sender.hasPermission("mdbd.admin")) {
+            return DBDAdminPlayerCommand.tabComplete(args);
         }
         return List.of();
     }
-
-    private Object getCurrentPhase() {
-        var session = gameManager.getCurrentSession();
-        return session != null ? session.getState() : null;
-    }
 }

src/main/java/dev/loki/command/SetupCommand.java

@@ -1,29 +1,55 @@
 package dev.loki.command;
 
+import dev.loki.config.LocationsConfig;
 import dev.loki.mdbd;
+import dev.loki.util.SpawnUtil;
 import dev.loki.util.TextUtil;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Arrays;
+import java.util.*;
-import java.util.List;
 
+/**
+ * /dbdsetup — настройка карты.
+ *
+ * Система:
+ *   1. Ванд: /dbdsetup wand (ЛКМ=pos1, ПКМ=pos2 — для ворот)
+ *   2. Обычные объекты: /dbdsetup set <тип> [номер] → сломай блок
+ *   3. Ворота: /dbdsetup set gate A|B (из pos1/pos2 ванда)
+ *
+ * Типы: hook, chest, generator, killer-spawn, survivor-spawn, gate
+ * Для спавнов можно указать номер: /dbdsetup set killer-spawn 0
+ */
 public class SetupCommand implements TabExecutor {
     private final mdbd plugin;
-    private final java.util.Map<String, Location> selectionCorners;
+
-    private final java.util.Set<java.util.UUID> selectingKillerSpawn = new java.util.HashSet<>();
+    // Wand positions for gates (LMB=pos1, RMB=pos2)
-    private final java.util.Set<java.util.UUID> selectingSurvivorSpawn = new java.util.HashSet<>();
+    private final Map<UUID, Location> pos1 = new HashMap<>();
+    private final Map<UUID, Location> pos2 = new HashMap<>();
+
+    // Setup mode data: mode + optional spawn index
+    private static final class SetupData {
+        final String mode;
+        int spawnIndex;  // -1 means "not specified, append"; resets to -1 after first use
+
+        SetupData(String mode, int spawnIndex) {
+            this.mode = mode;
+            this.spawnIndex = spawnIndex;
+        }
+    }
+    private final Map<UUID, SetupData> setupMode = new HashMap<>();
 
     public SetupCommand(mdbd plugin) {
         this.plugin = plugin;
-        this.selectionCorners = new java.util.HashMap<>();
     }
 
     @Override
@@ -37,191 +63,306 @@ public class SetupCommand implements TabExecutor {
             sender.sendMessage(Component.text("Только игроки!", NamedTextColor.RED));
             return true;
         }
-        if (args.length == 0) {
+        if (args.length == 0) { sendUsage(sender); return true; }
-            sendUsage(sender);
-            return true;
-        }
 
         return switch (args[0].toLowerCase()) {
-            case "wand"  -> giveWand(player);
+            case "wand"         -> giveWand(player);
-            case "pos1"  -> setPos(player, 1);
+            case "set"          -> handleSet(player, args);
-            case "pos2"  -> setPos(player, 2);
+            case "build"        -> buildMap(player);
-            case "set"   -> setObject(player, args);
+            case "clear"        -> clearMap(player);
-            case "build" -> buildMap(player);
+            case "clear-spawns" -> clearSpawns(player);
-            case "clear" -> clearMap(player);
+            case "lobby"        -> setLobby(player);
-            case "lobby" -> setLobby(player);
+            default             -> { sendUsage(sender); yield true; }
-            default -> { sendUsage(sender); yield true; }
         };
     }
 
-    // ── wand ─────────────────────────────────────────────────────────────────
+    // ── Wand ─────────────────────────────────────────────────────────────────
 
     private boolean giveWand(Player player) {
-        var wand = new org.bukkit.inventory.ItemStack(org.bukkit.Material.STICK);
+        ItemStack wand = new ItemStack(Material.WOODEN_AXE);
         wand.editMeta(meta -> {
-            meta.displayName(TextUtil.color("<#FF6B00>DBD Wand <white>(Выделение)"));
+            meta.displayName(TextUtil.color("<#FF6B00>DBD Setup Wand"));
             meta.lore(List.of(
-                TextUtil.color("<#FFD700>ЛКМ — Первая точка"),
+                TextUtil.color("<#FFD700>ЛКМ по блоку — Точка 1 (для ворот)"),
-                TextUtil.color("<#FFD700>ПКМ — Вторая точка")
+                TextUtil.color("<#FFD700>ПКМ по блоку — Точка 2 (для ворот)"),
+                TextUtil.color("<gray>Для остального: /dbdsetup set <тип> и ломай блок")
             ));
             var key = new org.bukkit.NamespacedKey(plugin, "dbd_wand");
             meta.getPersistentDataContainer().set(key,
                 org.bukkit.persistence.PersistentDataType.BYTE, (byte) 1);
         });
         player.getInventory().addItem(wand);
-        player.sendMessage(TextUtil.color("<#00FF00>Получена палочка! <gray>ЛКМ=pos1  ПКМ=pos2"));
+        player.sendMessage(TextUtil.color("<#00FF00>Получен DBD Setup Wand"));
         return true;
     }
 
-    private boolean setPos(Player player, int num) {
+    // ── Set mode ──────────────────────────────────────────────────────────────
-        String key = player.getUniqueId().toString();
-        Location loc = player.getLocation().getBlock().getLocation();
-        selectionCorners.put(key + "_pos" + num, loc);
-        player.sendMessage(TextUtil.color("<#00FF00>Установлена точка " + num + ": " + formatLoc(loc)));
-        return true;
-    }
 
-    /** Called by PlayerInteractListener when wand is used on a block. */
+    private boolean handleSet(Player player, String[] args) {
-    public void setWandPos(Player player, int num, Location loc) {
-        String key = player.getUniqueId().toString();
-        selectionCorners.put(key + "_pos" + num, loc);
-        player.sendMessage(TextUtil.color("<#00FF00>[Wand] Точка " + num + ": " + formatLoc(loc)));
-    }
-
-    // ── set <type> ────────────────────────────────────────────────────────────
-
-    private boolean setObject(Player player, String[] args) {
         if (args.length < 2) {
-            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdsetup set <тип>"));
+            player.sendMessage(TextUtil.color("<#FF0000>Использование: /dbdsetup set <тип> [номер]"));
-            player.sendMessage(TextUtil.color("<#FFD700>Типы: generator, hook, pallet, gate, killer-spawn, survivor-spawn, lobby"));
+            player.sendMessage(TextUtil.color(
+                "<#FFD700>Типы: hook, chest, generator, killer-spawn, survivor-spawn, gate"));
+            player.sendMessage(TextUtil.color(
+                "<#FFD700>Для спавнов можно указать номер: /dbdsetup set killer-spawn 0"));
             return true;
         }
 
         String type = args[1].toLowerCase();
-        var locations = plugin.getConfigManager().getLocations();
+        UUID uuid = player.getUniqueId();
 
-        switch (type) {
+        if (type.equals("gate")) {
-            case "generator" -> {
+            if (args.length < 3) {
-                plugin.getDbdAdminCommand().toggleGeneratorMode(player);
+                player.sendMessage(TextUtil.color("<#FF0000>Укажи: /dbdsetup set gate A (или B)"));
                 return true;
             }
-            case "killer-spawn", "killer_spawn" -> {
+            String gateId = args[2].toUpperCase();
-                if (selectingKillerSpawn.remove(player.getUniqueId())) {
+            if (!gateId.equals("A") && !gateId.equals("B")) {
-                    player.sendMessage(TextUtil.color("<#FFA500>Режим спавна киллера отключен"));
+                player.sendMessage(TextUtil.color("<#FF0000>Ворота могут быть только A или B"));
-                } else {
+                return true;
-                    selectingKillerSpawn.add(player.getUniqueId());
+            }
-                    player.sendMessage(TextUtil.color("<#FF4444>Режим спавна киллера включен!"));
+            return placeGate(player, gateId);
-                    player.sendMessage(TextUtil.color("<#FFD700>Сломайте блок для установки (блок не сломается)"));
+        }
+
+        String mode = switch (type) {
+            case "killer_spawn" -> "killer-spawn";
+            case "survivor_spawn" -> "survivor-spawn";
+            default -> type;
+        };
+
+        if (!List.of("hook", "chest", "generator", "killer-spawn", "survivor-spawn").contains(mode)) {
+            player.sendMessage(TextUtil.color("<#FF0000>Неизвестный тип: " + type));
+            return true;
+        }
+
+        // Parse optional spawn index
+        int spawnIndex = -1;
+        if (args.length >= 3 && (mode.equals("killer-spawn") || mode.equals("survivor-spawn"))) {
+            try {
+                spawnIndex = Integer.parseInt(args[2]);
+                if (spawnIndex < 0) {
+                    player.sendMessage(TextUtil.color("<#FF0000>Номер спавна должен быть >= 0"));
+                    return true;
                 }
+            } catch (NumberFormatException e) {
+                player.sendMessage(TextUtil.color("<#FF0000>Номер спавна должен быть числом: " + args[2]));
                 return true;
             }
-            case "survivor-spawn", "survivor_spawn" -> {
+        }
-                if (selectingSurvivorSpawn.remove(player.getUniqueId())) {
+
-                    player.sendMessage(TextUtil.color("<#FFA500>Режим спавна выжившего отключен"));
+        // Toggle: если уже в этом режиме с тем же типом — выключаем
-                } else {
+        SetupData currentData = setupMode.get(uuid);
-                    selectingSurvivorSpawn.add(player.getUniqueId());
+        if (currentData != null && mode.equals(currentData.mode)) {
-                    int current = locations.getSurvivorSpawns().size();
+            setupMode.remove(uuid);
-                    player.sendMessage(TextUtil.color("<#00FF00>Режим спавна выжившего включен! Уже: " + current));
+            player.sendMessage(TextUtil.color("<#FFA500>Режим установки <#FFD700>" + mode + " <#FFA500>выключен"));
-                    player.sendMessage(TextUtil.color("<#FFD700>Сломайте блок для установки (блок не сломается)"));
+            return true;
-                }
+        }
-                return true;
+
-            }
+        setupMode.put(uuid, new SetupData(mode, spawnIndex));
-            case "hook" -> {
+        String indexMsg = spawnIndex >= 0 ? " #" + spawnIndex : "";
-                Location loc = player.getLocation();
+        if (mode.contains("spawn")) {
-                locations.addLocation("hooks", loc);
+            player.sendMessage(TextUtil.color(
-                plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
+                "<#00FF00>Режим установки: <#FFD700>" + mode + indexMsg +
-                player.sendMessage(TextUtil.color("<#00FF00>Крюк установлен: " + formatLoc(loc)));
+                "\n<#00FF00>Сломай блок чтобы установить спавн (блок восстановится)" +
-            }
+                "\n<#FFA500>Повторно введи команду для выключения"));
-            case "pallet" -> {
+        } else {
-                Location loc = player.getLocation().getBlock().getLocation();
+            player.sendMessage(TextUtil.color(
-                locations.addLocation("pallets", loc);
+                "<#00FF00>Режим установки: <#FFD700>" + mode + indexMsg +
-                plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
+                "\n<#00FF00>Сломай блок чтобы установить (блок восстановится)" +
-                player.sendMessage(TextUtil.color("<#00FF00>Паллет установлен: " + formatLoc(loc)));
+                "\n<#FFA500>Введи команду снова чтобы выключить режим"));
-            }
-            case "gate" -> {
-                Location loc = player.getLocation();
-                locations.addLocation("exitgates", loc);
-                plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
-                player.sendMessage(TextUtil.color("<#00FF00>Ворота установлены: " + formatLoc(loc)));
-            }
-            case "lobby" -> {
-                Location loc = player.getLocation();
-                locations.setLobby(loc);
-                plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
-                player.sendMessage(TextUtil.color("<#00FF00>Лобби установлено: " + formatLoc(loc)));
-            }
-            default -> {
-                player.sendMessage(TextUtil.color("<#FF0000>Неизвестный тип: " + type));
-                player.sendMessage(TextUtil.color("<#FFD700>Типы: generator, hook, pallet, gate, killer-spawn, survivor-spawn, lobby"));
-            }
         }
         return true;
     }
 
-    // ── spawn selection callbacks (called by SetupBlockBreakListener) ─────────
+    private boolean placeGate(Player player, String gateId) {
+        Location p1 = pos1.get(player.getUniqueId());
+        Location p2 = pos2.get(player.getUniqueId());
 
-    public boolean isSelectingKillerSpawn(java.util.UUID uuid) {
+        if (p1 == null || p2 == null) {
-        return selectingKillerSpawn.contains(uuid);
+            player.sendMessage(TextUtil.color(
-    }
+                "<#FF0000>Сначала выбери оба угла топориком! (ЛКМ=точка 1, ПКМ=точка 2)"));
+            return true;
+        }
 
-    public boolean isSelectingSurvivorSpawn(java.util.UUID uuid) {
+        if (!p1.getWorld().equals(p2.getWorld())) {
-        return selectingSurvivorSpawn.contains(uuid);
+            player.sendMessage(TextUtil.color("<#FF0000>Точки должны быть в одном мире!"));
-    }
+            return true;
+        }
 
-    public void onKillerSpawnSelected(Player player, Location loc) {
+        Location center = new Location(
-        plugin.getConfigManager().getLocations().setKillerSpawn(loc);
+            p1.getWorld(),
-        plugin.getConfigManager().saveConfig("locations.yml",
+            (p1.getX() + p2.getX()) / 2.0,
-            plugin.getConfigManager().getLocations().getConfig());
+            Math.min(p1.getY(), p2.getY()),
-        player.sendMessage(TextUtil.color("<#FF4444>Спавн киллера установлен: " + formatLoc(loc)));
+            (p1.getZ() + p2.getZ()) / 2.0,
-    }
+            player.getLocation().getYaw(),
+            0f
+        );
 
-    public void onSurvivorSpawnSelected(Player player, Location loc) {
         var locations = plugin.getConfigManager().getLocations();
-        locations.addLocation("survivor-spawns", loc);
+        locations.setGate(gateId, center);
         plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
-        int count = locations.getSurvivorSpawns().size();
+
-        player.sendMessage(TextUtil.color("<#00FF00>Спавн выжившего #" + count + " добавлен: " + formatLoc(loc)));
+        player.sendMessage(TextUtil.color(
+            "<#00FF00>Ворота <#FFFFFF>" + gateId + " <#00FF00>установлены: " + formatLoc(center)));
+        return true;
     }
 
-    // ── build / clear / lobby ─────────────────────────────────────────────────
+    // ── Block break callback ───────────────────────────────────────────────────
+
+    /**
+     * Called when a block is broken in setup mode.
+     * Saves the location and restores the original block.
+     *
+     * @param player       The player who broke the block
+     * @param blockLoc     Location of the broken block
+     * @param restoreBlock The material to restore the block to (null = don't restore)
+     */
+    public void onBlockBroken(Player player, Location blockLoc, Material restoreBlock) {
+        UUID uuid = player.getUniqueId();
+        SetupData data = setupMode.get(uuid);
+        if (data == null) return;
+
+        String mode = data.mode;
+        var locations = plugin.getConfigManager().getLocations();
+        Location loc = SpawnUtil.blockBreakSpawn(blockLoc, player.getLocation().getYaw());
+
+        switch (mode) {
+            case "hook" -> {
+                locations.addLocation("hooks", blockLoc.clone().add(0.5, 0, 0.5));
+                player.sendMessage(TextUtil.color("<#00FF00>Крюк установлен: " + formatLoc(loc)));
+            }
+            case "chest" -> {
+                locations.addLocation("chests", blockLoc.clone().add(0.5, 0, 0.5));
+                player.sendMessage(TextUtil.color("<#00FF00>Сундук добавлен: " + formatLoc(loc)));
+            }
+            case "generator" -> {
+                locations.addLocation("generators", blockLoc.clone().add(0.5, 0, 0.5));
+                plugin.getGeneratorData().addGenerator(blockLoc.clone().add(0.5, 0, 0.5));
+                player.sendMessage(TextUtil.color("<#00FF00>Генератор добавлен: " + formatLoc(loc)));
+            }
+            case "killer-spawn" -> {
+                locations.setSingleLocation("killer-spawn", loc);
+                player.sendMessage(TextUtil.color("<#FF4444>Спавн киллера установлен: " + formatLoc(loc)));
+                data.spawnIndex = -1;
+            }
+            case "survivor-spawn" -> {
+                int currentCount = locations.getSurvivorSpawns().size();
+                if (currentCount >= 4) {
+                    player.sendMessage(TextUtil.color("<#FF0000>Достигнут лимит спавнов выживших (4)! Используй /dbdsetup clear-spawns для сброса."));
+                    break;
+                }
+                saveSpawn(locations, "survivor-spawns", loc, data.spawnIndex);
+                int newCount = locations.getSurvivorSpawns().size();
+                String label = switch (newCount) {
+                    case 1 -> "первого";
+                    case 2 -> "второго";
+                    case 3 -> "третьего";
+                    case 4 -> "четвёртого";
+                    default -> "#" + newCount;
+                };
+                player.sendMessage(TextUtil.color("<#00FF00>Спавн для <#FFD700>" + label + " <#00FF00>выжившего установлен! (всего: " + newCount + "/4) " + formatLoc(loc)));
+                // Сбрасываем индекс после использования, чтобы следующие блоки добавлялись
+                data.spawnIndex = -1;
+            }
+        }
+
+        plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
+
+        // Restore the block to its original material + send block update to client
+        if (restoreBlock != null) {
+            Material finalRestore = restoreBlock;
+            plugin.getServer().getScheduler().runTask(plugin, () -> {
+                blockLoc.getBlock().setType(finalRestore, false);
+                player.sendBlockChange(blockLoc, finalRestore.createBlockData());
+            });
+        }
+        // НЕ выходим из режима — чтобы можно было установить несколько подряд
+    }
+
+    /**
+     * Saves a spawn location at a specific index, or appends if index is -1.
+     */
+    private void saveSpawn(LocationsConfig locations, String path, Location loc, int index) {
+        if (index >= 0) {
+            locations.setLocationAtIndex(path, index, loc);
+        } else {
+            locations.addLocation(path, loc);
+        }
+    }
+
+    // ── Wand position callbacks ────────────────────────────────────────────────
+
+    public void setWandPos(Player player, int num, Location loc) {
+        if (num == 1) pos1.put(player.getUniqueId(), loc);
+        else          pos2.put(player.getUniqueId(), loc);
+        player.sendMessage(TextUtil.color("<#00FF00>[Wand] Точка " + num + ": " + formatLoc(loc)));
+    }
+
+    public boolean isInSetupMode(UUID uuid) {
+        return setupMode.containsKey(uuid);
+    }
+
+    public String getSetupMode(UUID uuid) {
+        SetupData data = setupMode.get(uuid);
+        return data != null ? data.mode : null;
+    }
+
+    /**
+     * Returns the spawn index for the current setup mode, or -1 if not specified.
+     */
+    public int getSpawnIndex(UUID uuid) {
+        SetupData data = setupMode.get(uuid);
+        return data != null ? data.spawnIndex : -1;
+    }
+
+    // ── Build / clear / lobby ─────────────────────────────────────────────────
 
     private boolean buildMap(Player player) {
-        player.sendMessage(TextUtil.color("<#FFD700>Строительство карты..."));
         plugin.getMapBuilder().buildMap(plugin.getConfigManager().getLocations());
         player.sendMessage(TextUtil.color("<#00FF00>Карта построена!"));
         return true;
     }
 
     private boolean clearMap(Player player) {
-        player.sendMessage(TextUtil.color("<#FFA500>Очистка карты..."));
         plugin.getMapBuilder().clearMap(plugin.getConfigManager().getLocations());
         player.sendMessage(TextUtil.color("<#00FF00>Карта очищена!"));
         return true;
     }
 
-    private boolean setLobby(Player player) {
+    private boolean clearSpawns(Player player) {
-        Location loc = player.getLocation();
+        var locations = plugin.getConfigManager().getLocations();
-        plugin.getConfigManager().getLocations().setLobby(loc);
+        locations.clearLocationList("killer-spawn");
-        plugin.getConfigManager().saveConfig("locations.yml",
+        locations.clearLocationList("survivor-spawns");
-            plugin.getConfigManager().getLocations().getConfig());
+        plugin.getConfigManager().saveConfig("locations.yml", locations.getConfig());
-        player.sendMessage(TextUtil.color("<#00FF00>Лобби установлено: " + formatLoc(loc)));
+        player.sendMessage(TextUtil.color("<#00FF00>Все спавны (киллер + выжившие) очищены!"));
         return true;
     }
 
-    // ── usage / helpers ───────────────────────────────────────────────────────
+    private boolean setLobby(Player player) {
+        plugin.getConfigManager().getLocations().setLobby(player.getLocation());
+        plugin.getConfigManager().saveConfig("locations.yml",
+            plugin.getConfigManager().getLocations().getConfig());
+        player.sendMessage(TextUtil.color("<#00FF00>Лобби установлено: " + formatLoc(player.getLocation())));
+        return true;
+    }
+
+    // ── Usage / helpers ───────────────────────────────────────────────────────
 
     private void sendUsage(CommandSender sender) {
         sender.sendMessage(TextUtil.color("<#FF6B00>=== DBD Setup ==="));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup wand — Получить палочку выделения"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup wand               — Получить ванд (ЛКМ/ПКМ для ворот)"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup pos1/pos2 — Установить точки выделения"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set hook           — Установить крюк (ломай блок)"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set <type> — Установить объект на карте"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set chest          — Установить сундук"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup build — Построить карту"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set generator      — Установить генератор"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup clear — Очистить карту"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set killer-spawn   — Спавн киллера (только 1)"));
-        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup lobby — Установить спавн лобби"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set survivor-spawn — Спавн выжившего (до 4)"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup set gate A|B       — Установить ворота (из точек ванда)"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup clear-spawns       — Очистить все спавны"));
+        sender.sendMessage(TextUtil.color("<#FFD700>/dbdsetup lobby              — Установить точку лобби"));
     }
 
     private String formatLoc(Location loc) {
-        return String.format("[%s, %.0f, %.0f, %.0f]",
+        return String.format("[%s, %.1f, %.1f, %.1f]",
             loc.getWorld().getName(), loc.getX(), loc.getY(), loc.getZ());
     }
 
@@ -229,19 +370,13 @@ public class SetupCommand implements TabExecutor {
     public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
                                                 @NotNull String label, @NotNull String[] args) {
         if (!sender.hasPermission("mdbd.admin")) return List.of();
-
         if (args.length == 1) {
-            return Arrays.asList("wand", "pos1", "pos2", "set", "build", "clear", "lobby")
+            return List.of("wand", "set", "build", "clear", "clear-spawns", "lobby").stream()
-                .stream()
+                .filter(s -> s.startsWith(args[0].toLowerCase())).toList();
-                .filter(s -> s.startsWith(args[0].toLowerCase()))
-                .toList();
         }
         if (args.length == 2 && args[0].equalsIgnoreCase("set")) {
-            return Arrays.asList("generator", "hook", "pallet", "gate",
+            return List.of("hook", "chest", "generator", "killer-spawn", "survivor-spawn", "gate").stream()
-                    "killer-spawn", "survivor-spawn", "lobby")
+                .filter(s -> s.startsWith(args[1].toLowerCase())).toList();
-                .stream()
-                .filter(s -> s.startsWith(args[1].toLowerCase()))
-                .toList();
         }
         return List.of();
     }

src/main/java/dev/loki/config/ConfigManager.java

@@ -1,5 +1,6 @@
 package dev.loki.config;
 
+import dev.loki.core.GameSession;
 import dev.loki.mdbd;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -7,6 +8,8 @@ import org.bukkit.configuration.file.YamlConfiguration;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 
 public class ConfigManager {
@@ -36,6 +39,22 @@ public class ConfigManager {
         plugin.getLogger().info("Configs loaded successfully");
     }
 
+    /**
+     * Reload all config files from disk and update all running game sessions with the new config.
+     */
+    public void reloadConfigs() {
+        loadConfigs();
+        // Update all active GameSessions with the new GameConfig reference
+        if (plugin.getGameManager() != null) {
+            for (GameSession session : plugin.getGameManager().getAllSessions()) {
+                if (session != null) {
+                    session.refreshConfig();
+                }
+            }
+        }
+        plugin.getLogger().info("Configs reloaded and applied to all running sessions");
+    }
+
     public void saveAllConfigs() {
         saveConfig("locations.yml", locationsConfig.getConfig());
         saveConfig("game.yml", gameConfig.getConfig());
@@ -48,7 +67,13 @@ public class ConfigManager {
         if (!file.exists()) {
             createDefaultConfig(fileName, file);
         }
-        return YamlConfiguration.loadConfiguration(file);
+        try (var reader = new InputStreamReader(
+                Files.newInputStream(file.toPath()), StandardCharsets.UTF_8)) {
+            return YamlConfiguration.loadConfiguration(reader);
+        } catch (IOException e) {
+            plugin.getLogger().warning("Could not read config UTF-8, fallback: " + fileName);
+            return YamlConfiguration.loadConfiguration(file);
+        }
     }
 
     private void createDefaultConfig(String resourceName, File targetFile) {

src/main/java/dev/loki/config/GameConfig.java

@@ -17,7 +17,7 @@ public class GameConfig {
         setDefault("lobby.countdown-4-players", 45);
         setDefault("lobby.countdown-5-players", 15);
         setDefault("lobby.role-assign-delay", 5);
-        setDefault("lobby.server-lobby-count", 3);
+        setDefault("lobby.server-lobby-count", 10);
         setDefault("lobby.persist-lobbies", true);
 
         // Players scale
@@ -42,7 +42,7 @@ public class GameConfig {
         setDefault("hooks.struggle-interval", 2);
         setDefault("hooks.max-hooks", 3);
         setDefault("hooks.interaction-range", 3.0);
-        setDefault("hooks.rescue-seconds", 3);
+        setDefault("hooks.rescue-seconds", 2);
         setDefault("hooks.sabotage-seconds", 10);
         setDefault("hooks.sabotage-recovery-seconds", 60);
 
@@ -64,17 +64,14 @@ public class GameConfig {
         setDefault("healing.heal-range", 3.0);
 
         // Carry / escape
-        setDefault("carry.escape-jumps", 15);
+        setDefault("carry.escape-shift-presses", 50);
         setDefault("carry.escape-speed-seconds", 3);
-        setDefault("carry.jump-fill-percent", 6.67);
 
         // Killer
         setDefault("killer.attack-cooldown", 2.5);
+        setDefault("killer.post-hit-cooldown", 4.0);
         setDefault("killer.attack-range", 3.0);
-        setDefault("killer.pallet-stun-seconds", 2.0);
-        setDefault("killer.pallet-break-seconds", 3.0);
         setDefault("killer.terror-radius", 32);
-        setDefault("killer.pallet-interaction-range", 3.0);
 
         // BossBar
         setDefault("bossbar.enabled", true);
@@ -84,15 +81,8 @@ public class GameConfig {
         setDefault("bossbar.appear-range", 32);
         setDefault("bossbar.full-range", 8);
 
-        // Window vault
-        setDefault("window.vault-survivor-fast", 1.0);
-        setDefault("window.vault-survivor-slow", 1.5);
-        setDefault("window.vault-killer", 1.5);
-        setDefault("window.vault-block-seconds", 15);
-
         // Endgame
         setDefault("endgame.gate-open-seconds", 20);
-        setDefault("endgame.collapse-seconds", 120);
         setDefault("endgame.chest-open-seconds", 3);
         setDefault("endgame.gate-interaction-range", 3.0);
 
@@ -115,6 +105,31 @@ public class GameConfig {
         // Hatch
         setDefault("hatch.min-survivors-for-open", 1);
         setDefault("hatch.require-more-gens-than-survivors", true);
+
+        // Block types for spawning
+        setDefault("blocks.generator", "BLAST_FURNACE");
+        setDefault("blocks.chest", "CHEST");
+        setDefault("blocks.hook", "IRON_BARS");
+
+        // Holograms
+        setDefault("holograms.enabled", true);
+        setDefault("holograms.generator.enabled", true);
+        setDefault("holograms.generator.height-offset", -1.0);
+        setDefault("holograms.hook.enabled", true);
+        setDefault("holograms.hook.height-offset", 0.0);
+        setDefault("holograms.chest.enabled", true);
+        setDefault("holograms.chest.height-offset", 0.0);
+
+        // Skill check
+        setDefault("skillcheck.chance", 0.005);
+        setDefault("skillcheck.win-percent", 5.0);
+        setDefault("skillcheck.loss-percent", 10.0);
+        setDefault("skillcheck.success-block", "GREEN_STAINED_GLASS_PANE");
+        setDefault("skillcheck.fail-block", "RED_STAINED_GLASS_PANE");
+        setDefault("skillcheck.neutral-block", "GRAY_STAINED_GLASS_PANE");
+
+        // Chest loot
+        setDefault("chest.loot-reset-minutes", 3.0);
     }
 
     private void setDefault(String path, Object value) {
@@ -193,19 +208,41 @@ public class GameConfig {
     // -------------------------------------------------------------------------
     // Carry / Escape
     // -------------------------------------------------------------------------
-    public int getCarryEscapeJumps() { return config.getInt("carry.escape-jumps", 15); }
+    /** Number of Shift presses required to escape from killer's carry (default 50). */
+    public int getCarryEscapePresses() { return config.getInt("carry.escape-shift-presses", 50); }
     public int getCarryEscapeSpeedSeconds() { return config.getInt("carry.escape-speed-seconds", 3); }
-    public double getCarryJumpFillPercent() { return config.getDouble("carry.jump-fill-percent", 6.67); }
 
     // -------------------------------------------------------------------------
     // Killer
     // -------------------------------------------------------------------------
     public int getAttackCooldown() { return (int)(config.getDouble("killer.attack-cooldown", 2.5) * 20); }
+    /** Кулдаун после ПОПАДАНИЯ по игроку (3–5 сек). Отличается от swing cooldown. */
+    public int getPostHitCooldown() { return (int)(config.getDouble("killer.post-hit-cooldown", 4.0) * 20); }
     public double getAttackRange() { return config.getDouble("killer.attack-range", 3.0); }
-    public int getPalletStunTicks() { return (int)(config.getDouble("killer.pallet-stun-seconds", 2.0) * 20); }
-    public int getPalletBreakTicks() { return (int)(config.getDouble("killer.pallet-break-seconds", 3.0) * 20); }
     public int getTerrorRadius() { return config.getInt("killer.terror-radius", 32); }
-    public double getPalletInteractionRange() { return config.getDouble("killer.pallet-interaction-range", 3.0); }
+
+    // -------------------------------------------------------------------------
+    // Block types (какие блоки спавнятся на местах объектов)
+    // -------------------------------------------------------------------------
+    public String getGeneratorBlock() { return config.getString("blocks.generator", "BLAST_FURNACE"); }
+    public String getChestBlock() { return config.getString("blocks.chest", "CHEST"); }
+    public String getHookBlock() { return config.getString("blocks.hook", "IRON_BARS"); }
+
+    // -------------------------------------------------------------------------
+    // Holograms
+    // -------------------------------------------------------------------------
+    public boolean isHologramsEnabled() { return config.getBoolean("holograms.enabled", true); }
+    public boolean isGeneratorHologramEnabled() { return config.getBoolean("holograms.generator.enabled", true); }
+    public double getGeneratorHologramHeightOffset() { return config.getDouble("holograms.generator.height-offset", -1.0); }
+    public boolean isHookHologramEnabled() { return config.getBoolean("holograms.hook.enabled", true); }
+    public double getHookHologramHeightOffset() { return config.getDouble("holograms.hook.height-offset", 0.0); }
+    public boolean isChestHologramEnabled() { return config.getBoolean("holograms.chest.enabled", true); }
+    public double getChestHologramHeightOffset() { return config.getDouble("holograms.chest.height-offset", 0.0); }
+
+    // -------------------------------------------------------------------------
+    // Chest loot
+    // -------------------------------------------------------------------------
+    public double getChestLootResetMinutes() { return config.getDouble("chest.loot-reset-minutes", 3.0); }
 
     // -------------------------------------------------------------------------
     // BossBar
@@ -217,19 +254,10 @@ public class GameConfig {
     public int getBossBarAppearRange() { return config.getInt("bossbar.appear-range", 32); }
     public int getBossBarFullRange() { return config.getInt("bossbar.full-range", 8); }
 
-    // -------------------------------------------------------------------------
-    // Window
-    // -------------------------------------------------------------------------
-    public int getVaultSurvivorFastTicks() { return (int)(config.getDouble("window.vault-survivor-fast", 1.0) * 20); }
-    public int getVaultSurvivorSlowTicks() { return (int)(config.getDouble("window.vault-survivor-slow", 1.5) * 20); }
-    public int getVaultKillerTicks() { return (int)(config.getDouble("window.vault-killer", 1.5) * 20); }
-    public int getVaultBlockSeconds() { return config.getInt("window.vault-block-seconds", 15); }
-
     // -------------------------------------------------------------------------
     // Endgame
     // -------------------------------------------------------------------------
     public int getGateOpenSeconds() { return config.getInt("endgame.gate-open-seconds", 20); }
-    public int getCollapseSeconds() { return config.getInt("endgame.collapse-seconds", 120); }
     public int getChestOpenSeconds() { return config.getInt("endgame.chest-open-seconds", 3); }
     public double getGateInteractionRange() { return config.getDouble("endgame.gate-interaction-range", 3.0); }
 
@@ -248,5 +276,15 @@ public class GameConfig {
     public String getColorHealing() { return config.getString("scoreboard.color-healing", "GREEN"); }
     public String getColorHooked() { return config.getString("scoreboard.color-hooked", "DARK_RED"); }
 
+    // -------------------------------------------------------------------------
+    // Skill check
+    // -------------------------------------------------------------------------
+    public double getSkillCheckChance() { return config.getDouble("skillcheck.chance", 0.005); }
+    public double getSkillCheckWinPercent() { return config.getDouble("skillcheck.win-percent", 5.0); }
+    public double getSkillCheckLossPercent() { return config.getDouble("skillcheck.loss-percent", 10.0); }
+    public String getSkillCheckSuccessBlock() { return config.getString("skillcheck.success-block", "GREEN_STAINED_GLASS_PANE"); }
+    public String getSkillCheckFailBlock() { return config.getString("skillcheck.fail-block", "RED_STAINED_GLASS_PANE"); }
+    public String getSkillCheckNeutralBlock() { return config.getString("skillcheck.neutral-block", "GRAY_STAINED_GLASS_PANE"); }
+
     public FileConfiguration getConfig() { return config; }
 }

src/main/java/dev/loki/config/LocationsConfig.java

@@ -25,31 +25,27 @@ public class LocationsConfig {
             config.set("lobby.yaw", 0.0);
             config.set("lobby.pitch", 0.0);
         }
-        if (!config.contains("generators")) {
+        // Безопасная проверка: contains() может вернуть true для пустого списка,
+        // поэтому также проверяем что getList() не null
+        if (!config.contains("generators") || config.getList("generators") == null) {
             config.set("generators", new ArrayList<>());
         }
-        if (!config.contains("hooks")) {
+        if (!config.contains("hooks") || config.getList("hooks") == null) {
             config.set("hooks", new ArrayList<>());
         }
-        if (!config.contains("pallets")) {
+        if (!config.contains("windows") || config.getList("windows") == null) {
-            config.set("pallets", new ArrayList<>());
-        }
-        if (!config.contains("windows")) {
             config.set("windows", new ArrayList<>());
         }
-        if (!config.contains("chests")) {
+        if (!config.contains("chests") || config.getList("chests") == null) {
             config.set("chests", new ArrayList<>());
         }
-        if (!config.contains("totems")) {
+        if (!config.contains("exitgates") || config.getList("exitgates") == null) {
-            config.set("totems", new ArrayList<>());
-        }
-        if (!config.contains("exitgates")) {
             config.set("exitgates", new ArrayList<>());
         }
-        if (!config.contains("killer-spawn")) {
+        if (!config.contains("killer-spawn") || config.getList("killer-spawn") == null) {
             config.set("killer-spawn", new ArrayList<>());
         }
-        if (!config.contains("survivor-spawns")) {
+        if (!config.contains("survivor-spawns") || config.getList("survivor-spawns") == null) {
             config.set("survivor-spawns", new ArrayList<>());
         }
     }
@@ -84,10 +80,6 @@ public class LocationsConfig {
         return loadLocationList("hooks");
     }
 
-    public List<Location> getPallets() {
-        return loadLocationList("pallets");
-    }
-
     public List<Location> getWindows() {
         return loadLocationList("windows");
     }
@@ -100,8 +92,10 @@ public class LocationsConfig {
         return loadLocationList("totems");
     }
 
-    public List<Location> getExitGates() {
+    // getExitGates() — определён в addLocation/setGate блоке
-        return loadLocationList("exitgates");
+
+    public List<Location> getKillerSpawns() {
+        return loadLocationList("killer-spawn");
     }
 
     public Location getKillerSpawn() {
@@ -109,39 +103,35 @@ public class LocationsConfig {
         return spawns.isEmpty() ? null : spawns.get(0);
     }
 
-    public void setKillerSpawn(Location loc) {
-        // killer-spawn is a single location stored as a list with one entry
-        List<String> list = new java.util.ArrayList<>();
-        list.add(String.format("%s,%.2f,%.2f,%.2f,%.1f,%.1f",
-            loc.getWorld().getName(),
-            loc.getX(), loc.getY(), loc.getZ(),
-            loc.getYaw(), loc.getPitch()));
-        config.set("killer-spawn", list);
-    }
-
     public List<Location> getSurvivorSpawns() {
         return loadLocationList("survivor-spawns");
     }
 
     private List<Location> loadLocationList(String path) {
         List<Location> locations = new ArrayList<>();
-        List<?> list = config.getList(path);
+        List<String> list = safeGetStringList(path);
-        if (list == null) return locations;
+        if (list.isEmpty()) return locations;
 
-        for (Object obj : list) {
+        for (String s : list) {
-            if (obj instanceof String) {
+            Location loc = parseLocation(s);
-                Location loc = parseLocation((String) obj);
+            if (loc != null) locations.add(loc);
-                if (loc != null) locations.add(loc);
-            }
         }
         return locations;
     }
 
     private Location parseLocation(String str) {
-        String[] parts = str.split(",");
+        // Handle both old format (world,x,y,z,yaw,pitch) and new format (world|x|y|z|yaw|pitch)
+        // New format uses | as separator to avoid issues with negative coordinates
+        String[] parts = str.contains("|") ? str.split("\\|") : str.split(",");
+        
         if (parts.length < 4) return null;
         World world = Bukkit.getWorld(parts[0].trim());
-        if (world == null) return null;
+        if (world == null) {
+            // Try to find by first loaded world as fallback
+            var loadedWorld = Bukkit.getWorlds().stream().findFirst();
+            if (loadedWorld.isEmpty()) return null;
+            world = loadedWorld.get();
+        }
         try {
             double x = Double.parseDouble(parts[1].trim());
             double y = Double.parseDouble(parts[2].trim());
@@ -155,15 +145,106 @@ public class LocationsConfig {
     }
 
     public void addLocation(String path, Location loc) {
-        List<String> list = config.getStringList(path);
+        List<String> list = safeGetStringList(path);
-        list.add(String.format("%s,%.2f,%.2f,%.2f,%.1f,%.1f",
+        list.add(locationToString(loc));
+        config.set(path, list);
+    }
+
+    /**
+     * Sets a location at a specific index in the list.
+     * If the index is beyond the current list size, pads with empty strings.
+     */
+    public void setLocationAtIndex(String path, int index, Location loc) {
+        List<String> list = safeGetStringList(path);
+        while (list.size() <= index) {
+            list.add("");
+        }
+        list.set(index, locationToString(loc));
+        config.set(path, list);
+    }
+
+    /** Безопасная загрузка StringList: использует getList с fallback на toString(). */
+    private List<String> safeGetStringList(String path) {
+        List<String> result = new ArrayList<>();
+        List<?> raw = config.getList(path);
+        if (raw != null) {
+            for (Object obj : raw) {
+                if (obj instanceof String s) {
+                    result.add(s);
+                } else if (obj != null) {
+                    result.add(obj.toString());
+                }
+            }
+        }
+        return result;
+    }
+
+    /** Очистить список локаций (используется при загрузке карты). */
+    public void clearLocationList(String path) {
+        config.set(path, new ArrayList<>());
+    }
+    public void setSingleLocation(String path, Location loc) {
+        List<String> list = new ArrayList<>();
+        list.add(locationToString(loc));
+        config.set(path, list);
+    }
+
+    /** Устанавливает ворота A или B (хранятся как gate-a / gate-b). */
+    public void setGate(String id, Location loc) {
+        String key = "gate-" + id.toLowerCase();
+        config.set(key, locationToString(loc));
+    }
+
+    public Location getGate(String id) {
+        String key = "gate-" + id.toLowerCase();
+        String str = config.getString(key);
+        return str != null ? parseLocation(str) : null;
+    }
+
+    public List<Location> getExitGates() {
+        // Пробуем новый формат gate-a / gate-b
+        List<Location> gates = new ArrayList<>();
+        Location a = getGate("a");
+        Location b = getGate("b");
+        if (a != null) gates.add(a);
+        if (b != null) gates.add(b);
+        // Фолбэк: старый список exitgates
+        if (gates.isEmpty()) {
+            gates.addAll(loadLocationList("exitgates"));
+        }
+        return gates;
+    }
+
+    private String locationToString(Location loc) {
+        // Use | as separator instead of , to avoid issues with negative coordinates in YAML
+        return String.format("%s|%.2f|%.2f|%.2f|%.1f|%.1f",
             loc.getWorld().getName(),
             loc.getX(), loc.getY(), loc.getZ(),
-            loc.getYaw(), loc.getPitch()));
+            loc.getYaw(), loc.getPitch());
-        config.set(path, list);
     }
 
     public FileConfiguration getConfig() {
         return config;
     }
+
+    /**
+     * Reload locations from the given FileConfiguration (freshly loaded from disk).
+     * This clears any stale in-memory state and re-applies defaults.
+     */
+    /** Reload internal FileConfiguration reference (used after config reload from disk). */
+    public void reload(FileConfiguration newConfig) {
+        // Replace defaults on new config
+        if (!newConfig.contains("lobby")) {
+            newConfig.set("lobby.world", "world");
+            newConfig.set("lobby.x", 0.0);
+            newConfig.set("lobby.y", 100.0);
+            newConfig.set("lobby.z", 0.0);
+            newConfig.set("lobby.yaw", 0.0);
+            newConfig.set("lobby.pitch", 0.0);
+        }
+        // Copy all data from new config to current config
+        for (String key : newConfig.getKeys(true)) {
+            config.set(key, newConfig.get(key));
+        }
+    }
 }

src/main/java/dev/loki/config/MessagesConfig.java

@@ -49,10 +49,6 @@ public class MessagesConfig {
         setDefault("survivor.heal.complete", "&#00FF00Вылечено!");
         setDefault("survivor.heal.interrupt", "&#FFD700Лечение прервано!");
         setDefault("survivor.sprint.exhausted", "&#FF8C00Вы устали...");
-        setDefault("survivor.pallet.drop", "&#DEB887Вы бросили паллет!");
-        setDefault("survivor.pallet.stun", "&#FFD700Киллер оглушен!");
-        setDefault("survivor.vault.fast", "&#00CED1Быстрый прыжок!");
-        setDefault("survivor.vault.slow", "&#87CEEBМедленный прыжок...");
 
         // Hook messages
         setDefault("hook.stage1", "&#FFFF00Крюк: Фаза 1");
@@ -66,16 +62,11 @@ public class MessagesConfig {
         // Item messages
         setDefault("item.found", "&#FFD700Найдено: %s");
         setDefault("item.medkit.use", "&#00FA9AИспользуете аптечку...");
-        setDefault("item.flashlight.blind", "&#FFFF00Ослепили киллера!");
-        setDefault("item.key.hatch", "&#00CED1Ключ открывает люк!");
-        setDefault("item.map.reveal", "&#87CEEBОбъекты показаны на карте");
 
         // Endgame
         setDefault("endgame.gates.powered", "&#00FF00Ворота запитаны!");
         setDefault("endgame.gates.opening", "&#FFD700Открываете ворота...");
         setDefault("endgame.hatch.open", "&#4B0082Люк открыт!");
-        setDefault("endgame.collapse.warning", "&#FF0000⚠ КОЛЛАПС ЧЕРЕЗ %s СЕК!");
-        setDefault("endgame.collapse.start", "&#8B0000КОЛЛАПС НАЧАЛСЯ!");
         setDefault("endgame.escape", "&#00FF00✓ ПОБЕГ!");
 
         // Error messages

src/main/java/dev/loki/core/GameManager.java

@@ -11,68 +11,137 @@ import java.util.UUID;
 public class GameManager {
     private final mdbd plugin;
     private final Map<UUID, GameSession> playerSessions;
+    /** Named sessions created by LobbyRegistry */
+    private final Map<String, GameSession> namedSessions;
     private GameSession currentSession;
 
     public GameManager(mdbd plugin) {
         this.plugin = plugin;
         this.playerSessions = new HashMap<>();
+        this.namedSessions  = new HashMap<>();
     }
 
+    // -------------------------------------------------------------------------
+    // Default single-session API (used by /dbd join without a name)
+    // -------------------------------------------------------------------------
+
     public boolean createGame() {
-        if (currentSession != null) {
+        if (currentSession != null) return false;
-            return false;
-        }
         currentSession = new GameSession(plugin);
         currentSession.start();
         return true;
     }
 
     public boolean joinGame(Player player) {
-        if (currentSession == null) {
+        if (currentSession == null) return false;
-            return false;
+        return joinSession(player, currentSession);
-        }
+    }
-        if (playerSessions.containsKey(player.getUniqueId())) {
-            return false;
-        }
 
-        // Register the player in the session as a Survivor (role assigned later)
+    // -------------------------------------------------------------------------
-        Survivor survivor = new Survivor(player.getUniqueId());
+    // Named-session API (used by LobbyRegistry)
-        currentSession.addPlayer(survivor);
+    // -------------------------------------------------------------------------
 
-        playerSessions.put(player.getUniqueId(), currentSession);
+    /**
-        // Notify session that player joined (teleport to lobby etc)
+     * Create a new named GameSession and store it.
-        currentSession.notifyPlayerJoined(player);
+     * @return the new session, or null if name already taken
+     */
+    public GameSession createNamedGame(String name) {
+        String key = name.toLowerCase();
+        // Remove stale session if it exists (e.g. from previous server run)
+        GameSession old = namedSessions.get(key);
+        if (old != null) {
+            old.stop();
+            namedSessions.remove(key);
+        }
+        GameSession session = new GameSession(plugin);
+        session.start();
+        namedSessions.put(key, session);
+        // Also set as current session for backward-compat if none exists
+        if (currentSession == null) currentSession = session;
+        return session;
+    }
+
+    /**
+     * Join a specific session directly.
+     * @return true on success
+     */
+    public boolean joinSession(Player player, GameSession session) {
+        if (session == null) return false;
+        
+        UUID playerId = player.getUniqueId();
+        GameSession currentSession = playerSessions.get(playerId);
+        
+        // If player is already in this session, do nothing (success)
+        if (currentSession == session) return true;
+        
+        // If player is in a different session, leave it first
+        if (currentSession != null) {
+            // Remove from old session
+            currentSession.removePlayer(playerId);
+            playerSessions.remove(playerId);
+        }
+        
+        Survivor survivor = new Survivor(playerId);
+        session.addPlayer(survivor);
+        playerSessions.put(playerId, session);
+        session.notifyPlayerJoined(player);
         return true;
     }
 
+    /** Remove a named session (called when lobby is deleted). */
+    public void removeNamedGame(String name) {
+        GameSession gs = namedSessions.remove(name.toLowerCase());
+        if (gs != null) {
+            if (gs == currentSession) currentSession = null;
+            // Remove all players in this session from the player map
+            playerSessions.entrySet().removeIf(e -> e.getValue() == gs);
+            gs.stop();
+        }
+    }
+
+    public GameSession getNamedSession(String name) {
+        return namedSessions.get(name.toLowerCase());
+    }
+
+    // -------------------------------------------------------------------------
+    // Shared API
+    // -------------------------------------------------------------------------
+
     public boolean leaveGame(Player player) {
         GameSession session = playerSessions.remove(player.getUniqueId());
-        if (session != null) {
+        if (session == null) return false;
-            session.removePlayer(player.getUniqueId());
+        session.removePlayer(player.getUniqueId());
-            // Teleport after removing from session
+        plugin.getLobbyManager().teleportToLobby(player);
-            plugin.getLobbyManager().teleportToLobby(player);
+        return true;
-            return true;
-        }
-        return false;
     }
 
     public void endGame() {
         if (currentSession != null) {
+            // Remove current session players from map
+            playerSessions.entrySet().removeIf(e -> e.getValue() == currentSession);
             currentSession.stop();
             currentSession = null;
-            playerSessions.clear();
         }
     }
 
-    public GameSession getCurrentSession() {
+    public void endAll() {
-        return currentSession;
+        namedSessions.values().forEach(GameSession::stop);
+        namedSessions.clear();
+        if (currentSession != null) { currentSession.stop(); currentSession = null; }
+        playerSessions.clear();
     }
 
-    public boolean isInGame(UUID uuid) {
+    public GameSession getCurrentSession()             { return currentSession; }
-        return playerSessions.containsKey(uuid);
+    public boolean isInGame(UUID uuid)                 { return playerSessions.containsKey(uuid); }
-    }
+    public GameSession getPlayerSession(UUID uuid)     { return playerSessions.get(uuid); }
 
-    public GameSession getPlayerSession(UUID uuid) {
+    /**
-        return playerSessions.get(uuid);
+     * Returns all active GameSessions (both current and named).
+     */
+    public java.util.Collection<GameSession> getAllSessions() {
+        java.util.Set<GameSession> all = new java.util.HashSet<>();
+        if (currentSession != null) all.add(currentSession);
+        all.addAll(namedSessions.values());
+        return all;
     }
 }

src/main/java/dev/loki/core/GameSession.java

@@ -5,7 +5,6 @@ import dev.loki.gate.GateManager;
 import dev.loki.hook.HookManager;
 import dev.loki.mdbd;
 import dev.loki.objective.GeneratorManager;
-import dev.loki.pallet.PalletManager;
 import dev.loki.phase.EndgamePhase;
 import dev.loki.phase.GameplayPhase;
 import dev.loki.phase.LobbyPhase;
@@ -31,8 +30,8 @@ public class GameSession {
     private GeneratorManager generatorManager;
 
     private boolean forceStarted = false;
+    private Runnable onStopped; // callback для LobbyRegistry
 
-    private PalletManager palletManager;
     private HookManager hookManager;
     private GateManager gateManager;
 
@@ -59,10 +58,20 @@ public class GameSession {
         }
         if (currentPhase != null) {
             currentPhase.exit(this);
+            currentPhase = null;
         }
         players.clear();
         eventBus.clear();
         plugin.getLogger().info("Game session stopped");
+        if (onStopped != null) {
+            Runnable cb = onStopped;
+            onStopped = null; // предотвращаем повторный вызов
+            Bukkit.getScheduler().runTask(plugin, cb);
+        }
+    }
+
+    public void setOnStopped(Runnable callback) {
+        this.onStopped = callback;
     }
 
     private void tick() {
@@ -76,11 +85,19 @@ public class GameSession {
     }
 
     private void transitionToNextPhase() {
+        Phase oldPhase = currentPhase;
         Phase next = determineNextPhase();
         if (next != null) {
-            currentPhase.exit(this);
+            oldPhase.exit(this);
             currentPhase = next;
             currentPhase.enter(this);
+        } else {
+            // Терминальная фаза завершена — всегда выходим из текущей фазы перед остановкой
+            if (oldPhase != null) {
+                oldPhase.exit(this);
+                currentPhase = null;
+            }
+            stop();
         }
     }
 
@@ -93,11 +110,10 @@ public class GameSession {
         if (currentPhase instanceof RoleAssignPhase) {
             return new GameplayPhase(generatorManager);
         }
-        if (currentPhase instanceof GameplayPhase) {
+        if (currentPhase instanceof GameplayPhase gp) {
-            return new EndgamePhase(
+            // Всегда переходим в EndgamePhase для корректного завершения игры
-                plugin.getConfigManager().getGame().getCollapseSeconds(),
+            // (очистка скорборда, телепорт в лобби, показ результатов)
-                gateManager, null, null
+            return new EndgamePhase(gateManager, null, null);
-            );
         }
         return null;
     }
@@ -159,9 +175,6 @@ public class GameSession {
         return generatorManager;
     }
 
-    public PalletManager getPalletManager() { return palletManager; }
-    public void setPalletManager(PalletManager pm) { this.palletManager = pm; }
-
     public HookManager getHookManager() { return hookManager; }
     public void setHookManager(HookManager hm) { this.hookManager = hm; }
 
@@ -179,10 +192,23 @@ public class GameSession {
         return ticksElapsed;
     }
 
+    public String getPhaseName() {
+        if (currentPhase == null) return "None";
+        return currentPhase.getClass().getSimpleName();
+    }
+
     public GameEventBus getEventBus() {
         return eventBus;
     }
 
+    /**
+     * Refresh the config reference so the session uses the latest values from disk.
+     */
+    public void refreshConfig() {
+        // The config is fetched fresh each time from the ConfigManager,
+        // so no cached reference needs updating.
+    }
+
     public void notifyPlayerJoined(org.bukkit.entity.Player player) {
         if (currentPhase != null) {
             currentPhase.onPlayerJoined(this, player);

src/main/java/dev/loki/data/GeneratorDataManager.java

@@ -90,7 +90,8 @@ public class GeneratorDataManager {
     }
 
     public static String formatLocation(Location loc) {
-        return String.format("%s:%.0f,%.0f,%.0f",
+        // Use | as separator to handle negative coordinates properly
+        return String.format("%s:%.0f|%.0f|%.0f",
             loc.getWorld().getName(),
             loc.getX(),
             loc.getY(),
@@ -98,13 +99,14 @@ public class GeneratorDataManager {
     }
 
     private Location parseLocation(String str) {
+        // Format: "world:x|y|z" — using | as separator for coordinates to handle negative numbers
         String[] parts = str.split(":");
         if (parts.length < 2) return null;
 
         World world = Bukkit.getWorld(parts[0].trim());
         if (world == null) return null;
 
-        String[] coords = parts[1].split(",");
+        String[] coords = parts[1].split("\\|");
         if (coords.length < 3) return null;
 
         try {

src/main/java/dev/loki/gate/GateOpening.java

@@ -3,7 +3,9 @@ package dev.loki.gate;
 import dev.loki.config.GameConfig;
 import dev.loki.player.Survivor;
 import org.bukkit.Location;
+import org.bukkit.Particle;
 import org.bukkit.Sound;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;
 
@@ -79,10 +81,17 @@ public class GateOpening {
 
     private void completeOpening(Survivor survivor, ExitGate gate) {
         Player player = survivor.getPlayer();
+        Location loc = gate.getLocation();
+        World world = loc.getWorld();
+        
         if (player != null) {
             player.sendMessage("§aВорота открыты!");
-            player.getWorld().playSound(gate.getLocation(),
+            if (world != null) {
-                Sound.BLOCK_IRON_DOOR_OPEN, 1.0f, 1.0f);
+                world.playSound(loc, Sound.BLOCK_IRON_DOOR_OPEN, 1.0f, 1.0f);
+                // Big particle burst when opened
+                world.spawnParticle(Particle.EXPLOSION_EMITTER, loc.clone().add(0, 1, 0), 1);
+                world.spawnParticle(Particle.FLAME, loc.clone().add(0, 1.5, 0), 15, 2, 1, 2, 0.1);
+            }
         }
         gate.updateProgress(1.0);
         openingPlayers.remove(survivor.getUuid());
@@ -93,6 +102,17 @@ public class GateOpening {
             player.getWorld().playSound(gate.getLocation(),
                 Sound.BLOCK_METAL_HIT, 0.3f, 1.0f);
         }
+        
+        // Spawn particles around the gate
+        if (progress % 5 == 0) {
+            Location loc = gate.getLocation();
+            World world = loc.getWorld();
+            if (world != null) {
+                // Green particles for progress (using CRIT for visibility)
+                world.spawnParticle(Particle.CRIT, 
+                    loc.clone().add(0, 1, 0), 3, 0.5, 0.5, 0.5, 0.1);
+            }
+        }
     }
 
     private class OpeningProgress {

src/main/java/dev/loki/hook/Hook.java

@@ -52,6 +52,12 @@ public class Hook {
         stageProgress = 0;
     }
 
+    /** Force-advance to SACRIFICE stage immediately (used by HookRecovery on 3 fails). */
+    public void advanceToSacrifice() {
+        currentStage = HookStage.SACRIFICE;
+        stageProgress = 0;
+    }
+
     public double getStageProgressPercent() {
         if (currentStage == HookStage.SACRIFICE) return 100;
         int stageDuration = currentStage.getDurationSeconds() * 20;

src/main/java/dev/loki/hook/HookHologram.java

@@ -0,0 +1,141 @@
+package dev.loki.hook;
+
+import dev.loki.mdbd;
+import org.bukkit.Location;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Display;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.TextDisplay;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Floating labels above hooks showing their status.
+ * Uses TextDisplay (Paper 1.19.4+) with ArmorStand fallback for older versions.
+ */
+public class HookHologram {
+
+    private final mdbd plugin;
+    private final HookManager manager;
+    private final Map<UUID, Object> displays = new HashMap<>(); // TextDisplay or ArmorStand
+    private BukkitTask task;
+    private boolean useTextDisplay;
+
+    public HookHologram(mdbd plugin, HookManager manager) {
+        this.plugin = plugin;
+        this.manager = manager;
+        this.useTextDisplay = isTextDisplayAvailable();
+    }
+
+    private static boolean isTextDisplayAvailable() {
+        try {
+            EntityType.valueOf("TEXT_DISPLAY");
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public void start() {
+        stop();
+        spawnAll();
+        task = plugin.getServer().getScheduler().runTaskTimer(plugin, this::refresh, 20L, 20L);
+        plugin.getLogger().info("[HookHologram] Started with " + displays.size() + " holograms (mode=" + (useTextDisplay ? "TextDisplay" : "ArmorStand") + ")");
+    }
+
+    public void stop() {
+        if (task != null) {
+            task.cancel();
+            task = null;
+        }
+        for (Object display : displays.values()) {
+            if (display instanceof TextDisplay td && td.isValid()) {
+                td.remove();
+            } else if (display instanceof ArmorStand as && as.isValid()) {
+                as.remove();
+            }
+        }
+        displays.clear();
+    }
+
+    private void spawnAll() {
+        double heightOffset = plugin.getConfigManager().getGame().getHookHologramHeightOffset();
+        int index = 0;
+        for (Hook hook : manager.getAllHooks()) {
+            Location loc = hook.getLocation();
+            if (loc.getWorld() == null) {
+                plugin.getLogger().warning("[HookHologram] Hook " + hook.getId() + " has null world, skipping");
+                continue;
+            }
+
+            Location holoLoc = loc.clone().add(0.5, 2.5 + heightOffset, 0.5);
+            try {
+                if (useTextDisplay) {
+                    TextDisplay display = loc.getWorld().spawn(holoLoc, TextDisplay.class, d -> {
+                        d.setBillboard(Display.Billboard.VERTICAL);
+                        d.setSeeThrough(true);
+                        d.setShadowed(true);
+                        d.setDefaultBackground(false);
+                        d.setPersistent(false);
+                        d.setTextOpacity((byte) -1);
+                        d.setViewRange(128.0f);
+                    });
+                    displays.put(hook.getId(), display);
+                } else {
+                    ArmorStand stand = loc.getWorld().spawn(holoLoc, ArmorStand.class, as -> {
+                        as.setInvisible(true);
+                        as.setInvulnerable(true);
+                        as.setGravity(false);
+                        as.setMarker(true);
+                        as.setCustomNameVisible(true);
+                        as.setPersistent(false);
+                    });
+                    displays.put(hook.getId(), stand);
+                }
+            } catch (Exception e) {
+                plugin.getLogger().warning("[HookHologram] Failed to spawn hologram for hook " + hook.getId() + ": " + e.getMessage());
+            }
+            index++;
+        }
+    }
+
+    private void refresh() {
+        int total = manager.getAllHooks().size();
+        int visibleIndex = 0;
+        for (Hook hook : manager.getAllHooks()) {
+            Object display = displays.get(hook.getId());
+            if (display == null) continue;
+
+            boolean valid = (display instanceof TextDisplay td && td.isValid()) ||
+                          (display instanceof ArmorStand as && as.isValid());
+            if (!valid) continue;
+
+            String status;
+            if (hook.isDisabled()) {
+                status = "§c✂ Саботирован";
+            } else if (hook.isOccupied()) {
+                int pct = (int) hook.getStageProgressPercent();
+                status = "§4Занят [" + hook.getCurrentStage().name() + " " + pct + "%]";
+            } else {
+                status = "§aСвободен";
+            }
+
+            visibleIndex++;
+            String text = "§c⚓ Крюк §f#" + visibleIndex + "/" + total + "\n§7" + status;
+
+            double heightOffset = plugin.getConfigManager().getGame().getHookHologramHeightOffset();
+            Location base = hook.getLocation().clone().add(0.5, 2.5 + heightOffset, 0.5);
+
+            if (display instanceof TextDisplay td) {
+                td.text(net.kyori.adventure.text.Component.text(text));
+                td.teleport(base);
+            } else if (display instanceof ArmorStand as) {
+                as.setCustomName(text);
+                as.teleport(base);
+            }
+        }
+    }
+}

src/main/java/dev/loki/hook/HookManager.java

@@ -27,12 +27,18 @@ public class HookManager {
     public void loadHooks(LocationsConfig config) {
         hooks.clear();
         List<Location> hookLocations = config.getHooks();
+        plugin.getLogger().info("[HookManager] Loading " + hookLocations.size() + " hooks from config");
         for (int i = 0; i < hookLocations.size(); i++) {
             Location loc = hookLocations.get(i);
+            if (loc == null || loc.getWorld() == null) {
+                plugin.getLogger().warning("[HookManager] Hook #" + i + " has invalid location, skipping");
+                continue;
+            }
             boolean basement = i < 4;
             UUID id = UUID.nameUUIDFromBytes(("hook_" + i).getBytes());
             hooks.put(id, new Hook(id, loc, basement));
         }
+        plugin.getLogger().info("[HookManager] Loaded " + hooks.size() + " valid hooks");
     }
 
     public void startTicking() {
@@ -89,6 +95,10 @@ public class HookManager {
     }
 
     public boolean tryHookSurvivor(Survivor survivor, Location killerLoc) {
+        if (survivor.getState() != PlayerState.CARRIED) {
+            return false;
+        }
+
         // Проверяем лимит крюков → если превышен, сразу смерть
         if (survivor.getHooksTaken() >= maxHooks) {
             survivor.setState(PlayerState.DEAD);
@@ -101,12 +111,13 @@ public class HookManager {
             return true; // "повешен" = завершён
         }
 
-        Hook nearest = findNearestUnoccupiedHook(killerLoc, 3.0);
+        Hook nearest = findNearestUnoccupiedHook(killerLoc, 5.0);
         if (nearest == null) {
             nearest = findAvailableHook().orElse(null);
         }
         if (nearest != null) {
             nearest.hookSurvivor(survivor);
+            survivor.setState(PlayerState.HOOKED);  // Set state to HOOKED
             survivor.incrementHooks();
             return true;
         }

src/main/java/dev/loki/hook/HookRecovery.java

@@ -0,0 +1,161 @@
+package dev.loki.hook;
+
+import dev.loki.config.GameConfig;
+import dev.loki.player.PlayerState;
+import dev.loki.player.Survivor;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Stage 2 self-unhook mechanic.
+ * On Stage 2 the survivor can attempt to struggle free by holding Shift.
+ * Each attempt takes struggle-interval ticks. Success chance increases per attempt.
+ * 3 failed attempts = immediate SACRIFICE.
+ */
+public class HookRecovery {
+
+    private static final int BASE_CHANCE_PCT  = 4;  // % за первую попытку
+    private static final int CHANCE_STEP_PCT  = 2;  // +2% за каждую следующую
+    private static final int MAX_ATTEMPTS     = 3;  // провал после 3 попыток
+
+    private final Plugin plugin;
+    private final GameConfig config;
+
+    /** survivorUUID → active struggle attempt task */
+    private final Map<UUID, BukkitTask> activeTasks   = new HashMap<>();
+    /** survivorUUID → number of failed attempts */
+    private final Map<UUID, Integer>    failedAttempts = new HashMap<>();
+
+    public HookRecovery(Plugin plugin, GameConfig config) {
+        this.plugin = plugin;
+        this.config  = config;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+
+    /**
+     * Start a recovery attempt.
+     * Call when a STAGE_2-hooked survivor holds Shift near their hook.
+     * @return true if attempt started
+     */
+    public boolean startAttempt(Survivor survivor, Hook hook) {
+        UUID uuid = survivor.getUuid();
+        if (activeTasks.containsKey(uuid)) return false;
+        if (hook.getCurrentStage() != HookStage.STAGE_2) return false;
+        if (!hook.isOccupied() || !uuid.equals(hook.getHookedSurvivor().getUuid())) return false;
+
+        int durationTicks = config.getStruggleInterval() * 20;
+
+        BukkitTask task = new BukkitRunnable() {
+            int elapsed = 0;
+
+            @Override
+            public void run() {
+                Player p = survivor.getPlayer();
+                if (p == null || !p.isOnline() || !p.isSneaking()
+                        || hook.getCurrentStage() != HookStage.STAGE_2) {
+                    cancelAttempt(uuid);
+                    cancel();
+                    return;
+                }
+
+                elapsed++;
+                double pct = (double) elapsed / durationTicks * 100;
+                p.sendActionBar(Component.text("§6Попытка вырваться: " + (int) pct + "%"));
+
+                if (elapsed >= durationTicks) {
+                    resolveAttempt(survivor, hook);
+                    cancel();
+                }
+            }
+        }.runTaskTimer(plugin, 1L, 1L);
+
+        activeTasks.put(uuid, task);
+        Player p = survivor.getPlayer();
+        if (p != null) {
+            p.sendMessage(Component.text(
+                "[DBD] Держите Shift чтобы вырваться с крюка...", NamedTextColor.YELLOW));
+        }
+        return true;
+    }
+
+    /** Cancel active attempt (e.g. survivor released Shift). */
+    public void cancelAttempt(UUID survivorUuid) {
+        BukkitTask task = activeTasks.remove(survivorUuid);
+        if (task != null) {
+            task.cancel();
+            Player p = plugin.getServer().getPlayer(survivorUuid);
+            if (p != null && p.isOnline()) p.sendActionBar(Component.empty());
+        }
+    }
+
+    public boolean isAttempting(UUID uuid) {
+        return activeTasks.containsKey(uuid);
+    }
+
+    /** Reset counters when survivor is unhooked for any reason. */
+    public void onUnhooked(UUID survivorUuid) {
+        cancelAttempt(survivorUuid);
+        failedAttempts.remove(survivorUuid);
+    }
+
+    public void shutdown() {
+        activeTasks.values().forEach(BukkitTask::cancel);
+        activeTasks.clear();
+        failedAttempts.clear();
+    }
+
+    // -------------------------------------------------------------------------
+    // Private
+    // -------------------------------------------------------------------------
+
+    private void resolveAttempt(Survivor survivor, Hook hook) {
+        UUID uuid = survivor.getUuid();
+        activeTasks.remove(uuid);
+
+        int failures = failedAttempts.getOrDefault(uuid, 0);
+        int chance   = BASE_CHANCE_PCT + failures * CHANCE_STEP_PCT;
+
+        Player p = survivor.getPlayer();
+        if (Math.random() * 100 < chance) {
+            // Success — unhook
+            hook.unhookSurvivor();
+            survivor.setState(PlayerState.INJURED);
+            failedAttempts.remove(uuid);
+            if (p != null && p.isOnline()) {
+                p.sendActionBar(Component.empty());
+                p.sendMessage(Component.text("[DBD] Вы вырвались с крюка!", NamedTextColor.GREEN));
+            }
+        } else {
+            // Failure
+            int newFailures = failures + 1;
+            failedAttempts.put(uuid, newFailures);
+            if (p != null && p.isOnline()) {
+                p.sendActionBar(Component.empty());
+                p.sendMessage(Component.text(
+                    "[DBD] Попытка не удалась! (" + newFailures + "/" + MAX_ATTEMPTS + ")",
+                    NamedTextColor.RED));
+            }
+
+            if (newFailures >= MAX_ATTEMPTS) {
+                // Force sacrifice
+                hook.advanceToSacrifice();
+                failedAttempts.remove(uuid);
+                if (p != null && p.isOnline()) {
+                    p.sendMessage(Component.text(
+                        "[DBD] Сущность поглотила вас!", NamedTextColor.DARK_RED));
+                }
+            }
+        }
+    }
+}

src/main/java/dev/loki/hook/HookRescue.java

@@ -27,6 +27,8 @@ public class HookRescue {
     private final ActionBar actionBar;
     private final GameConfig config;
     private final Map<UUID, RescueSession> activeRescues = new HashMap<>();
+    /** Called when rescue succeeds: (rescuer, victim) */
+    private java.util.function.BiConsumer<Survivor, Survivor> onRescueComplete;
 
     public HookRescue(mdbd plugin, ActionBar actionBar, GameConfig config) {
         this.plugin     = plugin;
@@ -118,6 +120,10 @@ public class HookRescue {
             rescuerPlayer.sendActionBar(Component.text("[DBD] Союзник спасён!", NamedTextColor.GREEN));
             rescuerPlayer.sendMessage(Component.text("[DBD] Спасение завершено!", NamedTextColor.GREEN));
         }
+
+        if (onRescueComplete != null && victim != null) {
+            onRescueComplete.accept(rescuer, victim);
+        }
     }
 
     public void cancelRescue(UUID uuid) {
@@ -134,6 +140,10 @@ public class HookRescue {
 
     public boolean isRescuing(UUID uuid) { return activeRescues.containsKey(uuid); }
 
+    public void setOnRescueComplete(java.util.function.BiConsumer<Survivor, Survivor> cb) {
+        this.onRescueComplete = cb;
+    }
+
     public void clear() {
         for (RescueSession session : activeRescues.values()) session.cancel();
         activeRescues.clear();

src/main/java/dev/loki/item/ChestLoot.java

@@ -5,20 +5,56 @@ import org.bukkit.inventory.ItemStack;
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
+/**
+ * Генератор случайного лута для сундуков.
+ * Может выдать: Медкит (разное количество зарядов), Набор для срезания.
+ */
 public class ChestLoot {
 
     private final Random random;
 
-    public ChestLoot() {
+    // Веса для разных типов лута (из конфига game.yml: loot.*)
+    private final int medkitWeight;
+    private final int medkitMinCharges;
+    private final int medkitMaxCharges;
+    private final int hookCutterWeight;
+
+    /** Config-aware constructor. */
+    public ChestLoot(dev.loki.config.GameConfig config) {
         this.random = ThreadLocalRandom.current();
+        var cfg = config.getConfig();
+        this.medkitWeight          = cfg.getInt("loot.medkit.weight",          60);
+        this.medkitMinCharges      = cfg.getInt("loot.medkit.min-charges",     12);
+        this.medkitMaxCharges      = cfg.getInt("loot.medkit.max-charges",     16);
+        this.hookCutterWeight      = cfg.getInt("loot.hook-cutter.weight",     40);
     }
 
-    /** 55% медкит, 45% фонарик. Заряды чуть рандомные. */
+    /** Fallback — hardcoded defaults. */
+    public ChestLoot() {
+        this.random               = ThreadLocalRandom.current();
+        this.medkitWeight         = 60;
+        this.medkitMinCharges     = 12;
+        this.medkitMaxCharges     = 16;
+        this.hookCutterWeight     = 40;
+    }
+
+    /**
+     * Бросает кубик и возвращает случайный предмет.
+     * Никогда не возвращает null.
+     */
     public ItemStack rollLoot() {
-        if (random.nextInt(100) < 55) {
+        int total = medkitWeight + hookCutterWeight;
-            return DBDItems.medkit(12 + random.nextInt(5));
+        if (total <= 0) {
+            return DBDItems.medkit(12);
+        }
+
+        int roll = random.nextInt(total);
+
+        if (roll < medkitWeight) {
+            int charges = medkitMinCharges + random.nextInt(Math.max(1, medkitMaxCharges - medkitMinCharges + 1));
+            return DBDItems.medkit(charges);
         } else {
-            return DBDItems.flashlight(6 + random.nextInt(3));
+            return DBDItems.hookCutter();
         }
     }
 }

src/main/java/dev/loki/item/DBDItems.java

@@ -10,7 +10,7 @@ import org.bukkit.persistence.PersistentDataType;
 import java.util.List;
 
 /**
- * Central factory for DBD custom items: Medkit and Flashlight.
+ * Central factory for DBD custom items: Medkit.
  * Items are identified by PersistentDataContainer tag "mdbd:item_type".
  * Charges are stored as "mdbd:charges".
  */
@@ -19,6 +19,17 @@ public final class DBDItems {
     public static final NamespacedKey KEY_TYPE    = new NamespacedKey("mdbd", "item_type");
     public static final NamespacedKey KEY_CHARGES = new NamespacedKey("mdbd", "charges");
 
+    // Custom Model Data IDs (соответствуют ресурспаку)
+    // Переопределяются через game.yml: items.model-data.medkit / hookcutter
+    private static int CMD_MEDKIT     = 1001;
+    private static int CMD_HOOKCUTTER = 1003;
+
+    /** Вызывать при загрузке плагина / reload, чтобы подхватить значения из конфига. */
+    public static void loadModelData(org.bukkit.configuration.file.FileConfiguration cfg) {
+        CMD_MEDKIT     = cfg.getInt("items.model-data.medkit",     1001);
+        CMD_HOOKCUTTER = cfg.getInt("items.model-data.hookcutter", 1003);
+    }
+
     private DBDItems() {}
 
     // ── Factories ─────────────────────────────────────────────────────────────
@@ -26,7 +37,7 @@ public final class DBDItems {
     /** Медкит — лечит одно состояние здоровья. */
     public static ItemStack medkit(int charges) {
         return build(
-            Material.PAPER,
+            Material.PAPER, CMD_MEDKIT,
             "<#00FF7F>Медкит",
             charges, ItemType.MEDKIT.getDefaultCharges(),
             List.of(
@@ -39,25 +50,25 @@ public final class DBDItems {
 
     public static ItemStack medkit() { return medkit(ItemType.MEDKIT.getDefaultCharges()); }
 
-    /** Фонарик — ослепляет киллера при попадании. */
+    /** Набор для срезания — снимает выжившего с крюка, киллер не может вешать 30 сек. */
-    public static ItemStack flashlight(int charges) {
+    public static ItemStack hookCutter() {
         return build(
-            Material.TORCH,
+            Material.SHEARS, CMD_HOOKCUTTER,
-            "<#FFD700>Фонарик",
+            "<#FF6B6B>Набор для срезания",
-            charges, ItemType.FLASHLIGHT.getDefaultCharges(),
+            1, 1,
             List.of(
-                "<gray>Ослепляет киллера при попадании.",
+                "<gray>Срезает выжившего с крюка.",
-                "<yellow>ПКМ <gray>— направить луч на киллера"
+                "<yellow>ПКМ <gray>— срезать выжившего с крюка",
+                "<dark_red>Киллер не сможет вешать на крюк 30 сек"
             ),
-            "FLASHLIGHT"
+            "HOOK_CUTTER"
         );
     }
 
-    public static ItemStack flashlight() { return flashlight(ItemType.FLASHLIGHT.getDefaultCharges()); }
-
     // ── Helpers ───────────────────────────────────────────────────────────────
 
-    private static ItemStack build(Material mat, String name, int charges, int maxCharges,
+    private static ItemStack build(Material mat, int customModelData, String name,
+                                   int charges, int maxCharges,
                                    List<String> loreLines, String typeId) {
         var item = new ItemStack(mat);
         item.editMeta(meta -> {
@@ -71,6 +82,11 @@ public final class DBDItems {
             lore.add(TextUtil.color(chargesBar(charges, maxCharges)));
             meta.lore(lore);
 
+            // Custom Model Data для ресурспака (0 = не задан)
+            if (customModelData > 0) {
+                meta.setCustomModelData(customModelData);
+            }
+
             meta.getPersistentDataContainer().set(KEY_TYPE, PersistentDataType.STRING, typeId);
             meta.getPersistentDataContainer().set(KEY_CHARGES, PersistentDataType.INTEGER, charges);
         });
@@ -105,12 +121,11 @@ public final class DBDItems {
         if (type == null) return item;
         return switch (type) {
             case "MEDKIT"     -> medkit(newCharges);
-            case "FLASHLIGHT" -> flashlight(newCharges);
             default -> item;
         };
     }
 
     public static boolean isMedkit(ItemStack item)     { return "MEDKIT".equals(getType(item)); }
-    public static boolean isFlashlight(ItemStack item) { return "FLASHLIGHT".equals(getType(item)); }
+    public static boolean isHookCutter(ItemStack item) { return "HOOK_CUTTER".equals(getType(item)); }
     public static boolean isDBDItem(ItemStack item)    { return getType(item) != null; }
 }

src/main/java/dev/loki/item/ItemFlashlight.java

@@ -1,96 +0,0 @@
-package dev.loki.item;
-
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataContainer;
-import org.bukkit.persistence.PersistentDataType;
-
-import java.util.Arrays;
-
-public class ItemFlashlight implements BaseItem {
-
-    private static final NamespacedKey ITEM_KEY = new NamespacedKey("mdbd", "item_type");
-    private static final NamespacedKey CHARGES_KEY = new NamespacedKey("mdbd", "charges");
-
-    private final int charges;
-
-    public ItemFlashlight() {
-        this(ItemType.FLASHLIGHT.getDefaultCharges());
-    }
-
-    public ItemFlashlight(int charges) {
-        this.charges = charges;
-    }
-
-    @Override
-    public ItemType getType() {
-        return ItemType.FLASHLIGHT;
-    }
-
-    @Override
-    public ItemStack createItemStack() {
-        ItemStack item = new ItemStack(Material.TORCH);
-        ItemMeta meta = item.getItemMeta();
-        if (meta != null) {
-            meta.setDisplayName("§e" + getType().getDisplayName());
-            meta.setLore(Arrays.asList(
-                "§7" + getType().getDescription(),
-                "§eCharges: §f" + charges + "/" + getType().getDefaultCharges(),
-                "§7Aim at Killer and click to blind"
-            ));
-
-            PersistentDataContainer pdc = meta.getPersistentDataContainer();
-            pdc.set(ITEM_KEY, PersistentDataType.STRING, getItemId());
-            pdc.set(CHARGES_KEY, PersistentDataType.INTEGER, charges);
-
-            item.setItemMeta(meta);
-        }
-        return item;
-    }
-
-    @Override
-    public boolean canUse(Player player) {
-        return charges > 0;
-    }
-
-    @Override
-    public void onUse(Player player) {
-        if (charges > 0) {
-            player.sendMessage("§eYou flash your flashlight!");
-        }
-    }
-
-    @Override
-    public void onDeplete(Player player) {
-        player.getInventory().setItemInMainHand(null);
-        player.sendMessage("§cYour flashlight batteries died!");
-    }
-
-    @Override
-    public int getCharges() {
-        return charges;
-    }
-
-    @Override
-    public void setCharges(int charges) {
-    }
-
-    @Override
-    public boolean isDepleted() {
-        return charges <= 0;
-    }
-
-    @Override
-    public String getItemId() {
-        return "FLASHLIGHT";
-    }
-
-    public static boolean isFlashlight(ItemStack item) {
-        if (item == null || !item.hasItemMeta()) return false;
-        PersistentDataContainer pdc = item.getItemMeta().getPersistentDataContainer();
-        return "FLASHLIGHT".equals(pdc.get(ITEM_KEY, PersistentDataType.STRING));
-    }
-}

src/main/java/dev/loki/item/ItemType.java

@@ -2,7 +2,7 @@ package dev.loki.item;
 
 public enum ItemType {
     MEDKIT("Medkit", "Heals one health state", 16),
-    FLASHLIGHT("Flashlight", "Blinds the Killer", 8);
+    HOOK_CUTTER("Hook Cutter", "Cuts a survivor off a hook", 1);
 
     private final String displayName;
     private final String description;

src/main/java/dev/loki/item/ItemUseListener.java

@@ -6,6 +6,7 @@ import dev.loki.player.PlayerState;
 import dev.loki.player.Survivor;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Location;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -17,8 +18,6 @@ import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.Plugin;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
 import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.scheduler.BukkitTask;
 
@@ -27,7 +26,7 @@ import java.util.Map;
 import java.util.UUID;
 
 /**
- * Handles right-click usage of DBD custom items (Medkit, Flashlight) during gameplay.
+ * Handles right-click usage of DBD custom items (Medkit) during gameplay.
  */
 public class ItemUseListener implements Listener {
 
@@ -71,9 +70,13 @@ public class ItemUseListener implements Listener {
 
         String type = DBDItems.getType(hand);
         if ("MEDKIT".equals(type)) {
+            // Медкит: нужен Shift (sneaking) + стоять на месте
+            if (!player.isSneaking()) {
+                player.sendMessage(Component.text(
+                    "[DBD] Зажмите Shift и стойте на месте для лечения.", NamedTextColor.YELLOW));
+                return;
+            }
             useMedkit(player, (Survivor) bp, hand);
-        } else if ("FLASHLIGHT".equals(type)) {
-            useFlashlight(player, hand);
         }
     }
 
@@ -82,32 +85,46 @@ public class ItemUseListener implements Listener {
     private void useMedkit(Player player, Survivor survivor, ItemStack item) {
         UUID uuid = player.getUniqueId();
 
-        // Повторный ПКМ — отмена лечения
+        // Повторный Shift+ПКМ — отмена лечения
         if (activeHeals.containsKey(uuid)) {
             cancelHeal(player);
             return;
         }
 
         if (survivor.getState() != PlayerState.INJURED) {
-            player.sendMessage(Component.text("Вы не ранены!", NamedTextColor.RED));
+            player.sendMessage(Component.text("[DBD] Вы не ранены!", NamedTextColor.RED));
             return;
         }
 
         int charges = DBDItems.getCharges(item);
         if (charges <= 0) {
-            player.sendMessage(Component.text("Медкит пуст!", NamedTextColor.RED));
+            player.sendMessage(Component.text("[DBD] Медкит пуст!", NamedTextColor.RED));
+            player.getInventory().setItemInMainHand(null);
             return;
         }
 
-        player.sendMessage(Component.text("Начинаете самолечение...", NamedTextColor.GREEN));
+        player.sendMessage(Component.text("[DBD] Самолечение... держите Shift и не двигайтесь.", NamedTextColor.GREEN));
+
+        // Запоминаем позицию для проверки движения
+        final Location startLoc = player.getLocation().clone();
 
         BukkitTask task = new BukkitRunnable() {
             int ticks = 0;
-            final int startCharges = charges;
+            final int healTicks = MEDKIT_TICKS;
 
             @Override
             public void run() {
-                if (!player.isOnline() || survivor.getState() != PlayerState.INJURED) {
+                if (!player.isOnline()) { cancelHeal(player); cancel(); return; }
+                if (survivor.getState() != PlayerState.INJURED) { cancelHeal(player); cancel(); return; }
+
+                // Прерывание при движении или отпускании Shift
+                if (!player.isSneaking()) {
+                    cancelHeal(player);
+                    cancel();
+                    return;
+                }
+                // Проверка движения (больше 0.5 блока от старта)
+                if (player.getLocation().distanceSquared(startLoc) > 0.25) {
                     cancelHeal(player);
                     cancel();
                     return;
@@ -116,38 +133,24 @@ public class ItemUseListener implements Listener {
                 ticks++;
 
                 // Прогресс в action bar
-                int filled = (int) (8.0 * ticks / MEDKIT_TICKS);
+                int filled = (int) (8.0 * ticks / healTicks);
-                int empty = 8 - filled;
+                int empty  = 8 - filled;
-                int pct = (int) (100.0 * ticks / MEDKIT_TICKS);
+                int pct    = (int) (100.0 * ticks / healTicks);
                 player.sendActionBar(Component.text(
                     "⚕ " + "█".repeat(filled) + "░".repeat(empty) + " " + pct + "%",
                     NamedTextColor.GREEN));
 
-                // Звук каждые 20 тиков
                 if (ticks % 20 == 0) {
                     player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_HURT, 0.15f, 1.8f);
-                    // Обновляем заряды на предмете
-                    int usedCharges = (int)(1.0 * ticks / MEDKIT_TICKS * startCharges);
-                    int remaining = Math.max(1, startCharges - usedCharges);
-                    player.getInventory().setItemInMainHand(DBDItems.setCharges(
-                        player.getInventory().getItemInMainHand(), remaining));
                 }
 
-                if (ticks >= MEDKIT_TICKS) {
+                if (ticks >= healTicks) {
                     survivor.setState(PlayerState.HEALTHY);
-                    player.sendMessage(Component.text("✔ Вы вылечились!", NamedTextColor.GREEN));
+                    player.sendMessage(Component.text("[DBD] ✔ Вы вылечились!", NamedTextColor.GREEN));
                     player.sendActionBar(Component.empty());
                     player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.6f, 1.5f);
-
+                    // Полностью убираем медкит (один раз использован)
-                    // Тратим заряды
+                    player.getInventory().setItemInMainHand(null);
-                    int remaining = startCharges - 8;
-                    if (remaining <= 0) {
-                        player.getInventory().setItemInMainHand(null);
-                        player.sendMessage(Component.text("Медкит израсходован.", NamedTextColor.RED));
-                    } else {
-                        player.getInventory().setItemInMainHand(DBDItems.medkit(remaining));
-                    }
-
                     activeHeals.remove(uuid);
                     cancel();
                 }
@@ -166,49 +169,4 @@ public class ItemUseListener implements Listener {
         }
     }
 
-    // ── Фонарик ───────────────────────────────────────────────────────────────
-
-    private void useFlashlight(Player player, ItemStack item) {
-        int charges = DBDItems.getCharges(item);
-        if (charges <= 0) {
-            player.sendMessage(Component.text("Батарейки сели!", NamedTextColor.RED));
-            return;
-        }
-
-        // Луч 15 блоков
-        var result = player.getWorld().rayTraceEntities(
-            player.getEyeLocation(),
-            player.getEyeLocation().getDirection(),
-            15.0,
-            e -> e instanceof Player && !e.equals(player)
-        );
-
-        boolean hitKiller = false;
-        if (result != null && result.getHitEntity() instanceof Player target) {
-            BasePlayer bp = session.getPlayer(target.getUniqueId());
-            if (bp != null && bp.isKiller()) {
-                target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 60, 1, false, false));
-                target.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, 50, 2, false, false));
-                target.playSound(target.getLocation(), Sound.ENTITY_BLAZE_HURT, 1.0f, 0.5f);
-                target.sendMessage(Component.text("☀ Вас ослепили фонариком!", NamedTextColor.YELLOW));
-                player.sendMessage(Component.text("✔ Ослепили киллера!", NamedTextColor.YELLOW));
-                hitKiller = true;
-            }
-        }
-
-        if (!hitKiller) {
-            player.sendMessage(Component.text("Мимо...", NamedTextColor.GRAY));
-        }
-
-        // 1 заряд за использование
-        int remaining = charges - 1;
-        if (remaining <= 0) {
-            player.getInventory().setItemInMainHand(null);
-            player.sendMessage(Component.text("Фонарик разрядился.", NamedTextColor.RED));
-        } else {
-            player.getInventory().setItemInMainHand(DBDItems.flashlight(remaining));
-        }
-
-        player.playSound(player.getLocation(), Sound.BLOCK_REDSTONE_TORCH_BURNOUT, 0.3f, 1.5f);
-    }
 }

src/main/java/dev/loki/killer/GeneratorKick.java

@@ -135,12 +135,13 @@ public class GeneratorKick {
     private void executeKick(Killer killer, Generator gen) {
         chargingTasks.remove(killer.getUuid());
 
-        // Remove progress
+        // Remove 20% progress (or configured percent) and STOP — no continuous regression
         double regPct = config.getKickRegressionPercent();
         double current = gen.getProgress();
         double newProg  = Math.max(0, current - regPct);
         gen.setProgress(newProg);
-        gen.setUnderRegression(true, config.getKickDuration() * 20);
+        // Block generator from repair for the cooldown duration
+        gen.setBlocked(true);
 
         Player p = killer.getPlayer();
         if (p != null && p.isOnline()) {
@@ -149,10 +150,16 @@ public class GeneratorKick {
             p.getWorld().playSound(p.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.6f, 1.3f);
         }
 
-        // Notify all players nearby
+        // Notify all players
-        Bukkit.broadcast(Component.text("[DBD] ⚡ Маньяк разрушил генератор!", NamedTextColor.DARK_RED));
+        Bukkit.broadcast(Component.text("[DBD] ⚡ Маньяк разрушил генератор! -" + (int)regPct + "%", NamedTextColor.DARK_RED));
 
-        // Start global cooldown
+        // Unblock generator after kick-duration (separate from global cooldown)
+        int unblockTicks = config.getKickDuration() * 20;
+        plugin.getServer().getScheduler().runTaskLater(plugin, () -> {
+            gen.setBlocked(false);
+        }, unblockTicks);
+
+        // Start global kick cooldown
         startGlobalCooldown();
     }
 

src/main/java/dev/loki/killer/KillerAttack.java

@@ -19,7 +19,8 @@ public class KillerAttack {
     private final PlayerManager playerManager;
     private final DamageHandler damageHandler;
     private final GameConfig config;
-    private final Map<UUID, Long> cooldowns;
+    private final Map<UUID, Long> cooldowns;         // swing cooldown (attack-cooldown)
+    private final Map<UUID, Long> postHitCooldowns;  // post-hit cooldown after landing a hit
     private BukkitTask cleanupTask;
 
     public KillerAttack(Plugin plugin, PlayerManager playerManager,
@@ -29,6 +30,7 @@ public class KillerAttack {
         this.damageHandler = damageHandler;
         this.config = config;
         this.cooldowns = new HashMap<>();
+        this.postHitCooldowns = new HashMap<>();
         startCleanupTask();
     }
 
@@ -51,34 +53,57 @@ public class KillerAttack {
             return false;
         }
 
+        // Apply both swing cooldown and post-hit cooldown
         applyCooldown(killer);
+        applyPostHitCooldown(killer);
         playAttackEffects(killerPlayer, targetPlayer);
 
         return true;
     }
 
     public boolean canAttack(Killer killer) {
-        Long lastAttack = cooldowns.get(killer.getUuid());
-        if (lastAttack == null) return true;
-
-        int cooldownTicks = config.getAttackCooldown();
         long currentTick = Bukkit.getCurrentTick();
-        return currentTick - lastAttack >= cooldownTicks;
+
+        // Check swing cooldown
+        Long lastSwing = cooldowns.get(killer.getUuid());
+        if (lastSwing != null && currentTick - lastSwing < config.getAttackCooldown()) {
+            return false;
+        }
+
+        // Check post-hit cooldown
+        Long lastHit = postHitCooldowns.get(killer.getUuid());
+        if (lastHit != null && currentTick - lastHit < config.getPostHitCooldown()) {
+            return false;
+        }
+
+        return true;
     }
 
     private void applyCooldown(Killer killer) {
         cooldowns.put(killer.getUuid(), (long) Bukkit.getCurrentTick());
     }
 
+    private void applyPostHitCooldown(Killer killer) {
+        postHitCooldowns.put(killer.getUuid(), (long) Bukkit.getCurrentTick());
+    }
+
     public double getCooldownProgress(Killer killer) {
-        Long lastAttack = cooldowns.get(killer.getUuid());
-        if (lastAttack == null) return 1.0;
-
-        int cooldownTicks = config.getAttackCooldown();
         long currentTick = Bukkit.getCurrentTick();
-        long elapsed = currentTick - lastAttack;
 
-        return Math.min(1.0, (double) elapsed / cooldownTicks);
+        // Return progress of whichever cooldown is longer
+        Long lastSwing = cooldowns.get(killer.getUuid());
+        Long lastHit   = postHitCooldowns.get(killer.getUuid());
+
+        long swingElapsed  = (lastSwing != null) ? currentTick - lastSwing : Integer.MAX_VALUE;
+        long hitElapsed    = (lastHit   != null) ? currentTick - lastHit   : Integer.MAX_VALUE;
+
+        int swingTicks = config.getAttackCooldown();
+        int hitTicks   = config.getPostHitCooldown();
+
+        double swingProgress = (lastSwing != null) ? Math.min(1.0, (double) swingElapsed / swingTicks) : 1.0;
+        double hitProgress   = (lastHit   != null) ? Math.min(1.0, (double) hitElapsed   / hitTicks)   : 1.0;
+
+        return Math.min(swingProgress, hitProgress);
     }
 
     public boolean isOnCooldown(Killer killer) {
@@ -112,8 +137,10 @@ public class KillerAttack {
     private void startCleanupTask() {
         cleanupTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> {
             long currentTick = Bukkit.getCurrentTick();
-            int cooldownTicks = config.getAttackCooldown();
+            int swingTicks = config.getAttackCooldown();
-            cooldowns.entrySet().removeIf(e -> currentTick - e.getValue() > cooldownTicks * 2);
+            int hitTicks   = config.getPostHitCooldown();
+            cooldowns.entrySet().removeIf(e -> currentTick - e.getValue() > swingTicks * 2);
+            postHitCooldowns.entrySet().removeIf(e -> currentTick - e.getValue() > hitTicks * 2);
         }, 1200L, 1200L);
     }
 
@@ -122,5 +149,6 @@ public class KillerAttack {
             cleanupTask.cancel();
         }
         cooldowns.clear();
+        postHitCooldowns.clear();
     }
-}
+}

src/main/java/dev/loki/killer/KillerCarry.java

@@ -8,6 +8,7 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.potion.PotionEffect;
@@ -21,9 +22,10 @@ import java.util.UUID;
 /**
  * Manages the Killer carrying a downed Survivor.
  *
- * Escape mechanic: Survivor spams SPACE (jump) to fill the escape bar.
+ * Survivor sits ON THE KILLER'S HEAD as a passenger.
- * When the bar reaches 100% the Survivor breaks free, is teleported
+ * Escape mechanic: Survivor spams SHIFT to escape.
- * slightly forward and receives Speed I for carry.escape-speed-seconds.
+ * Each shift press ejects survivor briefly, then re-mounts.
+ * After N presses (default 50, configurable), survivor breaks free permanently.
  */
 public class KillerCarry {
     private final Plugin plugin;
@@ -31,18 +33,16 @@ public class KillerCarry {
     private final Map<UUID, CarryData> activeCarries = new HashMap<>();
     private BukkitTask carryTask;
 
-    // Separate map: killerUUID -> carried survivor UUID (for jump listener)
+    /** survivor UUID → shift press count */
-    private final Map<UUID, UUID> killerToSurvivor = new HashMap<>();
+    private final Map<UUID, Integer> shiftPressCounts = new HashMap<>();
 
     private static class CarryData {
         final Killer killer;
         final Survivor survivor;
-        double wiggleProgress; // 0..100
 
         CarryData(Killer killer, Survivor survivor) {
-            this.killer   = killer;
+            this.killer = killer;
             this.survivor = survivor;
-            this.wiggleProgress = 0;
         }
     }
 
@@ -51,26 +51,46 @@ public class KillerCarry {
         this.config = config;
     }
 
-    // -------------------------------------------------------------------------
+    /**
-    // Called by PlayerJumpListener when a survivor jumps
+     * Called when a carried survivor presses Shift.
-    // -------------------------------------------------------------------------
+     * Each press counts toward escape. Survivor is briefly ejected then re-mounted.
-    public void onSurvivorJump(UUID survivorUuid) {
+     */
-        for (CarryData data : activeCarries.values()) {
+    public void onSurvivorShift(UUID survivorUuid) {
-            if (data.survivor.getUuid().equals(survivorUuid)) {
+        CarryData data = findCarryBySurvivor(survivorUuid);
-                data.wiggleProgress += config.getCarryJumpFillPercent();
+        if (data == null) return;
-                showWiggleProgress(data);
+
-                if (data.wiggleProgress >= 100) {
+        int presses = shiftPressCounts.merge(survivorUuid, 1, Integer::sum);
-                    Bukkit.getScheduler().runTask(plugin, () -> forceDrop(data.killer));
+        int requiredPresses = config.getCarryEscapePresses();
-                }
+
-                return;
+        Player kp = data.killer.getPlayer();
+        Player sp = data.survivor.getPlayer();
+        if (kp != null && sp != null && sp.isOnline()) {
+            // Eject survivor briefly
+            kp.removePassenger(sp);
+
+            // Visual + sound feedback
+            sp.playSound(sp.getLocation(), Sound.ENTITY_PLAYER_ATTACK_SWEEP, 0.3f, 2.0f);
+
+            int remaining = Math.max(0, requiredPresses - presses);
+            sp.sendActionBar(Component.text(
+                "§6Вырываетесь: §e" + presses + "/" + requiredPresses + " §7(Shift) §cОсталось: " + remaining)
+                .color(NamedTextColor.YELLOW));
+
+            if (presses >= requiredPresses) {
+                // Permanent escape!
+                shiftPressCounts.remove(survivorUuid);
+                forceDrop(data.killer);
+            } else {
+                // Re-mount after 3 ticks (visual: "falls off then gets back on")
+                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    if (isCarrying(data.killer) && sp.isOnline() && kp.isOnline()) {
+                        kp.addPassenger(sp);
+                    }
+                }, 3L);
             }
         }
     }
 
-    // -------------------------------------------------------------------------
-    // Public API
-    // -------------------------------------------------------------------------
-
     public boolean tryPickup(Killer killer, Survivor survivor) {
         if (!canPickup(killer, survivor)) return false;
 
@@ -93,16 +113,16 @@ public class KillerCarry {
 
     public boolean drop(Killer killer) {
         CarryData data = activeCarries.remove(killer.getUuid());
-        killerToSurvivor.remove(killer.getUuid());
         if (data == null) return false;
+        shiftPressCounts.remove(data.survivor.getUuid());
         stopCarry(data, false);
         return true;
     }
 
     public void forceDrop(Killer killer) {
         CarryData data = activeCarries.remove(killer.getUuid());
-        killerToSurvivor.remove(killer.getUuid());
         if (data == null) return;
+        shiftPressCounts.remove(data.survivor.getUuid());
         stopCarry(data, true);
     }
 
@@ -115,9 +135,8 @@ public class KillerCarry {
         return data != null ? data.survivor : null;
     }
 
-    public double getWiggleProgress(Killer killer) {
+    public int getShiftPresses(Survivor survivor) {
-        CarryData data = activeCarries.get(killer.getUuid());
+        return shiftPressCounts.getOrDefault(survivor.getUuid(), 0);
-        return data != null ? data.wiggleProgress : 0;
     }
 
     public void shutdown() {
@@ -126,27 +145,40 @@ public class KillerCarry {
             stopCarry(data, false);
         }
         activeCarries.clear();
-        killerToSurvivor.clear();
+        shiftPressCounts.clear();
     }
 
-    // -------------------------------------------------------------------------
+    private CarryData findCarryBySurvivor(UUID survivorUuid) {
-    // Private
+        for (CarryData data : activeCarries.values()) {
-    // -------------------------------------------------------------------------
+            if (data.survivor.getUuid().equals(survivorUuid)) return data;
+        }
+        return null;
+    }
 
     private void startCarry(Killer killer, Survivor survivor) {
         killer.setCarrying(true);
         survivor.setState(PlayerState.CARRIED);
 
+        Player killerPlayer = killer.getPlayer();
         Player survivorPlayer = survivor.getPlayer();
-        if (survivorPlayer != null) {
+        if (killerPlayer == null || survivorPlayer == null) return;
-            survivorPlayer.setInvisible(true);
+
-            survivorPlayer.sendMessage(Component.text(
+        // Survivor sits ON THE KILLER'S HEAD as a passenger
-                "[DBD] Нажимайте ПРОБЕЛ чтобы вырваться!", NamedTextColor.YELLOW));
+        survivorPlayer.setSwimming(false);
-        }
+        killerPlayer.addPassenger(survivorPlayer);
+
+        // Slow falling to prevent visual glitches
+        survivorPlayer.addPotionEffect(
+            new PotionEffect(PotionEffectType.SLOW_FALLING, Integer.MAX_VALUE, 0, false, false));
+
+        shiftPressCounts.put(survivor.getUuid(), 0);
+
+        int required = config.getCarryEscapePresses();
+        survivorPlayer.sendMessage(Component.text(
+            "[DBD] Спамьте SHIFT чтобы вырваться! (" + required + " нажатий)", NamedTextColor.YELLOW));
 
         CarryData data = new CarryData(killer, survivor);
         activeCarries.put(killer.getUuid(), data);
-        killerToSurvivor.put(killer.getUuid(), survivor.getUuid());
 
         if (carryTask == null) startCarryTask();
     }
@@ -154,38 +186,47 @@ public class KillerCarry {
     private void stopCarry(CarryData data, boolean escaped) {
         data.killer.setCarrying(false);
 
-        Player killerPlayer  = data.killer.getPlayer();
+        Player killerPlayer = data.killer.getPlayer();
         Player survivorPlayer = data.survivor.getPlayer();
 
-        if (survivorPlayer != null && survivorPlayer.isOnline()) {
+        if (survivorPlayer != null && survivorPlayer.isValid()) {
-            survivorPlayer.setInvisible(false);
+            // Dismount from killer
+            if (killerPlayer != null && killerPlayer.isValid()) {
+                killerPlayer.removePassenger(survivorPlayer);
+            }
 
+            // Remove slow falling
+            survivorPlayer.removePotionEffect(PotionEffectType.SLOW_FALLING);
+        }
+
+        if (survivorPlayer != null && survivorPlayer.isOnline()) {
             if (escaped) {
                 // Drop survivor slightly forward from killer
-                Location dropLoc = survivorPlayer.getLocation();
+                Location dropLoc = killerPlayer != null
-                if (killerPlayer != null) {
+                    ? killerPlayer.getLocation().clone()
-                    dropLoc = killerPlayer.getLocation().clone()
+                        .add(killerPlayer.getLocation().getDirection().multiply(2.0))
-                        .add(killerPlayer.getLocation().getDirection().multiply(2.0));
+                    : survivorPlayer.getLocation();
-                }
+                dropLoc.setY(dropLoc.getY() + 1);
                 survivorPlayer.teleport(dropLoc);
 
-                // Speed I
+                // Speed I after escape
                 int speedTicks = config.getCarryEscapeSpeedSeconds() * 20;
                 survivorPlayer.addPotionEffect(
                     new PotionEffect(PotionEffectType.SPEED, speedTicks, 0, false, true));
 
                 survivorPlayer.sendMessage(Component.text(
                     "[DBD] Вы вырвались!", NamedTextColor.GREEN));
+                survivorPlayer.playSound(survivorPlayer.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0f, 1.2f);
 
-                data.survivor.setState(PlayerState.DOWNED); // still downed, just free
+                // After escape, survivor is INJURED
+                data.survivor.setState(PlayerState.INJURED);
             } else {
-                survivorPlayer.teleport(data.killer.getPlayer() != null
+                survivorPlayer.teleport(killerPlayer != null
-                    ? data.killer.getPlayer().getLocation()
+                    ? killerPlayer.getLocation()
                     : survivorPlayer.getLocation());
                 data.survivor.setState(PlayerState.DOWNED);
             }
 
-            // Clear action bar progress
             survivorPlayer.sendActionBar(Component.empty());
         }
 
@@ -197,18 +238,14 @@ public class KillerCarry {
 
     private void startCarryTask() {
         carryTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> {
-            if (activeCarries.isEmpty()) return;
             for (CarryData data : new HashMap<>(activeCarries).values()) {
                 if (!isValidCarry(data)) {
                     activeCarries.remove(data.killer.getUuid());
-                    killerToSurvivor.remove(data.killer.getUuid());
+                    shiftPressCounts.remove(data.survivor.getUuid());
                     stopCarry(data, false);
-                    continue;
                 }
-                updateCarryPosition(data);
-                showWiggleProgress(data); // refresh bar every tick
             }
-        }, 1L, 1L);
+        }, 20L, 20L);
     }
 
     private boolean isValidCarry(CarryData data) {
@@ -216,24 +253,4 @@ public class KillerCarry {
         Player sp = data.survivor.getPlayer();
         return kp != null && sp != null && kp.isOnline() && sp.isOnline();
     }
-
-    private void updateCarryPosition(CarryData data) {
-        Player killerPlayer   = data.killer.getPlayer();
-        Player survivorPlayer = data.survivor.getPlayer();
-        if (killerPlayer == null || survivorPlayer == null) return;
-
-        Location carryLoc = killerPlayer.getLocation().clone().add(0, -0.5, 0);
-        survivorPlayer.teleport(carryLoc);
-    }
-
-    private void showWiggleProgress(CarryData data) {
-        Player survivorPlayer = data.survivor.getPlayer();
-        if (survivorPlayer == null) return;
-
-        double pct = Math.min(100, data.wiggleProgress);
-        int filled = (int) (pct / 10);
-        int empty  = 10 - filled;
-        String bar = "§e[" + "§a█".repeat(filled) + "§7░".repeat(empty) + "§e]";
-        survivorPlayer.sendActionBar(Component.text("§6Побег: " + bar + " " + (int) pct + "%"));
-    }
 }

src/main/java/dev/loki/killer/KillerController.java

@@ -104,8 +104,8 @@ public class KillerController {
         return carry.getCarried(killer);
     }
 
-    public double getWiggleProgress(Killer killer) {
+    public int getShiftPresses(Survivor survivor) {
-        return carry.getWiggleProgress(killer);
+        return carry.getShiftPresses(survivor);
     }
 
     public KillerAttack getAttack() {

src/main/java/dev/loki/killer/KillerMovement.java

@@ -62,7 +62,7 @@ public class KillerMovement {
     }
 
     private void applySpeed(Player player, double multiplier) {
-        AttributeInstance speedAttr = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED);
+        AttributeInstance speedAttr = player.getAttribute(Attribute.MOVEMENT_SPEED);
         if (speedAttr == null) return;
 
         double newSpeed = BASE_SPEED * multiplier;
@@ -70,7 +70,7 @@ public class KillerMovement {
     }
 
     private void resetSpeed(Player player) {
-        AttributeInstance speedAttr = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED);
+        AttributeInstance speedAttr = player.getAttribute(Attribute.MOVEMENT_SPEED);
         if (speedAttr == null) return;
 
         speedAttr.setBaseValue(BASE_SPEED);

src/main/java/dev/loki/listener/GeneratorSelectListener.java

@@ -1,45 +0,0 @@
-package dev.loki.listener;
-
-import dev.loki.command.DBDAdminCommand;
-import dev.loki.data.GeneratorDataManager;
-import dev.loki.util.TextUtil;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockBreakEvent;
-
-public class GeneratorSelectListener implements Listener {
-
-    private final DBDAdminCommand adminCommand;
-    private final GeneratorDataManager generatorData;
-
-    public GeneratorSelectListener(DBDAdminCommand adminCommand, GeneratorDataManager generatorData) {
-        this.adminCommand = adminCommand;
-        this.generatorData = generatorData;
-    }
-
-    @EventHandler
-    public void onBlockBreak(BlockBreakEvent event) {
-        Player player = event.getPlayer();
-        if (!adminCommand.isSelectingGenerator(player.getUniqueId())) {
-            return;
-        }
-
-        event.setCancelled(true);
-
-        Location loc = event.getBlock().getLocation();
-        Location genLoc = new Location(loc.getWorld(),
-            loc.getX() + 0.5,
-            loc.getY(),
-            loc.getZ() + 0.5);
-
-        generatorData.addGenerator(genLoc);
-
-        player.sendMessage(TextUtil.color("<#00FF00>Генератор установлен!"));
-        player.sendMessage(TextUtil.color("<#00CED1>Координаты: " + GeneratorDataManager.formatLocation(genLoc)));
-        player.sendMessage(TextUtil.color("<#FFD700>Всего генераторов: " + generatorData.getCount()));
-        player.sendMessage(TextUtil.color("<#FFA500>Режим выбора остается активным. Ломайте следующий блок или"));
-        player.sendMessage(TextUtil.color("<#FFA500>введите /dbdadmin create generator для отключения"));
-    }
-}

src/main/java/dev/loki/listener/PlayerInteractListener.java

@@ -25,17 +25,18 @@ import java.util.function.BiConsumer;
 public class PlayerInteractListener implements Listener {
     private final Plugin plugin;
     private final GameManager gameManager;
-    private final GeneratorManager generatorManager;
+    private GeneratorManager generatorManager;
     private SetupCommand setupCommand;
 
     private BiConsumer<Player, Action> onGeneratorInteract;
     private BiConsumer<Player, Boolean> onAttack;
-    private BiConsumer<Player, Boolean> onPalletInteract;
     private BiConsumer<Player, Boolean> onRescueAttempt;
     private BiConsumer<Player, Boolean> onChestInteract;
     private BiConsumer<Player, Boolean> onHatchInteract;
     /** Called when killer toggles sneak: (player, isSneaking) */
     private BiConsumer<Player, Boolean> onKillerSneak;
+    /** Called when a survivor sneaks near another injured/downed survivor: (healer, target) */
+    private BiConsumer<Player, Player> onHealSneak;
 
     private final Map<UUID, Long> lastClick = new ConcurrentHashMap<>();
     private static final long COOLDOWN_MS = 200;
@@ -43,6 +44,7 @@ public class PlayerInteractListener implements Listener {
     public PlayerInteractListener(Plugin plugin, GameManager gameManager, GeneratorManager generatorManager) {
         this.plugin = plugin;
         this.gameManager = gameManager;
+        // Можем инициализировать null — будет переустановлен в GameplayPhase.initSubHandlers()
         this.generatorManager = generatorManager;
     }
 
@@ -52,21 +54,96 @@ public class PlayerInteractListener implements Listener {
 
     public void setOnGeneratorInteract(BiConsumer<Player, Action> h) { this.onGeneratorInteract = h; }
     public void setOnAttack(BiConsumer<Player, Boolean> h) { this.onAttack = h; }
-    public void setOnPalletInteract(BiConsumer<Player, Boolean> h) { this.onPalletInteract = h; }
     public void setOnRescueAttempt(BiConsumer<Player, Boolean> h) { this.onRescueAttempt = h; }
     public void setOnChestInteract(BiConsumer<Player, Boolean> h) { this.onChestInteract = h; }
     public void setOnHatchInteract(BiConsumer<Player, Boolean> h) { this.onHatchInteract = h; }
     public void setOnKillerSneak(BiConsumer<Player, Boolean> h) { this.onKillerSneak = h; }
+    public void setOnHealSneak(BiConsumer<Player, Player> h) { this.onHealSneak = h; }
+    private BiConsumer<Player, Boolean> onCarriedShift;
+    public void setOnCarriedShift(BiConsumer<Player, Boolean> h) { this.onCarriedShift = h; }
+
+    public void setGeneratorManager(GeneratorManager manager) {
+        this.generatorManager = manager;
+    }
 
     @EventHandler
     public void onSneak(PlayerToggleSneakEvent event) {
         Player player = event.getPlayer();
         if (!gameManager.isInGame(player.getUniqueId())) return;
+
+        // For survivors: trigger generator repair when sneaking
+        if (event.isSneaking()) {
+            var session = gameManager.getPlayerSession(player.getUniqueId());
+            if (session != null) {
+                BasePlayer bp = session.getPlayer(player.getUniqueId());
+                if (bp != null && !bp.isKiller()) {
+                    // #11: Carried survivor shift-spam to escape
+                    if (bp.getState() == PlayerState.CARRIED && onCarriedShift != null) {
+                        onCarriedShift.accept(player, true);
+                        return;
+                    }
+
+                    // Only HEALTHY or INJURED survivors can repair/heal
+                    PlayerState st = bp.getState();
+                    if (st != PlayerState.HEALTHY && st != PlayerState.INJURED) return;
+
+                    // Generator repair takes priority over healing
+                    if (tryGeneratorInteract(player)) return;
+
+                    // Healing: check if sneaking near an injured/downed survivor
+                    if (onHealSneak != null) {
+                        Player nearestTarget = findNearestHealTarget(player, session);
+                        if (nearestTarget != null) {
+                            onHealSneak.accept(player, nearestTarget);
+                        }
+                    }
+                }
+            }
+        } else {
+            // When un-sneaking
+            var session = gameManager.getPlayerSession(player.getUniqueId());
+            if (session != null) {
+                BasePlayer bp = session.getPlayer(player.getUniqueId());
+                if (bp != null && !bp.isKiller()) {
+                    if (bp.getState() == PlayerState.CARRIED && onCarriedShift != null) {
+                        onCarriedShift.accept(player, false);
+                        return;
+                    }
+                }
+            }
+        }
+
         if (onKillerSneak != null) {
             onKillerSneak.accept(player, event.isSneaking());
         }
     }
 
+    /**
+     * Find the nearest injured or downed survivor within heal range.
+     * Returns null if none found or if the only target is self and not injured.
+     */
+    private Player findNearestHealTarget(Player healer, dev.loki.core.GameSession session) {
+        if (session == null) return null;
+        double healRange = session.getConfig().getHealRange();
+        Player nearest = null;
+        double nearestDist = healRange + 1.0;
+        for (BasePlayer other : session.getPlayers().values()) {
+            if (other.isKiller()) continue;
+            Player otherPlayer = other.getPlayer();
+            if (otherPlayer == null || !otherPlayer.isOnline()) continue;
+            // Самолечение только через медкит, не через шифт
+            if (otherPlayer.getUniqueId().equals(healer.getUniqueId())) continue;
+            PlayerState state = other.getState();
+            if (state != PlayerState.INJURED && state != PlayerState.DOWNED) continue;
+            double dist = healer.getLocation().distance(otherPlayer.getLocation());
+            if (dist <= healRange && dist < nearestDist) {
+                nearest = otherPlayer;
+                nearestDist = dist;
+            }
+        }
+        return nearest;
+    }
+
     @EventHandler
     public void onInteract(PlayerInteractEvent event) {
         if (event.getHand() != EquipmentSlot.HAND) return;
@@ -90,8 +167,9 @@ public class PlayerInteractListener implements Listener {
     }
 
     /**
-     * Handles the DBD wand (STICK with custom display name).
+     * Handles both old gate wand and new setup wand.
-     * LMB on block = pos1, RMB on block = pos2.
+     * Old gate wand: LMB on block = pos1, RMB on block = pos2.
+     * New setup wand: RMB on block = select block.
      * Returns true if the event was consumed by the wand.
      */
     private boolean handleWand(PlayerInteractEvent event, Player player) {
@@ -99,15 +177,13 @@ public class PlayerInteractListener implements Listener {
         if (!player.hasPermission("mdbd.admin")) return false;
 
         ItemStack item = event.getItem();
-        if (item == null || item.getType() != Material.STICK) return false;
+        if (item == null || item.getType() != Material.WOODEN_AXE) return false;
         if (!item.hasItemMeta()) return false;
 
-        // Reliable check: look for NBT persistent data tag instead of display name parsing
         var meta = item.getItemMeta();
-        var key = new org.bukkit.NamespacedKey("mdbd", "dbd_wand");
+        var gateWandKey = new org.bukkit.NamespacedKey("mdbd", "dbd_wand");
-        if (!meta.getPersistentDataContainer().has(key, org.bukkit.persistence.PersistentDataType.BYTE)) {
+
-            return false;
+        if (!meta.getPersistentDataContainer().has(gateWandKey, org.bukkit.persistence.PersistentDataType.BYTE)) return false;
-        }
 
         event.setCancelled(true);
 
@@ -116,6 +192,7 @@ public class PlayerInteractListener implements Listener {
             ? event.getClickedBlock().getLocation()
             : player.getLocation().getBlock().getLocation();
 
+        // ЛКМ=pos1, ПКМ=pos2
         if (action == Action.LEFT_CLICK_BLOCK || action == Action.LEFT_CLICK_AIR) {
             setupCommand.setWandPos(player, 1, loc);
         } else if (action == Action.RIGHT_CLICK_BLOCK || action == Action.RIGHT_CLICK_AIR) {
@@ -125,7 +202,22 @@ public class PlayerInteractListener implements Listener {
     }
 
     private boolean isIncapacitated(BasePlayer bp) {
-        return bp.getState() == PlayerState.DOWNED || bp.getState() == PlayerState.HOOKED;
+        return bp.getState() == PlayerState.DOWNED
+            || bp.getState() == PlayerState.HOOKED
+            || bp.getState() == PlayerState.CARRIED;
+    }
+
+    private boolean tryGeneratorInteract(Player player) {
+        if (onGeneratorInteract == null || generatorManager == null) return false;
+        var session = gameManager.getPlayerSession(player.getUniqueId());
+        if (session == null) return false;
+        BasePlayer bp = session.getPlayer(player.getUniqueId());
+        if (bp == null || bp.isKiller()) return false;
+        var gen = generatorManager.getNearestGenerator(
+            player.getLocation(), session.getConfig().getGeneratorInteractionRange());
+        if (gen == null) return false;
+        onGeneratorInteract.accept(player, Action.RIGHT_CLICK_AIR);
+        return true;
     }
 
     private boolean isOnCooldown(Player player) {
@@ -137,35 +229,44 @@ public class PlayerInteractListener implements Listener {
     }
 
     private void handleRightClick(PlayerInteractEvent event, Player player, BasePlayer bp) {
-        if (event.getClickedBlock() == null) {
+        // #13: Запрет входа в печки для всех (и маньяка тоже) — MUST be FIRST before any other checks
-            if (!bp.isKiller() && onGeneratorInteract != null && generatorManager != null && generatorManager.isInAnyZone(player)) {
+        if (event.getClickedBlock() != null) {
-                onGeneratorInteract.accept(player, event.getAction());
+            String type = event.getClickedBlock().getType().toString();
+            if (type.contains("FURNACE") || type.contains("SMOKER") || type.contains("BLAST_FURNACE")) {
+                event.setCancelled(true);
                 return;
             }
-            if (onAttack != null && bp.isKiller()) onAttack.accept(player, true);
+        }
+
+        if (!bp.isKiller() && tryGeneratorInteract(player)) return;
+
+        // Killer attack (hook/carry) — fires on both air AND block clicks
+        if (bp.isKiller() && onAttack != null) {
+            onAttack.accept(player, true);
             return;
         }
 
-        if (!bp.isKiller() && onGeneratorInteract != null && generatorManager != null && generatorManager.isInAnyZone(player)) {
+        if (event.getClickedBlock() == null) return;
-            onGeneratorInteract.accept(player, event.getAction());
-            return;
-        }
 
         String type = event.getClickedBlock().getType().toString();
-        if ((type.contains("FENCE") || type.contains("PLANKS")) && onPalletInteract != null && !bp.isKiller()) onPalletInteract.accept(player, true);
+
-        if (!bp.isKiller() && onRescueAttempt != null) onRescueAttempt.accept(player, true);
+        // Chest interaction - cancel vanilla GUI and use plugin chest system
-        if (type.contains("CHEST") && onChestInteract != null) onChestInteract.accept(player, true);
+        if (type.contains("CHEST") && onChestInteract != null && !bp.isKiller()) {
+            event.setCancelled(true);
+            onChestInteract.accept(player, true);
+            return;
+        }
+        // Hook rescue: if survivor clicks on a hook block, attempt rescue
+        if (!bp.isKiller() && onRescueAttempt != null) {
+            onRescueAttempt.accept(player, true);
+            if (type.contains("IRON_BARS") || type.contains("IRON")) event.setCancelled(true);
+        }
         if ((type.contains("HOPPER") || type.contains("PORTAL")) && onHatchInteract != null && !bp.isKiller()) onHatchInteract.accept(player, true);
+        // Cancel interaction with hook blocks to prevent block manipulation
+        if (type.contains("IRON_BARS") || type.contains("IRON")) event.setCancelled(true);
     }
 
     private void handleLeftClick(PlayerInteractEvent event, Player player, BasePlayer bp) {
-        if (event.getClickedBlock() != null) {
-            String type = event.getClickedBlock().getType().toString();
-            if ((type.contains("PLANKS") || type.contains("FENCE")) && onPalletInteract != null && bp.isKiller()) {
-                event.setCancelled(true);
-                onPalletInteract.accept(player, false);
-            }
-        }
         if (onAttack != null && bp.isKiller()) { event.setCancelled(true); onAttack.accept(player, false); }
     }
 

src/main/java/dev/loki/listener/PlayerJoinListener.java

@@ -0,0 +1,21 @@
+package dev.loki.listener;
+
+import dev.loki.world.LobbyManager;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class PlayerJoinListener implements Listener {
+    private final LobbyManager lobbyManager;
+
+    public PlayerJoinListener(LobbyManager lobbyManager) {
+        this.lobbyManager = lobbyManager;
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        lobbyManager.teleportToLobby(player);
+    }
+}

src/main/java/dev/loki/listener/PlayerJumpListener.java

@@ -1,10 +1,14 @@
 package dev.loki.listener;
 
+import dev.loki.player.BasePlayer;
+import dev.loki.player.PlayerState;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.plugin.Plugin;
 
 import java.util.HashSet;
@@ -13,43 +17,95 @@ import java.util.UUID;
 import java.util.function.Consumer;
 
 /**
- * Tracks jump events (velocity Y-positive when on ground) to support the
+ * Detects player jumps by monitoring Y-coordinate changes in PlayerMoveEvent.
- * carry-escape "spam space" mechanic.
+ * Bukkit 1.21 doesn't have PlayerJumpEvent, so we detect jumps manually.
+ *
+ * Jumping is DISABLED by default for all in-game players.
+ * Admin can toggle via /dbd admin jump.
  */
 public class PlayerJumpListener implements Listener {
-
     private final Plugin plugin;
+    private final Set<UUID> inGamePlayers = new HashSet<>();
+
     private Consumer<Player> onJump;
-    private final Set<UUID> registered = new HashSet<>();
+    private final Set<UUID> recentJumpers = new HashSet<>();
+
+    /** Whether jumping is allowed. Default: false (disabled). */
+    private static boolean jumpingAllowed = false;
 
     public PlayerJumpListener(Plugin plugin) {
         this.plugin = plugin;
     }
 
-    public void setOnJump(Consumer<Player> callback) {
+    public static boolean isJumpingAllowed() { return jumpingAllowed; }
-        this.onJump = callback;
+    public static void setJumpingAllowed(boolean allowed) { jumpingAllowed = allowed; }
-    }
 
-    public void register() {
+    /** Register player as in-game for jump detection */
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    public void addInGamePlayer(UUID uuid) { inGamePlayers.add(uuid); }
-    }
+    public void removeInGamePlayer(UUID uuid) { inGamePlayers.remove(uuid); }
+    public void clearInGamePlayers() { inGamePlayers.clear(); }
 
-    public void unregister() {
+    public void setOnJump(Consumer<Player> h) { this.onJump = h; }
-        HandlerList.unregisterAll(this);
-        onJump = null;
-        registered.clear();
-    }
 
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerMove(org.bukkit.event.player.PlayerMoveEvent event) {
+    public void onMove(PlayerMoveEvent event) {
-        // Detect jump: player was on ground and now has positive Y velocity
         Player player = event.getPlayer();
-        if (!player.isOnGround()) return;
+        if (!inGamePlayers.contains(player.getUniqueId())) return;
-        // Paper API: check if player jumped (velocity Y > 0 after the tick)
+
-        if (player.getVelocity().getY() > 0.1) {
+        Location from = event.getFrom();
-            if (onJump != null) {
+        Location to = event.getTo();
-                onJump.accept(player);
+        if (from == null || to == null) return;
+
+        // Detect jump: Y increased significantly (> 0.5 blocks)
+        double yDiff = to.getY() - from.getY();
+        if (yDiff > 0.5 && to.getY() > from.getY()) {
+            // Avoid double-triggering
+            if (recentJumpers.contains(player.getUniqueId())) return;
+            recentJumpers.add(player.getUniqueId());
+
+            // Remove from set after short delay
+            plugin.getServer().getScheduler().runTaskLater(plugin,
+                () -> recentJumpers.remove(player.getUniqueId()), 5L);
+
+            // Get player state
+            BasePlayer bp = getBasePlayer(player);
+            if (bp != null) {
+                PlayerState state = bp.getState();
+
+                // Survivors being carried can jump to try escape (always allowed)
+                if (!bp.isKiller() && state == PlayerState.CARRIED) {
+                    if (onJump != null) onJump.accept(player);
+                    return;
+                }
+
+                // Blocked states: HOOKED, DOWNED — never allow jumping
+                if (state == PlayerState.HOOKED || state == PlayerState.DOWNED) {
+                    event.setCancelled(true);
+                    return;
+                }
+
+                // Jumping disabled by default — cancel all jumps except carry escape
+                if (!jumpingAllowed) {
+                    event.setCancelled(true);
+                    return;
+                }
             }
         }
     }
-}
+
+    private BasePlayer getBasePlayer(Player player) {
+        // Get player from game session via Bukkit
+        var session = Bukkit.getServer().getPluginManager().getPlugin("Mdbd");
+        if (session instanceof dev.loki.mdbd mdbd) {
+            var gm = mdbd.getGameManager();
+            if (gm != null) {
+                var s = gm.getPlayerSession(player.getUniqueId());
+                if (s != null) return s.getPlayer(player.getUniqueId());
+            }
+        }
+        return null;
+    }
+
+    public void register() { plugin.getServer().getPluginManager().registerEvents(this, plugin); }
+    public void unregister() { org.bukkit.event.HandlerList.unregisterAll(this); }
+}

src/main/java/dev/loki/listener/PlayerMoveListener.java

@@ -8,6 +8,7 @@ import dev.loki.player.Survivor;
 import org.bukkit.Location;
 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.PlayerMoveEvent;
 import org.bukkit.event.player.PlayerToggleSneakEvent;
@@ -60,6 +61,7 @@ public class PlayerMoveListener implements Listener {
 
     private boolean shouldCancel(BasePlayer bp, Location to, Location from) {
         if (bp.getState() == PlayerState.HOOKED) return true;
+        if (bp.getState() == PlayerState.CARRIED) return true;
         if (bp.getState() == PlayerState.DOWNED) {
             double dist = Math.sqrt(Math.pow(to.getX() - from.getX(), 2) + Math.pow(to.getZ() - from.getZ(), 2));
             return dist > 0.08;
@@ -69,6 +71,7 @@ public class PlayerMoveListener implements Listener {
 
     private void handleMovement(Player player, BasePlayer bp, Location to) {
         if (onMovement != null) onMovement.accept(player, to);
+        if (bp.getState() == PlayerState.CARRIED) return; // Don't trigger move events for carried survivors
         if (!bp.isKiller() && onSurvivorMove != null) onSurvivorMove.accept((Survivor) bp, to);
         else if (bp.isKiller() && onKillerMove != null) onKillerMove.accept((Killer) bp, to);
     }