小项目 矿石冲刺赛

玩家与老师的四条命令 · 位置见本节说明

/orerush join     # 玩家报名
/orerush score    # 查询本局分数
/orerush start    # 老师开始
/orerush stop     # 老师取消并清空报名

只有比赛中才能加分 · 位置见本节说明

if (state != State.RUNNING) return;

避免重复报名清零 · 位置见本节说明

if (state != State.WAITING || scores.containsKey(id)) return false;
scores.put(id, 0);
return true;

区分未报名与零分 · 位置见本节说明

Integer score = round.snapshot().get(id);
String message = score == null ? "你尚未报名" : "本局得分: " + score;

统一分值入口 · 位置见本节说明

int points = GameRound.points(event.getBlock().getType().name());

两类深板岩矿石也要认 · 位置见本节说明

GameRound.points("DEEPSLATE_DIAMOND_ORE"); // 10
GameRound.points("DEEPSLATE_IRON_ORE");    // 3
GameRound.points("STONE");                 // 0

先检查再创建任务 · 位置见本节说明

if (!round.start(duration)) {
    sender.sendMessage("现在不能开始");
    return true;

}
// 通过后才调用runTaskTimer

回调中的顺序 · 位置见本节说明

if (round.tick()) { finish(); return; }
int left = round.remaining();

状态在规则类里改变 · 位置见本节说明

if (--remaining > 0) return false;
state = State.ENDING;
return true;

成绩快照不怕原表清空 · 位置见本节说明

var result = round.snapshot();
round.reset();
// result仍保留刚才的成绩，不能修改。

完整plugin.yml · 完整文件

name: OreRush
version: 1.0.0
main: de.teacherma.orerush.OreRushPlugin
api-version: '1.21.11'
author: TeacherMa
website: https://www.teacher-ma.de
commands:
  orerush:
    description: 报名和管理矿石冲刺
    usage: /orerush <join|score|start|stop>
permissions:
  blockacademy.orerush.admin:
    default: op

完整config.yml · 完整文件

world: "world"
duration-seconds: 60

完整GameRound.java · 本段1/2，顺序连接

package de.teacherma.orerush;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public final class GameRound {
    public enum State { WAITING, RUNNING, ENDING }
    private State state = State.WAITING;
    private int remaining;
    private final Map<UUID, Integer> scores = new HashMap<>();
    public State state() { return state; }
    public int remaining() { return remaining; }
    public boolean join(UUID id) {
        if (state != State.WAITING || scores.containsKey(id)) return false;
        scores.put(id, 0); return true;
    }
    public boolean start(int seconds) {
        if (state != State.WAITING || scores.isEmpty() || seconds < 1 || seconds > 3600)
            return false;
        scores.replaceAll((id, old) -> 0);
        remaining = seconds; state = State.RUNNING; return true;
    }
    public void add(UUID id, int points) {
        if (state == State.RUNNING && scores.containsKey(id) && points > 0)
            scores.computeIfPresent(id, (key, old) -> old + points);
    }

完整GameRound.java · 本段2/2，顺序连接

    public boolean tick() {
        if (state != State.RUNNING) return false;
        if (--remaining > 0) return false;
        state = State.ENDING; return true;
    }
    public Map<UUID, Integer> snapshot() { return Map.copyOf(scores); }
    public void reset() {
        state = State.WAITING; remaining = 0; scores.clear();
    }
    public static int points(String material) {
        if (material == null) return 0;
        return switch (material) {
            case "DIAMOND_ORE", "DEEPSLATE_DIAMOND_ORE" -> 10;
            case "GOLD_ORE", "DEEPSLATE_GOLD_ORE" -> 5;
            case "IRON_ORE", "DEEPSLATE_IRON_ORE" -> 3;
            default -> 0;
        };
    }
}

主类第1部分 · 本段1/2，顺序连接

package de.teacherma.orerush;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import org.bukkit.GameMode;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
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.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;

public final class OreRushPlugin extends JavaPlugin implements Listener {
    private final GameRound round = new GameRound();
    private final Map<UUID, String> names = new HashMap<>();

主类第1部分 · 本段2/2，顺序连接

    private BukkitTask task;
    private String worldName;
    private int duration;
    @Override
    public void onEnable() {
        saveDefaultConfig();
        var config = new YamlConfiguration();
        try { config.load(new File(getDataFolder(), "config.yml")); }
        catch (IOException | InvalidConfigurationException ex) {
            getLogger().log(java.util.logging.Level.SEVERE, "配置读取失败", ex);
            getServer().getPluginManager().disablePlugin(this); return;
        }

主类第2部分 · 顺序接在同一源文件

        worldName = config.getString("world", "");
        duration = config.getInt("duration-seconds", 0);
        if (!config.isString("world") || !config.isInt("duration-seconds")
                || getServer().getWorld(worldName) == null || duration < 1 || duration > 3600) {
            getLogger().severe("配置无效：world需已加载，duration-seconds需为1到3600的整数");
            getServer().getPluginManager().disablePlugin(this); return;
        }
        Objects.requireNonNull(getCommand("orerush")).setExecutor(this);
        getServer().getPluginManager().registerEvents(this, this);
    }
    @Override
    public boolean onCommand(CommandSender sender, Command command,
                             String label, String[] args) {
        if (args.length != 1) { sender.sendMessage("/orerush join|score|start|stop"); return true; }
        String action = args[0];
        if (action.equals("join") || action.equals("score")) {
            if (!(sender instanceof Player p)) {
                sender.sendMessage("报名和查分请在游戏中操作"); return true;
            }
            UUID id = p.getUniqueId();
            if (action.equals("score")) {
                Integer score = round.snapshot().get(id);
                p.sendMessage(score == null ? "你尚未报名" : "本局得分: " + score);
            } else if (!p.getWorld().getName().equals(worldName)
                    || p.getGameMode() != GameMode.SURVIVAL) {
                p.sendMessage("请在比赛世界使用生存模式报名");
            } else if (round.join(id)) {
                names.put(id, p.getName()); p.sendMessage("报名成功，等待老师开始");
            } else p.sendMessage("已经报名，或者比赛正在进行");
            return true;
        }

主类第3部分 · 顺序接在同一源文件

        if (!action.equals("start") && !action.equals("stop")) {
            sender.sendMessage("参数只能是 join、score、start、stop"); return true;
        }
        if (!sender.hasPermission("blockacademy.orerush.admin")) {
            sender.sendMessage("只有老师可以开始或停止比赛"); return true;
        }
        if (action.equals("stop")) {
            reset(); announce("本局已取消，报名已清空"); return true;
        }
        if (getServer().getWorld(worldName) == null || !round.start(duration)) {
            sender.sendMessage("无法开始：检查世界、报名人数和比赛状态"); return true;
        }
        announce("矿石冲刺开始，共 " + duration + " 秒！");
        task = getServer().getScheduler().runTaskTimer(this, () -> {
            if (round.tick()) { finish(); return; }
            int left = round.remaining();
            if (left % 10 == 0 || left <= 5) announce("剩余 " + left + " 秒");
        }, 20L, 20L);
        return true;
    }

主类第4部分 · 顺序接在同一源文件

    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
    public void onBreak(BlockBreakEvent event) {
        if (round.state() != GameRound.State.RUNNING) return;
        if (!event.getBlock().getWorld().getName().equals(worldName)) return;
        if (event.getPlayer().getGameMode() != GameMode.SURVIVAL) return;
        round.add(event.getPlayer().getUniqueId(),
                GameRound.points(event.getBlock().getType().name()));
    }
    private void finish() {
        if (task != null) task.cancel();
        task = null;
        announce("时间到，结算本局得分！");
        round.snapshot().entrySet().stream().sorted((a, b) -> {
            int order = Integer.compare(b.getValue(), a.getValue());
            return order != 0 ? order : a.getKey().toString().compareTo(b.getKey().toString());
        }).forEach(entry -> announce(names.getOrDefault(entry.getKey(), "未知玩家")
                + "：" + entry.getValue() + " 分"));
        reset();
    }
    private void announce(String text) { getServer().broadcast(Component.text(text)); }
    private void reset() {
        if (task != null) task.cancel();
        task = null; round.reset(); names.clear();
    }
    @Override
    public void onDisable() { reset(); }
}