fix: 修复模块加载并调整构建以兼容 Paper 26.1.2

- 创建了详细的 README.md 文件介绍 EssentialsC 插件
- 添加了核心特性和功能方块使用说明
- 包含了安装步骤和系统要求文档
- 提供了完整的命令列表和权限节点说明
- 添加了配置文件说明和多语言支持介绍
- 包含了从源码构建和贡献指南信息

.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: 检出代码
+        uses: actions/checkout@v4
+      
+      - name: 设置 Java
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+          cache: maven
+      
+      - name: 构建插件
+        run: mvn clean package -B
+      
+      - name: 创建发行版
+        uses: softprops/action-gh-release@v1
+        with:
+          files: target/essentialsc-*.jar
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -13,20 +13,9 @@
 *.tar.gz
 *.rar
 
-# Maven
-target/
-pom.xml.tag
-pom.xml.releaseBackup
-pom.xml.versionsBackup
-pom.xml.next
-release.properties
-dependency-reduced-pom.xml
-buildNumber.properties
-.mvn/timing.properties
-.mvn/wrapper/maven-wrapper.jar
-
 # Gradle
 .gradle/
+.gradle-user-home/
 build/
 !gradle-wrapper.jar
 !**/src/main/**/build/
@@ -68,5 +57,8 @@ Thumbs.db
 # Test server (不要上传测试服务器文件)
 test-server/
 
+# Reference files (不要上传参考资料)
+references/
+
 # Plugin build output
 *.jar.asc

README.md

@@ -1,109 +1,125 @@
 # EssentialsC
 
-一个轻量级的 Paper 服务器核心插件，灵感来自 CMI，但更加精简、易用且现代化。
+> 一个轻量级的 Paper 服务器插件，灵感来自 CMI，但更加精简、易用且现代化。
 
-## ✨ 功能特性
+[![Version](https://img.shields.io/github/v/release/Coldsmiles/EssentialsC?style=flat-square)](https://github.com/Coldsmiles/EssentialsC/releases)
+[![License](https://img.shields.io/github/license/Coldsmiles/EssentialsC?style=flat-square)](LICENSE)
+[![Paper](https://img.shields.io/badge/Paper-1.21+-8A2BE2?style=flat-square)](https://papermc.io/)
+[![Java](https://img.shields.io/badge/Java-21+-orange?style=flat-square)](https://www.oracle.com/java/)
+
+## ✨ 核心特性
 
 ### 🎯 随身功能方块
 随时随地打开各种功能性方块，无需放置实体方块：
-- 工作台 (`/workbench`)
+- **工作台** (`/workbench`, `/wb`)
-- 铁砧 (`/anvil`)
+- **铁砧** (`/anvil`)
-- 附魔台 (`/enchantingtable`)
+- **制图台** (`/cartographytable`, `/ct`)
-- 制图台 (`/cartographytable`)
+- **砂轮** (`/grindstone`, `/gs`)
-- 砂轮 (`/grindstone`)
+- **织布机** (`/loom`)
-- 织布机 (`/loom`)
+- **锻造台** (`/smithingtable`, `/st`)
-- 锻造台 (`/smithingtable`)
+- **切石机** (`/stonecutter`, `/sc`)
-- 切石机 (`/stonecutter`)
+- **末影箱** (`/enderchest`, `/ec`)
+
+### 📦 智能容器管理
+- **潜影盒快捷打开** - 潜行+右键直接打开（类似 CMI）
+  - ✅ 支持自定义标题（可配置）
+  - ✅ 防刷物品机制（快照验证 + 数量检查）
+  - ✅ 防止套娃（不能放入另一个潜影盒）
+  - ✅ 异常恢复（物品丢失自动掉落）
 
 ### 🔧 实用工具
-- **末影箱** (`/enderchest`) - 随时访问末影箱
 - **帽子** (`/hat`) - 将手中物品戴在头上
-- **自杀** (`/suicide`) - 快速自杀
+- **自杀** (`/suicide`, `/die`) - 快速自杀
 - **飞行** (`/fly`) - 切换飞行模式
+- **修复** (`/repair`, `/rep`) - 修复手中或所有物品
+- **饱食** (`/feed`) - 补满饱食度
 
 ### 💚 生存辅助
 - **治疗** (`/heal`) - 恢复生命值和饱食度
-- **隐身** (`/vanish`) - 管理员隐身模式
+- **隐身** (`/vanish`, `/v`) - 管理员隐身模式
 
 ### 📊 管理功能
-- **玩家查询** (`/seen`) - 查看玩家上线时间和信息
+- **玩家查询** (`/seen`, `/info`) - 查看玩家上线时间和信息
-- **管理菜单** (`/admin`) - 可视化 GUI 管理面板
+- **功能方块菜单** (`/essc blocks`) - GUI 方块集合面板
-  - 时间/天气控制
+- **配置重载** (`/essc reload`) - 重新加载配置文件
-  - 快捷状态恢复
-  - 插件重载
 
-### 🌍 多语言支持
+---
-- 完整的中文和英文配置
-- 方块标题自动跟随客户端语言
-- 可自定义所有消息文本
 
-### ⚡ 权限控制
+## 🌍 多语言支持
-- 精细的权限管理系统
-- 帮助菜单智能显示（只显示有权限的命令）
-- 默认仅 OP 可用，可通过权限插件授权
 
-## 📦 安装
+- ✅ 完整的中文和英文配置
+- ✅ 方块标题自动跟随客户端语言
+- ✅ 可自定义所有消息文本
 
-### 要求
+## ⚡ 权限系统
-- Paper 1.21+ 服务器
-- Java 21+
 
-### 步骤
+- ✅ 精细的权限管理
+- ✅ 帮助菜单智能显示（只显示有权限的命令）
+- ✅ 默认仅 OP 可用，可通过权限插件授权
+- ✅ CMI 风格的命令别名支持
+
+## 📦 快速开始
+
+### 系统要求
+- **服务器**: Paper 1.21+
+- **Java**: 21+
+
+### 安装步骤
 1. 下载最新版本的 [`essentialsc-*.jar`](https://github.com/Coldsmiles/EssentialsC/releases)
 2. 将文件放入服务器的 `plugins` 文件夹
 3. 重启服务器
 4. 编辑 `plugins/EssentialsC/config.yml` 配置语言
 5. （可选）使用权限插件为玩家授予相应权限
 
-## 🎮 命令
+## 🎮 命令列表
 
 ### 基础命令
-```
+| 命令 | 说明 |
-/essc help          # 显示帮助菜单（根据权限动态显示）
+|------|------|
-```
+| `/essc help` | 显示帮助菜单（根据权限动态显示） |
+| `/essc reload` | 重载配置（管理员） |
+| `/essc blocks` | 打开功能方块菜单 |
 
 ### 功能方块命令
-```
+| 命令 | 别名 | 说明 |
-/workbench          # 打开工作台
+|------|------|------|
-/anvil              # 打开铁砧
+| `/workbench` | `/wb` | 打开工作台 |
-/enchantingtable    # 打开附魔台
+| `/anvil` | - | 打开铁砧 |
-/cartographytable   # 打开制图台
+| `/cartographytable` | `/ct` | 打开制图台 |
-/grindstone         # 打开砂轮
+| `/grindstone` | `/gs` | 打开砂轮 |
-/loom               # 打开织布机
+| `/loom` | - | 打开织布机 |
-/smithingtable      # 打开锻造台
+| `/smithingtable` | `/st` | 打开锻造台 |
-/stonecutter        # 打开切石机
+| `/stonecutter` | `/sc` | 打开切石机 |
-/enderchest         # 打开末影箱
+| `/enderchest` | `/ec` | 打开末影箱 |
-```
 
 ### 其他命令
-```
+| 命令 | 别名 | 说明 |
-/hat                # 将手中物品戴在头上
+|------|------|------|
-/suicide            # 自杀
+| `/hat` | - | 将手中物品戴在头上 |
-/fly                # 切换飞行模式
+| `/suicide` | `/die` | 自杀 |
-/heal               # 恢复生命值和饱食度
+| `/fly` | - | 切换飞行模式 |
-/vanish             # 切换隐身模式（管理员）
+| `/heal` | - | 恢复生命值和饱食度 |
-/seen <玩家>        # 查看玩家信息（管理员）
+| `/vanish` | `/v` | 切换隐身模式（管理员） |
-/admin              # 打开管理菜单（管理员）
+| `/seen` | `/info` | 查看玩家信息（管理员） |
-```
+| `/feed` | - | 补满饱食度 |
+| `/repair` | `/rep` | 修复手中或所有物品 |
 
-### 命令别名
+> 💡 **提示**: 使用 `/repair all` 可以修复背包中的所有物品
-- `/essentialsc` = `/essc`
 
-## ⚙️ 配置
+## ⚙️ 配置说明
 
 ### config.yml
 ```yaml
-# 语言设置
+# 语言设置 (en_US, zh_CN)
-# 可用语言: en_US, zh_CN
 language: "zh_CN"
 
 # 通用设置
 settings:
-  # 启用或禁用命令反馈消息
+  enable-feedback: true  # 启用命令反馈消息
-  enable-feedback: true
 
-  # 所有插件消息的前缀
+# 潜影盒设置
-  message-prefix: "&6[EssentialsC] &r"
+shulkerbox:
+  default-title: "&e潜影盒"  # 默认标题（支持颜色代码）
 ```
 
 ### 自定义语言
@@ -111,12 +127,12 @@ settings:
 
 ## 🔐 权限节点
 
-所有命令默认需要 OP 权限。使用权限插件（如 LuckPerms）授予权限：
+所有命令默认需要 OP 权限。使用权限插件授予权限：
 
+### 基础权限
 ```
 essentialsc.command.workbench         # 工作台
 essentialsc.command.anvil             # 铁砧
-essentialsc.command.enchantingtable   # 附魔台
 essentialsc.command.cartographytable  # 制图台
 essentialsc.command.grindstone        # 砂轮
 essentialsc.command.loom              # 织布机
@@ -129,41 +145,32 @@ essentialsc.command.fly               # 飞行
 essentialsc.command.heal              # 治疗
 essentialsc.command.vanish            # 隐身
 essentialsc.command.seen              # 玩家查询
-essentialsc.command.admin             # 管理菜单
+essentialsc.command.feed              # 饱食度
+essentialsc.command.repair            # 修复
+essentialsc.shulkerbox.open           # 潜行+右键潜影盒
+```
+
+### 管理权限
+```
+essentialsc.command.blocks            # 功能方块菜单
+essentialsc.command.reload            # 重载配置
 essentialsc.command.help              # 帮助（默认开放）
+```
+
+### 通配符
+```
 essentialsc.*                         # 所有权限
 ```
 
-### 示例：使用 LuckPerms 授权
+## 🔨 从源码构建
-```bash
-# 给单个玩家授权
-/lp user <玩家名> permission set essentialsc.command.workbench true
-
-# 给用户组授权
-/lp group vip permission set essentialsc.command.workbench true
-
-# 授权所有命令
-/lp group admin permission set essentialsc.* true
-```
-
-## 🔨 构建
-
-从源代码构建插件：
 
 ```bash
 git clone https://github.com/Coldsmiles/EssentialsC.git
 cd EssentialsC
-mvn clean package
+./gradlew build
 ```
 
-编译后的文件位于 `target/essentialsc-*.jar`
+编译后的文件位于 `build/libs/essentialsc-*.jar`
-
-## 📝 开发计划
-
-- [ ] 冷却时间系统
-- [ ] 更多管理功能
-- [ ] 数据统计
-- [ ] API 支持
 
 ## 🤝 贡献
 
@@ -174,9 +181,6 @@ mvn clean package
 本项目采用 MIT 许可证 - 详见 [LICENSE](LICENSE) 文件
 
 ## 👨‍💻 作者
-
-**Coldsmiles_7**
-
 - GitHub: [@Coldsmiles](https://github.com/Coldsmiles)
 - 网站: www.infstar.cn
 

build.gradle

@@ -0,0 +1,207 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.language.jvm.tasks.ProcessResources
+
+import java.util.Collections
+
+plugins {
+    id 'java'
+    id 'io.papermc.paperweight.userdev' version '2.0.0-beta.21'
+    id 'com.gradleup.shadow' version '8.3.6'
+}
+
+group = 'cn.infstar'
+version = '1.3.0'
+
+repositories {
+    mavenCentral()
+    maven {
+        name = 'papermc'
+        url = uri('https://repo.papermc.io/repository/maven-public/')
+    }
+}
+
+dependencies {
+    paperweight.paperDevBundle('1.21.11-R0.1-SNAPSHOT')
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+}
+
+def moduleExcludes = [
+    'blocks': [
+        '**/commands/WorkbenchCommand.java',
+        '**/commands/AnvilCommand.java',
+        '**/commands/CartographyTableCommand.java',
+        '**/commands/GrindstoneCommand.java',
+        '**/commands/LoomCommand.java',
+        '**/commands/SmithingTableCommand.java',
+        '**/commands/StonecutterCommand.java',
+        '**/commands/EnderChestCommand.java',
+        '**/commands/BlocksMenuCommand.java',
+        '**/listeners/ShulkerBoxListener.java'
+    ],
+    'player': [
+        '**/commands/FlyCommand.java',
+        '**/commands/HealCommand.java',
+        '**/commands/FeedCommand.java',
+        '**/commands/VanishCommand.java',
+        '**/commands/SeenCommand.java',
+        '**/commands/HatCommand.java',
+        '**/commands/SuicideCommand.java',
+        '**/commands/RepairCommand.java'
+    ],
+    'jei-fix': [
+        '**/listeners/JeiRecipeSyncListener.java'
+    ],
+    'mob-drops': [
+        '**/listeners/MobDropListener.java',
+        '**/listeners/MobDropMenuListener.java',
+        '**/commands/MobDropCommand.java'
+    ]
+]
+
+def variantDefinitions = [
+    standard: [
+        archiveFileName: "EssentialsC-${project.version}.jar",
+        excludedModules: ['mob-drops']
+    ],
+    all: [
+        archiveFileName: "EssentialsC-all-${project.version}.jar",
+        excludedModules: []
+    ],
+    lite: [
+        archiveFileName: "EssentialsC-lite-${project.version}.jar",
+        excludedModules: ['blocks']
+    ]
+]
+
+if (project.hasProperty('excludeModules')) {
+    def customExcludedModules = project.property('excludeModules')
+        .split(',')
+        .collect { it.trim() }
+        .findAll { !it.isEmpty() }
+
+    variantDefinitions.custom = [
+        archiveFileName: "EssentialsC-custom-${project.version}.jar",
+        excludedModules: customExcludedModules
+    ]
+}
+
+def resolveExcludePatterns = { Collection<String> modules ->
+    modules.collectMany { module -> moduleExcludes.get(module, Collections.emptyList()) }.unique()
+}
+
+variantDefinitions.each { variantName, variantConfig ->
+    def unknownModules = variantConfig.excludedModules.findAll { !moduleExcludes.containsKey(it) }
+    if (!unknownModules.isEmpty()) {
+        throw new GradleException("Unknown modules for variant '${variantName}': ${unknownModules.join(', ')}")
+    }
+}
+
+def variantSourceSets = [:]
+
+variantDefinitions.each { variantName, variantConfig ->
+    def sourceSet = sourceSets.create(variantName)
+    sourceSet.java.srcDirs = sourceSets.main.java.srcDirs
+    sourceSet.resources.srcDirs = sourceSets.main.resources.srcDirs
+    resolveExcludePatterns(variantConfig.excludedModules).each { pattern ->
+        sourceSet.java.exclude(pattern)
+    }
+    sourceSet.compileClasspath += sourceSets.main.compileClasspath
+    sourceSet.runtimeClasspath += sourceSet.output + sourceSet.compileClasspath
+    variantSourceSets[variantName] = sourceSet
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8'
+}
+
+tasks.withType(ProcessResources).configureEach {
+    filteringCharset = 'UTF-8'
+}
+
+variantDefinitions.keySet().each { variantName ->
+    def sourceSet = variantSourceSets[variantName]
+    def processTaskName = sourceSet.processResourcesTaskName
+    tasks.named(processTaskName, ProcessResources).configure {
+        inputs.property('version', project.version)
+        filesMatching('paper-plugin.yml') {
+            expand('version': project.version)
+        }
+    }
+}
+
+tasks.named('jar').configure {
+    enabled = false
+}
+
+tasks.named('shadowJar').configure {
+    enabled = false
+}
+
+def variantJarTasks = variantDefinitions.collect { variantName, variantConfig ->
+    def taskName = "shadowJar${variantName.capitalize()}"
+    def sourceSet = variantSourceSets[variantName]
+
+    tasks.register(taskName, ShadowJar) {
+        group = 'build'
+        description = "Builds the ${variantName} plugin jar."
+        archiveFileName.set(variantConfig.archiveFileName as String)
+        from(sourceSet.output)
+        configurations = [project.configurations.runtimeClasspath]
+        dependsOn(tasks.named(sourceSet.classesTaskName))
+    }
+}
+
+tasks.named('assemble').configure {
+    dependsOn(variantJarTasks)
+}
+
+tasks.register('buildAllVersions') {
+    group = 'build'
+    description = 'Builds standard, all, and lite plugin jars.'
+    dependsOn(variantJarTasks)
+}
+
+tasks.register('deployToPaper12111', Copy) {
+    group = 'deployment'
+    description = 'Deploys the all variant to the local Paper 1.21.11 test server.'
+    def artifact = tasks.named('shadowJarAll').flatMap { it.archiveFile }
+    dependsOn(tasks.named('shadowJarAll'))
+    from(artifact)
+    into(layout.projectDirectory.dir('test-server/paper-1.21.11/plugins'))
+}
+
+tasks.register('deployToPaper26') {
+    group = 'deployment'
+    description = 'Deploys the all variant to the local Paper 26.1.2 test server.'
+    dependsOn(tasks.named('shadowJarAll'))
+
+    doFirst {
+        def pluginsDir = file("${projectDir}/test-server/paper-26.1.2/plugins")
+        if (!pluginsDir.exists()) {
+            return
+        }
+
+        fileTree(pluginsDir).matching {
+            include 'EssentialsC*.jar'
+        }.each { pluginJar ->
+            pluginJar.delete()
+        }
+    }
+
+    doLast {
+        def artifact = tasks.named('shadowJarAll').flatMap { it.archiveFile }
+        copy {
+            from(artifact)
+            into("${projectDir}/test-server/paper-26.1.2/plugins")
+        }
+    }
+}
+
+tasks.register('buildAndDeployToPaper26') {
+    group = 'deployment'
+    description = 'Builds and deploys the all variant to the local Paper 26.1.2 test server.'
+    dependsOn(tasks.named('clean'), tasks.named('deployToPaper26'))
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://mirrors.aliyun.com/gradle/distributions/v9.1.0/gradle-9.1.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,93 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -1,103 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>cn.infstar</groupId>
-    <artifactId>essentialsc</artifactId>
-    <version>1.1.0</version>
-    <packaging>jar</packaging>
-
-    <name>essentialsc</name>
-
-    <properties>
-        <java.version>21</java.version>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <test.server.path>${project.basedir}/test-server/plugins</test.server.path>
-    </properties>
-
-    <build>
-        <defaultGoal>clean package</defaultGoal>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.13.0</version>
-                <configuration>
-                    <source>${java.version}</source>
-                    <target>${java.version}</target>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.5.3</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-antrun-plugin</artifactId>
-                <version>3.1.0</version>
-                <executions>
-                    <execution>
-                        <id>copy-to-test-server</id>
-                        <phase>package</phase>
-                        <configuration>
-                            <target>
-                                <echo message="Cleaning old plugin files..."/>
-                                <!-- 删除测试服务器中所有旧版本的插件文件 -->
-                                <delete>
-                                    <fileset dir="${test.server.path}" includes="essentialsc-*.jar"/>
-                                </delete>
-                                <echo message="Copying plugin to test server..."/>
-                                <copy file="${project.build.directory}/${project.build.finalName}.jar"
-                                      tofile="${test.server.path}/${project.build.finalName}.jar"
-                                      overwrite="true"/>
-                                <echo message="Plugin copied successfully!"/>
-                            </target>
-                        </configuration>
-                        <goals>
-                            <goal>run</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-    </build>
-
-    <repositories>
-        <!-- 阿里云 Maven 镜像 -->
-        <repository>
-            <id>aliyunmaven</id>
-            <url>https://maven.aliyun.com/repository/public</url>
-        </repository>
-        <!-- PaperMC 仓库 -->
-        <repository>
-            <id>papermc-repo</id>
-            <url>https://repo.papermc.io/repository/maven-public/</url>
-        </repository>
-    </repositories>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.papermc.paper</groupId>
-            <artifactId>paper-api</artifactId>
-            <version>1.21.11-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-</project>

settings.gradle

@@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        // 阿里云 Gradle 插件镜像（优先）
+        maven {
+            name = 'aliyun-gradle-plugin'
+            url = uri('https://maven.aliyun.com/repository/gradle-plugin')
+        }
+        // Gradle 官方插件仓库
+        gradlePluginPortal()
+        // PaperMC 官方仓库（用于 paperweight 插件）
+        maven {
+            name = 'papermc'
+            url = uri('https://repo.papermc.io/repository/maven-public/')
+        }
+    }
+}
+
+rootProject.name = 'EssentialsC'

src/main/java/cn/infstar/essentialsC/EssentialsC.java

@@ -1,6 +1,8 @@
 package cn.infstar.essentialsC;
 
-import cn.infstar.essentialsC.commands.*;
+import cn.infstar.essentialsC.commands.BaseCommand;
+import cn.infstar.essentialsC.commands.CommandRegistry;
+import cn.infstar.essentialsC.commands.HelpCommand;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -14,76 +16,120 @@ public final class EssentialsC extends JavaPlugin {
 
     @Override
     public void onEnable() {
-        // 初始化语言管理器
         langManager = new LangManager(this);
-        
+        registerPluginChannels();
+        registerListeners();
         registerCommands();
-        getLogger().info("EssentialsC 插件已启用！");
+
-        getLogger().info("当前语言: " + langManager.getCurrentLanguage());
+        getLogger().info("EssentialsC enabled. Version: " + getDescription().getVersion());
     }
 
     @Override
     public void onDisable() {
-        getLogger().info("EssentialsC 插件已禁用！");
+        getLogger().info("EssentialsC disabled.");
     }
 
-    /**
-     * 获取语言管理器实例
-     */
     public static LangManager getLangManager() {
         return langManager;
     }
 
+    private void registerPluginChannels() {
+        org.bukkit.plugin.messaging.Messenger messenger = getServer().getMessenger();
+        messenger.registerOutgoingPluginChannel(this, "fabric:recipe_sync");
+        messenger.registerOutgoingPluginChannel(this, "neoforge:recipe_content");
+    }
+
+    private void registerListeners() {
+        if (registerListener("cn.infstar.essentialsC.listeners.ShulkerBoxListener")) {
+            getLogger().info("- Shulker box module");
+        }
+
+        if (registerListener("cn.infstar.essentialsC.listeners.JeiRecipeSyncListener")) {
+            getLogger().info("- JEI recipe sync");
+        }
+
+        if (registerListener("cn.infstar.essentialsC.listeners.MobDropListener")) {
+            createOptionalInstance("cn.infstar.essentialsC.listeners.MobDropMenuListener");
+            getLogger().info("- Mob drop control");
+        }
+    }
+
+    private boolean registerListener(String className) {
+        try {
+            Class<?> listenerClass = Class.forName(className);
+            Object listenerInstance = listenerClass.getConstructor(EssentialsC.class).newInstance(this);
+            getServer().getPluginManager().registerEvents((org.bukkit.event.Listener) listenerInstance, this);
+            return true;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private void createOptionalInstance(String className) {
+        try {
+            Class<?> targetClass = Class.forName(className);
+            targetClass.getConstructor(EssentialsC.class).newInstance(this);
+        } catch (Exception ignored) {
+        }
+    }
+
     private void registerCommands() {
         try {
-            // 获取 CommandMap
             Field bukkitCommandMap = Bukkit.getServer().getClass().getDeclaredField("commandMap");
             bukkitCommandMap.setAccessible(true);
             org.bukkit.command.CommandMap commandMap = (org.bukkit.command.CommandMap) bukkitCommandMap.get(Bukkit.getServer());
 
-            // 注册所有命令
+            for (CommandRegistry.CommandSpec spec : CommandRegistry.getCommandSpecs()) {
-            registerCommand(commandMap, "workbench", new WorkbenchCommand());
+                BaseCommand executor = CommandRegistry.getCommand(spec.name());
-            registerCommand(commandMap, "anvil", new AnvilCommand());
+                if (executor == null) {
-            registerCommand(commandMap, "enchantingtable", new EnchantingTableCommand());
+                    continue;
-            registerCommand(commandMap, "cartographytable", new CartographyTableCommand());
+                }
-            registerCommand(commandMap, "grindstone", new GrindstoneCommand());
+                registerCommandWithAliases(commandMap, spec.name(), executor, spec.aliases().toArray(String[]::new));
-            registerCommand(commandMap, "loom", new LoomCommand());
+            }
-            registerCommand(commandMap, "smithingtable", new SmithingTableCommand());
-            registerCommand(commandMap, "stonecutter", new StonecutterCommand());
-            registerCommand(commandMap, "enderchest", new EnderChestCommand());
-            registerCommand(commandMap, "hat", new HatCommand());
-            registerCommand(commandMap, "suicide", new SuicideCommand());
-            registerCommand(commandMap, "fly", new FlyCommand());
-            registerCommand(commandMap, "heal", new HealCommand());
-            registerCommand(commandMap, "vanish", new VanishCommand());
-            registerCommand(commandMap, "seen", new SeenCommand());
-            registerCommand(commandMap, "admin", new AdminMenuCommand());
-            registerCommand(commandMap, "feed", new FeedCommand());
-            registerCommand(commandMap, "repair", new RepairCommand());
-            registerCommand(commandMap, "essentialsc", new HelpCommand());
 
-            getLogger().info("成功注册 18 个命令！");
+            registerCommandWithAliases(commandMap, "essentialsc", new HelpCommand(), "essc");
         } catch (Exception e) {
-            getLogger().severe("无法注册命令: " + e.getMessage());
+            getLogger().severe("Failed to register commands: " + e.getMessage());
             e.printStackTrace();
         }
     }
 
-    private void registerCommand(org.bukkit.command.CommandMap commandMap, String name, cn.infstar.essentialsC.commands.BaseCommand executor) {
+    private void registerCommandWithAliases(org.bukkit.command.CommandMap commandMap, String name, BaseCommand executor, String... aliases) {
         Command command = new Command(name) {
             @Override
             public boolean execute(CommandSender sender, String commandLabel, String[] args) {
                 return executor.onCommand(sender, this, commandLabel, args);
             }
+
+            @Override
+            public java.util.List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
+                if (executor instanceof org.bukkit.command.TabCompleter completer) {
+                    return completer.onTabComplete(sender, this, alias, args);
+                }
+                return super.tabComplete(sender, alias, args);
+            }
         };
 
-        // 为 essentialsc 命令添加简化别名
+        command.setPermission(executor.getPermission());
-        if (name.equals("essentialsc")) {
+        commandMap.register("", command);
-            command.setAliases(java.util.Arrays.asList("essc"));
+
+        for (String alias : aliases) {
+            Command aliasCmd = new Command(alias) {
+                @Override
+                public boolean execute(CommandSender sender, String commandLabel, String[] args) {
+                    return executor.onCommand(sender, this, commandLabel, args);
                 }
 
-        command.setPermission(executor.getPermission());
+                @Override
-        // 注册到默认命名空间，使玩家可以直接使用 /workbench 而不是 /essentialsc:workbench
+                public java.util.List<String> tabComplete(CommandSender sender, String label, String[] args) throws IllegalArgumentException {
-        commandMap.register("", command);
+                    if (executor instanceof org.bukkit.command.TabCompleter completer) {
+                        return completer.onTabComplete(sender, this, label, args);
+                    }
+                    return super.tabComplete(sender, label, args);
+                }
+            };
+            aliasCmd.setPermission(executor.getPermission());
+            commandMap.register("", aliasCmd);
+        }
     }
 }

src/main/java/cn/infstar/essentialsC/LangManager.java

@@ -1,5 +1,6 @@
 package cn.infstar.essentialsC;
 
+import org.bukkit.ChatColor;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -82,6 +83,13 @@ public class LangManager {
         }
     }
     
+    /**
+     * 获取插件前缀
+     */
+    public String getPrefix() {
+        return translateColorCodes(langFile.getString("prefix", "&6[EssentialsC] &r"));
+    }
+    
     /**
      * 获取翻译文本
      */
@@ -104,6 +112,23 @@ public class LangManager {
         return value;
     }
     
+    /**
+     * 获取字符串列表（用于 Lore 等多行文本）
+     */
+    public java.util.List<String> getStringList(String path) {
+        java.util.List<String> values = langFile.getStringList(path);
+        if (values.isEmpty()) {
+            // 如果找不到，返回包含错误信息的列表
+            return java.util.Arrays.asList("&cMissing translation: " + path);
+        }
+        // 翻译颜色代码
+        java.util.List<String> translated = new java.util.ArrayList<>();
+        for (String value : values) {
+            translated.add(translateColorCodes(value));
+        }
+        return translated;
+    }
+    
     /**
      * 重新加载配置和语言
      */
@@ -123,6 +148,6 @@ public class LangManager {
      * 翻译颜色代码
      */
     private String translateColorCodes(String text) {
-        return text.replace("&", "§");
+        return text == null ? "" : ChatColor.translateAlternateColorCodes('&', text);
     }
 }

src/main/java/cn/infstar/essentialsC/commands/AdminMenuCommand.java

@@ -1,128 +0,0 @@
-package cn.infstar.essentialsC.commands;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-
-public class AdminMenuCommand extends BaseCommand implements Listener {
-    
-    private static final int MENU_SIZE = 27;
-    
-    public AdminMenuCommand() {
-        super("essentialsc.command.admin");
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-    
-    @Override
-    protected boolean execute(@NotNull Player player, String[] args) {
-        openMenu(player);
-        return true;
-    }
-    
-    private void openMenu(Player player) {
-        String title = getLang().getString("admin-menu-title");
-        Inventory menu = Bukkit.createInventory(null, MENU_SIZE, title);
-        
-        // 时间控制
-        addItem(menu, 10, Material.CLOCK, getLang().getString("admin-time-control"), 
-                Arrays.asList("§7左键: 设为白天", "§7右键: 设为夜晚"));
-        addItem(menu, 11, Material.SUNFLOWER, getLang().getString("admin-weather-control"), 
-                Arrays.asList("§7左键: 晴天", "§7右键: 雨天"));
-        
-        // 状态恢复
-        addItem(menu, 13, Material.GOLDEN_APPLE, getLang().getString("admin-heal-self"), 
-                Arrays.asList("§7补满生命值和饱食度"));
-        addItem(menu, 14, Material.BREAD, getLang().getString("admin-feed-self"), 
-                Arrays.asList("§7补满饱食度"));
-        addItem(menu, 15, Material.ANVIL, getLang().getString("admin-repair-hand"), 
-                Arrays.asList("§7修复当前手持物品"));
-        
-        // 管理员功能
-        addItem(menu, 21, Material.ENDER_PEARL, getLang().getString("admin-vanish"), 
-                Arrays.asList("§7点击切换隐身状态"));
-        addItem(menu, 22, Material.BOOK, getLang().getString("admin-reload"), 
-                Arrays.asList("§7重新加载配置文件"));
-        
-        player.openInventory(menu);
-    }
-    
-    private void addItem(Inventory inv, int slot, Material material, String name, java.util.List<String> lore) {
-        ItemStack item = new ItemStack(material);
-        ItemMeta meta = item.getItemMeta();
-        if (meta != null) {
-            meta.setDisplayName(name);
-            meta.setLore(lore);
-            item.setItemMeta(meta);
-        }
-        inv.setItem(slot, item);
-    }
-    
-    @EventHandler
-    public void onMenuClick(InventoryClickEvent event) {
-        String title = getLang().getString("admin-menu-title");
-        if (!event.getView().getTitle().equals(title)) return;
-        if (!(event.getWhoClicked() instanceof Player player)) return;
-        
-        event.setCancelled(true);
-        ItemStack clicked = event.getCurrentItem();
-        if (clicked == null || !clicked.hasItemMeta()) return;
-        
-        String name = clicked.getItemMeta().getDisplayName();
-        String timeControl = getLang().getString("admin-time-control");
-        String weatherControl = getLang().getString("admin-weather-control");
-        String healSelf = getLang().getString("admin-heal-self");
-        String feedSelf = getLang().getString("admin-feed-self");
-        String repairHand = getLang().getString("admin-repair-hand");
-        String vanish = getLang().getString("admin-vanish");
-        String reload = getLang().getString("admin-reload");
-        
-        switch (name) {
-            case String t when t.equals(timeControl) -> {
-                if (event.isLeftClick()) player.getWorld().setTime(1000);
-                else player.getWorld().setTime(13000);
-                player.sendMessage(getLang().getString("admin-time-set"));
-            }
-            case String w when w.equals(weatherControl) -> {
-                if (event.isLeftClick()) player.getWorld().setStorm(false);
-                else player.getWorld().setStorm(true);
-                player.sendMessage(getLang().getString("admin-weather-set"));
-            }
-            case String h when h.equals(healSelf) -> {
-                player.setHealth(player.getMaxHealth());
-                player.setFoodLevel(20);
-                player.sendMessage(getLang().getString("admin-heal-success"));
-            }
-            case String f when f.equals(feedSelf) -> {
-                player.setFoodLevel(20);
-                player.setSaturation(20f);
-                player.sendMessage(getLang().getString("admin-feed-success"));
-            }
-            case String r when r.equals(repairHand) -> {
-                var item = player.getInventory().getItemInMainHand();
-                if (item.getItemMeta() instanceof org.bukkit.inventory.meta.Damageable d) {
-                    d.setDamage(0);
-                    item.setItemMeta((org.bukkit.inventory.meta.ItemMeta) d);
-                    player.sendMessage(getLang().getString("admin-repair-success"));
-                }
-            }
-            case String v when v.equals(vanish) -> {
-                new VanishCommand().execute(player, new String[]{});
-                openMenu(player); // 刷新菜单
-            }
-            case String rl when rl.equals(reload) -> {
-                plugin.reloadConfig();
-                player.sendMessage(getLang().getString("admin-reload-success"));
-            }
-            default -> {} // 忽略其他点击
-        }
-    }
-}

src/main/java/cn/infstar/essentialsC/commands/AnvilCommand.java

@@ -10,8 +10,8 @@ public class AnvilCommand extends BaseCommand {
     
     @Override
     protected boolean execute(Player player, String[] args) {
+        // 使用 Paper API 打开铁砧（标题跟随客户端语言）
         player.openAnvil(null, true);
-        player.sendMessage(getLang().getString("anvil-opened"));
         return true;
     }
 }

src/main/java/cn/infstar/essentialsC/commands/BaseCommand.java

@@ -6,7 +6,6 @@ import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
 
 public abstract class BaseCommand implements CommandExecutor {
     
@@ -32,21 +31,24 @@ public abstract class BaseCommand implements CommandExecutor {
     }
     
     @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player player)) {
+        if (sender instanceof Player player) {
-            sender.sendMessage(getLang().getString("messages.player-only"));
-            return true;
-        }
-        
             if (!player.hasPermission(permission)) {
                 String message = getLang().getString("messages.no-permission", 
                     java.util.Map.of("permission", permission));
                 player.sendMessage(message);
                 return true;
             }
-        
             return execute(player, args);
+        } else {
+            return executeConsole(sender, args);
+        }
     }
     
     protected abstract boolean execute(Player player, String[] args);
+    
+    protected boolean executeConsole(CommandSender sender, String[] args) {
+        sender.sendMessage(getLang().getString("messages.player-only"));
+        return true;
+    }
 }

src/main/java/cn/infstar/essentialsC/commands/BlocksMenuCommand.java

@@ -0,0 +1,148 @@
+package cn.infstar.essentialsC.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+
+import java.util.List;
+
+public class BlocksMenuCommand extends BaseCommand implements Listener {
+
+    private static final int MENU_SIZE = 36;
+    private static boolean listenerRegistered = false;
+
+    private final NamespacedKey blockKey;
+
+    private static final class BlocksMenuHolder implements InventoryHolder {
+        private final Inventory inventory;
+
+        private BlocksMenuHolder(String title) {
+            this.inventory = Bukkit.createInventory(this, MENU_SIZE, title);
+        }
+
+        @Override
+        public Inventory getInventory() {
+            return inventory;
+        }
+    }
+
+    public BlocksMenuCommand() {
+        super("essentialsc.command.blocks");
+        if (!listenerRegistered) {
+            plugin.getServer().getPluginManager().registerEvents(this, plugin);
+            listenerRegistered = true;
+        }
+        this.blockKey = new NamespacedKey(plugin, "block_key");
+    }
+
+    @Override
+    protected boolean execute(Player player, String[] args) {
+        openMenu(player);
+        return true;
+    }
+
+    private void openMenu(Player player) {
+        String title = plugin.getConfig().getString("blocks-menu.title", "&6&lEssentialsC &8- &e&lBlocks Menu");
+        Inventory menu = new BlocksMenuHolder(translateColor(title)).getInventory();
+
+        var itemsConfig = plugin.getConfig().getConfigurationSection("blocks-menu.items");
+        if (itemsConfig == null) {
+            return;
+        }
+
+        for (String key : itemsConfig.getKeys(false)) {
+            var section = itemsConfig.getConfigurationSection(key);
+            if (section == null) {
+                continue;
+            }
+
+            String permission = section.getString("permission");
+            if (permission != null && !player.hasPermission(permission)) {
+                continue;
+            }
+
+            int slot = section.getInt("slot");
+            Material material = Material.matchMaterial(section.getString("material", "STONE"));
+            if (material == null) {
+                material = Material.STONE;
+            }
+
+            String name = translateColor(section.getString("name", "&fItem"));
+            List<String> lore = section.getStringList("lore").stream()
+                .map(this::translateColor)
+                .toList();
+
+            addItem(menu, slot, material, name, lore, key);
+        }
+
+        player.openInventory(menu);
+    }
+
+    private void addItem(Inventory inv, int slot, Material material, String name, List<String> lore, String key) {
+        ItemStack item = new ItemStack(material);
+        ItemMeta meta = item.getItemMeta();
+        if (meta != null) {
+            meta.setDisplayName(name);
+            meta.setLore(lore);
+            meta.getPersistentDataContainer().set(this.blockKey, PersistentDataType.STRING, key);
+            item.setItemMeta(meta);
+        }
+        inv.setItem(slot, item);
+    }
+
+    @EventHandler
+    public void onMenuClick(InventoryClickEvent event) {
+        if (!(event.getView().getTopInventory().getHolder(false) instanceof BlocksMenuHolder)) {
+            return;
+        }
+        if (!(event.getWhoClicked() instanceof Player player)) {
+            return;
+        }
+
+        event.setCancelled(true);
+        ItemStack clicked = event.getCurrentItem();
+        if (clicked == null || !clicked.hasItemMeta()) {
+            return;
+        }
+
+        ItemMeta meta = clicked.getItemMeta();
+        String key = meta.getPersistentDataContainer().get(this.blockKey, PersistentDataType.STRING);
+        BaseCommand blockCommand = CommandRegistry.getCommand(key);
+        if (blockCommand != null) {
+            playBlockOpenSound(player, key);
+            blockCommand.execute(player, new String[0]);
+        }
+    }
+
+    private void playBlockOpenSound(Player player, String key) {
+        org.bukkit.Sound sound = switch (key) {
+            case "workbench" -> org.bukkit.Sound.BLOCK_WOOD_HIT;
+            case "anvil" -> org.bukkit.Sound.BLOCK_ANVIL_USE;
+            case "cartographytable" -> org.bukkit.Sound.UI_CARTOGRAPHY_TABLE_TAKE_RESULT;
+            case "grindstone" -> org.bukkit.Sound.BLOCK_GRINDSTONE_USE;
+            case "loom" -> org.bukkit.Sound.UI_LOOM_TAKE_RESULT;
+            case "smithingtable" -> org.bukkit.Sound.BLOCK_SMITHING_TABLE_USE;
+            case "stonecutter" -> org.bukkit.Sound.BLOCK_STONE_HIT;
+            case "enderchest" -> org.bukkit.Sound.BLOCK_ENDER_CHEST_OPEN;
+            default -> null;
+        };
+
+        if (sound != null) {
+            player.playSound(player.getLocation(), sound, 1.0f, 1.0f);
+        }
+    }
+
+    private String translateColor(String text) {
+        return text == null ? "" : ChatColor.translateAlternateColorCodes('&', text);
+    }
+}

src/main/java/cn/infstar/essentialsC/commands/CommandRegistry.java

@@ -0,0 +1,111 @@
+package cn.infstar.essentialsC.commands;
+
+import java.lang.reflect.Constructor;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public final class CommandRegistry {
+
+    private static final Map<String, CommandSpec> COMMANDS = new LinkedHashMap<>();
+    private static final Map<String, String> ALIAS_TO_COMMAND = new HashMap<>();
+    private static final Map<String, BaseCommand> COMMAND_CACHE = new HashMap<>();
+    private static final Set<String> UNAVAILABLE_COMMANDS = new java.util.HashSet<>();
+
+    static {
+        register("workbench", "essentialsc.command.workbench", "cn.infstar.essentialsC.commands.WorkbenchCommand", "wb");
+        register("anvil", "essentialsc.command.anvil", "cn.infstar.essentialsC.commands.AnvilCommand");
+        register("cartographytable", "essentialsc.command.cartographytable", "cn.infstar.essentialsC.commands.CartographyTableCommand", "ct", "cartography");
+        register("grindstone", "essentialsc.command.grindstone", "cn.infstar.essentialsC.commands.GrindstoneCommand", "gs");
+        register("loom", "essentialsc.command.loom", "cn.infstar.essentialsC.commands.LoomCommand");
+        register("smithingtable", "essentialsc.command.smithingtable", "cn.infstar.essentialsC.commands.SmithingTableCommand", "st", "smithing");
+        register("stonecutter", "essentialsc.command.stonecutter", "cn.infstar.essentialsC.commands.StonecutterCommand", "sc");
+        register("enderchest", "essentialsc.command.enderchest", "cn.infstar.essentialsC.commands.EnderChestCommand", "ec");
+        register("blocks", "essentialsc.command.blocks", "cn.infstar.essentialsC.commands.BlocksMenuCommand");
+        register("hat", "essentialsc.command.hat", "cn.infstar.essentialsC.commands.HatCommand");
+        register("suicide", "essentialsc.command.suicide", "cn.infstar.essentialsC.commands.SuicideCommand", "die");
+        register("fly", "essentialsc.command.fly", "cn.infstar.essentialsC.commands.FlyCommand");
+        register("heal", "essentialsc.command.heal", "cn.infstar.essentialsC.commands.HealCommand");
+        register("vanish", "essentialsc.command.vanish", "cn.infstar.essentialsC.commands.VanishCommand", "v");
+        register("seen", "essentialsc.command.seen", "cn.infstar.essentialsC.commands.SeenCommand", "info");
+        register("feed", "essentialsc.command.feed", "cn.infstar.essentialsC.commands.FeedCommand");
+        register("repair", "essentialsc.command.repair", "cn.infstar.essentialsC.commands.RepairCommand", "rep");
+        register("mobdrops", "essentialsc.mobdrops.enderman", "cn.infstar.essentialsC.commands.MobDropCommand");
+    }
+
+    private CommandRegistry() {
+    }
+
+    private static void register(String name, String permission, String className, String... aliases) {
+        List<String> aliasList = List.of(aliases);
+        CommandSpec spec = new CommandSpec(name, permission, className, aliasList);
+        COMMANDS.put(name, spec);
+        ALIAS_TO_COMMAND.put(name, name);
+        for (String alias : aliasList) {
+            ALIAS_TO_COMMAND.put(alias, name);
+        }
+    }
+
+    public static Collection<CommandSpec> getCommandSpecs() {
+        return Collections.unmodifiableCollection(COMMANDS.values());
+    }
+
+    public static String resolveCommandName(String input) {
+        if (input == null) {
+            return null;
+        }
+        return ALIAS_TO_COMMAND.get(input.toLowerCase());
+    }
+
+    public static boolean isAvailable(String name) {
+        return getCommand(name) != null;
+    }
+
+    public static String getPermission(String name) {
+        CommandSpec spec = COMMANDS.get(name);
+        return spec == null ? null : spec.permission();
+    }
+
+    public static BaseCommand getCommand(String name) {
+        String resolvedName = resolveCommandName(name);
+        if (resolvedName == null) {
+            return null;
+        }
+
+        BaseCommand cached = COMMAND_CACHE.get(resolvedName);
+        if (cached != null) {
+            return cached;
+        }
+        if (UNAVAILABLE_COMMANDS.contains(resolvedName)) {
+            return null;
+        }
+
+        CommandSpec spec = COMMANDS.get(resolvedName);
+        if (spec == null) {
+            return null;
+        }
+
+        try {
+            Class<?> rawClass = Class.forName(spec.className());
+            if (!BaseCommand.class.isAssignableFrom(rawClass)) {
+                UNAVAILABLE_COMMANDS.add(resolvedName);
+                return null;
+            }
+
+            Constructor<? extends BaseCommand> constructor = rawClass.asSubclass(BaseCommand.class).getDeclaredConstructor();
+            BaseCommand command = constructor.newInstance();
+            COMMAND_CACHE.put(resolvedName, command);
+            return command;
+        } catch (ReflectiveOperationException | LinkageError ignored) {
+            UNAVAILABLE_COMMANDS.add(resolvedName);
+            return null;
+        }
+    }
+
+    public record CommandSpec(String name, String permission, String className, List<String> aliases) {
+    }
+}

src/main/java/cn/infstar/essentialsC/commands/EnchantingTableCommand.java

@@ -1,17 +0,0 @@
-package cn.infstar.essentialsC.commands;
-
-import org.bukkit.entity.Player;
-
-public class EnchantingTableCommand extends BaseCommand {
-    
-    public EnchantingTableCommand() {
-        super("essentialsc.command.enchantingtable");
-    }
-    
-    @Override
-    protected boolean execute(Player player, String[] args) {
-        player.openEnchanting(null, true);
-        player.sendMessage(getLang().getString("enchantingtable-opened"));
-        return true;
-    }
-}

src/main/java/cn/infstar/essentialsC/commands/EnderChestCommand.java

@@ -2,6 +2,10 @@ package cn.infstar.essentialsC.commands;
 
 import org.bukkit.entity.Player;
 
+/**
+ * 末影箱命令 - 参考 EssentialsX 实现
+ * 直接打开玩家的末影箱，确保数据安全
+ */
 public class EnderChestCommand extends BaseCommand {
     
     public EnderChestCommand() {
@@ -10,7 +14,9 @@ public class EnderChestCommand extends BaseCommand {
     
     @Override
     protected boolean execute(Player player, String[] args) {
-        // 打开玩家的末影箱（标题由客户端决定）
+        // 直接打开玩家的末影箱（EssentialsX 方式）
+        // 优点：100% 安全，不会吞物品或刷物品
+        // 缺点：标题显示为 "Ender Chest"（由客户端语言决定）
         player.openInventory(player.getEnderChest());
         return true;
     }

src/main/java/cn/infstar/essentialsC/commands/HelpCommand.java

@@ -2,62 +2,130 @@ package cn.infstar.essentialsC.commands;
 
 import cn.infstar.essentialsC.EssentialsC;
 import cn.infstar.essentialsC.LangManager;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
 import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
 
-public class HelpCommand extends BaseCommand {
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class HelpCommand extends BaseCommand implements TabCompleter {
 
     public HelpCommand() {
         super("essentialsc.command.help");
     }
 
     @Override
-    protected boolean execute(@NotNull Player player, String[] args) {
+    protected boolean execute(Player player, String[] args) {
+        return handleCommand(player, player, args);
+    }
+
+    @Override
+    protected boolean executeConsole(CommandSender sender, String[] args) {
+        if (args.length > 0 && args[0].equalsIgnoreCase("reload")) {
+            if (!sender.hasPermission("essentialsc.command.reload")) {
+                sender.sendMessage(getLang().getString("messages.no-permission"));
+                return true;
+            }
+            plugin.reloadConfig();
+            EssentialsC.getLangManager().reload();
+            sender.sendMessage(getLang().getString("prefix") + "Configuration reloaded.");
+            return true;
+        }
+        sender.sendMessage(getLang().getString("messages.player-only"));
+        return true;
+    }
+
+    private boolean handleCommand(CommandSender sender, Player player, String[] args) {
+        if (args.length > 0) {
+            String subCommand = args[0].toLowerCase();
+
+            if (subCommand.equals("reload")) {
+                if (!sender.hasPermission("essentialsc.command.reload")) {
+                    sender.sendMessage(getLang().getString("messages.no-permission"));
+                    return true;
+                }
+                plugin.reloadConfig();
+                EssentialsC.getLangManager().reload();
+                sender.sendMessage(getLang().getString("prefix") + "Configuration reloaded.");
+                return true;
+            }
+
+            String actualCommand = getActualCommand(subCommand);
+            BaseCommand targetCommand = CommandRegistry.getCommand(actualCommand);
+            if (actualCommand != null && targetCommand != null) {
+                String permission = CommandRegistry.getPermission(actualCommand);
+                if (permission != null && !player.hasPermission(permission)) {
+                    player.sendMessage(getLang().getString("messages.no-permission"));
+                    return true;
+                }
+
+                if (actualCommand.equals("seen")) {
+                    if (args.length < 2) {
+                        player.sendMessage(getLang().getString("prefix") + getLang().getString("messages.seen-usage-console"));
+                        return true;
+                    }
+                    targetCommand.execute(player, new String[]{args[1]});
+                } else {
+                    targetCommand.execute(player, new String[0]);
+                }
+                return true;
+            }
+
+            if (subCommand.equals("version") || subCommand.equals("v")) {
+                player.sendMessage(getLang().getString("prefix") + "EssentialsC v" + plugin.getDescription().getVersion());
+                player.sendMessage(getLang().getString("prefix") + "Running on Paper " + Bukkit.getVersion());
+                return true;
+            }
+
+            player.sendMessage(getLang().getString("prefix") + getLang().getString("messages.unknown-subcommand",
+                Map.of("command", subCommand)));
+            player.sendMessage(getLang().getString("prefix") + getLang().getString("messages.help-usage"));
+            return true;
+        }
+
         LangManager lang = getLang();
         String version = plugin.getDescription().getVersion();
 
         player.sendMessage(lang.getString("help.title"));
-        player.sendMessage(lang.getString("help.version", 
+        player.sendMessage(lang.getString("help.version", Map.of("version", version)));
-            java.util.Map.of("version", version)));
         player.sendMessage("");
 
-        // 功能方块命令（检查权限后显示）
         boolean hasBlockCommands = false;
         StringBuilder blockCommands = new StringBuilder();
 
-        if (player.hasPermission("essentialsc.command.workbench")) {
+        if (CommandRegistry.isAvailable("workbench") && player.hasPermission("essentialsc.command.workbench")) {
             blockCommands.append(lang.getString("help.commands.workbench")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.anvil")) {
+        if (CommandRegistry.isAvailable("anvil") && player.hasPermission("essentialsc.command.anvil")) {
             blockCommands.append(lang.getString("help.commands.anvil")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.enchantingtable")) {
+        if (CommandRegistry.isAvailable("cartographytable") && player.hasPermission("essentialsc.command.cartographytable")) {
-            blockCommands.append(lang.getString("help.commands.enchantingtable")).append("\n");
-            hasBlockCommands = true;
-        }
-        if (player.hasPermission("essentialsc.command.cartographytable")) {
             blockCommands.append(lang.getString("help.commands.cartographytable")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.grindstone")) {
+        if (CommandRegistry.isAvailable("grindstone") && player.hasPermission("essentialsc.command.grindstone")) {
             blockCommands.append(lang.getString("help.commands.grindstone")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.loom")) {
+        if (CommandRegistry.isAvailable("loom") && player.hasPermission("essentialsc.command.loom")) {
             blockCommands.append(lang.getString("help.commands.loom")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.smithingtable")) {
+        if (CommandRegistry.isAvailable("smithingtable") && player.hasPermission("essentialsc.command.smithingtable")) {
             blockCommands.append(lang.getString("help.commands.smithingtable")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.stonecutter")) {
+        if (CommandRegistry.isAvailable("stonecutter") && player.hasPermission("essentialsc.command.stonecutter")) {
             blockCommands.append(lang.getString("help.commands.stonecutter")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.enderchest")) {
+        if (CommandRegistry.isAvailable("enderchest") && player.hasPermission("essentialsc.command.enderchest")) {
             blockCommands.append(lang.getString("help.commands.enderchest")).append("\n");
             hasBlockCommands = true;
         }
@@ -68,38 +136,33 @@ public class HelpCommand extends BaseCommand {
             player.sendMessage("");
         }
 
-        // 其他命令（检查权限后显示）
         boolean hasOtherCommands = false;
         StringBuilder otherCommands = new StringBuilder();
 
-        if (player.hasPermission("essentialsc.command.hat")) {
+        if (CommandRegistry.isAvailable("hat") && player.hasPermission("essentialsc.command.hat")) {
             otherCommands.append(lang.getString("help.commands.hat")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.suicide")) {
+        if (CommandRegistry.isAvailable("suicide") && player.hasPermission("essentialsc.command.suicide")) {
             otherCommands.append(lang.getString("help.commands.suicide")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.fly")) {
+        if (CommandRegistry.isAvailable("fly") && player.hasPermission("essentialsc.command.fly")) {
             otherCommands.append(lang.getString("help.commands.fly")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.heal")) {
+        if (CommandRegistry.isAvailable("heal") && player.hasPermission("essentialsc.command.heal")) {
             otherCommands.append(lang.getString("help.commands.heal")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.vanish")) {
+        if (CommandRegistry.isAvailable("vanish") && player.hasPermission("essentialsc.command.vanish")) {
             otherCommands.append(lang.getString("help.commands.vanish")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.seen")) {
+        if (CommandRegistry.isAvailable("seen") && player.hasPermission("essentialsc.command.seen")) {
             otherCommands.append(lang.getString("help.commands.seen")).append("\n");
             hasOtherCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.admin")) {
-            otherCommands.append(lang.getString("help.commands.admin")).append("\n");
-            hasOtherCommands = true;
-        }
 
         if (hasOtherCommands) {
             player.sendMessage(lang.getString("help.section-other"));
@@ -110,4 +173,82 @@ public class HelpCommand extends BaseCommand {
         player.sendMessage(lang.getString("help.footer"));
         return true;
     }
+
+    private String getActualCommand(String alias) {
+        return CommandRegistry.resolveCommandName(alias);
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length == 1) {
+            List<String> completions = new ArrayList<>();
+            String partial = args[0].toLowerCase();
+
+            String[][] subCommands = {
+                {"reload", "essentialsc.command.reload"},
+                {"blocks", "essentialsc.command.blocks"},
+                {"workbench", "essentialsc.command.workbench"},
+                {"wb", "essentialsc.command.workbench"},
+                {"anvil", "essentialsc.command.anvil"},
+                {"cartographytable", "essentialsc.command.cartographytable"},
+                {"cartography", "essentialsc.command.cartographytable"},
+                {"ct", "essentialsc.command.cartographytable"},
+                {"grindstone", "essentialsc.command.grindstone"},
+                {"gs", "essentialsc.command.grindstone"},
+                {"loom", "essentialsc.command.loom"},
+                {"smithingtable", "essentialsc.command.smithingtable"},
+                {"smithing", "essentialsc.command.smithingtable"},
+                {"st", "essentialsc.command.smithingtable"},
+                {"stonecutter", "essentialsc.command.stonecutter"},
+                {"sc", "essentialsc.command.stonecutter"},
+                {"enderchest", "essentialsc.command.enderchest"},
+                {"ec", "essentialsc.command.enderchest"},
+                {"hat", "essentialsc.command.hat"},
+                {"suicide", "essentialsc.command.suicide"},
+                {"die", "essentialsc.command.suicide"},
+                {"fly", "essentialsc.command.fly"},
+                {"heal", "essentialsc.command.heal"},
+                {"vanish", "essentialsc.command.vanish"},
+                {"v", "essentialsc.command.vanish"},
+                {"seen", "essentialsc.command.seen"},
+                {"info", "essentialsc.command.seen"},
+                {"feed", "essentialsc.command.feed"},
+                {"repair", "essentialsc.command.repair"},
+                {"rep", "essentialsc.command.repair"},
+                {"mobdrops", "essentialsc.mobdrops.enderman"},
+                {"version", null},
+                {"help", null}
+            };
+
+            for (String[] subCmd : subCommands) {
+                if (!subCmd[0].startsWith(partial)) {
+                    continue;
+                }
+
+                String actualCommand = getActualCommand(subCmd[0]);
+                boolean available = actualCommand == null || CommandRegistry.isAvailable(actualCommand);
+                if (available && (subCmd[1] == null || sender.hasPermission(subCmd[1]))) {
+                    completions.add(subCmd[0]);
+                }
+            }
+
+            return completions;
+        }
+
+        if (args.length == 2) {
+            String subCmd = args[0].toLowerCase();
+            if ((subCmd.equals("seen") || subCmd.equals("info")) && sender.hasPermission("essentialsc.command.seen")) {
+                List<String> players = new ArrayList<>();
+                String partial = args[1].toLowerCase();
+                for (Player p : Bukkit.getOnlinePlayers()) {
+                    if (p.getName().toLowerCase().startsWith(partial)) {
+                        players.add(p.getName());
+                    }
+                }
+                return players;
+            }
+        }
+
+        return new ArrayList<>();
+    }
 }

src/main/java/cn/infstar/essentialsC/commands/MobDropCommand.java

@@ -0,0 +1,81 @@
+package cn.infstar.essentialsC.commands;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.Arrays;
+
+/**
+ * 生物掉落物控制命令
+ * /mobdrops - 打开控制菜单
+ */
+public class MobDropCommand extends BaseCommand {
+
+    public static final class MobDropMenuHolder implements InventoryHolder {
+        private final Inventory inventory;
+
+        public MobDropMenuHolder(String title) {
+            this.inventory = Bukkit.createInventory(this, 27, title);
+        }
+
+        @Override
+        public Inventory getInventory() {
+            return inventory;
+        }
+    }
+    
+    public MobDropCommand() {
+        super("essentialsc.mobdrops.enderman");
+    }
+    
+    @Override
+    protected boolean execute(Player player, String[] args) {
+        openMobDropMenu(player);
+        return true;
+    }
+    
+    /**
+     * 打开生物掉落控制菜单
+     */
+    private void openMobDropMenu(Player player) {
+        // 读取当前配置
+        boolean endermanEnabled = plugin.getConfig().getBoolean("mob-drops.enderman.enabled", true);
+        
+        // 创建菜单
+        Inventory menu = new MobDropMenuHolder("§6§l生物掉落控制").getInventory();
+        
+        // 末影人控制项
+        ItemStack endermanItem = new ItemStack(Material.ENDER_PEARL);
+        ItemMeta endermanMeta = endermanItem.getItemMeta();
+        endermanMeta.setDisplayName("§d末影人掉落");
+        endermanMeta.setLore(Arrays.asList(
+            "§7当前状态: " + (endermanEnabled ? "§a✅ 开启" : "§c❌ 关闭"),
+            "",
+            "§e点击切换状态"
+        ));
+        endermanItem.setItemMeta(endermanMeta);
+        
+        // 放置在中间
+        menu.setItem(13, endermanItem);
+        
+        // 装饰物品
+        ItemStack glass = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
+        ItemMeta glassMeta = glass.getItemMeta();
+        glassMeta.setDisplayName(" ");
+        glass.setItemMeta(glassMeta);
+        
+        for (int i = 0; i < 27; i++) {
+            if (menu.getItem(i) == null) {
+                menu.setItem(i, glass);
+            }
+        }
+        
+        player.openInventory(menu);
+    }
+}

src/main/java/cn/infstar/essentialsC/listeners/JeiRecipeSyncListener.java

@@ -0,0 +1,391 @@
+package cn.infstar.essentialsC.listeners;
+
+import cn.infstar.essentialsC.EssentialsC;
+import io.netty.buffer.Unpooled;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
+import net.minecraft.network.protocol.common.custom.DiscardedPayload;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.item.crafting.RecipeHolder;
+import net.minecraft.world.item.crafting.RecipeMap;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * JEI 配方同步监听器
+ * 解决 Minecraft 1.21.2+ 配方不同步问题
+ * 支持 Fabric 和 NeoForge 客户端
+ */
+public class JeiRecipeSyncListener implements Listener {
+    
+    private final EssentialsC plugin;
+    private final boolean enabled;
+    private final boolean debug;
+    private final boolean sendPlayerMessage;
+    
+    public JeiRecipeSyncListener(EssentialsC plugin) {
+        this.plugin = plugin;
+        
+        FileConfiguration config = plugin.getConfig();
+        this.enabled = config.getBoolean("jei-sync.enabled", true);
+        this.debug = config.getBoolean("jei-sync.debug", false);
+        this.sendPlayerMessage = config.getBoolean("jei-sync.send-player-message", true);
+    }
+    
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        if (!enabled) {
+            return;
+        }
+        
+        Player player = event.getPlayer();
+        String clientBrand = player.getClientBrandName();
+        
+        if (debug) {
+            plugin.getLogger().info("========================================");
+            plugin.getLogger().info("玩家 " + player.getName() + " 加入");
+            plugin.getLogger().info("客户端品牌: '" + (clientBrand != null ? clientBrand : "null") + "'");
+            plugin.getLogger().info("JEI 同步功能: " + (enabled ? "启用" : "禁用"));
+            plugin.getLogger().info("========================================");
+        }
+        
+        if (clientBrand == null || clientBrand.isEmpty()) {
+            if (debug) {
+                plugin.getLogger().info("跳过 " + player.getName() + "：客户端品牌为空");
+            }
+            return;
+        }
+        
+        // 统一转换为小写进行比较，支持更多变体
+        String brandLower = clientBrand.toLowerCase();
+        
+        if (brandLower.contains("fabric")) {
+            if (debug) {
+                plugin.getLogger().info("检测到 Fabric 客户端，开始发送配方同步...");
+            }
+            sendPlayerMessage(player, "Fabric");
+            sendFabricRecipeSync(player);
+        } else if (brandLower.contains("neoforge") || brandLower.contains("forge")) {
+            if (debug) {
+                plugin.getLogger().info("检测到 NeoForge/Forge 客户端，开始发送配方同步...");
+            }
+            sendPlayerMessage(player, "NeoForge");
+            sendNeoForgeRecipeSync(player);
+        } else {
+            if (debug) {
+                plugin.getLogger().info("跳过 " + player.getName() + "：不支持的客户端类型 '" + clientBrand + "'");
+            }
+        }
+    }
+    
+    /**
+     * 发送提示消息给玩家
+     */
+    private void sendPlayerMessage(Player player, String clientType) {
+        if (!sendPlayerMessage) {
+            return;
+        }
+        
+        String messageKey;
+        if (clientType.equalsIgnoreCase("fabric")) {
+            messageKey = "messages.jei-sync-fabric";
+        } else if (clientType.equalsIgnoreCase("neoforge")) {
+            messageKey = "messages.jei-sync-neoforge";
+        } else {
+            return;
+        }
+        
+        // 使用统一前缀 + 消息内容
+        String prefix = EssentialsC.getLangManager().getString("prefix");
+        String message = EssentialsC.getLangManager().getString(messageKey);
+        String fullMessage = prefix + " " + message;
+        
+        net.kyori.adventure.text.Component component = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().deserialize(fullMessage);
+        player.sendMessage(component);
+    }
+    
+    /**
+     * 发送 Fabric 格式的配方同步数据包
+     */
+    @SuppressWarnings({"unchecked", "deprecation"})
+    private void sendFabricRecipeSync(Player player) {
+        try {
+            ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
+            MinecraftServer server = serverPlayer.level().getServer();
+            if (server == null) {
+                if (debug) plugin.getLogger().warning("服务器实例为 null");
+                return;
+            }
+            
+            RecipeMap recipeMap = server.getRecipeManager().recipes;
+            
+            if (debug) {
+                plugin.getLogger().info("开始构建 Fabric 配方数据");
+            }
+            
+            // 创建 Fabric Payload（与参考插件完全一致）
+            var list = new ArrayList<FabricRecipeEntry>();
+            var seen = new HashSet<RecipeSerializer<?>>();
+            
+            for (RecipeSerializer<?> serializer : BuiltInRegistries.RECIPE_SERIALIZER) {
+                if (!seen.add(serializer)) continue;
+                
+                List<RecipeHolder<?>> recipes = new ArrayList<>();
+                for (RecipeHolder<?> holder : recipeMap.values()) {
+                    if (holder.value().getSerializer() == serializer) {
+                        recipes.add(holder);
+                    }
+                }
+                
+                if (!recipes.isEmpty()) {
+                    RecipeSerializer<?> entrySerializer = recipes.get(0).value().getSerializer();
+                    list.add(new FabricRecipeEntry(entrySerializer, recipes));
+                }
+            }
+            
+            var payload = new FabricRecipeSyncPayload(list);
+            
+            if (debug) {
+                plugin.getLogger().info("Fabric 配方条目数: " + list.size());
+            }
+            
+            // 构建 buffer
+            RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(
+                Unpooled.buffer(), 
+                server.registryAccess()
+            );
+            
+            // 使用 CODEC 编码（与参考插件完全一致）
+            var codec = getFabricCodec();
+            codec.encode(buffer, payload);
+            
+            // 发送数据包
+            byte[] bytes = new byte[buffer.writerIndex()];
+            buffer.getBytes(0, bytes);
+            
+            Identifier id = Identifier.fromNamespaceAndPath("fabric", "recipe_sync");
+            DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
+            serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
+            
+            if (debug) {
+                plugin.getLogger().info("已发送 Fabric 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
+            }
+            
+        } catch (Exception e) {
+            plugin.getLogger().warning("发送 Fabric 配方同步失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * 获取 Fabric Codec
+     */
+    @SuppressWarnings({"unchecked", "deprecation"})
+    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeSyncPayload> getFabricCodec() {
+        return FabricRecipeEntry.CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list())
+            .map(FabricRecipeSyncPayload::new, FabricRecipeSyncPayload::entries);
+    }
+    
+    /**
+     * 发送 NeoForge 格式的配方同步数据包
+     */
+    @SuppressWarnings({"unchecked", "deprecation"})
+    private void sendNeoForgeRecipeSync(Player player) {
+        try {
+            ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
+            MinecraftServer server = serverPlayer.level().getServer();
+            if (server == null) {
+                if (debug) plugin.getLogger().warning("服务器实例为 null");
+                return;
+            }
+            
+            RecipeMap recipeMap = server.getRecipeManager().recipes;
+            
+            if (debug) {
+                plugin.getLogger().info("开始构建 NeoForge 配方数据");
+            }
+            
+            // 获取所有配方类型
+            java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> allRecipeTypes = 
+                BuiltInRegistries.RECIPE_TYPE.stream().toList();
+            
+            if (debug) {
+                plugin.getLogger().info("NeoForge 配方类型数: " + allRecipeTypes.size());
+            }
+            
+            // 创建 NeoForge Payload（与参考插件完全一致）
+            var payload = createNeoForgePayload(allRecipeTypes, recipeMap);
+            
+            // 构建 buffer
+            RegistryFriendlyByteBuf buffer = new RegistryFriendlyByteBuf(
+                Unpooled.buffer(), 
+                server.registryAccess()
+            );
+            
+            // 使用 STREAM_CODEC 编码（与参考插件完全一致）
+            var streamCodec = getNeoForgeStreamCodec();
+            streamCodec.encode(buffer, payload);
+            
+            // 发送数据包
+            byte[] bytes = new byte[buffer.writerIndex()];
+            buffer.getBytes(0, bytes);
+            
+            Identifier id = Identifier.fromNamespaceAndPath("neoforge", "recipe_content");
+            DiscardedPayload discardedPayload = new DiscardedPayload(id, bytes);
+            serverPlayer.connection.send(new ClientboundCustomPayloadPacket(discardedPayload));
+            
+            // 发送 Tags 同步（NeoForge 需要）
+            serverPlayer.connection.send(new net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket(
+                net.minecraft.tags.TagNetworkSerialization.serializeTagsToNetwork(server.registries())
+            ));
+            
+            if (debug) {
+                plugin.getLogger().info("已发送 NeoForge 配方同步 [" + id + "], 大小: " + bytes.length + " bytes");
+            }
+            
+        } catch (Exception e) {
+            plugin.getLogger().warning("发送 NeoForge 配方同步失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * 创建 NeoForge 配载对象
+     */
+    private NeoForgeRecipeSyncPayload createNeoForgePayload(
+            java.util.List<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
+            RecipeMap recipeMap) {
+        var recipeTypeSet = new java.util.HashSet<>(recipeTypes);
+        
+        if (recipeTypeSet.isEmpty()) {
+            return new NeoForgeRecipeSyncPayload(recipeTypeSet, java.util.List.of());
+        } else {
+            var recipeSubset = recipeMap.values().stream()
+                .filter(h -> recipeTypeSet.contains(h.value().getType()))
+                .toList();
+            return new NeoForgeRecipeSyncPayload(recipeTypeSet, recipeSubset);
+        }
+    }
+    
+    /**
+     * 获取 NeoForge StreamCodec
+     */
+    @SuppressWarnings({"unchecked", "deprecation"})
+    private net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, NeoForgeRecipeSyncPayload> getNeoForgeStreamCodec() {
+        return net.minecraft.network.codec.StreamCodec.composite(
+            net.minecraft.network.codec.ByteBufCodecs.registry(net.minecraft.core.registries.Registries.RECIPE_TYPE)
+                .apply(net.minecraft.network.codec.ByteBufCodecs.collection(java.util.HashSet::new)),
+            NeoForgeRecipeSyncPayload::recipeTypes,
+            RecipeHolder.STREAM_CODEC.apply(net.minecraft.network.codec.ByteBufCodecs.list()),
+            NeoForgeRecipeSyncPayload::recipes,
+            NeoForgeRecipeSyncPayload::new
+        );
+    }
+    
+    /**
+     * Fabric 配方条目
+     */
+    @SuppressWarnings("deprecation")
+    private static class FabricRecipeEntry {
+        final Object serializer;  // 使用 Object 避免 NMS 类型不兼容
+        final List<RecipeHolder<?>> recipes;
+        
+        FabricRecipeEntry(Object serializer, List<RecipeHolder<?>> recipes) {
+            this.serializer = serializer;
+            this.recipes = recipes;
+        }
+        
+        static final net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, FabricRecipeEntry> CODEC = 
+            net.minecraft.network.codec.StreamCodec.ofMember(
+                FabricRecipeEntry::write,
+                FabricRecipeEntry::read
+            );
+        
+        @SuppressWarnings("unchecked")
+        private static FabricRecipeEntry read(RegistryFriendlyByteBuf buf) {
+            Identifier recipeSerializerId = buf.readIdentifier();
+            RecipeSerializer<?> recipeSerializer = BuiltInRegistries.RECIPE_SERIALIZER.getValue(recipeSerializerId);
+            
+            if (recipeSerializer == null) {
+                throw new RuntimeException("Tried syncing unsupported packet serializer '" + recipeSerializerId + "'!");
+            }
+            
+            int count = buf.readVarInt();
+            var list = new ArrayList<RecipeHolder<?>>();
+            
+            for (int i = 0; i < count; i++) {
+                net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> id = 
+                    buf.readResourceKey(net.minecraft.core.registries.Registries.RECIPE);
+                
+                // 使用反射获取 streamCodec，避免 NMS 类型不兼容
+                try {
+                    var streamCodecMethod = recipeSerializer.getClass().getMethod("streamCodec");
+                    var streamCodec = streamCodecMethod.invoke(recipeSerializer);
+                    net.minecraft.world.item.crafting.Recipe<?> recipe = 
+                        ((net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>) streamCodec)
+                            .decode(buf);
+                    list.add(new RecipeHolder<>(id, recipe));
+                } catch (Exception e) {
+                    throw new RuntimeException("Failed to decode recipe: " + e.getMessage(), e);
+                }
+            }
+            
+            return new FabricRecipeEntry(recipeSerializer, list);
+        }
+        
+        private void write(RegistryFriendlyByteBuf buf) {
+            // 使用反射获取 key，避免 NMS 类型不兼容
+            try {
+                var getKeyMethod = BuiltInRegistries.RECIPE_SERIALIZER.getClass().getMethod("getKey", Object.class);
+                Identifier identifier = (Identifier) getKeyMethod.invoke(BuiltInRegistries.RECIPE_SERIALIZER, this.serializer);
+                buf.writeIdentifier(identifier);
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to get serializer key: " + e.getMessage(), e);
+            }
+            
+            buf.writeVarInt(this.recipes.size());
+            
+            // 使用反射获取 streamCodec，避免 NMS 类型不兼容
+            try {
+                var streamCodecMethod = this.serializer.getClass().getMethod("streamCodec");
+                @SuppressWarnings("unchecked")
+                var codec = (net.minecraft.network.codec.StreamCodec<RegistryFriendlyByteBuf, net.minecraft.world.item.crafting.Recipe<?>>) 
+                    streamCodecMethod.invoke(this.serializer);
+                
+                for (RecipeHolder<?> recipe : this.recipes) {
+                    buf.writeResourceKey(recipe.id());
+                    codec.encode(buf, recipe.value());
+                }
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to encode recipe: " + e.getMessage(), e);
+            }
+        }
+    }
+    
+    /**
+     * Fabric 配方同步 Payload
+     */
+    private record FabricRecipeSyncPayload(List<FabricRecipeEntry> entries) {
+    }
+    
+    /**
+     * NeoForge 配方同步 Payload
+     */
+    private record NeoForgeRecipeSyncPayload(
+            java.util.Set<net.minecraft.world.item.crafting.RecipeType<?>> recipeTypes,
+            java.util.List<RecipeHolder<?>> recipes) {
+    }
+}

src/main/java/cn/infstar/essentialsC/listeners/MobDropListener.java

@@ -0,0 +1,63 @@
+package cn.infstar.essentialsC.listeners;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDeathEvent;
+
+/**
+ * 生物掉落物控制监听器
+ * 当前仅支持末影人
+ */
+public class MobDropListener implements Listener {
+    
+    private final EssentialsC plugin;
+    private boolean endermanDropEnabled;
+    
+    public MobDropListener(EssentialsC plugin) {
+        this.plugin = plugin;
+        loadConfig();
+        
+        // 注册监听器
+    }
+    
+    /**
+     * 加载配置
+     */
+    private void loadConfig() {
+        FileConfiguration config = plugin.getConfig();
+        config.addDefault("mob-drops.enderman.enabled", true);
+        config.options().copyDefaults(true);
+        
+        try {
+            config.save(plugin.getDataFolder().toPath().resolve("config.yml").toFile());
+        } catch (Exception e) {
+            plugin.getLogger().warning("无法保存配置文件: " + e.getMessage());
+        }
+        
+        this.endermanDropEnabled = config.getBoolean("mob-drops.enderman.enabled", true);
+    }
+    
+    @EventHandler
+    public void onEntityDeath(EntityDeathEvent event) {
+        if (event.getEntityType() != EntityType.ENDERMAN) {
+            return;
+        }
+        
+        boolean enabled = plugin.getConfig().getBoolean("mob-drops.enderman.enabled", true);
+        
+        if (!enabled) {
+            event.getDrops().clear();
+        }
+    }
+    
+    /**
+     * 重新加载配置
+     */
+    public void reload() {
+        loadConfig();
+        plugin.getLogger().info("生物掉落物配置已重载（末影人: " + (endermanDropEnabled ? "开启" : "关闭") + "）");
+    }
+}

src/main/java/cn/infstar/essentialsC/listeners/MobDropMenuListener.java

@@ -0,0 +1,101 @@
+package cn.infstar.essentialsC.listeners;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.Arrays;
+
+public class MobDropMenuListener implements Listener {
+    
+    private final EssentialsC plugin;
+    
+    public MobDropMenuListener(EssentialsC plugin) {
+        this.plugin = plugin;
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+    
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getView().getTopInventory().getHolder(false) instanceof cn.infstar.essentialsC.commands.MobDropCommand.MobDropMenuHolder)) {
+            return;
+        }
+        
+        event.setCancelled(true);
+        
+        if (!(event.getWhoClicked() instanceof Player player)) {
+            return;
+        }
+        
+        ItemStack clickedItem = event.getCurrentItem();
+        if (clickedItem == null) {
+            return;
+        }
+        
+        if (event.getSlot() == 13) {
+            toggleEndermanDrops(player);
+            Bukkit.getScheduler().runTaskLater(plugin, () -> openMobDropMenu(player), 2L);
+        }
+    }
+    
+    private void toggleEndermanDrops(Player player) {
+        FileConfiguration config = plugin.getConfig();
+        boolean currentValue = config.getBoolean("mob-drops.enderman.enabled", true);
+        boolean newValue = !currentValue;
+        
+        config.set("mob-drops.enderman.enabled", newValue);
+        
+        try {
+            config.save(plugin.getDataFolder().toPath().resolve("config.yml").toFile());
+        } catch (Exception e) {
+            player.sendMessage(EssentialsC.getLangManager().getString("prefix") + 
+                EssentialsC.getLangManager().getString("messages.mobdrop-save-failed",
+                    java.util.Map.of("error", e.getMessage())));
+            return;
+        }
+        
+        String status = newValue ? "§a开启" : "§c关闭";
+        player.sendMessage(EssentialsC.getLangManager().getString("prefix") + 
+            EssentialsC.getLangManager().getString("messages.mobdrop-toggled",
+                java.util.Map.of("status", status)));
+    }
+    
+    private void openMobDropMenu(Player player) {
+        boolean endermanEnabled = plugin.getConfig().getBoolean("mob-drops.enderman.enabled", true);
+        
+        Inventory menu = new cn.infstar.essentialsC.commands.MobDropCommand.MobDropMenuHolder("§6§l生物掉落控制").getInventory();
+        
+        ItemStack endermanItem = new ItemStack(Material.ENDER_PEARL);
+        ItemMeta endermanMeta = endermanItem.getItemMeta();
+        endermanMeta.setDisplayName("§d末影人掉落");
+        endermanMeta.setLore(Arrays.asList(
+            "§7当前状态: " + (endermanEnabled ? "§a✅ 开启" : "§c❌ 关闭"),
+            "",
+            "§e点击切换状态"
+        ));
+        endermanItem.setItemMeta(endermanMeta);
+        
+        menu.setItem(13, endermanItem);
+        
+        ItemStack glass = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
+        ItemMeta glassMeta = glass.getItemMeta();
+        glassMeta.setDisplayName(" ");
+        glass.setItemMeta(glassMeta);
+        
+        for (int i = 0; i < 27; i++) {
+            if (menu.getItem(i) == null) {
+                menu.setItem(i, glass);
+            }
+        }
+        
+        player.openInventory(menu);
+    }
+}

src/main/java/cn/infstar/essentialsC/listeners/ShulkerBoxListener.java

@@ -0,0 +1,322 @@
+package cn.infstar.essentialsC.listeners;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.block.ShulkerBox;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.BlockStateMeta;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+public class ShulkerBoxListener implements Listener {
+
+    private static final int SHULKER_SIZE = 27;
+
+    private static final Set<Material> SHULKER_BOX_MATERIALS = Set.of(
+        Material.SHULKER_BOX,
+        Material.WHITE_SHULKER_BOX,
+        Material.ORANGE_SHULKER_BOX,
+        Material.MAGENTA_SHULKER_BOX,
+        Material.LIGHT_BLUE_SHULKER_BOX,
+        Material.YELLOW_SHULKER_BOX,
+        Material.LIME_SHULKER_BOX,
+        Material.PINK_SHULKER_BOX,
+        Material.GRAY_SHULKER_BOX,
+        Material.LIGHT_GRAY_SHULKER_BOX,
+        Material.CYAN_SHULKER_BOX,
+        Material.PURPLE_SHULKER_BOX,
+        Material.BLUE_SHULKER_BOX,
+        Material.BROWN_SHULKER_BOX,
+        Material.GREEN_SHULKER_BOX,
+        Material.RED_SHULKER_BOX,
+        Material.BLACK_SHULKER_BOX
+    );
+
+    private final EssentialsC plugin;
+    private final Map<UUID, OpenShulkerSession> openShulkerBoxes = new HashMap<>();
+
+    private static final class ShulkerBoxHolder implements InventoryHolder {
+        private final Inventory inventory;
+
+        private ShulkerBoxHolder(String title) {
+            this.inventory = Bukkit.createInventory(this, SHULKER_SIZE, title);
+        }
+
+        @Override
+        public Inventory getInventory() {
+            return this.inventory;
+        }
+    }
+
+    private static final class OpenShulkerSession {
+        private final ItemStack sourceItem;
+        private final EquipmentSlot sourceHand;
+        private final int preferredSlot;
+
+        private OpenShulkerSession(ItemStack sourceItem, EquipmentSlot sourceHand, int preferredSlot) {
+            this.sourceItem = sourceItem;
+            this.sourceHand = sourceHand;
+            this.preferredSlot = preferredSlot;
+        }
+    }
+
+    public ShulkerBoxListener(EssentialsC plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        if (!player.isSneaking() || !player.hasPermission("essentialsc.shulkerbox.open")) {
+            return;
+        }
+
+        if (openShulkerBoxes.containsKey(player.getUniqueId())) {
+            return;
+        }
+
+        EquipmentSlot hand = event.getHand() == EquipmentSlot.OFF_HAND ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND;
+        ItemStack sourceItem = getItemFromHand(player, hand);
+        if (!isShulkerBox(sourceItem)) {
+            return;
+        }
+
+        if (!(sourceItem.getItemMeta() instanceof BlockStateMeta blockStateMeta)) {
+            return;
+        }
+        if (!(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox)) {
+            return;
+        }
+
+        event.setUseItemInHand(org.bukkit.event.Event.Result.DENY);
+        event.setUseInteractedBlock(org.bukkit.event.Event.Result.DENY);
+
+        ItemStack sourceSnapshot = sourceItem.clone();
+        plugin.getServer().getScheduler().runTask(plugin, () -> {
+            if (!player.isOnline() || openShulkerBoxes.containsKey(player.getUniqueId())) {
+                return;
+            }
+            openShulkerBox(player, hand, sourceSnapshot, shulkerBox);
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) {
+            return;
+        }
+
+        InventoryView view = event.getView();
+        Inventory topInventory = view.getTopInventory();
+        if (!(topInventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+            return;
+        }
+
+        int topSize = topInventory.getSize();
+        boolean clickTopInventory = event.getRawSlot() >= 0 && event.getRawSlot() < topSize;
+
+        if (clickTopInventory && isShulkerBox(event.getCursor())) {
+            event.setCancelled(true);
+            sendNestedMessage(player);
+            return;
+        }
+
+        if (clickTopInventory && event.getClick() == ClickType.NUMBER_KEY) {
+            ItemStack hotbarItem = player.getInventory().getItem(event.getHotbarButton());
+            if (isShulkerBox(hotbarItem)) {
+                event.setCancelled(true);
+                sendNestedMessage(player);
+                return;
+            }
+        }
+
+        if (event.isShiftClick() && isShulkerBox(event.getCurrentItem())) {
+            event.setCancelled(true);
+            sendNestedMessage(player);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onInventoryDrag(InventoryDragEvent event) {
+        InventoryView view = event.getView();
+        Inventory topInventory = view.getTopInventory();
+        if (!(topInventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+            return;
+        }
+
+        if (!isShulkerBox(event.getOldCursor())) {
+            return;
+        }
+
+        int topSize = topInventory.getSize();
+        for (int rawSlot : event.getRawSlots()) {
+            if (rawSlot >= 0 && rawSlot < topSize) {
+                event.setCancelled(true);
+                if (event.getWhoClicked() instanceof Player player) {
+                    sendNestedMessage(player);
+                }
+                return;
+            }
+        }
+    }
+
+    @EventHandler
+    public void onInventoryClose(InventoryCloseEvent event) {
+        if (!(event.getPlayer() instanceof Player player)) {
+            return;
+        }
+
+        commitOpenShulker(player, event.getInventory());
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        commitOpenShulker(player, player.getOpenInventory().getTopInventory());
+    }
+
+    @EventHandler
+    public void onPluginDisable(PluginDisableEvent event) {
+        if (event.getPlugin() != plugin) {
+            return;
+        }
+
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            commitOpenShulker(player, player.getOpenInventory().getTopInventory());
+        }
+    }
+
+    private void commitOpenShulker(Player player, Inventory inventory) {
+        if (!(inventory.getHolder(false) instanceof ShulkerBoxHolder)) {
+            return;
+        }
+
+        OpenShulkerSession session = openShulkerBoxes.remove(player.getUniqueId());
+        if (session == null) {
+            return;
+        }
+
+        ItemStack updatedShulker = session.sourceItem.clone();
+        writeInventoryBack(updatedShulker, inventory.getContents());
+        restoreItemToPlayer(player, session, updatedShulker);
+    }
+
+    private void openShulkerBox(Player player, EquipmentSlot hand, ItemStack sourceItem, ShulkerBox shulkerBox) {
+        removeItemFromHand(player, hand);
+
+        ShulkerBoxHolder holder = new ShulkerBoxHolder(resolveTitle(sourceItem));
+        holder.getInventory().setContents(cloneContents(shulkerBox.getInventory().getContents()));
+
+        int preferredSlot = hand == EquipmentSlot.HAND ? player.getInventory().getHeldItemSlot() : -1;
+        openShulkerBoxes.put(player.getUniqueId(), new OpenShulkerSession(sourceItem, hand, preferredSlot));
+        player.openInventory(holder.getInventory());
+    }
+
+    private void writeInventoryBack(ItemStack shulkerItem, ItemStack[] contents) {
+        if (!(shulkerItem.getItemMeta() instanceof BlockStateMeta blockStateMeta)) {
+            plugin.getLogger().warning("Failed to save shulker box contents: missing BlockStateMeta.");
+            return;
+        }
+
+        if (!(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox)) {
+            plugin.getLogger().warning("Failed to save shulker box contents: block state is not a ShulkerBox.");
+            return;
+        }
+
+        shulkerBox.getInventory().setContents(cloneContents(contents));
+        blockStateMeta.setBlockState(shulkerBox);
+        shulkerItem.setItemMeta(blockStateMeta);
+    }
+
+    private void restoreItemToPlayer(Player player, OpenShulkerSession session, ItemStack shulkerItem) {
+        PlayerInventory inventory = player.getInventory();
+
+        if (session.sourceHand == EquipmentSlot.OFF_HAND) {
+            if (isEmpty(inventory.getItemInOffHand())) {
+                inventory.setItemInOffHand(shulkerItem);
+                return;
+            }
+        } else if (session.preferredSlot >= 0 && isEmpty(inventory.getItem(session.preferredSlot))) {
+            inventory.setItem(session.preferredSlot, shulkerItem);
+            return;
+        }
+
+        Map<Integer, ItemStack> leftovers = inventory.addItem(shulkerItem);
+        for (ItemStack leftover : leftovers.values()) {
+            player.getWorld().dropItemNaturally(player.getLocation(), leftover);
+        }
+    }
+
+    private ItemStack[] cloneContents(ItemStack[] contents) {
+        ItemStack[] copied = new ItemStack[SHULKER_SIZE];
+        for (int i = 0; i < SHULKER_SIZE && i < contents.length; i++) {
+            copied[i] = contents[i] == null ? null : contents[i].clone();
+        }
+        return copied;
+    }
+
+    private ItemStack getItemFromHand(Player player, EquipmentSlot hand) {
+        return hand == EquipmentSlot.OFF_HAND
+            ? player.getInventory().getItemInOffHand()
+            : player.getInventory().getItemInMainHand();
+    }
+
+    private void removeItemFromHand(Player player, EquipmentSlot hand) {
+        if (hand == EquipmentSlot.OFF_HAND) {
+            player.getInventory().setItemInOffHand(null);
+        } else {
+            player.getInventory().setItem(player.getInventory().getHeldItemSlot(), null);
+        }
+    }
+
+    private String resolveTitle(ItemStack shulkerBox) {
+        if (shulkerBox.hasItemMeta() && shulkerBox.getItemMeta().hasDisplayName()) {
+            return shulkerBox.getItemMeta().getDisplayName();
+        }
+
+        String defaultTitle = plugin.getConfig().getString("shulkerbox.default-title", "");
+        if (defaultTitle != null && !defaultTitle.isEmpty()) {
+            return ChatColor.translateAlternateColorCodes('&', defaultTitle);
+        }
+        return "Shulker Box";
+    }
+
+    private void sendNestedMessage(Player player) {
+        player.sendMessage(EssentialsC.getLangManager().getString("prefix")
+            + EssentialsC.getLangManager().getString("messages.shulkerbox-nested"));
+    }
+
+    private boolean isShulkerBox(ItemStack item) {
+        return item != null && !item.getType().isAir() && SHULKER_BOX_MATERIALS.contains(item.getType());
+    }
+
+    private boolean isEmpty(ItemStack item) {
+        return item == null || item.getType().isAir();
+    }
+}

src/main/resources/config.yml

@@ -10,5 +10,95 @@ settings:
   # 启用或禁用命令反馈消息
   enable-feedback: true
 
-  # 所有插件消息的前缀
+# 功能方块菜单配置
-  message-prefix: "&6[EssentialsC] &r"
+blocks-menu:
+  title: "&6&lEssentialsC &8- &e&l功能方块菜单"
+  items:
+    workbench:
+      slot: 10
+      material: CRAFTING_TABLE
+      name: "&e工作台"
+      lore:
+        - "&7/workbench"
+        - "&7打开工作台"
+      permission: essentialsc.command.workbench
+    anvil:
+      slot: 11
+      material: ANVIL
+      name: "&e铁砧"
+      lore:
+        - "&7/anvil"
+        - "&7打开铁砧"
+      permission: essentialsc.command.anvil
+    cartographytable:
+      slot: 19
+      material: CARTOGRAPHY_TABLE
+      name: "&e制图台"
+      lore:
+        - "&7/cartographytable"
+        - "&7打开制图台"
+      permission: essentialsc.command.cartographytable
+    grindstone:
+      slot: 20
+      material: GRINDSTONE
+      name: "&e砂轮"
+      lore:
+        - "&7/grindstone"
+        - "&7打开砂轮"
+      permission: essentialsc.command.grindstone
+    loom:
+      slot: 21
+      material: LOOM
+      name: "&e织布机"
+      lore:
+        - "&7/loom"
+        - "&7打开织布机"
+      permission: essentialsc.command.loom
+    smithingtable:
+      slot: 22
+      material: SMITHING_TABLE
+      name: "&e锻造台"
+      lore:
+        - "&7/smithingtable"
+        - "&7打开锻造台"
+      permission: essentialsc.command.smithingtable
+    stonecutter:
+      slot: 23
+      material: STONECUTTER
+      name: "&e切石机"
+      lore:
+        - "&7/stonecutter"
+        - "&7打开切石机"
+      permission: essentialsc.command.stonecutter
+    enderchest:
+      slot: 31
+      material: ENDER_CHEST
+      name: "&e末影箱"
+      lore:
+        - "&7/enderchest"
+        - "&7打开末影箱"
+      permission: essentialsc.command.enderchest
+
+# 潜影盒设置
+shulkerbox:
+  # 潜影盒默认标题（当潜影盒没有自定义名称时使用）
+  # 支持颜色代码（使用 & 符号）
+  # 留空则使用 "Shulker Box"（客户端语言）
+  default-title: "&e潜影盒"
+
+# JEI/REI 配方同步设置（MC 1.21.2+）
+# 解决 Fabric/NeoForge 客户端配方不同步问题
+jei-sync:
+  # 是否启用 JEI 配方同步功能
+  enabled: true
+  # 是否在控制台显示同步日志
+  debug: true
+  # 是否向玩家发送同步提示消息
+  send-player-message: true
+
+# 生物掉落物控制
+mob-drops:
+  # 末影人掉落物控制
+  enderman:
+    # 是否允许末影人死亡后掉落物品和经验
+    enabled: true

src/main/resources/lang/en_US.yml

@@ -1,6 +1,9 @@
 # English Language File (en_US)
 # You can customize all messages here
 
+# Plugin prefix
+prefix: "&6[EssentialsC] &r"
+
 # Command messages
 messages:
   no-permission: "&cYou don't have permission to use this command!\n&7Required permission: {permission}"
@@ -14,20 +17,6 @@ messages:
   vanish-enabled: "&aYou are now vanished!"
   vanish-disabled: "&cYou are no longer vanished!"
   seen-usage: "&cUsage: /seen <player>"
-  admin-menu-title: "&6EssentialsC Admin Menu"
-  admin-time-control: "&eTime Control"
-  admin-weather-control: "&eWeather Control"
-  admin-heal-self: "&aHeal Self"
-  admin-feed-self: "&aFeed Self"
-  admin-repair-hand: "&aRepair Hand Item"
-  admin-vanish: "&dVanish Mode"
-  admin-reload: "&dReload Plugin"
-  admin-time-set: "&aTime set!"
-  admin-weather-set: "&aWeather set!"
-  admin-heal-success: "&aHealed!"
-  admin-feed-success: "&aFed!"
-  admin-repair-success: "&aRepaired!"
-  admin-reload-success: "&aConfig reloaded!"
   anvil-opened: "&aAnvil opened!"
   enchantingtable-opened: "&aEnchanting table opened!"
   heal-self: "&aYour health and hunger have been restored!"
@@ -69,6 +58,5 @@ help:
     heal: "  &f/heal &7- Restore health and hunger"
     vanish: "  &f/vanish &7- Toggle vanish mode"
     seen: "  &f/seen &7- View player information"
-    admin: "  &f/admin &7- Open admin menu"
     feed: "  &f/feed &7- Restore hunger"
     repair: "  &f/repair &7- Repair hand or all items"

src/main/resources/lang/zh_CN.yml

@@ -1,6 +1,9 @@
 # Chinese Language File (zh_CN)
 # 中文语言文件
 
+# 插件前缀
+prefix: "&7[&6EssentialsC&7]&f:"
+
 # 命令消息
 messages:
   no-permission: "&c你没有权限执行此命令！\n&7需要权限: {permission}"
@@ -14,20 +17,6 @@ messages:
   vanish-enabled: "&a你已进入隐身模式！"
   vanish-disabled: "&c你已退出隐身模式！"
   seen-usage: "&c用法: /seen <玩家名>"
-  admin-menu-title: "&6EssentialsC 管理菜单"
-  admin-time-control: "&e时间控制"
-  admin-weather-control: "&e天气控制"
-  admin-heal-self: "&a治疗自己"
-  admin-feed-self: "&a喂饱自己"
-  admin-repair-hand: "&a修复手中物品"
-  admin-vanish: "&d隐身模式"
-  admin-reload: "&d重载插件"
-  admin-time-set: "&a时间已设置！"
-  admin-weather-set: "&a天气已设置！"
-  admin-heal-success: "&a已治疗！"
-  admin-feed-success: "&a已喂饱！"
-  admin-repair-success: "&a已修复！"
-  admin-reload-success: "&a配置已重载！"
   anvil-opened: "&a已打开铁砧！"
   enchantingtable-opened: "&a已打开附魔台！"
   heal-self: "&a你的生命值和饱食度已补满！"
@@ -44,6 +33,14 @@ messages:
   no-permission-repair-all: "&c你没有权限修复所有物品！"
   player-not-found: "&c未找到玩家: {player}"
   no-permission-others: "&c你没有权限治疗其他玩家！"
+  seen-usage-console: "&c用法: /seen <玩家名>"
+  unknown-subcommand: "&c未知子命令: {command}"
+  help-usage: "&7使用 §f/essc help &7查看所有可用命令"
+  mobdrop-save-failed: "&c保存配置失败: {error}"
+  mobdrop-toggled: "&a末影人掉落已{status}！"
+  shulkerbox-nested: "&c不能在潜影盒中放入另一个潜影盒！"
+  jei-sync-fabric: "&6JEI-FIX&8(&bFabric&8):&e正在同步合成配方..."
+  jei-sync-neoforge: "&6JEI-FIX&8(&bNeoForge&8):&e正在同步合成配方..."
 
 # 帮助命令
 help:
@@ -69,6 +66,6 @@ help:
     heal: "  &f/heal &7- 恢复生命值和饱食度"
     vanish: "  &f/vanish &7- 切换隐身模式"
     seen: "  &f/seen &7- 查看玩家信息"
-    admin: "  &f/admin &7- 打开管理菜单"
     feed: "  &f/feed &7- 补满饱食度"
     repair: "  &f/repair &7- 修复手中或所有物品"
+    blocks: "  &f/blocks &7- 打开功能方块菜单"

src/main/resources/paper-plugin.yml

@@ -1,10 +1,11 @@
 name: EssentialsC
 description: 精简版基础插件
-version: '${version}'
+version: ${version}
 
 main: cn.infstar.essentialsC.EssentialsC
 api-version: '1.21'
 load: POSTWORLD
+folia-supported: false
 
 authors: [ Coldsmiles_7 ]
 website: www.infstar.cn
@@ -55,18 +56,30 @@ permissions:
   essentialsc.command.seen:
     description: Allows use of /seen command
     default: op
-  essentialsc.command.admin:
-    description: Allows use of /admin command
-    default: op
   essentialsc.command.feed:
     description: Allows use of /feed command
     default: op
   essentialsc.command.repair:
     description: Allows use of /repair command
     default: op
+  essentialsc.command.repair.all:
+    description: Allows use of /repair all
+    default: op
+  essentialsc.command.blocks:
+    description: Allows use of /essc blocks command
+    default: true
   essentialsc.command.help:
     description: Allows use of /essentialsc help command
     default: true
+  essentialsc.command.reload:
+    description: Allows use of /essc reload command
+    default: op
+  essentialsc.shulkerbox.open:
+    description: Allows right-click to open shulker boxes without placing them
+    default: op
+  essentialsc.mobdrops.enderman:
+    description: Allows control of enderman drops
+    default: op
   essentialsc.*:
     description: All EssentialsC permissions
     default: false
@@ -86,7 +99,10 @@ permissions:
       essentialsc.command.heal: true
       essentialsc.command.vanish: true
       essentialsc.command.seen: true
-      essentialsc.command.admin: true
+      essentialsc.command.reload: true
       essentialsc.command.feed: true
       essentialsc.command.repair: true
+      essentialsc.command.repair.all: true
       essentialsc.command.help: true
+      essentialsc.shulkerbox.open: true
+      essentialsc.mobdrops.enderman: true