Project: The Ore Sprint

Four commands for players and teachers · See the instructions in this section for their positions

/orerush join     # Player registration
/orerush score    # Query the score of this bureau
/orerush start    # Teacher starts
/orerush stop     # Teacher cancels and clears registration

Extra points can only be added during the game. See the description of this section for the position.

if (state != State.RUNNING) return;

Avoid repeated registration and clearing · See the instructions in this section for the location

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

Distinguish between unregistered and zero points. See the description in this section for the location.

Integer score = round.snapshot().get(id);
String message = score == null ? "You have not registered yet" : "Score of this game: " + score;

Unified score entrance · See the description in this section for the location

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

Two types of deep slate ores must also be recognized. See the description in this section for their locations.

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

Check first and then create the task · See the instructions in this section for the location

if (!round.start(duration)) {
    sender.sendMessage("Cannot start now");
    return true;

}
// Called after passing runTaskTimer

The order and position in the callback are described in this section.

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

The status changes in the rule class. See the description in this section for the location.

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

The score snapshot is not afraid of clearing the original table. See the description in this section for the location.

var result = round.snapshot();
round.reset();
// result The previous results are still retained and cannot be modified..

Complete plugin.yml · Complete file

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: Sign up and manage ore sprint
    usage: /orerush <join|score|start|stop>
permissions:
  blockacademy.orerush.admin:
    default: op

Complete config.yml · Complete file

world: "world"
duration-seconds: 60

Complete GameRound.java · This paragraph 1/2, sequential connection

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);
    }

Complete GameRound.java · This paragraph 2/2, sequential connection

    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;
        };
    }
}

Main class part 1 · This paragraph 1/2, sequential connection

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<>();

Main Class Part 1·This paragraph 2/2, sequential connection

    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, "Configuration read failed", ex);
            getServer().getPluginManager().disablePlugin(this); return;
        }

Main class part 2·sequentially connected to the same source file

        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("Invalid configuration: world Need to be loaded, duration-seconds Need to be 1 to 3600 integer");
            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("Please operate in the game to register and check scores."); return true;
            }
            UUID id = p.getUniqueId();
            if (action.equals("score")) {
                Integer score = round.snapshot().get(id);
                p.sendMessage(score == null ? "You have not registered yet" : "Score of this game: " + score);
            } else if (!p.getWorld().getName().equals(worldName)
                    || p.getGameMode() != GameMode.SURVIVAL) {
                p.sendMessage("Please use survival mode to register in the competition world");
            } else if (round.join(id)) {
                names.put(id, p.getName()); p.sendMessage("Registration successful, waiting for the teacher to start");
            } else p.sendMessage("Already registered, or the competition is in progress");
            return true;
        }

Main class part 3·sequentially connected to the same source file

        if (!action.equals("start") && !action.equals("stop")) {
            sender.sendMessage("Parameters can only be join, score, start, stop"); return true;
        }
        if (!sender.hasPermission("blockacademy.orerush.admin")) {
            sender.sendMessage("Only the teacher can start or stop the game"); return true;
        }
        if (action.equals("stop")) {
            reset(); announce("This office has been canceled and the registration has been cleared"); return true;
        }
        if (getServer().getWorld(worldName) == null || !round.start(duration)) {
            sender.sendMessage("Unable to start: Check world, registrants and race status"); return true;
        }
        announce("Ore sprint begins, total " + duration + " seconds!");
        task = getServer().getScheduler().runTaskTimer(this, () -> {
            if (round.tick()) { finish(); return; }
            int left = round.remaining();
            if (left % 10 == 0 || left <= 5) announce("Remaining " + left + " seconds");
        }, 20L, 20L);
        return true;
    }

Main Class Part 4·Sequentially connected to the same source file

    @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("Time is up, settle the score of this game!");
        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(), "Unknown player")
                + ": " + entry.getValue() + " points"));
        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(); }
}