添加新音符类型

package com.example.burst;

import com.seecmd.mod.api.Mod;
import com.seecmd.mod.api.ModContext;
import com.seecmd.mod.api.ModInfo;
import com.seecmd.mod.api.registry.RegistryKey;
import com.seecmd.mod.api.registry.ResourceLocation;
import com.seecmd.mod.api.spi.JudgmentKindDefinition;
import com.seecmd.mod.api.spi.NoteTypeDefinition;

import java.util.List;

public final class BurstNoteMod implements Mod {

    private static final String MOD_ID = "burst_note";

    /** 注册键：命名空间必须等于模组 id，path 自取。 */
    private static final RegistryKey<NoteTypeDefinition> BURST_TYPE =
            RegistryKey.of(MOD_ID, "burst", NoteTypeDefinition.class);

    @Override
    public ModInfo info() {
        return ModInfo.of(MOD_ID, "Burst Note", "0.1.0",
                List.of("YourName"), "双击音符（burst）示例");
    }

    @Override
    public void onPreInit(ModContext ctx) {
        JudgmentKindDefinition perfect = ctx.registries().judgmentKinds()
                .get(ResourceLocation.of("seecmd", "perfect"))
                .orElseThrow(() -> new IllegalStateException("宿主缺少内置判定等级 seecmd:perfect"));
        JudgmentKindDefinition miss = ctx.registries().judgmentKinds()
                .get(ResourceLocation.of("seecmd", "miss"))
                .orElseThrow(() -> new IllegalStateException("宿主缺少内置判定等级 seecmd:miss"));

        ctx.registries().noteTypes().register(BURST_TYPE, new BurstNoteType(perfect, miss));
        ctx.getLogger().info("已注册音符类型 " + BURST_TYPE.location());
    }
}

package com.example.burst;

import com.google.gson.JsonObject;
import com.seecmd.mod.api.context.NoteView;
import com.seecmd.mod.api.render.RenderCanvas;
import com.seecmd.mod.api.spi.JudgeContext;
import com.seecmd.mod.api.spi.JudgeInput;
import com.seecmd.mod.api.spi.JudgeInputState;
import com.seecmd.mod.api.spi.JudgeSink;
import com.seecmd.mod.api.spi.JudgmentKindDefinition;
import com.seecmd.mod.api.spi.NoteData;
import com.seecmd.mod.api.spi.NoteParseContext;
import com.seecmd.mod.api.spi.NoteRenderContext;
import com.seecmd.mod.api.spi.NoteTypeDefinition;
import com.seecmd.mod.api.spi.TimeoutStrategy;

import java.awt.Color;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public final class BurstNoteType implements NoteTypeDefinition {

    /** 谱面 JSON 的 "type" 就是它，不加命名空间前缀。 */
    private static final String TYPE_KEY = "burst";

    /** 第一击与音符时间的最大允许偏差。 */
    private static final long HIT_WINDOW_MS = 150L;

    /** 第二次点击相对第一次的默认窗口。 */
    private static final long DEFAULT_SECOND_TAP_MS = 260L;

    /** MOD_HANDLED 的兜底宽限上限。 */
    private static final long TIMEOUT_GRACE_MS = 2_000L;

    private static final Color COLOR_WAITING = new Color(255, 196, 64);
    private static final Color COLOR_ARMED = new Color(120, 230, 255);

    private final JudgmentKindDefinition perfectKind;
    private final JudgmentKindDefinition missKind;

    public BurstNoteType(JudgmentKindDefinition perfectKind, JudgmentKindDefinition missKind) {
        this.perfectKind = perfectKind;
        this.missKind = missKind;
    }

    @Override
    public String displayName() {
        return "双击";
    }

    @Override
    public String serializationKey() {
        return TYPE_KEY;
    }

    @Override
    public NoteData deserialize(JsonObject json, NoteParseContext ctx) {
        BurstNote note = new BurstNote();
        note.setTime(json.get("time").getAsLong());
        note.setLane(json.get("lane").getAsInt());
        note.setEndTime(null);
        // typeKey 由宿主按 serializationKey 匹配后填充，模组侧不要自己写

        long secondTapMs = json.has("secondTapWindow")
                ? json.get("secondTapWindow").getAsLong()
                : DEFAULT_SECOND_TAP_MS;
        note.setExtensionData(new TapState(Math.max(80L, secondTapMs)));
        return note;
    }

    @Override
    public void onJudge(JudgeInput input, JudgeSink sink) {
        // 宿主兜底 MISS 也会经过这里。不产出等级 = 沿用内置判定等级。
    }

    @Override
    public boolean overridesJudgment() {
        return true;
    }

    @Override
    public TimeoutStrategy timeoutStrategy() {
        return TimeoutStrategy.MOD_HANDLED;
    }

    @Override
    public long modHandledTimeoutCapMs() {
        return TIMEOUT_GRACE_MS;
    }

    @Override
    public void onJudgeTick(long timeMs, JudgeInputState state, JudgeContext ctx, JudgeSink sink) {
        List<NoteView> pending = ctx.notes();
        if (pending.isEmpty()) {
            return;
        }

        Set<NoteView> handled = new HashSet<>();
        // 同一帧里多个键映射到同一轨时，只算一次点击。
        Set<Integer> lanesThisFrame = new HashSet<>();
        for (Integer keyCode : state.pressedKeys()) {
            int lane = state.keyToLane(keyCode);
            if (lane < 0 || !lanesThisFrame.add(lane)) {
                continue;
            }

            for (NoteView note : pending) {
                if (handled.contains(note) || note.lane() != lane) continue;
                if (!(note.extensionData() instanceof TapState tap)) continue;

                if (tap.firstTapMs < 0L) {
                    if (Math.abs(timeMs - note.time()) > HIT_WINDOW_MS) continue;
                    tap.firstTapMs = timeMs;
                } else if (timeMs - tap.firstTapMs <= tap.secondTapMs) {
                    sink.accept(perfectKind, timeMs, note);
                    handled.add(note);
                } else {
                    continue;   // 已过期，交给下面的超时扫描
                }
                break;
            }
        }

        // 自己处理超时：宿主只负责兜底，宽限期内不会替我们判。
        for (NoteView note : pending) {
            if (handled.contains(note)) continue;
            if (!(note.extensionData() instanceof TapState tap)) continue;
            boolean expired = tap.firstTapMs < 0L
                    ? timeMs - note.time() > HIT_WINDOW_MS
                    : timeMs - tap.firstTapMs > tap.secondTapMs;
            if (expired) {
                sink.accept(missKind, timeMs, note);
            }
        }
    }

    @Override
    public void render(RenderCanvas canvas, NoteRenderContext ctx) {
        double w = Math.min(ctx.width(), 56.0);
        double h = Math.max(8.0, w * 0.34);
        double top = ctx.y() - h / 2;

        TapState tap = ctx.extensionData() instanceof TapState t ? t : null;
        boolean armed = tap != null && tap.firstTapMs >= 0L;

        canvas.save();
        if (armed) {
            double pulse = 0.5 + 0.5 * Math.sin(ctx.musicTimeMs() / 90.0);
            canvas.setColor(COLOR_ARMED);
            canvas.setAlpha(0.18 + 0.22 * pulse);
            canvas.fillRect(ctx.x() - w / 2 - 3, top - 3, w + 6, h + 6);
        }
        canvas.setAlpha(1.0);
        canvas.setColor(armed ? COLOR_ARMED : COLOR_WAITING);
        canvas.fillRect(ctx.x() - w / 2, top, w, h * 0.42);
        canvas.fillRect(ctx.x() - w / 2, top + h * 0.58, w, h * 0.42);
        canvas.restore();
    }

    /** 每个音符一份的运行时状态，存在 NoteData.extensionData 里。 */
    private static final class TapState {
        private final long secondTapMs;
        private long firstTapMs = -1L;

        private TapState(long secondTapMs) {
            this.secondTapMs = secondTapMs;
        }
    }

    /** 自定义运行时音符：保存宿主定位用的时间/轨道，以及自己的状态。 */
    private static final class BurstNote extends NoteData {

        private long time;
        private int lane;
        /** 与 serializationKey 一致；宿主侧还会按谱面 type 匹配回填。 */
        private String typeKey = TYPE_KEY;
        private Long endTime;
        private boolean judged;
        private Object extensionData;

        @Override public long time() { return time; }
        @Override public int lane() { return lane; }
        @Override public String typeKey() { return typeKey; }
        @Override public Long endTime() { return endTime; }
        @Override public boolean isJudged() { return judged; }
        @Override public Object extensionData() { return extensionData; }

        @Override public void setTime(long time) { this.time = time; }
        @Override public void setLane(int lane) { this.lane = lane; }
        @Override public void setEndTime(Long endTime) { this.endTime = endTime; }
        @Override public void setJudged(boolean judged) { this.judged = judged; }
        @Override public void setExtensionData(Object data) { this.extensionData = data; }
    }
}