del

LiteLevels - 轻量级自定义等级系统

为你的Minecraft服务器打造独特的RPG体验！

插件简介
LiteLevels是一个功能强大且轻量级的自定义等级系统插件，专为Paper 1.20.1服务器设计。它完全替代了原版的经验系统，为玩家提供更加丰富和有趣的成长体验。

✨ 核心特色
完全自定义的等级系统

• 替代原版经验机制，提供更灵活的等级设计
• 支持自定义每级所需经验值
• 智能拦截原版经验获取，无缝转换为自定义系统

独特的魔法值系统

• 每个等级拥有不同的魔法值上限
• 支持魔法值加成和动态调整
• 为魔法类插件提供完美的数值基础

生命值加成系统

• 等级越高，生命值越多
• 可配置的生命值加成曲线
• 让玩家真正感受到成长的力量

强大的数据持久化

• 支持SQLite和MySQL双数据库
• 自动保存机制，数据安全有保障

完善的API支持

• 为其他插件提供丰富的API接口
• 集成PlaceholderAPI，支持7个实用占位符
• 模块化设计，易于扩展和集成

游戏体验
玩家成长之旅
新手阶段 (1-3级)

• 快速成长，体验升级的乐趣
• 每次升级都有明显的属性提升
• 精美的升级提示和音效

进阶阶段 (4-7级)

• 更强的战斗能力
• 丰富的魔法值支持
• ️ 显著的生命值加成

大师阶段 (8-10级)

• 成为服务器的顶尖玩家
• 强大的属性加成
• 独特的成就感和荣誉

数值系统设计
等级 所需经验 魔法值上限 生命值加成
1级 100 50 +2
2级 200 60 +4
3级 300 70 +6
5级 800 100 +10
10级 4000 220 +20
快速开始
系统要求

• 服务端: Paper 1.20.1 或更高版本
• Java版本: Java 17+
• 可选依赖: PlaceholderAPI (用于占位符功能)

安装步骤

1. 下载插件
   
   将 LiteLevels.jar 放入服务器的 plugins 文件夹
   
   
2. 启动服务器
   
   插件会自动生成配置文件和数据库
   
   
3. 配置插件
   
   编辑 plugins/LiteLevels/config.yml 进行个性化设置
   
   
4. 重载配置
   
   /ll reload

⚙️ 基础配置
config.yml 核心设置

# LiteLevels 配置文件
# 版本: 1.0.0

# 调试模式
debug: false

# 等级系统设置
level-system:
  # 每级所需经验值列表 (从1级开始)
  exp-requirements:
    - 100.0    # 1级需要100经验
    - 200.0    # 2级需要200经验
    - 300.0    # 3级需要300经验
    - 500.0    # 4级需要500经验
    - 800.0    # 5级需要800经验
    - 1200.0   # 6级需要1200经验
    - 1700.0   # 7级需要1700经验
    - 2300.0   # 8级需要2300经验
    - 3000.0   # 9级需要3000经验
    - 4000.0   # 10级需要4000经验

  # 每级魔法值上限列表
  magic-limits:
    - 50.0     # 1级魔法值上限50
    - 60.0     # 2级魔法值上限60
    - 70.0     # 3级魔法值上限70
    - 85.0     # 4级魔法值上限85
    - 100.0    # 5级魔法值上限100
    - 120.0    # 6级魔法值上限120
    - 140.0    # 7级魔法值上限140
    - 165.0    # 8级魔法值上限165
    - 190.0    # 9级魔法值上限190
    - 220.0    # 10级魔法值上限220

  # 每级生命值加成列表
  health-bonus:
    - 2.0      # 1级生命值加成2
    - 4.0      # 2级生命值加成4
    - 6.0      # 3级生命值加成6
    - 8.0      # 4级生命值加成8
    - 10.0     # 5级生命值加成10
    - 12.0     # 6级生命值加成12
    - 14.0     # 7级生命值加成14
    - 16.0     # 8级生命值加成16
    - 18.0     # 9级生命值加成18
    - 20.0     # 10级生命值加成20

  # 是否启用生命值加成
  enable-health-bonus: false

  # 最大等级
  max-level: 10

# 数据库配置
database:
  # 数据库类型: sqlite 或 mysql (默认: sqlite)
  type: "sqlite"

  # SQLite配置
  sqlite:
    # 数据库文件名
    file: "litelevels.db"

  # MySQL配置
  mysql:
    # 主机地址
    host: "localhost"
    # 端口
    port: 3306
    # 数据库名
    database: "litelevels"
    # 用户名
    username: "root"
    # 密码
    password: "password"
    # 是否使用SSL
    use-ssl: false
    # 连接池配置
    pool:
      # 最大连接数
      max-connections: 10
      # 最小连接数
      min-connections: 2
      # 连接超时时间(秒)
      connection-timeout: 30

# 数据保存设置
data-save:
  # 自动保存间隔(秒) - 0表示禁用自动保存
  auto-save-interval: 300
  # 玩家退出时是否立即保存
  save-on-quit: true
  # 服务器关闭时是否保存所有数据
  save-on-shutdown: true

功能详解
玩家命令
命令 描述 权限
/ll info 查看自己的等级信息 litelevels.use
/ll give <经验值> 给自己添加经验 litelevels.give
管理员命令
命令 描述 权限
/ll set <玩家> <等级> [经验%] 设置玩家等级 litelevels.admin
/ll reload 重载配置文件 litelevels.admin
/ll save 手动保存所有数据 litelevels.admin
️ PlaceholderAPI占位符
占位符 描述 示例
%ll_currentexp% 当前经验值 150
%ll_currentlevel% 当前等级 5
%ll_currentmagic% 当前魔法值 80
%ll_currenthealth% 当前生命值 24
%ll_maxexp% 最大经验值 800
%ll_maxmagic% 最大魔法值 100
%ll_maxhealth% 最大生命值 30
开发者API
API使用示例

public class LiteLevelsAPI {

    private static ConfigManager configManager;

    /**
     * 初始化API（内部使用）
     */
    static {
        if (LiteLevels.getInstance() != null) {
            configManager = LiteLevels.getInstance().getConfigManager();
        }
    }

    // ==================== 数据获取方法 ====================

    /**
     * 获取玩家等级数据
     * 统一的数据获取方法，供所有其他方法调用
     *
     * @param player 玩家
     * @return 玩家等级数据，如果玩家不在线或数据不存在则返回null
     */
    public static PlayerLevelData getPlayerData(Player player) {
        if (player == null || !player.isOnline()) {
            return null;
        }
        UUID playerId = player.getUniqueId();
        return PlayerLevelData.playerDataMap.get(playerId);
    }

    /**
     * 检查玩家数据是否已加载
     *
     * @param player 玩家
     * @return 如果数据已加载则返回true
     */
    public static boolean isDataLoaded(Player player) {
        return getPlayerData(player) != null;
    }

    // ==================== 等级相关方法 ====================

    /**
     * 获取玩家等级
     *
     * @param player 玩家
     * @return 玩家等级，如果数据不存在则返回0
     */
    public static int getLevel(Player player) {
        PlayerLevelData data = getPlayerData(player);
        return data != null ? data.getLevel() : 0;
    }

    /**
     * 设置玩家等级
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param level 等级
     */
    public static void setLevel(Player player, int level) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家设置等级: " + player.getName());
            return;
        }
        LevelUtil.setLevel(player, level);
    }

    /**
     * 获取最大等级
     *
     * @return 系统设定的最大等级
     */
    public static int getMaxLevel() {
        return configManager != null ? configManager.getMaxLevel() : 10;
    }

    // ==================== 经验相关方法 ====================

    /**
     * 获取玩家当前经验值
     *
     * @param player 玩家
     * @return 当前经验值，如果数据不存在则返回0
     */
    public static double getCurrentExp(Player player) {
        PlayerLevelData data = getPlayerData(player);
        return data != null ? data.getCurrentExp() : 0.0;
    }

    /**
     * 获取指定等级所需的经验值
     *
     * @param level 等级
     * @return 所需经验值
     */
    public static double getRequiredExp(int level) {
        return configManager != null ? configManager.getRequiredExp(level) : 100.0;
    }

    /**
     * 获取玩家当前等级所需的经验值
     *
     * @param player 玩家
     * @return 当前等级所需经验值
     */
    public static double getRequiredExp(Player player) {
        int level = getLevel(player);
        return getRequiredExp(level);
    }

    /**
     * 设置玩家当前经验值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param exp 经验值
     */
    public static void setCurrentExp(Player player, double exp) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家设置经验: " + player.getName());
            return;
        }
        LevelUtil.setCurrentExp(player, exp);
    }

    /**
     * 给玩家添加经验值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param exp 经验值
     */
    public static void addExp(Player player, double exp) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家添加经验: " + player.getName());
            return;
        }
        LevelUtil.addExp(player, exp, false);
    }

    /**
     * 给玩家添加经验值（强制，跳过事件检查）
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param exp 经验值
     */
    public static void addExpForce(Player player, double exp) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家强制添加经验: " + player.getName());
            return;
        }
        LevelUtil.addExp(player, exp, true);
    }

    // ==================== 魔法相关方法 ====================

    /**
     * 获取玩家魔法值
     *
     * @param player 玩家
     * @return 魔法值，如果数据不存在则返回0
     */
    public static double getMagic(Player player) {
        PlayerLevelData data = getPlayerData(player);
        return data != null ? data.getMagic() : 0.0;
    }

    /**
     * 获取玩家最大魔法值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @return 最大魔法值
     */
    public static double getMaxMagic(Player player) {
        return LevelUtil.getMaxMagic(player);
    }

    /**
     * 获取指定等级的魔法值上限
     *
     * @param level 等级
     * @return 魔法值上限
     */
    public static double getMagicLimit(int level) {
        return configManager != null ? configManager.getMagicLimit(level) : 50.0;
    }

    /**
     * 设置玩家魔法值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param magic 魔法值
     */
    public static void setMagic(Player player, double magic) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家设置魔法值: " + player.getName());
            return;
        }
        LevelUtil.setMagic(player, magic);
    }

    /**
     * 给玩家添加魔法值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @param magic 魔法值
     */
    public static void addMagic(Player player, double magic) {
        if (!isDataLoaded(player)) {
            MessageUtil.logWarning("尝试为未加载数据的玩家添加魔法值: " + player.getName());
            return;
        }
        LevelUtil.addMagic(player, magic);
    }

    // ==================== 生命值相关方法 ====================

    /**
     * 获取玩家最大血量
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     * @return 最大血量
     */
    public static double getMaxHealth(Player player) {
        return LevelUtil.getMaxHealth(player);
    }

    /**
     * 获取指定等级的生命值加成
     *
     * @param level 等级
     * @return 生命值加成
     */
    public static double getHealthBonus(int level) {
        return configManager != null ? configManager.getHealthBonus(level) : 0.0;
    }

    /**
     * 检查是否启用生命值加成
     *
     * @return 如果启用生命值加成则返回true
     */
    public static boolean isHealthBonusEnabled() {
        return configManager != null && configManager.isEnableHealthBonus();
    }

    // ==================== 显示更新方法 ====================

    /**
     * 更新玩家经验条显示
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     */
    public static void updateExpDisplay(Player player) {
        if (!isDataLoaded(player)) {
            return;
        }
        LevelUtil.updateExpDisplay(player);
    }

    /**
     * 更新玩家生命值
     * 使用统一的LevelUtil方法
     *
     * @param player 玩家
     */
    public static void updatePlayerHealth(Player player) {
        PlayerLevelData data = getPlayerData(player);
        if (data != null) {
            LevelUtil.updatePlayerHealth(player, data);
        }
    }

    // ==================== 工具方法 ====================

    /**
     * 获取玩家等级进度百分比
     *
     * @param player 玩家
     * @return 进度百分比 (0.0 - 100.0)
     */
    public static double getLevelProgress(Player player) {
        PlayerLevelData data = getPlayerData(player);
        if (data == null) {
            return 0.0;
        }

        double currentExp = data.getCurrentExp();
        double requiredExp = getRequiredExp(player);

        if (requiredExp <= 0) {
            return 100.0;
        }

        return Math.min(100.0, (currentExp / requiredExp) * 100.0);
    }

    /**
     * 检查玩家是否达到最大等级
     *
     * @param player 玩家
     * @return 如果达到最大等级则返回true
     */
    public static boolean isMaxLevel(Player player) {
        return getLevel(player) >= getMaxLevel();
    }

    /**
     * 获取升级到下一级还需要的经验值
     *
     * @param player 玩家
     * @return 还需要的经验值，如果已达到最大等级则返回0
     */
    public static double getExpToNextLevel(Player player) {
        if (isMaxLevel(player)) {
            return 0.0;
        }

        double currentExp = getCurrentExp(player);
        double requiredExp = getRequiredExp(player);

        return Math.max(0.0, requiredExp - currentExp);
    }
}

个性化定制
消息自定义
所有玩家可见的消息都可以在 message.yml 中自定义：

# LiteLevels 消息配置文件
# 版本: 1.0.0

# 系统消息
system:
  plugin-enabled: "&a[LiteLevels] 插件已成功启动!"
  plugin-disabled: "&c[LiteLevels] 插件已关闭!"
  reload-success: "&a[LiteLevels] 配置文件重载成功!"
  reload-failed: "&c[LiteLevels] 配置文件重载失败!"
  data-loaded: "&a玩家数据已加载完成!"
  data-saved: "&a玩家数据已保存!"

# 等级系统消息
level:
  level-up: "&c[系统]&a恭喜你升级到了&b&l{level}&a级!"
  max-level-reached: "&c[系统]&a已经达到系统设定的最大等级!"
  exp-gained: "&a获得经验值: &e&l{exp}"
  current-level: "&a当前等级: &b&l{level}"
  current-exp: "&a当前经验: &e&l{current_exp}&a/&e&l{required_exp}"
  current-magic: "&a当前魔法值: &d&l{current_magic}&a/&d&l{max_magic}"

# 命令消息
command:
  no-permission: "&c你没有权限执行此命令!"
  player-only: "&c此命令只能由玩家执行!"
  unknown-command: "&c未知命令! 使用 /litelevels help 查看帮助"
  player-not-found: "&c玩家不存在或不在线!"
  invalid-number: "&c请输入有效的数字!"
  level-set-success: "&a已成功设置玩家&c&l{player}&a的等级为&b&l{level}&a级!"
  exp-set-success: "&a已成功设置玩家&c&l{player}&a的经验为&e&l{exp}!"
  exp-give-success: "&a已为你添加经验&e&l{exp}!"
  magic-set-success: "&a已成功设置玩家&c&l{player}&a的魔法值为&d&l{magic}!"

# 帮助信息
help:
  header: "&6========== LiteLevels 帮助 =========="
  footer: "&6=================================="
  commands:
    - "&a/ll info &7- 查看自己的等级信息"
    - "&a/ll set <玩家> <等级> [经验百分比] &7- 设置玩家等级"
    - "&a/ll give <经验值> &7- 给自己添加经验"
    - "&a/ll reload &7- 重载配置文件"