ci: 添加 release 权限

.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

@@ -68,5 +68,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`) - 参考 EssentialsX 实现，100% 数据安全
+- **潜影盒快捷打开** - 潜行+右键直接打开（类似 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,26 +145,24 @@ 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
@@ -158,13 +172,6 @@ mvn clean package
 
 编译后的文件位于 `target/essentialsc-*.jar`
 
-## 📝 开发计划
-
-- [ ] 冷却时间系统
-- [ ] 更多管理功能
-- [ ] 数据统计
-- [ ] API 支持
-
 ## 🤝 贡献
 
 欢迎提交 Issue 和 Pull Request！

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>cn.infstar</groupId>
     <artifactId>essentialsc</artifactId>
-    <version>1.1.0</version>
+    <version>1.2.0</version>
     <packaging>jar</packaging>
 
     <name>essentialsc</name>
@@ -42,34 +42,6 @@
                     </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>

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

@@ -1,6 +1,7 @@
 package cn.infstar.essentialsC;
 
 import cn.infstar.essentialsC.commands.*;
+import cn.infstar.essentialsC.listeners.ShulkerBoxListener;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -17,7 +18,12 @@ public final class EssentialsC extends JavaPlugin {
         // 初始化语言管理器
         langManager = new LangManager(this);
         
+        // 注册监听器
+        registerListeners();
+        
+        // 注册命令
         registerCommands();
+        
         getLogger().info("EssentialsC 插件已启用！");
         getLogger().info("当前语言: " + langManager.getCurrentLanguage());
     }
@@ -34,6 +40,15 @@ public final class EssentialsC extends JavaPlugin {
         return langManager;
     }
     
+    /**
+     * 注册所有监听器
+     */
+    private void registerListeners() {
+        // 注册潜影盒右键打开监听器
+        new ShulkerBoxListener(this);
+        getLogger().info("成功注册监听器！");
+    }
+    
     private void registerCommands() {
         try {
             // 获取 CommandMap
@@ -41,49 +56,77 @@ public final class EssentialsC extends JavaPlugin {
             bukkitCommandMap.setAccessible(true);
             org.bukkit.command.CommandMap commandMap = (org.bukkit.command.CommandMap) bukkitCommandMap.get(Bukkit.getServer());
             
-            // 注册所有命令
+            // 注册所有命令（使用 CMI 风格：独立命令 + 别名）
-            registerCommand(commandMap, "workbench", new WorkbenchCommand());
+            registerCommandWithAliases(commandMap, "workbench", new WorkbenchCommand(), "wb");
-            registerCommand(commandMap, "anvil", new AnvilCommand());
+            registerCommandWithAliases(commandMap, "anvil", new AnvilCommand());
-            registerCommand(commandMap, "enchantingtable", new EnchantingTableCommand());
+            registerCommandWithAliases(commandMap, "cartographytable", new CartographyTableCommand(), "ct", "cartography");
-            registerCommand(commandMap, "cartographytable", new CartographyTableCommand());
+            registerCommandWithAliases(commandMap, "grindstone", new GrindstoneCommand(), "gs");
-            registerCommand(commandMap, "grindstone", new GrindstoneCommand());
+            registerCommandWithAliases(commandMap, "loom", new LoomCommand());
-            registerCommand(commandMap, "loom", new LoomCommand());
+            registerCommandWithAliases(commandMap, "smithingtable", new SmithingTableCommand(), "st", "smithing");
-            registerCommand(commandMap, "smithingtable", new SmithingTableCommand());
+            registerCommandWithAliases(commandMap, "stonecutter", new StonecutterCommand(), "sc");
-            registerCommand(commandMap, "stonecutter", new StonecutterCommand());
+            registerCommandWithAliases(commandMap, "enderchest", new EnderChestCommand(), "ec");
-            registerCommand(commandMap, "enderchest", new EnderChestCommand());
+            registerCommandWithAliases(commandMap, "hat", new HatCommand());
-            registerCommand(commandMap, "hat", new HatCommand());
+            registerCommandWithAliases(commandMap, "suicide", new SuicideCommand(), "die");
-            registerCommand(commandMap, "suicide", new SuicideCommand());
+            registerCommandWithAliases(commandMap, "fly", new FlyCommand());
-            registerCommand(commandMap, "fly", new FlyCommand());
+            registerCommandWithAliases(commandMap, "heal", new HealCommand());
-            registerCommand(commandMap, "heal", new HealCommand());
+            registerCommandWithAliases(commandMap, "vanish", new VanishCommand(), "v");
-            registerCommand(commandMap, "vanish", new VanishCommand());
+            registerCommandWithAliases(commandMap, "seen", new SeenCommand(), "info");
-            registerCommand(commandMap, "seen", new SeenCommand());
+            registerCommandWithAliases(commandMap, "feed", new FeedCommand());
-            registerCommand(commandMap, "admin", new AdminMenuCommand());
+            registerCommandWithAliases(commandMap, "repair", new RepairCommand(), "rep");
-            registerCommand(commandMap, "feed", new FeedCommand());
+            registerCommandWithAliases(commandMap, "essentialsc", new HelpCommand(), "essc");
-            registerCommand(commandMap, "repair", new RepairCommand());
-            registerCommand(commandMap, "essentialsc", new HelpCommand());
             
-            getLogger().info("成功注册 18 个命令！");
+            getLogger().info("成功注册所有命令！");
         } catch (Exception e) {
             getLogger().severe("无法注册命令: " + e.getMessage());
             e.printStackTrace();
         }
     }
     
-    private void registerCommand(org.bukkit.command.CommandMap commandMap, String name, cn.infstar.essentialsC.commands.BaseCommand executor) {
+    /**
+     * 注册命令并支持别名
+     * @param commandMap Bukkit CommandMap
+     * @param name 主命令名
+     * @param executor 命令执行器
+     * @param aliases 别名列表（可选）
+     */
+    private void registerCommandWithAliases(org.bukkit.command.CommandMap commandMap, String name, cn.infstar.essentialsC.commands.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);
             }
-        };
             
-        // 为 essentialsc 命令添加简化别名
+            @Override
-        if (name.equals("essentialsc")) {
+            public java.util.List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
-            command.setAliases(java.util.Arrays.asList("essc"));
+                if (executor instanceof org.bukkit.command.TabCompleter) {
-        }
+                    return ((org.bukkit.command.TabCompleter) executor).onTabComplete(sender, this, alias, args);
+                }
+                return super.tabComplete(sender, alias, args);
+            }
+        };
         
         command.setPermission(executor.getPermission());
         // 注册到默认命名空间，使玩家可以直接使用 /workbench 而不是 /essentialsc:workbench
         commandMap.register("", command);
+        
+        // 注册别名
+        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);
+                }
+                
+                @Override
+                public java.util.List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
+                    if (executor instanceof org.bukkit.command.TabCompleter) {
+                        return ((org.bukkit.command.TabCompleter) executor).onTabComplete(sender, this, alias, args);
+                    }
+                    return super.tabComplete(sender, alias, args);
+                }
+            };
+            aliasCmd.setPermission(executor.getPermission());
+            commandMap.register("", aliasCmd);
+        }
     }
 }

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

@@ -82,6 +82,13 @@ public class LangManager {
         }
     }
     
+    /**
+     * 获取插件前缀
+     */
+    public String getPrefix() {
+        return translateColorCodes(langFile.getString("prefix", "&6[EssentialsC] &r"));
+    }
+    
     /**
      * 获取翻译文本
      */
@@ -104,6 +111,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;
+    }
+    
     /**
      * 重新加载配置和语言
      */

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/BlocksMenuCommand.java

@@ -0,0 +1,128 @@
+package cn.infstar.essentialsC.commands;
+
+import org.bukkit.Bukkit;
+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.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+
+public class BlocksMenuCommand extends BaseCommand implements Listener {
+    
+    private static final int MENU_SIZE = 36;
+    private final NamespacedKey blockKey;
+    
+    public BlocksMenuCommand() {
+        super("essentialsc.command.blocks");
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        blockKey = new NamespacedKey(plugin, "block_key");
+    }
+    
+    @Override
+    protected boolean execute(@NotNull 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&l功能方块菜单");
+        Inventory menu = Bukkit.createInventory(null, MENU_SIZE, translateColor(title));
+        
+        // 从配置中读取所有物品
+        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"));
+            java.util.List<String> lore = section.getStringList("lore").stream()
+                .map(this::translateColor)
+                .collect(java.util.stream.Collectors.toList());
+            
+            addItem(menu, slot, material, name, lore, key);
+        }
+        
+        player.openInventory(menu);
+    }
+    
+    private void addItem(Inventory inv, int slot, Material material, String name, java.util.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) {
+        // 动态获取配置的标题
+        String configTitle = plugin.getConfig().getString("blocks-menu.title", "&6&lEssentialsC &8- &e&l功能方块菜单");
+        String actualTitle = translateColor(configTitle);
+        
+        if (!event.getView().getTitle().equals(actualTitle)) 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);
+        
+        // 点击后执行对应命令并播放音效（如果有）
+        if (key != null && HelpCommand.COMMAND_CACHE.containsKey(key)) {
+            playBlockOpenSound(player, key);
+            HelpCommand.COMMAND_CACHE.get(key).execute(player, new String[]{});
+        }
+    }
+    
+    /**
+     * 播放对应方块的打开音效（优先使用交互音效）
+     */
+    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.replace("&", "§");
+    }
+}

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,10 +2,41 @@ 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.Arrays;
+import java.util.List;
+
+public class HelpCommand extends BaseCommand implements TabCompleter {
+    
+    // 缓存命令实例，避免重复创建
+    static final java.util.Map<String, BaseCommand> COMMAND_CACHE = new java.util.HashMap<>();
+    
+    static {
+        COMMAND_CACHE.put("workbench", new WorkbenchCommand());
+        COMMAND_CACHE.put("anvil", new AnvilCommand());
+        COMMAND_CACHE.put("cartographytable", new CartographyTableCommand());
+        COMMAND_CACHE.put("grindstone", new GrindstoneCommand());
+        COMMAND_CACHE.put("loom", new LoomCommand());
+        COMMAND_CACHE.put("smithingtable", new SmithingTableCommand());
+        COMMAND_CACHE.put("stonecutter", new StonecutterCommand());
+        COMMAND_CACHE.put("enderchest", new EnderChestCommand());
+        COMMAND_CACHE.put("hat", new HatCommand());
+        COMMAND_CACHE.put("suicide", new SuicideCommand());
+        COMMAND_CACHE.put("fly", new FlyCommand());
+        COMMAND_CACHE.put("heal", new HealCommand());
+        COMMAND_CACHE.put("vanish", new VanishCommand());
+        COMMAND_CACHE.put("seen", new SeenCommand());
+        COMMAND_CACHE.put("feed", new FeedCommand());
+        COMMAND_CACHE.put("repair", new RepairCommand());
+        COMMAND_CACHE.put("blocks", new BlocksMenuCommand());
+    }
     
     public HelpCommand() {
         super("essentialsc.command.help");
@@ -13,6 +44,53 @@ public class HelpCommand extends BaseCommand {
     
     @Override
     protected boolean execute(@NotNull Player player, String[] args) {
+        if (args.length > 0) {
+            String subCommand = args[0].toLowerCase();
+            
+            // 管理相关
+            if (subCommand.equals("reload")) {
+                if (!player.hasPermission("essentialsc.command.reload")) {
+                    player.sendMessage(getLang().getString("messages.no-permission"));
+                    return true;
+                }
+                plugin.reloadConfig();
+                EssentialsC.getLangManager().reload();
+                player.sendMessage("§a配置已重载！");
+                return true;
+            }
+            // 功能方块和其他命令 - 使用别名映射
+            String actualCommand = getActualCommand(subCommand);
+            if (actualCommand != null && COMMAND_CACHE.containsKey(actualCommand)) {
+                String permission = getPermissionForCommand(actualCommand);
+                if (!player.hasPermission(permission)) {
+                    player.sendMessage(getLang().getString("messages.no-permission"));
+                    return true;
+                }
+                
+                // seen 需要特殊处理参数
+                if (actualCommand.equals("seen")) {
+                    if (args.length < 2) {
+                        player.sendMessage("§c用法: /essc seen <玩家名>");
+                        return true;
+                    }
+                    COMMAND_CACHE.get("seen").execute(player, new String[]{args[1]});
+                } else {
+                    COMMAND_CACHE.get(actualCommand).execute(player, new String[]{});
+                }
+                return true;
+            } else if (subCommand.equals("version") || subCommand.equals("v")) {
+                player.sendMessage("§6EssentialsC §fv" + plugin.getDescription().getVersion());
+                player.sendMessage("§7运行在 Paper " + Bukkit.getVersion());
+                return true;
+            } else {
+                // 未知子命令
+                player.sendMessage("§c未知子命令: " + subCommand);
+                player.sendMessage("§7使用 §f/essc help §7查看所有可用命令");
+                return true;
+            }
+        }
+        
+        // 显示帮助
         LangManager lang = getLang();
         String version = plugin.getDescription().getVersion();
         
@@ -33,10 +111,6 @@ public class HelpCommand extends BaseCommand {
             blockCommands.append(lang.getString("help.commands.anvil")).append("\n");
             hasBlockCommands = true;
         }
-        if (player.hasPermission("essentialsc.command.enchantingtable")) {
-            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;
@@ -96,10 +170,6 @@ public class HelpCommand extends BaseCommand {
             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 +180,97 @@ public class HelpCommand extends BaseCommand {
         player.sendMessage(lang.getString("help.footer"));
         return true;
     }
+    
+    /**
+     * 将别名映射到实际命令名
+     */
+    private String getActualCommand(String alias) {
+        return switch (alias) {
+            case "wb" -> "workbench";
+            case "cartography", "ct" -> "cartographytable";
+            case "gs" -> "grindstone";
+            case "smithing", "st" -> "smithingtable";
+            case "sc" -> "stonecutter";
+            case "ec" -> "enderchest";
+            case "die" -> "suicide";
+            case "info" -> "seen";
+            case "rep" -> "repair";
+            default -> alias;
+        };
+    }
+    
+    /**
+     * 获取命令对应的权限节点
+     */
+    private String getPermissionForCommand(String command) {
+        return "essentialsc.command." + command;
+    }
+    
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull 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"},
+                {"version", null},
+                {"help", null}
+            };
+            
+            for (String[] subCmd : subCommands) {
+                if (subCmd[0].startsWith(partial)) {
+                    if (subCmd[1] == null || sender.hasPermission(subCmd[1])) {
+                        completions.add(subCmd[0]);
+                    }
+                }
+            }
+            
+            return completions;
+        } else 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/listeners/ShulkerBoxListener.java

@@ -0,0 +1,234 @@
+package cn.infstar.essentialsC.listeners;
+
+import cn.infstar.essentialsC.EssentialsC;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.ShulkerBox;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+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 final EssentialsC plugin;
+    // 存储玩家打开的潜影盒：玩家UUID -> (原始物品快照, 当前物品引用)
+    private final Map<UUID, ShulkerBoxData> openShulkerBoxes = new HashMap<>();
+    
+    // 预定义所有潜影盒材质（性能优化）
+    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 static class ShulkerBoxData {
+        ItemStack originalSnapshot; // 打开时的物品快照（用于验证）
+        ItemStack currentItem;      // 当前物品引用（用于更新）
+        int totalItems;             // 打开时的物品总数（用于防刷）
+        
+        ShulkerBoxData(ItemStack snapshot, ItemStack current, int items) {
+            this.originalSnapshot = snapshot;
+            this.currentItem = current;
+            this.totalItems = items;
+        }
+    }
+    
+    public ShulkerBoxListener(EssentialsC plugin) {
+        this.plugin = plugin;
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+    
+    @EventHandler
+    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.hasPermission("essentialsc.shulkerbox.open")) {
+            return;
+        }
+        
+        ItemStack item = event.getItem();
+        if (item == null || !isShulkerBox(item)) {
+            return;
+        }
+        
+        // 只有潜行+右键才打开潜影盒
+        if (!player.isSneaking()) {
+            return;
+        }
+        
+        // 取消默认行为（防止放置潜影盒）
+        event.setCancelled(true);
+        
+        // 打开潜影盒
+        openShulkerBox(player, item);
+    }
+    
+    @EventHandler
+    public void onInventoryClose(InventoryCloseEvent event) {
+        if (!(event.getPlayer() instanceof Player player)) {
+            return;
+        }
+        
+        UUID playerId = player.getUniqueId();
+        ShulkerBoxData data = openShulkerBoxes.remove(playerId);
+        
+        if (data == null) {
+            return;
+        }
+        
+        Inventory closedInventory = event.getInventory();
+        ItemStack currentItem = data.currentItem;
+        
+        // 验证物品是否还存在
+        if (currentItem == null || currentItem.getType().isAir()) {
+            // 物品已不存在，丢弃 inventory 中的所有物品
+            for (ItemStack item : closedInventory.getContents()) {
+                if (item != null && !item.getType().isAir()) {
+                    player.getWorld().dropItemNaturally(player.getLocation(), item);
+                }
+            }
+            return;
+        }
+        
+        // 更新潜影盒物品中的内容
+        if (currentItem.getItemMeta() instanceof BlockStateMeta blockStateMeta) {
+            if (blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox) {
+                // 将 inventory 的内容复制回潜影盒
+                ItemStack[] contents = closedInventory.getContents();
+                for (int i = 0; i < 27 && i < contents.length; i++) {
+                    shulkerBox.getInventory().setItem(i, contents[i]);
+                }
+                
+                // 更新物品元数据
+                blockStateMeta.setBlockState(shulkerBox);
+                currentItem.setItemMeta(blockStateMeta);
+            }
+        }
+    }
+    
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) {
+            return;
+        }
+        
+        // 检查是否是玩家打开的潜影盒（使用 get 避免两次查找）
+        if (openShulkerBoxes.get(player.getUniqueId()) == null) {
+            return;
+        }
+        
+        // 获取点击的物品
+        ItemStack clickedItem = event.getCurrentItem();
+        if (clickedItem == null) {
+            return;
+        }
+        
+        // 检查是否是潜影盒，如果是则阻止放置
+        if (isShulkerBox(clickedItem)) {
+            event.setCancelled(true);
+            player.sendMessage("§c不能在潜影盒中放入另一个潜影盒！");
+        }
+    }
+    
+
+    
+    /**
+     * 检查物品是否为潜影盒（O(1) 时间复杂度）
+     */
+    private boolean isShulkerBox(ItemStack item) {
+        return SHULKER_BOX_MATERIALS.contains(item.getType());
+    }
+    
+    /**
+     * 打开潜影盒
+     */
+    private void openShulkerBox(Player player, ItemStack shulkerBox) {
+        // 获取潜影盒的 BlockStateMeta
+        if (!(shulkerBox.getItemMeta() instanceof BlockStateMeta blockStateMeta)) {
+            return;
+        }
+        
+        // 获取潜影盒的方块状态
+        if (!(blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBoxBlock)) {
+            return;
+        }
+        
+        // 创建物品快照（用于后续验证）
+        ItemStack snapshot = shulkerBox.clone();
+        
+        // 计算当前物品总数（用于防刷检查）
+        int totalItems = 0;
+        for (ItemStack item : shulkerBoxBlock.getInventory().getContents()) {
+            if (item != null && !item.getType().isAir()) {
+                totalItems += item.getAmount();
+            }
+        }
+        
+        // 获取潜影盒的自定义名称，如果没有则使用配置中的默认标题
+        String title;
+        if (shulkerBox.hasItemMeta() && shulkerBox.getItemMeta().hasDisplayName()) {
+            // 使用潜影盒的自定义名称
+            title = shulkerBox.getItemMeta().getDisplayName();
+        } else {
+            // 使用配置文件中的默认标题
+            String defaultTitle = plugin.getConfig().getString("shulkerbox.default-title", "");
+            if (defaultTitle != null && !defaultTitle.isEmpty()) {
+                // 转换颜色代码 & -> §
+                title = defaultTitle.replace('&', '§');
+            } else {
+                // 如果配置为空，使用 "Shulker Box"（客户端会自动翻译）
+                title = "Shulker Box";
+            }
+        }
+        
+        // 创建一个新的 inventory（基于潜影盒的内容）
+        Inventory inventory = Bukkit.createInventory(null, 27, title);
+        
+        // 复制潜影盒的内容到新 inventory
+        ItemStack[] contents = shulkerBoxBlock.getInventory().getContents();
+        for (int i = 0; i < 27 && i < contents.length; i++) {
+            inventory.setItem(i, contents[i]);
+        }
+        
+        // 记录玩家打开的潜影盒（包含快照和当前引用）
+        openShulkerBoxes.put(player.getUniqueId(), new ShulkerBoxData(snapshot, shulkerBox, totalItems));
+        
+        // 打开 inventory
+        player.openInventory(inventory);
+    }
+}

src/main/resources/config.yml

@@ -10,5 +10,78 @@ 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潜影盒"

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: "&6[EssentialsC] &r"
+
 # 命令消息
 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你的生命值和饱食度已补满！"
@@ -69,6 +58,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

@@ -55,18 +55,24 @@ 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.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.*:
     description: All EssentialsC permissions
     default: false
@@ -86,7 +92,8 @@ 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.help: true
+      essentialsc.shulkerbox.open: true