1.0.0

.gitignore

@@ -0,0 +1,43 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+.kotlin
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,10 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 已忽略包含查询文件的默认文件夹
+/queries/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/

.idea/gradle.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="distributionType" value="LOCAL" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="$PROJECT_DIR$/../../../../../gradle-8.7" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+          </set>
+        </option>
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="ms-21" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

REDME.md

@@ -0,0 +1,24 @@
+# PlayerBlockLife 插件
+
+## 🎮 简介
+PlayerBlockLife 是一个独特的Minecraft插件，为服务器增加了一种新颖的游戏玩法。每个玩家拥有5个生命方块，这些方块埋藏在地下，并使用玩家的皮肤作为材质。当其他玩家挖完这些方块时，该玩家就会死亡。
+
+## ✨ 特色功能
+- 🎭 使用玩家皮肤作为方块材质
+- ⚡ 实时皮肤加载，无需预生成
+- 🔄 异步数据处理，不影响服务器性能
+- 📊 完整的生命值系统和状态效果
+- 🎯 精美的粒子效果和音效
+- 🔧 高度可配置的游戏规则
+- 🗺️ 支持多世界和地区保护
+- 💾 多种数据存储方式
+- 👨‍💼 完善的管理员工具
+
+## 🚀 快速开始
+
+### 1. 安装插件
+1. 下载插件JAR文件
+2. 放入服务器的`plugins`文件夹
+3. 重启服务器
+
+### 2. 玩家操作

build.gradle

@@ -0,0 +1,83 @@
+plugins {
+    id 'java'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
+}
+
+group = 'com.playerblocklife'
+version = '1.0.0'
+
+sourceCompatibility = 17
+targetCompatibility = 17
+
+repositories {
+    mavenCentral()
+    maven {
+        url = 'https://repo.papermc.io/repository/maven-public/'
+    }
+    maven {
+        url = 'https://hub.spigotmc.org/nexus/content/repositories/snapshots/'
+    }
+}
+
+dependencies {
+    compileOnly 'io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT'
+    // 或者使用Spigot API：
+    // compileOnly 'org.spigotmc:spigot-api:1.20.4-R0.1-SNAPSHOT'
+
+    // 依赖库
+    implementation 'com.google.code.gson:gson:2.10.1'
+    implementation 'org.yaml:snakeyaml:2.2'
+}
+
+shadowJar {
+    archiveClassifier.set('')
+    minimize()
+
+    // 排除签名文件
+    exclude 'META-INF/*.SF'
+    exclude 'META-INF/*.DSA'
+    exclude 'META-INF/*.RSA'
+
+    // 如果需要重定位依赖包名，可以在这里添加
+    // relocate 'com.google.gson', 'com.playerblocklife.libs.gson'
+    // relocate 'org.yaml', 'com.playerblocklife.libs.yaml'
+}
+
+// 确保构建时包含shadowJar
+tasks.build.dependsOn tasks.shadowJar
+
+// 配置编译选项
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+    options.compilerArgs += ['-parameters']
+}
+
+// 配置测试
+test {
+    useJUnitPlatform()
+}
+
+// 配置JAR任务
+jar {
+    manifest {
+        attributes(
+                'Implementation-Version': project.version,
+                'Main-Class': 'com.playerblocklife.PlayerBlockLife'
+        )
+    }
+}
+
+// 添加自定义任务
+task buildPlugin {
+    dependsOn shadowJar
+    group = 'build'
+    description = '构建插件JAR文件'
+
+    doLast {
+        println "=" * 50
+        println "插件构建完成！"
+        println "文件位置: ${shadowJar.archiveFile.get().asFile.absolutePath}"
+        println "文件大小: ${shadowJar.archiveFile.get().asFile.length() / 1024} KB"
+        println "=" * 50
+    }
+}

gradle.properties

@@ -0,0 +1,9 @@
+# Gradle??
+org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.daemon=true
+
+# ????
+pluginVersion=1.0.0
+mcVersion=1.20.4

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Fri Feb 13 18:09:01 CST 2026
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 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.
+#
+
+##############################################################################
+#
+#   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/master/subprojects/plugins/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
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# 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"'
+
+# 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
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# 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
+    which java >/dev/null 2>&1 || 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
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        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" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    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
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# 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,89 @@
+@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
+
+@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=.
+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%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="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!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'PlayerBlockLife'

src/main/java/com/playerblocklife/AdminCommands.java

@@ -0,0 +1,102 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+public class AdminCommands implements CommandExecutor {
+    private final PlayerBlockLife plugin;
+
+    public AdminCommands(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!sender.hasPermission("playerblocklife.admin")) {
+            sender.sendMessage("§c你没有权限使用此命令！");
+            return true;
+        }
+
+        if (command.getName().equalsIgnoreCase("pblreload")) {
+            plugin.reloadConfig();
+            plugin.getBlockManager().loadData();
+            plugin.getSkinManager().loadAllSkins();
+            sender.sendMessage("§a插件配置已重载！");
+            return true;
+        }
+
+        if (command.getName().equalsIgnoreCase("pbldelete")) {
+            if (args.length < 1) {
+                sender.sendMessage("§c用法: /pbldelete <玩家名>");
+                return true;
+            }
+
+            String targetName = args[0];
+            Player target = Bukkit.getPlayer(targetName);
+            UUID targetId;
+
+            if (target != null) {
+                targetId = target.getUniqueId();
+            } else {
+                // 尝试从离线玩家获取UUID
+                targetId = Bukkit.getOfflinePlayer(targetName).getUniqueId();
+            }
+
+            plugin.getBlockManager().clearPlayerBlocks(targetId);
+            sender.sendMessage("§a已删除玩家 " + targetName + " 的生命方块");
+            return true;
+        }
+
+        if (command.getName().equalsIgnoreCase("pblrevive")) {
+            Player target;
+
+            if (args.length < 1) {
+                if (!(sender instanceof Player)) {
+                    sender.sendMessage("§c控制台使用时必须指定玩家名: /pblrevive <玩家名>");
+                    return true;
+                }
+                target = (Player) sender;
+            } else {
+                target = Bukkit.getPlayer(args[0]);
+                if (target == null) {
+                    sender.sendMessage("§c玩家不存在或不在线！");
+                    return true;
+                }
+            }
+
+            plugin.getLifeSystem().revivePlayer(target);
+            sender.sendMessage("§a玩家 " + target.getName() + " 已复活！");
+            return true;
+        }
+
+        if (command.getName().equalsIgnoreCase("pblstats")) {
+            int totalPlayers = plugin.getBlockManager().getPlayerBlocksCount();
+            int totalBlocks = plugin.getBlockManager().getTotalBlocksCount();
+
+            sender.sendMessage("§a===== PlayerBlockLife 统计 =====");
+            sender.sendMessage("§7注册玩家数: §e" + totalPlayers);
+            sender.sendMessage("§7总生命方块数: §e" + totalBlocks);
+            sender.sendMessage("§7在线玩家生命方块:");
+
+            for (Player player : Bukkit.getOnlinePlayers()) {
+                int blocks = plugin.getBlockManager().getRemainingBlocks(player.getUniqueId());
+                sender.sendMessage("§7- " + player.getName() + ": §e" + blocks + " §7/ §a5");
+            }
+
+            return true;
+        }
+
+        sender.sendMessage("§c未知的管理员命令！");
+        sender.sendMessage("§e可用命令:");
+        sender.sendMessage("§7/pblreload §8- §f重载插件配置");
+        sender.sendMessage("§7/pbldelete <玩家> §8- §f删除玩家的生命方块");
+        sender.sendMessage("§7/pblrevive [玩家] §8- §f复活被淘汰的玩家");
+        sender.sendMessage("§7/pblstats §8- §f查看插件统计");
+        return true;
+    }
+}

src/main/java/com/playerblocklife/BlockBreakListener.java

@@ -0,0 +1,81 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+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.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import java.util.UUID;
+
+public class BlockBreakListener implements Listener {
+    private final PlayerBlockLife plugin;
+
+    public BlockBreakListener(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player breaker = event.getPlayer();
+        Block block = event.getBlock();
+        Location location = block.getLocation();
+
+        if (block.getType() != Material.PLAYER_HEAD &&
+                block.getType() != Material.PLAYER_WALL_HEAD) {
+            return;
+        }
+
+        UUID ownerId = plugin.getBlockManager().getBlockOwner(location);
+        if (ownerId == null) {
+            return;
+        }
+
+        if (ownerId.equals(breaker.getUniqueId())) {
+            if (breaker.getGameMode() != GameMode.CREATIVE) {
+                breaker.sendMessage("§c你不能挖掘自己的生命方块！");
+                event.setCancelled(true);
+            }
+            return;
+        }
+
+        if (plugin.getBlockManager().removeBlock(location, breaker)) {
+            int remaining = plugin.getBlockManager().getRemainingBlocks(ownerId);
+
+            if (remaining <= 0) {
+                plugin.getLifeSystem().handlePlayerDeath(ownerId);
+            }
+
+            breaker.sendMessage("§a✓ 成功破坏一个生命方块！");
+            breaker.sendMessage("§7剩余方块: §e" + remaining);
+
+            if (remaining == 1) {
+                breaker.sendMessage("§6⚡ 对方只剩最后1个生命方块了！");
+                breaker.playSound(breaker.getLocation(),
+                        org.bukkit.Sound.ENTITY_PLAYER_LEVELUP, 1.0f, 1.5f);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getBlock();
+
+        if (block.getType() == Material.PLAYER_HEAD ||
+                block.getType() == Material.PLAYER_WALL_HEAD) {
+
+            UUID ownerId = plugin.getBlockManager().getBlockOwner(block.getLocation());
+            if (ownerId != null && !ownerId.equals(player.getUniqueId())) {
+                player.sendMessage("§c你不能在这里放置方块，这是别人的生命方块区域！");
+                event.setCancelled(true);
+            }
+        }
+    }
+}

src/main/java/com/playerblocklife/CheckLifeBlocksCommand.java

@@ -0,0 +1,69 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.UUID;
+
+public class CheckLifeBlocksCommand implements CommandExecutor {
+    private final PlayerBlockLife plugin;
+
+    public CheckLifeBlocksCommand(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("§c只有玩家可以使用此命令！");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        UUID playerId = player.getUniqueId();
+
+        List<Location> blocks = plugin.getBlockManager().getPlayerBlocks(playerId);
+        int remaining = blocks.size();
+
+        if (remaining == 0) {
+            player.sendMessage("§c你还没有设置生命方块！");
+            player.sendMessage("§7使用 §e/setlifeblocks §7来设置你的生命方块");
+            return true;
+        }
+
+        player.sendMessage("§a========== 你的生命方块信息 ==========");
+        player.sendMessage("§7剩余方块数量: §e" + remaining + " §7/ §a5");
+        player.sendMessage("§7当前生命值: §c" +
+                (plugin.getLifeSystem().getPlayerHealth(playerId) != null ?
+                        plugin.getLifeSystem().getPlayerHealth(playerId) : "20") + " ❤");
+
+        if (remaining <= 2) {
+            player.sendMessage("§c⚠ 警告！生命方块即将耗尽！");
+        }
+
+        player.sendMessage("§7方块位置:");
+        for (int i = 0; i < blocks.size(); i++) {
+            Location loc = blocks.get(i);
+            String worldName = loc.getWorld() != null ? loc.getWorld().getName() : "未知世界";
+            player.sendMessage("§7" + (i + 1) + ". §e世界: " + worldName +
+                    " §7坐标: §a" + loc.getBlockX() + " §7, §a" +
+                    loc.getBlockY() + " §7, §a" + loc.getBlockZ());
+        }
+
+        player.sendMessage("§a======================================");
+
+        if (remaining > 0) {
+            player.sendMessage("§e提示：");
+            player.sendMessage("§7- 方块距离你: §a" +
+                    (int) player.getLocation().distance(blocks.get(0)) + " §7格");
+            player.sendMessage("§7- 使用指南针可以追踪方块位置");
+        }
+
+        return true;
+    }
+}

src/main/java/com/playerblocklife/ConfigManager.java

@@ -0,0 +1,63 @@
+package com.playerblocklife;
+
+import org.bukkit.configuration.file.FileConfiguration;
+
+public class ConfigManager {
+    private final PlayerBlockLife plugin;
+    private FileConfiguration config;
+
+    public ConfigManager(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+        loadConfig();
+    }
+
+    public void loadConfig() {
+        plugin.saveDefaultConfig();
+        config = plugin.getConfig();
+    }
+
+    public void reloadConfig() {
+        plugin.reloadConfig();
+        config = plugin.getConfig();
+    }
+
+    public int getBlocksPerPlayer() {
+        return config.getInt("blocks.amount", 5);
+    }
+
+    public int getSpreadRange() {
+        return config.getInt("blocks.spread", 5);
+    }
+
+    public int getDepth() {
+        return config.getInt("blocks.depth", -1);
+    }
+
+    public boolean isDieWhenBlocksGone() {
+        return config.getBoolean("game.die_when_blocks_gone", true);
+    }
+
+    public boolean isBecomeSpectator() {
+        return config.getBoolean("game.become_spectator", true);
+    }
+
+    public boolean isHealthSystemEnabled() {
+        return config.getBoolean("game.health_system", true);
+    }
+
+    public boolean isSkinSystemEnabled() {
+        return config.getBoolean("skin.enabled", true);
+    }
+
+    public String getSkinSource() {
+        return config.getString("skin.source", "player_profile");
+    }
+
+    public String getMessage(String path, String defaultValue) {
+        String message = config.getString("messages." + path, defaultValue);
+        if (message != null) {
+            message = message.replace("&", "§");
+        }
+        return message;
+    }
+}

src/main/java/com/playerblocklife/LifeSystem.java

@@ -0,0 +1,156 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class LifeSystem {
+    private final PlayerBlockLife plugin;
+    private final Map<UUID, Integer> playerHealth = new HashMap<>();
+    private final Map<UUID, Long> lastDamageTime = new HashMap<>();
+
+    public LifeSystem(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    public void checkAllPlayers() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            checkPlayerHealth(player);
+        }
+    }
+
+    public void checkPlayerHealth(Player player) {
+        UUID playerId = player.getUniqueId();
+        int remainingBlocks = plugin.getBlockManager().getRemainingBlocks(playerId);
+
+        if (remainingBlocks == 0 && !playerHealth.containsKey(playerId)) {
+            playerHealth.put(playerId, 20);
+            return;
+        }
+
+        int newHealth = calculateHealthFromBlocks(remainingBlocks);
+        Integer currentHealth = playerHealth.get(playerId);
+
+        if (currentHealth == null) {
+            playerHealth.put(playerId, newHealth);
+            return;
+        }
+
+        if (currentHealth != newHealth) {
+            playerHealth.put(playerId, newHealth);
+
+            if (newHealth < currentHealth) {
+                player.sendMessage("§c你的生命值减少了！当前: §4" + newHealth + " ❤");
+                player.playSound(player.getLocation(),
+                        org.bukkit.Sound.ENTITY_PLAYER_HURT, 1.0f, 1.0f);
+                lastDamageTime.put(playerId, System.currentTimeMillis());
+            } else if (newHealth > currentHealth) {
+                player.sendMessage("§a你的生命值恢复了！当前: §2" + newHealth + " ❤");
+                player.playSound(player.getLocation(),
+                        org.bukkit.Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 1.5f);
+            }
+
+            if (newHealth <= 5) {
+                player.sendTitle("§4⚠ 警告！", "§c生命值过低！", 10, 40, 10);
+                player.playSound(player.getLocation(),
+                        org.bukkit.Sound.BLOCK_NOTE_BLOCK_BELL, 1.0f, 0.5f);
+            }
+
+            if (remainingBlocks == 0) {
+                handlePlayerDeath(playerId);
+            }
+        }
+
+        applyStatusEffects(player, remainingBlocks);
+    }
+
+    private int calculateHealthFromBlocks(int remainingBlocks) {
+        if (remainingBlocks >= 5) return 20;
+        if (remainingBlocks == 4) return 16;
+        if (remainingBlocks == 3) return 12;
+        if (remainingBlocks == 2) return 8;
+        if (remainingBlocks == 1) return 4;
+        return 0;
+    }
+
+    private void applyStatusEffects(Player player, int remainingBlocks) {
+        if (remainingBlocks <= 2) {
+            player.addPotionEffect(new PotionEffect(
+                    PotionEffectType.SLOW, 100, 1, true, true));
+
+            if (remainingBlocks == 1) {
+                player.addPotionEffect(new PotionEffect(
+                        PotionEffectType.WEAKNESS, 100, 0, true, true));
+                player.addPotionEffect(new PotionEffect(
+                        PotionEffectType.BLINDNESS, 100, 0, true, true));
+            }
+        } else {
+            player.removePotionEffect(PotionEffectType.SLOW);
+            player.removePotionEffect(PotionEffectType.WEAKNESS);
+            player.removePotionEffect(PotionEffectType.BLINDNESS);
+        }
+    }
+
+    public void handlePlayerDeath(UUID playerId) {
+        Player player = Bukkit.getPlayer(playerId);
+        if (player == null || !player.isOnline()) {
+            return;
+        }
+
+        player.setHealth(0);
+        player.sendTitle("§4☠ 你死了！", "§c所有生命方块已被挖光", 20, 100, 20);
+
+        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
+            onlinePlayer.sendMessage("§4☠ 玩家 " + player.getName() + " 的生命方块已被全部挖光，惨遭淘汰！");
+            onlinePlayer.playSound(onlinePlayer.getLocation(),
+                    org.bukkit.Sound.ENTITY_WITHER_DEATH, 0.7f, 0.8f);
+        }
+
+        plugin.getBlockManager().clearPlayerBlocks(playerId);
+        playerHealth.remove(playerId);
+
+        Bukkit.getScheduler().runTaskLater(plugin, () -> {
+            if (player.isOnline()) {
+                player.setGameMode(GameMode.SPECTATOR);
+                player.sendMessage("§e你已被淘汰，可以观察其他玩家。");
+                player.sendMessage("§7等待下一轮游戏开始...");
+            }
+        }, 100L);
+    }
+
+    public Integer getPlayerHealth(UUID playerId) {
+        return playerHealth.get(playerId);
+    }
+
+    public void setPlayerHealth(UUID playerId, int health) {
+        playerHealth.put(playerId, health);
+    }
+
+    public boolean isPlayerAlive(UUID playerId) {
+        Integer health = playerHealth.get(playerId);
+        return health != null && health > 0;
+    }
+
+    public void revivePlayer(Player player) {
+        UUID playerId = player.getUniqueId();
+        playerHealth.put(playerId, 20);
+        player.setGameMode(GameMode.SURVIVAL);
+        player.setHealth(20.0);
+        player.setFoodLevel(20);
+        player.setSaturation(5.0f);
+
+        player.removePotionEffect(PotionEffectType.SLOW);
+        player.removePotionEffect(PotionEffectType.WEAKNESS);
+        player.removePotionEffect(PotionEffectType.BLINDNESS);
+
+        player.sendMessage("§a你已复活！生命值已恢复。");
+        player.playSound(player.getLocation(),
+                org.bukkit.Sound.ENTITY_PLAYER_LEVELUP, 1.0f, 1.0f);
+    }
+}

src/main/java/com/playerblocklife/PlayerBlockLife.java

@@ -0,0 +1,104 @@
+package com.playerblocklife;
+
+import org.bukkit.plugin.java.JavaPlugin;
+import java.util.logging.Level;
+
+public class PlayerBlockLife extends JavaPlugin {
+    private static PlayerBlockLife instance;
+    private PlayerBlockManager blockManager;
+    private SkinManager skinManager;
+    private LifeSystem lifeSystem;
+    private ConfigManager configManager;
+
+    // 在 PlayerBlockLife.java 中添加：
+
+    @Override
+    public void reloadConfig() {
+        super.reloadConfig();
+        configManager.reloadConfig();
+        getLogger().info("配置已重新加载");
+    }
+    @Override
+    public void onEnable() {
+        instance = this;
+        saveDefaultConfig();
+
+        this.configManager = new ConfigManager(this);
+        this.skinManager = new SkinManager(this);
+        this.blockManager = new PlayerBlockManager(this, skinManager);
+        this.lifeSystem = new LifeSystem(this);
+
+        getServer().getPluginManager().registerEvents(new BlockBreakListener(this), this);
+        getServer().getPluginManager().registerEvents(new PlayerJoinListener(this), this);
+        getServer().getPluginManager().registerEvents(new PlayerQuitListener(this), this);
+
+        getCommand("setlifeblocks").setExecutor(new SetLifeBlocksCommand(this));
+        getCommand("checklifeblocks").setExecutor(new CheckLifeBlocksCommand(this));
+        getCommand("pblreload").setExecutor(new AdminCommands(this));
+        getCommand("pbldelete").setExecutor(new AdminCommands(this));
+
+        blockManager.loadData();
+        skinManager.loadAllSkins();
+
+        startScheduler();
+
+        getLogger().info("§a========================================");
+        getLogger().info("§ePlayerBlockLife v" + getDescription().getVersion() + " 已启用");
+        getLogger().info("§e作者: " + getDescription().getAuthors());
+        getLogger().info("§a========================================");
+    }
+
+    @Override
+    public void onDisable() {
+        if (blockManager != null) {
+            blockManager.saveData();
+        }
+        if (skinManager != null) {
+            skinManager.saveSkinData();
+        }
+        getLogger().info("§cPlayerBlockLife 插件已禁用");
+    }
+
+    private void startScheduler() {
+        getServer().getScheduler().runTaskTimerAsynchronously(this, () -> {
+            blockManager.saveData();
+            skinManager.saveSkinData();
+        }, 6000L, 6000L);
+
+        getServer().getScheduler().runTaskTimer(this, () -> {
+            lifeSystem.checkAllPlayers();
+        }, 200L, 200L);
+    }
+
+    public static PlayerBlockLife getInstance() {
+        return instance;
+    }
+
+    public PlayerBlockManager getBlockManager() {
+        return blockManager;
+    }
+
+    public SkinManager getSkinManager() {
+        return skinManager;
+    }
+
+    public LifeSystem getLifeSystem() {
+        return lifeSystem;
+    }
+
+    public ConfigManager getConfigManager() {
+        return configManager;
+    }
+
+    public void logInfo(String message) {
+        getLogger().info(message);
+    }
+
+    public void logWarning(String message) {
+        getLogger().warning(message);
+    }
+
+    public void logError(String message, Throwable throwable) {
+        getLogger().log(Level.SEVERE, message, throwable);
+    }
+}

src/main/java/com/playerblocklife/PlayerBlockManager.java

@@ -0,0 +1,593 @@
+package com.playerblocklife;
+
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.Skull;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.Rotatable;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.util.Vector;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class PlayerBlockManager {
+    private final PlayerBlockLife plugin;
+    private final SkinManager skinManager;
+    private final Map<UUID, List<Location>> playerBlocks = new ConcurrentHashMap<>();
+    private final Map<Location, UUID> blockOwners = new ConcurrentHashMap<>();
+    private final Map<UUID, Material> playerBlockTypes = new ConcurrentHashMap<>();
+    private final File dataFile;
+    private final Random random = new Random();
+
+    public PlayerBlockManager(PlayerBlockLife plugin, SkinManager skinManager) {
+        this.plugin = plugin;
+        this.skinManager = skinManager;
+        this.dataFile = new File(plugin.getDataFolder(), "blockdata.yml");
+    }
+
+    /**
+     * 为玩家设置生命方块
+     */
+    public boolean setLifeBlocks(Player player, Location center) {
+        UUID playerId = player.getUniqueId();
+        String playerName = player.getName();
+
+        // 检查是否已有生命方块
+        if (hasLifeBlocks(playerId)) {
+            player.sendMessage("§c你已经有生命方块了！");
+            player.sendMessage("§e使用 /checklifeblocks 查看位置");
+            return false;
+        }
+
+        // 检查玩家皮肤是否已加载
+        if (!skinManager.isSkinLoaded(playerId)) {
+            player.sendMessage("§e你的皮肤正在加载中，请稍候...");
+            player.sendMessage("§7(如果长时间未加载完成，请重新加入服务器)");
+            return false;
+        }
+
+        List<Location> blocks = new ArrayList<>();
+        int blocksPlaced = 0;
+
+        // 尝试在中心周围生成5个方块
+        for (int attempt = 0; attempt < 20 && blocksPlaced < 5; attempt++) {
+            Location blockLoc = findSuitableLocation(center);
+
+            if (blockLoc != null && placePlayerHead(blockLoc, playerId, playerName)) {
+                blocks.add(blockLoc);
+                blockOwners.put(blockLoc, playerId);
+                blocksPlaced++;
+
+                // 添加放置效果
+                spawnPlaceEffects(blockLoc);
+            }
+        }
+
+        if (blocksPlaced > 0) {
+            playerBlocks.put(playerId, blocks);
+            saveData();
+
+            player.sendMessage("§a========================================");
+            player.sendMessage("§a成功生成 §e" + blocksPlaced + " §a个生命方块！");
+            player.sendMessage("§6方块使用了你的皮肤头像");
+            player.sendMessage("§c⚠ 警告: 方块被挖光时，你将死亡！");
+            player.sendMessage("§7使用 /checklifeblocks 查看方块位置");
+            player.sendMessage("§a========================================");
+
+            return true;
+        } else {
+            player.sendMessage("§c无法生成生命方块！");
+            player.sendMessage("§7请确保周围有足够的空间（至少5个可放置位置）");
+            return false;
+        }
+    }
+
+    /**
+     * 寻找合适的位置
+     */
+    private Location findSuitableLocation(Location center) {
+        for (int i = 0; i < 10; i++) {
+            int x = random.nextInt(11) - 5; // -5 到 5
+            int z = random.nextInt(11) - 5;
+
+            Location testLoc = center.clone().add(x, -1, z);
+            Block block = testLoc.getBlock();
+
+            // 检查位置是否合适
+            if (isSuitableLocation(testLoc)) {
+                return testLoc;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 检查位置是否合适
+     * 修复：移除 isReplaceable() 方法调用
+     */
+    private boolean isSuitableLocation(Location location) {
+        Block block = location.getBlock();
+
+        // 检查是否已有方块
+        if (blockOwners.containsKey(location)) {
+            return false;
+        }
+
+        // 检查方块是否可替换（修复了 isReplaceable() 方法不存在的问题）
+        Material type = block.getType();
+        if (!type.isAir()) {
+            // 检查是否是固体方块，固体方块不能替换
+            if (type.isSolid()) {
+                return false;
+            }
+
+            // 检查是否是液体
+            if (type == Material.WATER || type == Material.LAVA ||
+                    type == Material.WATER_CAULDRON || type == Material.LAVA_CAULDRON) {
+                return false;
+            }
+
+            // 检查一些特定的不可替换方块
+            switch (type) {
+                case FIRE:
+                case SOUL_FIRE:
+                case COBWEB:
+                case BAMBOO:
+                case BAMBOO_SAPLING:
+                case SCAFFOLDING:
+                case LADDER:
+                case VINE:
+                case TWISTING_VINES:
+                case WEEPING_VINES:
+                case GLOW_LICHEN:
+                    // 这些方块可以替换
+                    break;
+                default:
+                    // 如果不是固体，也不是特定的透明方块，也不是空气，则检查是否是透明方块
+                    if (!type.isTransparent()) {
+                        return false;
+                    }
+                    break;
+            }
+        }
+
+        // 检查下方是否有支撑方块
+        Block below = location.clone().add(0, -1, 0).getBlock();
+        Material belowType = below.getType();
+
+        if (belowType.isAir() || !belowType.isSolid()) {
+            return false;
+        }
+
+        // 检查是否在水或岩浆中
+        if (block.isLiquid() || below.isLiquid()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 放置玩家头颅方块
+     */
+    private boolean placePlayerHead(Location location, UUID playerId, String playerName) {
+        try {
+            Block block = location.getBlock();
+
+            // 检查方块是否已被占用
+            if (blockOwners.containsKey(location)) {
+                return false;
+            }
+
+            // 设置方块为玩家头颅
+            block.setType(Material.PLAYER_HEAD);
+
+            // 获取并设置头颅数据
+            Skull skullState = (Skull) block.getState();
+            OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(playerId);
+
+            // 设置头颅所有者
+            skullState.setOwningPlayer(offlinePlayer);
+
+            // 设置朝向（随机方向）
+            BlockData blockData = block.getBlockData();
+            if (blockData instanceof Rotatable) {
+                Rotatable rotatable = (Rotatable) blockData;
+                BlockFace[] faces = {BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST};
+                rotatable.setRotation(faces[random.nextInt(faces.length)]);
+                block.setBlockData(rotatable);
+            }
+
+            // 更新方块
+            skullState.update(true, false);
+
+            return true;
+        } catch (Exception e) {
+            plugin.logError("放置玩家头颅失败: " + location, e);
+            return false;
+        }
+    }
+
+    /**
+     * 生成放置效果
+     */
+    private void spawnPlaceEffects(Location location) {
+        World world = location.getWorld();
+        if (world == null) return;
+
+        // 粒子效果
+        world.spawnParticle(Particle.ENCHANTMENT_TABLE,
+                location.clone().add(0.5, 0.5, 0.5),
+                30, 0.3, 0.3, 0.3, 0.1);
+
+        // 音效
+        world.playSound(location, Sound.BLOCK_ANVIL_PLACE, 0.5f, 1.2f);
+    }
+
+    /**
+     * 检查方块是否属于某个玩家
+     */
+    public UUID getBlockOwner(Location location) {
+        return blockOwners.get(location);
+    }
+
+    /**
+     * 移除方块（当被挖掘时）
+     */
+    public boolean removeBlock(Location location, Player breaker) {
+        UUID ownerId = blockOwners.get(location);
+        if (ownerId == null) {
+            return false;
+        }
+
+        List<Location> blocks = playerBlocks.get(ownerId);
+        if (blocks == null || !blocks.contains(location)) {
+            return false;
+        }
+
+        // 移除方块
+        blocks.remove(location);
+        blockOwners.remove(location);
+
+        // 设置方块为空气
+        location.getBlock().setType(Material.AIR);
+
+        // 生成破坏效果
+        spawnBreakEffects(location, breaker);
+
+        // 检查玩家是否还有剩余方块
+        int remaining = blocks.size();
+
+        // 通知所有相关玩家
+        notifyBlockBreak(ownerId, breaker, remaining);
+
+        // 保存数据
+        saveData();
+
+        return true;
+    }
+
+    /**
+     * 生成破坏效果
+     */
+    private void spawnBreakEffects(Location location, Player breaker) {
+        World world = location.getWorld();
+        if (world == null) return;
+
+        // 粒子效果
+        world.spawnParticle(Particle.BLOCK_CRACK,
+                location.clone().add(0.5, 0.5, 0.5),
+                50, 0.5, 0.5, 0.5, 0.5, Material.PLAYER_HEAD.createBlockData());
+
+        world.spawnParticle(Particle.SMOKE_LARGE,
+                location.clone().add(0.5, 0.5, 0.5),
+                20, 0.3, 0.3, 0.3, 0.05);
+
+        // 音效
+        world.playSound(location, Sound.ENTITY_ITEM_BREAK, 1.0f, 0.8f);
+        world.playSound(location, Sound.BLOCK_GLASS_BREAK, 0.8f, 1.0f);
+
+        // 对挖掘者造成轻微击退
+        if (breaker != null) {
+            Location breakerLoc = breaker.getLocation();
+            Vector direction = location.toVector().subtract(breakerLoc.toVector()).normalize();
+            breaker.setVelocity(direction.multiply(-0.5).setY(0.3));
+        }
+    }
+
+    /**
+     * 通知方块被破坏
+     */
+    private void notifyBlockBreak(UUID ownerId, Player breaker, int remaining) {
+        Player owner = Bukkit.getPlayer(ownerId);
+        String ownerName = Bukkit.getOfflinePlayer(ownerId).getName();
+
+        // 通知方块所有者
+        if (owner != null && owner.isOnline()) {
+            owner.sendMessage("§c⚠ 警告！你的生命方块被破坏了！");
+            owner.sendMessage("§7破坏者: §e" + (breaker != null ? breaker.getName() : "未知"));
+            owner.sendMessage("§7剩余生命方块: §a" + remaining + " §7/ §c5");
+
+            if (remaining <= 2) {
+                owner.sendMessage("§4⚠ 警告！生命方块即将耗尽！");
+            }
+
+            // 播放警告音效
+            owner.playSound(owner.getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, 0.8f, 0.5f);
+        }
+
+        // 通知破坏者
+        if (breaker != null && !breaker.getUniqueId().equals(ownerId)) {
+            breaker.sendMessage("§6你破坏了一个生命方块！");
+            breaker.sendMessage("§7所有者: §e" + (ownerName != null ? ownerName : "未知玩家"));
+            breaker.sendMessage("§7对方剩余生命方块: §a" + remaining);
+
+            // 给予挖掘者经验奖励
+            breaker.giveExp(5);
+            breaker.playSound(breaker.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1.0f, 1.0f);
+        }
+
+        // 广播给附近玩家
+        World world = owner != null ? owner.getWorld() : (breaker != null ? breaker.getWorld() : null);
+        if (world != null) {
+            for (Player nearby : world.getPlayers()) {
+                if (nearby != owner && nearby != breaker &&
+                        nearby.getLocation().distance(owner != null ? owner.getLocation() : breaker.getLocation()) < 30) {
+                    nearby.sendMessage("§7[附近] §e一个生命方块被破坏了！");
+                }
+            }
+        }
+    }
+
+    /**
+     * 获取玩家剩余方块数量
+     */
+    public int getRemainingBlocks(UUID playerId) {
+        List<Location> blocks = playerBlocks.get(playerId);
+        return blocks != null ? blocks.size() : 0;
+    }
+
+    /**
+     * 检查玩家是否有生命方块
+     */
+    public boolean hasLifeBlocks(UUID playerId) {
+        List<Location> blocks = playerBlocks.get(playerId);
+        return blocks != null && !blocks.isEmpty();
+    }
+
+    /**
+     * 获取玩家的所有生命方块位置
+     */
+    public List<Location> getPlayerBlocks(UUID playerId) {
+        return playerBlocks.getOrDefault(playerId, new ArrayList<>());
+    }
+
+    /**
+     * 清除玩家的所有生命方块
+     */
+    public void clearPlayerBlocks(UUID playerId) {
+        List<Location> blocks = playerBlocks.remove(playerId);
+        if (blocks != null) {
+            for (Location loc : blocks) {
+                blockOwners.remove(loc);
+                loc.getBlock().setType(Material.AIR);
+            }
+        }
+        saveData();
+    }
+
+    /**
+     * 重新生成玩家的生命方块
+     */
+    public boolean regeneratePlayerBlocks(Player player) {
+        UUID playerId = player.getUniqueId();
+
+        // 清除旧方块
+        clearPlayerBlocks(playerId);
+
+        // 生成新方块
+        return setLifeBlocks(player, player.getLocation());
+    }
+
+    /**
+     * 获取已注册玩家的数量
+     */
+    public int getPlayerBlocksCount() {
+        return playerBlocks.size();
+    }
+
+    /**
+     * 获取总方块数量
+     */
+    public int getTotalBlocksCount() {
+        int total = 0;
+        for (List<Location> blocks : playerBlocks.values()) {
+            total += blocks.size();
+        }
+        return total;
+    }
+
+    /**
+     * 加载数据
+     */
+    @SuppressWarnings("unchecked")
+    public void loadData() {
+        if (!dataFile.exists()) {
+            return;
+        }
+
+        try {
+            Yaml yaml = new Yaml();
+            Map<String, Object> data = yaml.load(new FileReader(dataFile));
+
+            if (data == null) {
+                return;
+            }
+
+            // 加载方块数据
+            if (data.containsKey("blocks")) {
+                Map<String, List<Map<String, Object>>> blocksData =
+                        (Map<String, List<Map<String, Object>>>) data.get("blocks");
+
+                for (Map.Entry<String, List<Map<String, Object>>> entry : blocksData.entrySet()) {
+                    UUID playerId = UUID.fromString(entry.getKey());
+                    List<Location> locations = new ArrayList<>();
+
+                    for (Map<String, Object> locData : entry.getValue()) {
+                        String worldName = (String) locData.get("world");
+                        double x = (double) locData.get("x");
+                        double y = (double) locData.get("y");
+                        double z = (double) locData.get("z");
+
+                        World world = Bukkit.getWorld(worldName);
+                        if (world != null) {
+                            Location location = new Location(world, x, y, z);
+                            locations.add(location);
+                            blockOwners.put(location, playerId);
+                        }
+                    }
+
+                    if (!locations.isEmpty()) {
+                        playerBlocks.put(playerId, locations);
+                    }
+                }
+            }
+
+            plugin.logInfo("已加载 " + playerBlocks.size() + " 个玩家的方块数据");
+            plugin.logInfo("总共 " + blockOwners.size() + " 个生命方块");
+
+        } catch (Exception e) {
+            plugin.logError("加载方块数据失败", e);
+        }
+    }
+
+    /**
+     * 保存数据
+     */
+    public void saveData() {
+        try {
+            Map<String, Object> data = new HashMap<>();
+            Map<String, List<Map<String, Object>>> blocksData = new HashMap<>();
+
+            // 保存方块数据
+            for (Map.Entry<UUID, List<Location>> entry : playerBlocks.entrySet()) {
+                String playerId = entry.getKey().toString();
+                List<Map<String, Object>> locations = new ArrayList<>();
+
+                for (Location loc : entry.getValue()) {
+                    Map<String, Object> locData = new HashMap<>();
+                    locData.put("world", loc.getWorld().getName());
+                    locData.put("x", loc.getX());
+                    locData.put("y", loc.getY());
+                    locData.put("z", loc.getZ());
+                    locations.add(locData);
+                }
+
+                blocksData.put(playerId, locations);
+            }
+
+            data.put("blocks", blocksData);
+
+            // 写入文件
+            Yaml yaml = new Yaml();
+            yaml.dump(data, new FileWriter(dataFile));
+
+        } catch (Exception e) {
+            plugin.logError("保存方块数据失败", e);
+        }
+    }
+
+    /**
+     * 获取所有玩家的方块数据
+     */
+    public Map<UUID, List<Location>> getAllPlayerBlocks() {
+        return new HashMap<>(playerBlocks);
+    }
+
+    /**
+     * 获取所有方块的位置和所有者
+     */
+    public Map<Location, UUID> getAllBlockOwners() {
+        return new HashMap<>(blockOwners);
+    }
+
+    /**
+     * 检查位置是否包含生命方块
+     */
+    public boolean isLifeBlock(Location location) {
+        return blockOwners.containsKey(location);
+    }
+
+    /**
+     * 获取玩家的生命方块位置列表（用于显示）
+     */
+    public List<String> getPlayerBlockLocations(UUID playerId) {
+        List<Location> blocks = playerBlocks.get(playerId);
+        List<String> locations = new ArrayList<>();
+
+        if (blocks != null) {
+            for (Location loc : blocks) {
+                String worldName = loc.getWorld() != null ? loc.getWorld().getName() : "未知世界";
+                locations.add(String.format("世界: %s, 坐标: %d, %d, %d",
+                        worldName,
+                        loc.getBlockX(),
+                        loc.getBlockY(),
+                        loc.getBlockZ()));
+            }
+        }
+
+        return locations;
+    }
+
+    /**
+     * 获取距离玩家最近的方块
+     */
+    public Location getNearestBlock(Player player) {
+        UUID playerId = player.getUniqueId();
+        List<Location> blocks = playerBlocks.get(playerId);
+
+        if (blocks == null || blocks.isEmpty()) {
+            return null;
+        }
+
+        Location nearest = null;
+        double nearestDistance = Double.MAX_VALUE;
+
+        for (Location block : blocks) {
+            double distance = player.getLocation().distance(block);
+            if (distance < nearestDistance) {
+                nearestDistance = distance;
+                nearest = block;
+            }
+        }
+
+        return nearest;
+    }
+
+    /**
+     * 获取所有生命方块的统计信息
+     */
+    public Map<String, Object> getStats() {
+        Map<String, Object> stats = new HashMap<>();
+        stats.put("totalPlayers", playerBlocks.size());
+        stats.put("totalBlocks", blockOwners.size());
+
+        // 按世界统计
+        Map<String, Integer> blocksPerWorld = new HashMap<>();
+        for (Location loc : blockOwners.keySet()) {
+            String worldName = loc.getWorld() != null ? loc.getWorld().getName() : "unknown";
+            blocksPerWorld.put(worldName, blocksPerWorld.getOrDefault(worldName, 0) + 1);
+        }
+        stats.put("blocksPerWorld", blocksPerWorld);
+
+        return stats;
+    }
+}

src/main/java/com/playerblocklife/PlayerJoinListener.java

@@ -0,0 +1,72 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+
+import java.util.UUID;
+
+public class PlayerJoinListener implements Listener {
+    private final PlayerBlockLife plugin;
+
+    public PlayerJoinListener(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        UUID playerId = player.getUniqueId();
+
+        // 异步加载玩家皮肤
+        plugin.getSkinManager().loadPlayerSkinAsync(player);
+
+        // 延迟发送消息，确保皮肤加载完成
+        Bukkit.getScheduler().runTaskLater(plugin, () -> {
+            int remainingBlocks = plugin.getBlockManager().getRemainingBlocks(playerId);
+
+            if (remainingBlocks > 0) {
+                player.sendMessage("§a========================================");
+                player.sendMessage("§e欢迎回来，§6" + player.getName() + "§e！");
+                player.sendMessage("§7你还有 §e" + remainingBlocks + " §7个生命方块");
+                player.sendMessage("§7使用 §e/checklifeblocks §7查看方块位置");
+                player.sendMessage("§a========================================");
+
+                if (remainingBlocks <= 2) {
+                    player.sendMessage("§c⚠ 警告！你的生命方块即将耗尽！");
+                    player.playSound(player.getLocation(),
+                            org.bukkit.Sound.ENTITY_WITHER_SPAWN, 0.5f, 1.0f);
+                }
+            } else {
+                player.sendMessage("§e欢迎加入游戏！");
+                player.sendMessage("§7使用 §e/setlifeblocks §7来设置你的生命方块");
+                player.sendMessage("§6游戏规则：");
+                player.sendMessage("§7- 每个玩家有5个生命方块");
+                player.sendMessage("§7- 方块被其他玩家挖光时，你将死亡");
+                player.sendMessage("§7- 方块使用你的皮肤作为材质");
+                player.sendMessage("§7- 你可以自由移动，但方块固定位置");
+            }
+        }, 40L);
+    }
+
+    @EventHandler
+    public void onPlayerRespawn(PlayerRespawnEvent event) {
+        Player player = event.getPlayer();
+        UUID playerId = player.getUniqueId();
+
+        if (!plugin.getLifeSystem().isPlayerAlive(playerId)) {
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                if (player.isOnline()) {
+                    player.setGameMode(GameMode.SPECTATOR);
+                    player.sendMessage("§e你已被淘汰，可以观察其他玩家。");
+                    player.sendMessage("§7等待下一轮游戏开始...");
+                }
+            }, 20L);
+        }
+    }
+}

src/main/java/com/playerblocklife/PlayerQuitListener.java

@@ -0,0 +1,18 @@
+package com.playerblocklife;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class PlayerQuitListener implements Listener {
+    private final PlayerBlockLife plugin;
+
+    public PlayerQuitListener(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        plugin.logInfo("玩家 " + event.getPlayer().getName() + " 离开了游戏");
+    }
+}

src/main/java/com/playerblocklife/SetLifeBlocksCommand.java

@@ -0,0 +1,132 @@
+package com.playerblocklife;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+public class SetLifeBlocksCommand implements CommandExecutor {
+    private final PlayerBlockLife plugin;
+
+    public SetLifeBlocksCommand(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("§c只有玩家可以使用此命令！");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        UUID playerId = player.getUniqueId();
+
+        if (args.length > 0 && args[0].equalsIgnoreCase("help")) {
+            showHelp(player);
+            return true;
+        }
+
+        if (args.length > 0 && player.hasPermission("playerblocklife.admin")) {
+            if (args[0].equalsIgnoreCase("other")) {
+                if (args.length < 2) {
+                    player.sendMessage("§c用法: /setlifeblocks other <玩家名>");
+                    return true;
+                }
+
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) {
+                    player.sendMessage("§c找不到玩家: " + args[1]);
+                    return true;
+                }
+
+                setBlocksForPlayer(target, player);
+                return true;
+            }
+        }
+
+        setBlocksForPlayer(player, null);
+        return true;
+    }
+
+    private void setBlocksForPlayer(Player target, Player executor) {
+        UUID targetId = target.getUniqueId();
+
+        if (plugin.getBlockManager().hasLifeBlocks(targetId)) {
+            if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                executor.sendMessage("§c玩家 " + target.getName() + " 已经有生命方块了！");
+            } else {
+                target.sendMessage("§c你已经有生命方块了！");
+                target.sendMessage("§e使用 /checklifeblocks 查看位置");
+                target.sendMessage("§e使用 /setlifeblocks reset 重置方块位置");
+            }
+            return;
+        }
+
+        if (!plugin.getSkinManager().isSkinLoaded(targetId)) {
+            if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                executor.sendMessage("§e玩家 " + target.getName() + " 的皮肤正在加载中，请稍候...");
+            } else {
+                target.sendMessage("§e你的皮肤正在加载中，请稍候...");
+                target.sendMessage("§7(如果长时间未加载完成，请重新加入服务器)");
+            }
+
+            plugin.getSkinManager().loadPlayerSkinAsync(target);
+
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                boolean success = plugin.getBlockManager().setLifeBlocks(target, target.getLocation());
+                if (success) {
+                    if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                        executor.sendMessage("§a已为玩家 " + target.getName() + " 生成生命方块！");
+                    }
+                } else {
+                    if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                        executor.sendMessage("§c为玩家 " + target.getName() + " 生成生命方块失败！");
+                    } else {
+                        target.sendMessage("§c生成失败，请稍后再试或联系管理员");
+                    }
+                }
+            }, 40L);
+
+            return;
+        }
+
+        boolean success = plugin.getBlockManager().setLifeBlocks(target, target.getLocation());
+
+        if (success) {
+            if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                executor.sendMessage("§a已为玩家 " + target.getName() + " 生成生命方块！");
+            }
+        } else {
+            if (executor != null && !targetId.equals(executor.getUniqueId())) {
+                executor.sendMessage("§c为玩家 " + target.getName() + " 生成生命方块失败！");
+            } else {
+                target.sendMessage("§c生成失败，请确保周围有足够空间");
+            }
+        }
+    }
+
+    private void showHelp(Player player) {
+        player.sendMessage("§a========== PlayerBlockLife 帮助 ==========");
+        player.sendMessage("§e/setlifeblocks §7- 设置你的生命方块");
+        player.sendMessage("§e/checklifeblocks §7- 查看你的生命方块位置");
+        player.sendMessage("§e/setlifeblocks reset §7- 重置生命方块位置");
+
+        if (player.hasPermission("playerblocklife.admin")) {
+            player.sendMessage("§6管理员命令:");
+            player.sendMessage("§e/setlifeblocks other <玩家> §7- 为其他玩家设置生命方块");
+            player.sendMessage("§e/pblreload §7- 重载插件配置");
+            player.sendMessage("§e/pbldelete <玩家> §7- 删除玩家的生命方块");
+        }
+
+        player.sendMessage("§7游戏规则:");
+        player.sendMessage("§7- 每个玩家有5个生命方块");
+        player.sendMessage("§7- 方块被挖光时，玩家死亡");
+        player.sendMessage("§7- 方块使用玩家的皮肤作为材质");
+        player.sendMessage("§a======================================");
+    }
+}

src/main/java/com/playerblocklife/SkinManager.java

@@ -0,0 +1,290 @@
+package com.playerblocklife;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.profile.PlayerProfile;
+import org.bukkit.profile.PlayerTextures;
+import org.yaml.snakeyaml.Yaml;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.net.URL;
+import java.nio.file.Files;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SkinManager {
+    private final PlayerBlockLife plugin;
+    private final Map<UUID, String> playerSkinData = new ConcurrentHashMap<>();
+    private final Map<UUID, Integer> playerCustomModelData = new ConcurrentHashMap<>();
+    private final Map<UUID, Long> skinLoadTime = new ConcurrentHashMap<>();
+    private final File skinDataFile;
+    private final File skinCacheDir;
+    private int nextCustomModelData = 1000;
+    private static final long SKIN_CACHE_TIME = 7 * 24 * 60 * 60 * 1000L;
+
+    public SkinManager(PlayerBlockLife plugin) {
+        this.plugin = plugin;
+        this.skinDataFile = new File(plugin.getDataFolder(), "skindata.yml");
+        this.skinCacheDir = new File(plugin.getDataFolder(), "skincache");
+
+        if (!skinCacheDir.exists()) {
+            skinCacheDir.mkdirs();
+        }
+    }
+
+    public void loadAllSkins() {
+        loadSkinDataFromFile();
+        Bukkit.getOnlinePlayers().forEach(this::loadPlayerSkinAsync);
+    }
+
+    public void loadPlayerSkinAsync(Player player) {
+        UUID playerId = player.getUniqueId();
+
+        if (playerSkinData.containsKey(playerId)) {
+            return;
+        }
+
+        if (loadSkinFromCache(playerId)) {
+            plugin.logInfo("从缓存加载皮肤: " + player.getName());
+            return;
+        }
+
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            try {
+                plugin.logInfo("开始加载皮肤: " + player.getName());
+
+                String skinBase64 = getSkinFromPlayerProfile(player);
+
+                if (skinBase64 == null) {
+                    skinBase64 = getDefaultSteveSkin();
+                    plugin.logWarning("使用默认皮肤: " + player.getName());
+                }
+
+                if (skinBase64 != null) {
+                    playerSkinData.put(playerId, skinBase64);
+                    int modelData = allocateCustomModelData(playerId);
+                    saveSkinToCache(playerId, skinBase64);
+                    skinLoadTime.put(playerId, System.currentTimeMillis());
+
+                    plugin.logInfo("皮肤加载完成: " + player.getName() + " (模型数据: " + modelData + ")");
+
+                    Bukkit.getScheduler().runTask(plugin, () -> {
+                        if (player.isOnline()) {
+                            player.sendMessage("§a你的皮肤方块已准备就绪！");
+                        }
+                    });
+                }
+            } catch (Exception e) {
+                plugin.logError("加载皮肤失败: " + player.getName(), e);
+            }
+        });
+    }
+
+    private String getSkinFromPlayerProfile(Player player) {
+        try {
+            PlayerProfile profile = player.getPlayerProfile();
+            PlayerTextures textures = profile.getTextures();
+            URL skinUrl = textures.getSkin();
+
+            if (skinUrl != null) {
+                BufferedImage skinImage = ImageIO.read(skinUrl);
+                if (skinImage == null) {
+                    return null;
+                }
+
+                int headX = 8;
+                int headY = 8;
+                int headWidth = 8;
+                int headHeight = 8;
+
+                if (skinImage.getWidth() >= headX + headWidth &&
+                        skinImage.getHeight() >= headY + headHeight) {
+
+                    BufferedImage headImage = skinImage.getSubimage(headX, headY, headWidth, headHeight);
+
+                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                    ImageIO.write(headImage, "PNG", baos);
+                    byte[] imageBytes = baos.toByteArray();
+
+                    JsonObject textureJson = new JsonObject();
+                    JsonObject timestampJson = new JsonObject();
+
+                    return player.getUniqueId().toString();
+                }
+            }
+        } catch (Exception e) {
+            plugin.logWarning("从PlayerProfile获取皮肤失败: " + e.getMessage());
+        }
+
+        return null;
+    }
+
+    private boolean loadSkinFromCache(UUID playerId) {
+        try {
+            File cacheFile = new File(skinCacheDir, playerId.toString() + ".cache");
+            if (cacheFile.exists()) {
+                long lastModified = cacheFile.lastModified();
+                if (System.currentTimeMillis() - lastModified < SKIN_CACHE_TIME) {
+                    String skinData = new String(Files.readAllBytes(cacheFile.toPath()));
+                    playerSkinData.put(playerId, skinData);
+                    allocateCustomModelData(playerId);
+                    return true;
+                }
+            }
+        } catch (Exception e) {
+            plugin.logWarning("读取皮肤缓存失败: " + e.getMessage());
+        }
+        return false;
+    }
+
+    private void saveSkinToCache(UUID playerId, String skinData) {
+        try {
+            File cacheFile = new File(skinCacheDir, playerId.toString() + ".cache");
+            Files.write(cacheFile.toPath(), skinData.getBytes());
+        } catch (Exception e) {
+            plugin.logWarning("保存皮肤缓存失败: " + e.getMessage());
+        }
+    }
+
+    private synchronized int allocateCustomModelData(UUID playerId) {
+        if (playerCustomModelData.containsKey(playerId)) {
+            return playerCustomModelData.get(playerId);
+        }
+
+        int modelData = nextCustomModelData++;
+        playerCustomModelData.put(playerId, modelData);
+        return modelData;
+    }
+
+    private String getDefaultSteveSkin() {
+        return "8667ba71-b85a-4004-af54-457a9734eed7";
+    }
+
+    public ItemStack createPlayerHead(UUID playerId, String playerName) {
+        ItemStack head = new ItemStack(org.bukkit.Material.PLAYER_HEAD);
+        SkullMeta meta = (SkullMeta) head.getItemMeta();
+
+        if (meta != null) {
+            OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(playerId);
+            meta.setOwningPlayer(offlinePlayer);
+
+            Integer customModelData = playerCustomModelData.get(playerId);
+            if (customModelData != null) {
+                meta.setCustomModelData(customModelData);
+            }
+
+            meta.setDisplayName("§e" + playerName + "的生命方块");
+
+            List<String> lore = new ArrayList<>();
+            lore.add("§7所有者: §e" + playerName);
+            lore.add("§c⚠ 警告: 挖掘此方块将减少玩家生命值");
+            lore.add("§7剩余生命: §a" + plugin.getBlockManager().getRemainingBlocks(playerId) + "/5");
+            meta.setLore(lore);
+
+            head.setItemMeta(meta);
+        }
+
+        return head;
+    }
+
+    public boolean isSkinLoaded(UUID playerId) {
+        return playerSkinData.containsKey(playerId);
+    }
+
+    public Integer getCustomModelData(UUID playerId) {
+        return playerCustomModelData.get(playerId);
+    }
+
+    public Map<UUID, String> getAllSkinData() {
+        return new HashMap<>(playerSkinData);
+    }
+
+    public Map<UUID, Integer> getAllCustomModelData() {
+        return new HashMap<>(playerCustomModelData);
+    }
+
+    private void loadSkinDataFromFile() {
+        if (!skinDataFile.exists()) {
+            return;
+        }
+
+        try {
+            Yaml yaml = new Yaml();
+            Map<String, Object> data = yaml.load(new FileReader(skinDataFile));
+
+            if (data != null && data.containsKey("skins")) {
+                Map<String, Object> skins = (Map<String, Object>) data.get("skins");
+                for (Map.Entry<String, Object> entry : skins.entrySet()) {
+                    UUID playerId = UUID.fromString(entry.getKey());
+                    String skinData = (String) entry.getValue();
+                    playerSkinData.put(playerId, skinData);
+                }
+            }
+
+            if (data != null && data.containsKey("modelData")) {
+                Map<String, Integer> modelData = (Map<String, Integer>) data.get("modelData");
+                for (Map.Entry<String, Integer> entry : modelData.entrySet()) {
+                    UUID playerId = UUID.fromString(entry.getKey());
+                    playerCustomModelData.put(playerId, entry.getValue());
+                    nextCustomModelData = Math.max(nextCustomModelData, entry.getValue() + 1);
+                }
+            }
+
+            plugin.logInfo("已加载 " + playerSkinData.size() + " 个玩家的皮肤数据");
+        } catch (Exception e) {
+            plugin.logError("加载皮肤数据文件失败", e);
+        }
+    }
+
+    public void saveSkinData() {
+        try {
+            Map<String, Object> data = new HashMap<>();
+
+            Map<String, String> skins = new HashMap<>();
+            for (Map.Entry<UUID, String> entry : playerSkinData.entrySet()) {
+                skins.put(entry.getKey().toString(), entry.getValue());
+            }
+            data.put("skins", skins);
+
+            Map<String, Integer> modelData = new HashMap<>();
+            for (Map.Entry<UUID, Integer> entry : playerCustomModelData.entrySet()) {
+                modelData.put(entry.getKey().toString(), entry.getValue());
+            }
+            data.put("modelData", modelData);
+
+            Yaml yaml = new Yaml();
+            yaml.dump(data, new FileWriter(skinDataFile));
+
+            plugin.logInfo("皮肤数据已保存");
+        } catch (Exception e) {
+            plugin.logError("保存皮肤数据失败", e);
+        }
+    }
+
+    public void cleanupOldCache() {
+        File[] cacheFiles = skinCacheDir.listFiles();
+        if (cacheFiles != null) {
+            long now = System.currentTimeMillis();
+            int cleaned = 0;
+
+            for (File file : cacheFiles) {
+                if (now - file.lastModified() > SKIN_CACHE_TIME) {
+                    if (file.delete()) {
+                        cleaned++;
+                    }
+                }
+            }
+
+            if (cleaned > 0) {
+                plugin.logInfo("清理了 " + cleaned + " 个过期皮肤缓存");
+            }
+        }
+    }
+}

src/main/resources/config.yml

@@ -0,0 +1,382 @@
+# PlayerBlockLife 配置文件
+# 版本: 1.0.0
+
+# 方块设置
+blocks:
+  # 每个玩家的生命方块数量
+  amount: 5
+  # 方块生成范围（以玩家为中心的正方形边长的一半）
+  spread: 5
+  # 方块埋藏深度（0为地面，负数为地下）
+  depth: -1
+  # 方块材质类型
+  # 可选值: player_head, custom_block, default
+  material: player_head
+  # 是否在生成方块时自动填充周围的方块
+  fill_around: true
+
+  # 当使用玩家头颅时的设置
+  player_head:
+    # 是否随机旋转头颅方向
+    random_rotation: true
+    # 是否显示玩家名字
+    show_player_name: true
+    # 是否显示特殊效果
+    show_effects: true
+
+  # 当使用自定义方块时的设置
+  custom_block:
+    # 自定义方块材质
+    material: DIAMOND_BLOCK
+    # 是否发光
+    glowing: true
+    # 发光等级 (0-15)
+    light_level: 3
+
+# 游戏规则
+game:
+  # 方块被挖光时是否死亡
+  die_when_blocks_gone: true
+  # 死亡后是否变成观察者
+  become_spectator: true
+  # 观察者模式
+  spectator_mode:
+    # 是否可以飞行
+    can_fly: true
+    # 是否可以看到其他玩家
+    can_see_players: true
+    # 是否可以穿墙
+    can_clip: true
+
+  # 是否启用生命值系统
+  health_system: true
+  # 生命值计算公式
+  health_formula:
+    # 方块数量与生命值的关系
+    # 格式: 方块数量:生命值
+    5: 20
+    4: 16
+    3: 12
+    2: 8
+    1: 4
+    0: 0
+
+  # 状态效果
+  status_effects:
+    # 当剩余2个方块时
+    two_blocks_left:
+      - type: SLOW
+        amplifier: 1
+        duration: 100
+    # 当剩余1个方块时
+    one_block_left:
+      - type: SLOW
+        amplifier: 2
+        duration: 100
+      - type: WEAKNESS
+        amplifier: 0
+        duration: 100
+      - type: BLINDNESS
+        amplifier: 0
+        duration: 100
+
+  # 挖掘奖励
+  break_rewards:
+    # 是否给予经验
+    give_exp: true
+    # 经验数量
+    exp_amount: 5
+    # 是否给予物品
+    give_items: false
+    # 物品列表
+    items:
+      - DIAMOND:1
+      - GOLD_INGOT:3
+
+  # 广播设置
+  broadcast:
+    # 方块被破坏时是否广播
+    on_block_break: true
+    # 广播范围（格数）
+    range: 30
+    # 玩家死亡时是否全服广播
+    on_player_death: true
+    # 新玩家加入时是否广播
+    on_player_join: false
+
+# 皮肤系统
+skin:
+  # 是否启用皮肤系统
+  enabled: true
+  # 皮肤来源
+  source: player_profile
+  # 可选值: player_profile, mojang_api, local_cache
+  # player_profile: 从玩家本地缓存获取（推荐，不调用外部API）
+  # mojang_api: 从Mojang API获取（需要网络）
+  # local_cache: 从本地缓存获取
+
+  # 缓存设置
+  cache:
+    # 是否启用缓存
+    enabled: true
+    # 缓存过期时间（天）
+    expire_days: 7
+    # 缓存最大大小（MB）
+    max_size_mb: 100
+
+  # 默认皮肤（当无法获取玩家皮肤时）
+  default_skin:
+    # 使用哪个玩家的皮肤作为默认
+    player_name: Steve
+    # 或使用自定义UUID
+    uuid: 8667ba71-b85a-4004-af54-457a9734eed7
+    # 是否随机分配默认皮肤
+    random_default: false
+    # 可选的默认皮肤列表
+    available_skins:
+      - Steve
+      - Alex
+      - Enderman
+
+  # 皮肤处理
+  processing:
+    # 是否异步处理皮肤
+    async: true
+    # 处理线程数
+    threads: 2
+    # 超时时间（秒）
+    timeout: 10
+    # 重试次数
+    retry_times: 3
+
+# 数据存储
+storage:
+  # 存储类型
+  # 可选值: yaml, json, sqlite, mysql
+  type: yaml
+
+  # 自动保存
+  auto_save:
+    # 是否启用自动保存
+    enabled: true
+    # 保存间隔（秒）
+    interval: 300
+
+  # YAML存储设置
+  yaml:
+    # 数据文件编码
+    encoding: UTF-8
+    # 是否压缩
+    compress: false
+
+  # SQLite设置
+  sqlite:
+    # 数据库文件路径
+    file: plugins/PlayerBlockLife/data.db
+    # 连接池大小
+    pool_size: 5
+
+  # MySQL设置
+  mysql:
+    # 数据库主机
+    host: localhost
+    # 数据库端口
+    port: 3306
+    # 数据库名
+    database: minecraft
+    # 用户名
+    username: root
+    # 密码
+    password: password
+    # 表前缀
+    table_prefix: pbl_
+    # 连接池设置
+    pool:
+      max_connections: 10
+      min_connections: 2
+      connection_timeout: 30000
+      idle_timeout: 600000
+
+# 消息配置
+messages:
+  # 消息前缀
+  prefix: "&6[&ePlayerBlockLife&6]&r "
+  # 消息颜色
+  colors:
+    success: "&a"
+    error: "&c"
+    warning: "&e"
+    info: "&7"
+    highlight: "&6"
+
+  # 命令消息
+  commands:
+    setlifeblocks:
+      success: "&a已为你生成 {blocks} 个生命方块！"
+      already_has: "&c你已经有生命方块了！使用 /checklifeblocks 查看位置"
+      no_skin: "&e你的皮肤正在加载中，请稍候..."
+      failed: "&c无法生成生命方块，请确保周围有足够空间"
+
+    checklifeblocks:
+      no_blocks: "&c你还没有设置生命方块！使用 /setlifeblocks 来设置"
+      info: "&a你的生命方块信息："
+      location: "&7{index}. &e世界: {world} &7坐标: &a{x}&7, &a{y}&7, &a{z}"
+      remaining: "&7剩余方块: &e{remaining}&7/&a5"
+      health: "&7当前生命值: &c{health} ❤"
+
+    admin:
+      reload: "&a插件配置已重载！"
+      delete_success: "&a已删除玩家 {player} 的生命方块"
+      delete_failed: "&c删除失败，玩家不存在或没有生命方块"
+      revive_success: "&a玩家 {player} 已复活！"
+      revive_failed: "&c复活失败，玩家不存在或未死亡"
+
+  # 游戏消息
+  game:
+    block_destroyed:
+      owner: "&c⚠ 警告！你的生命方块被 {breaker} 破坏了！"
+      breaker: "&a你破坏了 {owner} 的生命方块！"
+      remaining: "&7对方剩余生命方块: &a{remaining}"
+      broadcast: "&7[附近] &e一个生命方块被破坏了！"
+
+    death:
+      title: "&4☠ 你死了！"
+      subtitle: "&c所有生命方块已被挖光"
+      broadcast: "&4☠ 玩家 {player} 的生命方块已被全部挖光，惨遭淘汰！"
+      spectator: "&e你已被淘汰，可以观察其他玩家。等待下一轮游戏开始..."
+
+    warning:
+      low_blocks: "&c⚠ 警告！生命方块即将耗尽！"
+      last_block: "&4⚠ 警告！这是最后一个生命方块！"
+      health_low: "&4⚠ 警告！生命值过低！"
+
+  # 加入消息
+  join:
+    welcome: "&e欢迎加入游戏！"
+    welcome_back: "&e欢迎回来，{player}！"
+    rules: |
+      &6游戏规则：
+      &7- 每个玩家有5个生命方块
+      &7- 方块被其他玩家挖光时，你将死亡
+      &7- 方块使用你的皮肤作为材质
+      &7- 你可以自由移动，但方块固定位置
+    remaining_blocks: "&7你还有 {blocks} 个生命方块"
+    commands: "&7使用 &e/setlifeblocks &7来设置你的生命方块"
+
+# 效果设置
+effects:
+  # 方块放置效果
+  place:
+    particles:
+      - type: ENCHANTMENT_TABLE
+        count: 30
+        offset_x: 0.3
+        offset_y: 0.3
+        offset_z: 0.3
+        speed: 0.1
+    sounds:
+      - type: BLOCK_ANVIL_PLACE
+        volume: 0.5
+        pitch: 1.2
+
+  # 方块破坏效果
+  break:
+    particles:
+      - type: BLOCK_CRACK
+        count: 50
+        offset_x: 0.5
+        offset_y: 0.5
+        offset_z: 0.5
+        speed: 0.5
+        data: PLAYER_HEAD
+      - type: SMOKE_LARGE
+        count: 20
+        offset_x: 0.3
+        offset_y: 0.3
+        offset_z: 0.3
+        speed: 0.05
+    sounds:
+      - type: ENTITY_ITEM_BREAK
+        volume: 1.0
+        pitch: 0.8
+      - type: BLOCK_GLASS_BREAK
+        volume: 0.8
+        pitch: 1.0
+    knockback:
+      enabled: true
+      power: 0.5
+      vertical: 0.3
+
+  # 玩家受伤效果
+  damage:
+    particles:
+      - type: DAMAGE_INDICATOR
+        count: 10
+    sounds:
+      - type: ENTITY_PLAYER_HURT
+        volume: 1.0
+        pitch: 1.0
+
+  # 玩家死亡效果
+  player_death:
+    particles:
+      - type: EXPLOSION_HUGE
+        count: 5
+    sounds:
+      - type: ENTITY_WITHER_DEATH
+        volume: 0.7
+        pitch: 0.8
+      - type: ENTITY_LIGHTNING_BOLT_THUNDER
+        volume: 1.0
+        pitch: 0.5
+
+# 保护设置
+protection:
+  # 是否保护生命方块不被非玩家破坏
+  protect_from_non_players: true
+  # 是否保护生命方块不被爆炸破坏
+  protect_from_explosions: true
+  # 是否保护生命方块不被火焰烧毁
+  protect_from_fire: true
+  # 是否保护生命方块不被活塞推动
+  protect_from_pistons: true
+  # 是否允许TNT破坏生命方块
+  allow_tnt_damage: false
+  # 是否允许苦力怕爆炸破坏生命方块
+  allow_creeper_explosions: false
+  # 是否允许末影龙破坏生命方块
+  allow_ender_dragon_damage: false
+  # 是否允许其他插件修改生命方块
+  allow_plugin_modification: false
+
+# 世界保护
+world_guard:
+  # 是否与WorldGuard集成
+  enabled: false
+  # 需要保护的地区标志
+  region_flags:
+    - block-break
+    - block-place
+    - pvp
+  # 白名单地区（允许破坏生命方块的地区）
+  whitelist_regions: []
+  # 黑名单地区（不允许破坏生命方块的地区）
+  blacklist_regions: []
+
+# 调试设置
+debug:
+  # 是否启用调试模式
+  enabled: false
+  # 调试级别
+  # 可选值: INFO, WARNING, ERROR, DEBUG
+  level: INFO
+  # 是否记录到文件
+  log_to_file: true
+  # 日志文件路径
+  log_file: plugins/PlayerBlockLife/debug.log
+  # 是否显示详细事件日志
+  verbose_events: false
+  # 是否记录性能数据
+  log_performance: false
+  # 性能日志间隔（秒）
+  performance_log_interval: 60

src/main/resources/plugin.yml

@@ -0,0 +1,35 @@
+commands:
+  setlifeblocks:
+    description: 设置你的生命方块（使用你的皮肤）
+    usage: /<command>
+    aliases: [sbl, lifeblocks, setblocks]
+    permission: playerblocklife.set
+
+  checklifeblocks:
+    description: 查看你的生命方块位置
+    usage: /<command>
+    aliases: [cbl, checklife, myblocks]
+    permission: playerblocklife.check
+
+  pblreload:
+    description: 重载插件配置
+    usage: /<command>
+    aliases: [pblr, pblreload]
+    permission: playerblocklife.admin
+
+  pbldelete:
+    description: 删除指定玩家的生命方块
+    usage: /<command> <玩家>
+    aliases: [pbldel, deleteblocks]
+    permission: playerblocklife.admin
+
+  pblrevive:
+    description: 复活被淘汰的玩家
+    usage: /<command> [玩家]
+    aliases: [revive]
+    permission: playerblocklife.admin
+
+  pblstats:
+    description: 查看插件统计信息
+    usage: /<command>
+    permission: playerblocklife.admin