增加了重载文件

在危险度操作类中取消了监听事件的注册，

build.gradle

@@ -3,7 +3,7 @@ plugins {
 }
 
 group = 'com.sakurarealm'
-version = '1.0'
+version = '1.2'
 
 repositories {
     mavenCentral()

src/main/java/com/sakurarealm/playerrisk/Listener.java

@@ -1,37 +0,0 @@
-package com.sakurarealm.playerrisk;
-
-import com.palmergames.bukkit.towny.event.PlayerEnterTownEvent;
-import com.palmergames.bukkit.towny.event.PlayerLeaveTownEvent;
-import org.apache.commons.lang.NotImplementedException;
-import org.bukkit.event.entity.PlayerDeathEvent;
-
-public class Listener implements org.bukkit.event.Listener {
-    /**
-     * TODO: 当玩家进入城镇时, 危险度不再增加.
-     *
-     * @param event The PlayerEnterTownEvent.
-     */
-    public void onPlayerEnterTown(PlayerEnterTownEvent event) {
-        throw new NotImplementedException("Not implemented yet.");
-    }
-
-    /**
-     * TODO: 当玩家离开城镇时, 危险度开始增加.
-     *
-     * @param event The PlayerLeaveTownEvent.
-     */
-    public void onPlayerLeaveTown(PlayerLeaveTownEvent event) {
-        throw new NotImplementedException("Not implemented yet.");
-    }
-
-    /**
-     * TODO: 当玩家死亡时, 危险度重置.
-     *
-     * @param event The PlayerDeathEvent.
-     */
-    public void onPlayerDeath(PlayerDeathEvent event) {
-        throw new NotImplementedException("Not implemented yet.");
-    }
-
-    // TODO: Add any other event handlers needed to manage player risk.
-}

src/main/java/com/sakurarealm/playerrisk/PlayerRisk.java

@@ -1,18 +1,47 @@
 package com.sakurarealm.playerrisk;
 
+import com.palmergames.bukkit.towny.TownyAPI;
+import com.palmergames.bukkit.towny.event.PlayerEnterTownEvent;
+import com.palmergames.bukkit.towny.event.PlayerLeaveTownEvent;
+import com.palmergames.bukkit.towny.object.Town;
 import com.sakurarealm.playerrisk.api.PlayerRiskManager;
 import com.sakurarealm.playerrisk.api.PlayerRiskSettings;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.plugin.java.JavaPlugin;
 
-public final class PlayerRisk extends JavaPlugin {
+import java.util.*;
 
-    PlayerRiskManager playerRiskManager = null;
+public final class PlayerRisk extends JavaPlugin implements Listener {
 
+    private PlayerRiskManager playerRiskManager = null;
+    private boolean boolLogger = false;
+
+    //假设的方法，您需要根据实际情况来实现它
+    private String getCurrentBiome(Player player) {
+        //实现获取玩家当前所在生物群系的逻辑
+        return player.getLocation().getBlock().getBiome().name();
+    }
+
+
+    /**
+     * 返回getPlayerRiskManager用于调用危险度
+     */
     public PlayerRiskManager getPlayerRiskManager() {
         if (playerRiskManager == null) {
-            throw new NullPointerException("PlayerRisk plugin is not initialized.");
+            throw new NullPointerException(ChatColor.RED + "PlayerRisk plugin is not initialized.");
         }
         return playerRiskManager;
     }
@@ -28,12 +57,239 @@ public final class PlayerRisk extends JavaPlugin {
     public void onEnable() {
         // Plugin startup logic
         load();
-        getCommand("playerrisk").setExecutor(new CommandHandler(this));
+        getCommand("playerrisk").setExecutor(this::onCommand);
+        //注册监听器
+        Bukkit.getPluginManager().registerEvents(this,this);
+
+        getLogger().info(ChatColor.RED+"PlayerRisks插件开始运行");
+
+        getServer().getScheduler().scheduleSyncRepeatingTask(this, this::addRiskToOutTownPlayers,
+                0, playerRiskManager.settings.getIncreaseInterval()*20);
+
     }
 
     @Override
     public void onDisable() {
         // Plugin shutdown logic
+        getLogger().info(ChatColor.GREEN+"PlayerRisk插件关闭");
     }
 
+
+    /**
+     * 指令重载
+     * @param commandSender Source of the command
+     * @param command Command which was executed
+     * @param s Alias of the command which was used
+     * @param strings Passed command arguments
+     * @return
+     */
+    public boolean onCommand(CommandSender commandSender, Command command, String s, String[] strings){
+
+        if (s.equalsIgnoreCase("playerrisk") || s.equalsIgnoreCase("pr")){
+            if (strings.length == 0){
+                if (!commandSender.isOp()){
+                    //不是op不能执行此命令
+                    return false;
+                }
+                boolLogger = !boolLogger;
+                playerRiskManager.setBoolLogger(boolLogger);
+                if (boolLogger){
+                    commandSender.sendMessage(ChatColor.GREEN+"危险度插件日志开启");
+                }else {
+                    commandSender.sendMessage(ChatColor.GREEN+"危险度插件日志关闭");
+                }
+                return false;
+            }else if (strings[0].equalsIgnoreCase("reload")){
+                if (!commandSender.isOp()){
+                    //不是op不能执行此命令
+                    return false;
+                }
+                String reload = strings[0];
+                if (reload.equalsIgnoreCase("reload")){
+                    //重新加载插件
+                    //先取消定时任务
+                    Bukkit.getScheduler().cancelTasks(this);
+
+                    //重新加载文件
+
+                    playerRiskManager.setSettings(new PlayerRiskSettings(this));
+
+                    //重新注册定时任务
+                    getServer().getScheduler().scheduleSyncRepeatingTask(this, this::addRiskToOutTownPlayers,
+                            0, playerRiskManager.settings.getIncreaseInterval()*20);
+
+                    commandSender.sendMessage(ChatColor.GREEN+"危险度插件重载成功");
+                    return true;
+                }
+            } else if (strings.length == 2 && strings[0].equalsIgnoreCase("query")) {
+                //查询玩家的危险度
+                Player player = Bukkit.getPlayer(strings[1]);
+                if (player == null){
+                    commandSender.sendMessage(ChatColor.RED+"玩家"+strings[1]+"不存在");
+                }
+                if (player != null) {
+                    playerRiskManager.questRiskLevel(player);
+                    return true;
+                }
+                return false;
+            } else if (strings[0].equalsIgnoreCase("clear")){
+                if (!commandSender.isOp()){
+                    //不是op不能执行此命令
+                    return false;
+                }
+                if (strings.length == 2){
+                    //长度为2，清空某位玩家的危险度
+                    Player player = Bukkit.getPlayer(strings[1]);
+                    if (player == null){
+                        commandSender.sendMessage(ChatColor.RED+strings[1]+"玩家不存在!");
+                        return false;
+                    }
+                    playerRiskManager.removePlayerLevel(strings[1]);
+                }
+            }else if (strings.length == 3 && strings[0].equalsIgnoreCase("set")){
+                if (!commandSender.isOp()){
+                    //不是op不能执行此命令
+                    return false;
+                }
+                Player player = Bukkit.getPlayer(strings[1]);
+                if (player == null){
+                    commandSender.sendMessage(ChatColor.RED+strings[1]+"玩家不存在!");
+                }
+
+                playerRiskManager.setRisk2Player(strings[1], Integer.parseInt(strings[2]));
+            }
+        }else {
+            //指令错误
+            commandSender.sendMessage(ChatColor.RED+"请输入正确的指令!");
+            return false;
+        }
+        return false;
+    }
+
+    /**
+     * 玩家退出游戏后从map集合中移出
+     */
+    @EventHandler
+    public void playerOffOnline(PlayerQuitEvent event){
+        Player player = event.getPlayer();
+
+        String name = player.getName();
+
+        playerRiskManager.offOnlinePlayer(name);
+
+        if (boolLogger) getLogger().info(ChatColor.GREEN+player.getName()+"退出了游戏");
+    }
+
+    /**
+     * 当玩家登录时,判断玩家是否在野外群落中
+     * @param event
+     */
+    @EventHandler
+    public void onPlayerJoinGame(PlayerJoinEvent event){
+        Player player = event.getPlayer();
+        String name = player.getName();
+        if (boolLogger)getLogger().info(ChatColor.AQUA+name+"进入了游戏");
+        if(!playerRiskManager.playerLoginBoolean(name)){
+            Location location = player.getLocation();
+            if (!this.playerStayTown(location)){
+                //为空，则在野外上线，但是map集合中又没有记录，重新开始计算
+                playerRiskManager.addPlayerToHashMap(player.getName(),getCurrentBiome(player));
+            }
+        }
+    }
+
+    @EventHandler
+    public void playerRespawn(PlayerRespawnEvent event){
+        Player player = event.getPlayer();
+        Location respawnLocation = event.getRespawnLocation();
+        if(!this.playerStayTown(respawnLocation)){
+            //重生在野外
+            playerRiskManager.addPlayerToHashMap(player.getName(),getCurrentBiome(player));
+        }
+    }
+
+
+    /**
+     * TODO: 当玩家进入城镇时, 危险度不再增加.
+     *
+     * @param event The PlayerEnterTownEvent.
+     */
+    @EventHandler
+    public void onPlayerEnterTown(PlayerEnterTownEvent event) {
+        //当玩家进入城镇后，移出map集合并且清零
+        Player player = event.getPlayer();
+
+        if (boolLogger) getLogger().info(ChatColor.AQUA+"玩家"+player.getName()+"进入了城镇 ");
+
+        playerRiskManager.removePlayerLevel(player.getName());
+        player.sendMessage(ChatColor.GREEN+"进入城镇,危险度归零!");
+
+    }
+
+    /**
+     * TODO: 当玩家离开城镇时, 危险度开始增加.
+     *
+     * @param event The PlayerLeaveTownEvent.
+     */
+    @EventHandler
+    public void onPlayerLeaveTown(PlayerLeaveTownEvent event) {
+        //当玩家离开城镇后,把玩家姓名放入map中
+        Player player = event.getPlayer();
+
+
+        playerRiskManager.addPlayerToHashMap(player.getName(),getCurrentBiome(player));
+        player.sendMessage(ChatColor.RED+"离开城镇,开始计算危险度!");
+
+    }
+
+    /**
+     * TODO: 当玩家死亡时, 危险度重置.
+     *
+     * @param event The PlayerDeathEvent.
+     */
+    @EventHandler
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        Player player = event.getEntity();
+
+        if (boolLogger) getLogger().info(ChatColor.GREEN+player.getName()+"死亡了，停止计算危险度");
+
+        playerRiskManager.removePlayerLevel(player.getName());
+
+    }
+
+
+    // TODO: Add any other event handlers needed to manage player risk.
+
+    /**
+     * 此方法会每过60s执行一次,用于增加危险度
+     */
+    public void addRiskToOutTownPlayers(){
+        //获取所有玩家的生物群系的危险度
+        HashMap<String, HashMap<String, Integer>> playerBiomeRisk = playerRiskManager.getPlayerBiomeRisk();
+        for (String name : playerBiomeRisk.keySet()){
+
+            //通过玩家姓名获取所在的biome
+            Player player = Bukkit.getPlayer(name);
+            //当前玩家所在的生物群系
+            String biome = getCurrentBiome(player);
+
+            playerRiskManager.setPlayerRiskLevel(name,biome);
+
+        }
+    }
+
+    /**
+     * 用于判断玩家是否在城镇
+     * @param location
+     * @return
+     */
+    public boolean playerStayTown(Location location) {
+        Town town = TownyAPI.getInstance().getTown(location);
+        if (town == null){
+            //为空则不再城镇
+            return false;
+        }else {
+            return true;
+        }
+    }
 }

src/main/java/com/sakurarealm/playerrisk/api/PlayerRiskManager.java

@@ -1,12 +1,21 @@
 package com.sakurarealm.playerrisk.api;
 
-import com.sakurarealm.playerrisk.Listener;
 import com.sakurarealm.playerrisk.PlayerRisk;
 import com.sakurarealm.playerrisk.hook.PlaceHolderAPIHook;
 import org.apache.commons.lang.NotImplementedException;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
+import org.bukkit.block.Biome;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
+import java.util.HashMap;
+import java.util.Random;
 import java.util.UUID;
+import java.util.logging.Logger;
 
 /**
  * 危机度区间为0~level_max级，每次离开安全区（城镇），重置危险等级：每待n秒会使危机等级（变量）提升1点，
@@ -17,58 +26,273 @@ import java.util.UUID;
  */
 public class PlayerRiskManager {
 
+    private boolean boolLogger = false;
+    Logger logger = Logger.getLogger("PlayerRisk");
+
     private final PlayerRisk plugin;
 
+    public PlayerRiskSettings settings;
+
+    //用来记录在野外下线的玩家的危险度,这部分后续可以改成用数据库记录
+    private final HashMap<String,HashMap<String,Integer>> OffOnlinePlayerBiomeRisk;
+
+    //记录玩家的总危险度
+    private final HashMap<String, Integer> playerRiskLevels;
+
+    //用来记录每个玩家在每个生物群系里面的危险度
+    private final HashMap<String,HashMap<String,Integer>> playerBiomeRisk;
+
     // TODO: Add any data structures needed to manage player risk.
 
     public PlayerRiskManager(PlayerRisk plugin, PlayerRiskSettings settings) {
         this.plugin = plugin;
         // Register the event listener.
-        plugin.getServer().getPluginManager().registerEvents(new Listener(), plugin);
+//        plugin.getServer().getPluginManager().registerEvents(new Listener(), plugin);
+
+        this.playerRiskLevels = new HashMap<>();
+        this.playerBiomeRisk = new HashMap<>();
+        this.OffOnlinePlayerBiomeRisk = new HashMap<>();
+
+        //注入settings
+        this.settings = settings;
         new PlaceHolderAPIHook(this).register();
     }
 
-    public int getPlayerRiskLevel(String playerName) {
-        // Get offline player by name.
-        OfflinePlayer player = plugin.getServer().getOfflinePlayer(playerName);
-        return getPlayerRiskLevel(player);
-    }
-
-    public int getPlayerRiskLevel(UUID playerId) {
-        // Get offline player by UUID.
-        OfflinePlayer player = plugin.getServer().getOfflinePlayer(playerId);
-        return getPlayerRiskLevel(player);
-    }
-
     /**
-     * TODO: 获取玩家的危险度等级
      *
-     * @param player 玩家
+     * @param playerName  通过玩家姓名获取玩家总危险度
-     * @return 危险度等级
+     * @return
      */
-    public int getPlayerRiskLevel(OfflinePlayer player) {
+    public int getPlayerRiskLevel(String playerName) {
-        throw new NotImplementedException("Not implemented yet.");
-    }
 
-    public void setPlayerRiskLevel(String playerName, int level) {
+        Integer riskLevel = playerRiskLevels.get(playerName);
-        // Get offline player by name.
+        if (riskLevel == null){
-        OfflinePlayer player = plugin.getServer().getOfflinePlayer(playerName);
+            return 0;
-        setPlayerRiskLevel(player, level);
+        }
-    }
+        return riskLevel;
-
-    public void setPlayerRiskLevel(UUID playerId, int level) {
-        // Get offline player by UUID.
-        OfflinePlayer player = plugin.getServer().getOfflinePlayer(playerId);
-        setPlayerRiskLevel(player, level);
     }
 
     /**
-     * TODO: 设置玩家的危险度等级
+     *
+     * @param playerName 玩家姓名，
+     * @param biome  生物群系
+     * @return 返回该玩家在Biome中的危险度
      */
-    public void setPlayerRiskLevel(OfflinePlayer player, int level) {
+    public int getBiomeRiskLevel(String playerName,String biome){
-        throw new NotImplementedException("Not implemented yet.");
+
+        Integer level = playerBiomeRisk.get(playerName).get(biome);
+
+        return level;
     }
 
+
+    /**
+     * 修改玩家某个biome的危险度
+     * @param playerName
+     * @param biome
+     */
+    public void setPlayerRiskLevel(String playerName,String biome) {
+
+        if (playerBiomeRisk.get(playerName).get(biome) == null){
+            playerBiomeRisk.get(playerName).put(biome,1);
+            if (boolLogger) logger.info(ChatColor.GOLD+playerName+"进入了新的生物去群系且社危险度为1");
+        }else {
+            if (playerBiomeRisk.get(playerName).get(biome) < settings.getLevelMax()/5 && playerRiskLevels.get(playerName) < settings.getLevelMax()) {
+                playerBiomeRisk.get(playerName).put(biome, playerBiomeRisk.get(playerName).get(biome) + 1);
+            }else {
+                if (boolLogger) logger.info(ChatColor.GOLD+playerName+"的"+biome+"的危险度为:"+playerBiomeRisk.get(playerName).get(biome));
+            }
+        }
+
+        //修改总群系的危险度
+        addAllBiomeRisk(playerName);
+
+        if (boolLogger) logger.info(ChatColor.GOLD+playerName+"的"+biome+"的危险度:"+playerBiomeRisk.get(playerName).get(biome));
+    }
+
+    /**
+     * 玩家死亡或者进入城镇后，通过玩家姓名将玩家从HashMap里删除
+     * @param playerName
+     */
+    public void removePlayerLevel(String playerName){
+
+        playerRiskLevels.remove(playerName);
+        playerBiomeRisk.remove(playerName);
+    }
+
+    /**
+     * 玩家下线后，通过玩家姓名将玩家判断是删除玩家危险度还是记录
+     * @param playerName
+     */
+    public void offOnlinePlayer(String playerName){
+
+        if (playerRiskLevels.get(playerName) != null) {
+
+            HashMap<String, Integer> biomeRisks = playerBiomeRisk.get(playerName);
+            for (String biome : biomeRisks.keySet()) {
+
+                if (boolLogger) logger.info(ChatColor.AQUA+playerName+"保存的"+biome+"群系危险度:"+biomeRisks.get(biome));
+            }
+            //下线后记录到下线的HashMap中
+            OffOnlinePlayerBiomeRisk.put(playerName, biomeRisks);
+
+            if (boolLogger) logger.info(ChatColor.GOLD+playerName+"的危险度被记录了");
+        }
+
+        playerRiskLevels.remove(playerName);
+        playerBiomeRisk.remove(playerName);
+    }
+
+
+    /**
+     * 玩家离开城镇,并进入对应的biome后,将玩家放入对应的HashMap中
+     * 注意此处，当玩家从1群系到2群系的时候，不能调用此方法修改HashMap
+     * @param playerName
+     * @param biome
+     */
+    public void addPlayerToHashMap(String playerName,String biome){
+        HashMap<String,Integer> biomeRisk = new HashMap<>();
+        biomeRisk.put(biome,0);//从0开始计算
+        playerBiomeRisk.put(playerName,biomeRisk);
+
+        playerRiskLevels.put(playerName,0);
+    }
+
+
+
     // TODO Add any other methods needed to manage player risk.
 
+    /**
+     *
+     * @param playerName 通过玩家姓名获取修改危险度
+     */
+    public void addAllBiomeRisk(String playerName){
+        HashMap<String, Integer> stringIntegerHashMap = playerBiomeRisk.get(playerName);
+        //循环叠加每个群系的危险度
+        Integer sumLevel = 0;
+        for (String str : stringIntegerHashMap.keySet()){
+            sumLevel += stringIntegerHashMap.get(str);
+        }
+        //放入总值
+        playerRiskLevels.put(playerName,sumLevel);
+
+        if (boolLogger) logger.info(ChatColor.GREEN+playerName+"的总危险度:"+sumLevel);
+
+    }
+
+    public HashMap<String, HashMap<String, Integer>> getPlayerBiomeRisk() {
+        return playerBiomeRisk;
+    }
+
+    /**
+     * 判断玩家上下时是否在野外,如果玩家记录在HashMap集合中，则true
+     * @param name
+     */
+    public boolean playerLoginBoolean(String name) {
+        int sumRiskLevel = 0;
+
+        //不为空则玩家在野外下线
+        if (OffOnlinePlayerBiomeRisk.containsKey(name)){
+            //获取之前下线前保存的生物群系集合
+            HashMap<String, Integer> biomeRisks = OffOnlinePlayerBiomeRisk.get(name);
+
+            //把之前保存的生物群系危险度集合放入
+            playerBiomeRisk.put(name,biomeRisks);
+
+            //计算总危险度
+            for (String biome : biomeRisks.keySet()){
+                if (boolLogger)  logger.info(ChatColor.RED+biome);
+                Integer level = biomeRisks.get(biome);
+                sumRiskLevel += level;
+                if (boolLogger) logger.info(ChatColor.GREEN+name+"登录后的"+biome+"的危险度"+level);
+            }
+
+            //计入总危险度
+            playerRiskLevels.put(name,sumRiskLevel);
+            if (boolLogger) logger.info(ChatColor.AQUA+name+"登录后的总危险度"+sumRiskLevel);
+
+            //最后删除 OffOnlinePlayerBiomeRisk 中保存的集合
+            OffOnlinePlayerBiomeRisk.remove(name);
+
+            return true;
+        }
+        return false;
+    }
+
+
+    public void setSettings(PlayerRiskSettings settings) {
+        //清空危险度信息，重载文件
+        OffOnlinePlayerBiomeRisk.clear();
+        playerRiskLevels.clear();
+        playerBiomeRisk.clear();
+        this.settings = settings;
+    }
+
+    /**
+     * 会清空玩家的危险度然后随机赋予几个群系危险度
+     * @param name
+     * @param level
+     */
+    public void setRisk2Player(String name,int level){
+        if (level > 50){
+            level = 50;
+        }
+
+        HashMap<String,Integer> biomeRisk = new HashMap<>();
+//        HashMap<String,HashMap<String, Integer>> biomeRiskLevel = new HashMap<>();
+        int copyLevel = level;
+        Random random = new Random();
+
+
+
+        for (Biome biome : Biome.values()){
+            int i = random.nextInt(5);
+            if (i == 1){
+                if (copyLevel >= 10){
+                    copyLevel -= 10;
+                    biomeRisk.put(biome.name(),10);
+                }else if ( copyLevel > 0){
+                    biomeRisk.put(biome.name(),copyLevel);
+                    break;
+                }
+            }
+            if (level == 0){
+                break;
+            }
+        }
+
+        playerRiskLevels.put(name,level);
+        playerBiomeRisk.put(name,biomeRisk);
+
+        Player player = Bukkit.getPlayer(name);
+        for (String biome : biomeRisk.keySet()){
+            player.sendMessage(ChatColor.GREEN+biome+"群系的危险度被设置为:"+biomeRisk.get(biome));
+        }
+    }
+
+    /**
+     * 查询玩家的危险度
+     */
+    public void questRiskLevel(Player player){
+        HashMap<String, Integer> biomeRisk = playerBiomeRisk.get(player.getName());
+        Integer level = playerRiskLevels.get(player.getName());
+        player.sendMessage(ChatColor.AQUA+"总危险度为:"+level);
+
+        if (biomeRisk == null){
+            player.sendMessage(ChatColor.GOLD+"玩家"+"危险度为:"+0);
+            return;
+        }
+
+        for (String biome : biomeRisk.keySet()){
+            player.sendMessage(ChatColor.GREEN+biome+"群系的危险度为:"+biomeRisk.get(biome));
+        }
+    }
+
+    public boolean isBoolLogger() {
+        return boolLogger;
+    }
+
+    public void setBoolLogger(boolean boolLogger) {
+        this.boolLogger = boolLogger;
+    }
 }

src/main/java/com/sakurarealm/playerrisk/api/PlayerRiskSettings.java

@@ -1,6 +1,11 @@
 package com.sakurarealm.playerrisk.api;
 
 import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.Plugin;
+
+import java.io.File;
 
 public class PlayerRiskSettings {
 
@@ -12,6 +17,17 @@ public class PlayerRiskSettings {
         increaseInterval = config.getInt("increase-interval");
     }
 
+
+    public PlayerRiskSettings(Plugin plugin){
+        //保存配置文件
+        plugin.saveResource("config.yml",false);
+        FileConfiguration config;
+        File file = new File(plugin.getDataFolder(), "config.yml");
+        config = YamlConfiguration.loadConfiguration(file);
+        this.increaseInterval = config.getInt("settings.increase-interval");
+        this.levelMax = config.getInt("settings.level-max");
+    }
+
     public int getIncreaseInterval() {
         return increaseInterval;
     }

src/main/java/com/sakurarealm/playerrisk/hook/PlaceHolderAPIHook.java

@@ -31,8 +31,10 @@ public class PlaceHolderAPIHook extends PlaceholderExpansion {
     @Override
     public String onRequest(OfflinePlayer player, String params) {
         if (params.equals("level")) { // prisk_level
-            return String.valueOf(playerRiskManager.getPlayerRiskLevel(player));
+            int playerRiskLevel = playerRiskManager.getPlayerRiskLevel(player.getName());
+            String level = String.valueOf(playerRiskLevel);
+            return level;
         }
-        return null;
+        return "0";
     }
 }

src/main/resources/plugin.yml

@@ -14,4 +14,4 @@ commands:
   playerrisk:
     description: PlayerRisk command
     usage: /playerrisk
-    aliases: [ pr, prisk ]
+    aliases: [pr]