new file: .editorconfig

new file:   .gitattributes
	new file:   Charts/track.json
	new file:   ProjectOnrinto.csproj
	new file:   ProjectOnrinto.sln
	new file:   Scenes/Audio/audio_stream_player.tscn
	new file:   Scenes/Game/level.tscn
	new file:   Scenes/Prefabs/beat.tscn
	new file:   Scripts/Core/GameManager.cs
	new file:   Scripts/Core/GameManager.cs.uid
	new file:   Scripts/Core/MusicClock.cs
	new file:   Scripts/Core/MusicClock.cs.uid
	new file:   Scripts/Core/TrackGenerator.cs
	new file:   Scripts/Core/TrackGenerator.cs.uid
	new file:   Scripts/Data/ChartEvent.cs
	new file:   Scripts/Data/ChartEvent.cs.uid
	new file:   Scripts/Data/JsonConverter.cs
	new file:   Scripts/Data/JsonConverter.cs.uid
	new file:   Scripts/Data/TrackData.cs
	new file:   Scripts/Data/TrackData.cs.uid
	new file:   Scripts/GameObjects/NoteObject.cs
	new file:   Scripts/GameObjects/NoteObject.cs.uid
	new file:   icon.svg
	new file:   icon.svg.import
	new file:   project.godot

Scripts/Core/GameManager.cs

@@ -0,0 +1,71 @@
+using Godot;
+using Onrinto.Chart;
+
+public partial class GameManager : Node3D
+{
+    public TrackData CurrentTrack { get; private set; }
+    public static GameManager Instance { get; private set; }
+
+    public float CurrentAbsoluteSpeed { get; private set; }
+    public float CurrentAbsZ { get; private set; }
+
+    private int absoluteSpeedPointIndexArrow = 0;
+
+    private void UpdateAbsoluteState(double time)
+    {
+        var points = CurrentTrack.AbsoluteSpeedPoints;
+        if(points == null || points.Count == 0) return;
+
+        double firstPointTime = CurrentTrack.TickToSeconds(points[0].Tick);
+        if(time < firstPointTime)
+        {
+            CurrentAbsoluteSpeed = points[0].Speed;
+            return;
+        }
+
+        for(int i = absoluteSpeedPointIndexArrow; i < points.Count - 1; i++)
+        {
+            double pointTime_from = CurrentTrack.TickToSeconds(points[i].Tick);
+            double pointTime_to = CurrentTrack.TickToSeconds(points[i + 1].Tick);
+
+            if(time >= pointTime_from && time < pointTime_to)
+            {
+                absoluteSpeedPointIndexArrow = i;
+
+                if(points[i].IsLinear)
+                {
+                    double t = (time - pointTime_from) / (pointTime_to - pointTime_from);
+                    CurrentAbsoluteSpeed = Mathf.Lerp(points[i].Speed, points[i + 1].Speed, (float)t);
+                }
+                else
+                {
+                    CurrentAbsoluteSpeed = points[i].Speed;
+                }
+                return;
+            }
+        }
+
+        absoluteSpeedPointIndexArrow = points.Count - 1;
+        CurrentAbsoluteSpeed = points[^1].Speed;
+    }
+
+    // Called when the node enters the scene tree for the first time.
+    public override void _Ready()
+    {
+        if (Instance != null){ QueueFree(); return; }
+        Instance = this;
+        
+        ProcessPriority = -100;
+    }
+
+    // Called every frame. 'delta' is the elapsed time since the previous frame.
+    public override void _Process(double delta)
+    {
+        double tNow = MusicClock.Instance.CurrentTime;
+
+        if(CurrentTrack == null) return;
+
+        UpdateAbsoluteState(tNow);
+        CurrentAbsZ = CurrentTrack.GetZ(tNow, CurrentTrack.RelativeSpeedPoints, CurrentTrack.RelativeZTable);
+    }
+}

Scripts/Core/GameManager.cs.uid

@@ -0,0 +1 @@
+uid://ch71v2vkldtbd

Scripts/Core/MusicClock.cs

@@ -0,0 +1,26 @@
+using Godot;
+
+public partial class MusicClock : AudioStreamPlayer
+{
+	public static MusicClock Instance {get; private set; }
+
+	private double currentTime;
+	public double CurrentTime { get; private set; }
+	
+	public override void _Ready()
+	{
+		Instance = this;
+		if (Stream == null) GD.PrintErr("MusicClock: No Audio File?");
+	}
+
+	public override void _Process(double delta)
+	{
+		if(!Playing) return;
+
+		double rawTime = GetPlaybackPosition();
+		double delay = AudioServer.GetTimeSinceLastMix();
+		double latency = AudioServer.GetOutputLatency();
+
+		CurrentTime = rawTime + delay - latency;
+	}
+}

Scripts/Core/MusicClock.cs.uid

@@ -0,0 +1 @@
+uid://d1ct3oyh0fr1s

Scripts/Core/TrackGenerator.cs

@@ -0,0 +1,64 @@
+using Godot;
+using System.Text.Json;
+using Onrinto.Chart;
+using System.Text.Json.Serialization;
+using System.Linq;
+using System.Collections.Generic;
+using System.Security.Cryptography.X509Certificates;
+
+public partial class TrackGenerator : Node3D
+{
+	TrackData track = new TrackData();
+	List<ChartEvent> _notes = new List<ChartEvent>();
+	[Export] public PackedScene NotePrefab;
+
+	// Called when the node enters the scene tree for the first time.
+	public override void _Ready()
+	{
+		//Load chart data.
+		string chart_path = "res://Charts/track.json";
+		if (!FileAccess.FileExists(chart_path))
+		{
+			GD.PrintErr($"Can't find chart file: {chart_path}");
+			return;
+		}
+
+		using var file = FileAccess.Open(chart_path, FileAccess.ModeFlags.Read);
+		string json = file.GetAsText();
+
+		var options = new JsonSerializerOptions {
+			PropertyNameCaseInsensitive = true,
+			Converters = { new JsonStringEnumConverter(), new Vector2Converter() }
+		};
+		try {
+			track = JsonSerializer.Deserialize<TrackData>(json, options);
+
+			// foreach (var e in track.Events) {
+			// 	GD.Print($"事件时间: {e.Tick}, 类型: {e.GetType().Name}");
+			// 	if (e is AnimatedEvent ani) {
+			// 		GD.Print($"  -> 这是一个动画音符开始位置: {ani.StartPosition}, 结束位置: {ani.EndPosition}");
+			// 	}
+			// }
+		} catch (JsonException ex) {
+			GD.PrintErr("Failed to parse chart JSON: " + ex.Message);
+		}
+
+		_notes = track.Events.OrderBy(e => e.Tick).ToList(); // Ensure events are sorted by time.
+	}
+
+	private void spawnNote(ChartEvent e) {
+		var noteInstance = NotePrefab.Instantiate<NoteObject>();
+
+		float speed = 20.0f;
+		double hitTime = (double)(e.Tick / track.TicksPerBeat * 60.0 / track.BPM);
+		float initialZ = (float)(hitTime * speed);
+
+		noteInstance.Initialize(e, hitTime, initialZ); // Initial Z position
+		AddChild(noteInstance);
+	}
+	// Called every frame. 'delta' is the elapsed time since the previous frame.
+	public override void _Process(double delta)
+	{
+		
+	}
+}

Scripts/Core/TrackGenerator.cs.uid

@@ -0,0 +1 @@
+uid://bmanbpeqbrkk1

Scripts/Data/ChartEvent.cs

@@ -0,0 +1,94 @@
+using Godot;
+using System;
+using System.Text.Json.Serialization;
+
+namespace Onrinto.Chart;
+
+public enum EventType { Hole, Obstacle, Beat, Catch, Through, Jump, Dash, Float };
+public enum AnimationType { Linear, Sin, Back };
+
+public class TempoPoint
+{
+	public double Tick { get; set; }
+	public float BPM { get; set; }
+
+	[JsonConstructor]
+	public TempoPoint(double tick, float bpm, bool isLinear)
+	{
+		Tick = tick;
+		BPM = bpm;
+	}
+}
+
+public class SpeedPoint
+{
+	public double Tick { get; set; }
+	public float Speed { get; set; }
+	public bool IsLinear { get; set; }
+
+	[JsonConstructor]
+	public SpeedPoint(double tick, float speed, bool isLinear)
+	{
+		Tick = tick;
+		Speed = speed;
+		IsLinear = isLinear;
+	}
+}
+
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
+[JsonDerivedType(typeof(ChartEvent), typeDiscriminator: "Onrinto.Chart.ChartEvent")]
+[JsonDerivedType(typeof(AnimatedEvent), typeDiscriminator: "Onrinto.Chart.AnimatedEvent")]
+[Serializable]
+public class ChartEvent
+{
+
+	public EventType Type { get; set; }
+	public double Tick { get; set; }
+	public Vector2 Position { get; set; }
+	public double HitTime { get; set; }
+	public double HitAbsZ { get; set; }
+
+	public ChartEvent(EventType type, double tick, Vector2 position)
+	{
+		Type = type;
+		Tick = tick;
+		Position = position;
+	}
+}
+
+[Serializable]
+public class AnimatedEvent : ChartEvent
+{
+	public AnimationType AniType { get; set; }
+	public int In_Out { get; set; }
+
+	public double AniStartTime { get; set; }
+	public double AniEndTime { get; set; }
+
+	public Vector2 StartPosition { get; set; }
+	public Vector2 EndPosition { get; set; }
+
+	public float RelativeSpeed { get; set; }
+
+	public AnimatedEvent(
+		EventType type,
+		double tick,
+		Vector2 position,
+		AnimationType aniType,
+		int in_Out,
+		double aniStartTime,
+		double aniEndTime,
+		float relativeSpeed,
+		Vector2 startPosition,
+		Vector2 endPosition
+	) : base(type, tick, position)
+	{
+		AniType = aniType;
+		In_Out = in_Out;
+		AniStartTime = aniStartTime;
+		AniEndTime = aniEndTime;
+		RelativeSpeed = relativeSpeed;
+		StartPosition = startPosition;
+		EndPosition = endPosition;
+	}
+}

Scripts/Data/ChartEvent.cs.uid

@@ -0,0 +1 @@
+uid://bg6k051syuyb6

Scripts/Data/JsonConverter.cs

@@ -0,0 +1,46 @@
+using Godot;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+//unread...
+
+namespace Onrinto.Chart;
+
+public class Vector2Converter : JsonConverter<Vector2>
+{
+    public override Vector2 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        // 预设默认值
+        float x = 0;
+        float y = 0;
+
+        if (reader.TokenType != JsonTokenType.StartObject)
+            throw new JsonException("预期一个对象来解析 Vector2");
+
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonTokenType.EndObject)
+                return new Vector2(x, y);
+
+            if (reader.TokenType == JsonTokenType.PropertyName)
+            {
+                string propertyName = reader.GetString()?.ToLower(); // 统一转小写处理
+                reader.Read();
+
+                if (propertyName == "x") x = (float)reader.GetDouble();
+                else if (propertyName == "y") y = (float)reader.GetDouble();
+            }
+        }
+
+        return new Vector2(x, y);
+    }
+
+    public override void Write(Utf8JsonWriter writer, Vector2 value, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+        writer.WriteNumber("x", value.X);
+        writer.WriteNumber("y", value.Y);
+        writer.WriteEndObject();
+    }
+}

Scripts/Data/JsonConverter.cs.uid

@@ -0,0 +1 @@
+uid://25r22gy8t7ny

Scripts/Data/TrackData.cs

@@ -0,0 +1,119 @@
+using System.Collections.Generic;
+using System.Linq;
+using Godot;
+
+namespace Onrinto.Chart;
+
+public class TrackData
+{
+    public int BPM { get; set; }
+    public double Offset { get; set; }
+    public double TicksPerBeat { get; set; }
+    public double BeatDuration => 60.0 / BPM;
+    public List<ChartEvent> Events { get; set; } = new List<ChartEvent>();
+    public List<TempoPoint> TempoPoints { get; set; } = new List<TempoPoint>();
+    public List<SpeedPoint> RelativeSpeedPoints { get; set; } = new List<SpeedPoint>();
+    public List<SpeedPoint> AbsoluteSpeedPoints { get; set; } = new List<SpeedPoint>();
+
+    public List<double> TempoSecondsTable { get; private set; } = new List<double>();
+    public List<float> RelativeZTable { get; private set; } = new List<float>();
+
+    public void Initialize()
+    {
+        InitializeTempoTable();
+        InitializeRelativeZTable(RelativeSpeedPoints);
+
+        foreach(var e in Events)
+        {
+            e.HitTime = TickToSeconds(e.Tick);
+            e.HitAbsZ = GetZ(e.HitTime, RelativeSpeedPoints, RelativeZTable);
+        }
+    }
+
+    public void InitializeTempoTable()
+    {
+        TempoSecondsTable.Clear();
+        if(TempoPoints == null || TempoPoints.Count == 0) return;
+
+        TempoPoints = TempoPoints.OrderBy(tp => tp.Tick).ToList();
+        double cachedSeconds = 0.0;
+        TempoSecondsTable.Add(cachedSeconds);
+
+        for(int i = 0; i < TempoPoints.Count - 1; i++)
+        {
+            double ticksDelta = TempoPoints[i + 1].Tick - TempoPoints[i].Tick;
+            double secondsDelta = ticksDelta / TicksPerBeat * 60.0 / TempoPoints[i].BPM;
+            cachedSeconds += secondsDelta;
+            TempoSecondsTable.Add(cachedSeconds);
+        }
+    }
+
+    public void InitializeRelativeZTable(List<SpeedPoint> speedPoints)
+    {
+        RelativeZTable.Clear();
+        if(speedPoints == null || speedPoints.Count == 0) return;
+
+        speedPoints = speedPoints.OrderBy(sp => sp.Tick).ToList();
+        float cachedZ = 0.0f;
+        RelativeZTable.Add(cachedZ);
+
+        for(int i = 0; i < speedPoints.Count - 1; i++)
+        {
+            double timeDelta = TickToSeconds(speedPoints[i + 1].Tick) - TickToSeconds(speedPoints[i].Tick);
+            
+            if(speedPoints[i].IsLinear)
+            {
+                cachedZ += (float)timeDelta * (speedPoints[i].Speed + speedPoints[i + 1].Speed) * 0.5f;
+            }
+            else
+            {
+                cachedZ += (float)timeDelta * speedPoints[i].Speed;
+            }
+            RelativeZTable.Add(cachedZ);
+        }
+    }
+
+    public double TickToSeconds(double tick)
+    {
+        if(TempoPoints == null || TempoPoints.Count == 0) 
+            return tick / TicksPerBeat * 60.0 / BPM;
+
+        int idx = 0;
+        for(int i = 0; i < TempoPoints.Count; i++)
+        {
+            if(tick >= TempoPoints[i].Tick) idx = i;
+            else break;
+        }
+
+        return TempoSecondsTable[idx] + (tick - TempoPoints[idx].Tick) / TicksPerBeat * 60.0 / TempoPoints[idx].BPM;
+    }
+
+    public float GetZ(double time, List<SpeedPoint> speedPoints, List<float> zTable)
+    {
+        if(speedPoints == null || speedPoints.Count == 0) return 0.0f;
+
+        int idx = 0;
+        for(int i = 0; i < speedPoints.Count; i++)
+        {
+            if(time >= TickToSeconds(speedPoints[i].Tick)) idx = i;
+            else break;
+        }
+
+        var point = speedPoints[idx];
+        float cachedZ = zTable[idx];
+        double pointTime = TickToSeconds(point.Tick);
+        double deltaTime = time - pointTime;
+
+        if(point.IsLinear && idx < speedPoints.Count - 1)
+        {
+            double nextTime = TickToSeconds(speedPoints[idx + 1].Tick);
+            float t = (float)((time - pointTime) / (nextTime - pointTime));
+            float currentSpeed = Mathf.Lerp(point.Speed, speedPoints[idx + 1].Speed, t);
+            return cachedZ + (float)deltaTime * (point.Speed + currentSpeed) * 0.5f;
+        }
+        else
+        {
+            return cachedZ + (float)deltaTime * point.Speed;
+        }
+    }
+}

Scripts/Data/TrackData.cs.uid

@@ -0,0 +1 @@
+uid://beb5iifgf08kg

Scripts/GameObjects/NoteObject.cs

@@ -0,0 +1,39 @@
+using Godot;
+using Onrinto.Chart;
+
+public partial class NoteObject : Node3D
+{
+	private double _hitSeconds;
+	private bool _isHit = false;
+	private bool _initialized = false;
+
+	public void Initialize(ChartEvent chartEvent, double hitSeconds, float initialZ)
+	{
+		_hitSeconds = hitSeconds;
+		Position = new Vector3(chartEvent.Position.X, chartEvent.Position.Y, initialZ);
+
+		_initialized = true;
+	}
+
+	// Called when the node enters the scene tree for the first time.
+	public override void _Ready()
+	{
+
+	}
+
+	// Called every frame. 'delta' is the elapsed time since the previous frame.
+	public override void _Process(double delta)
+	{
+		if (!_initialized) return;
+
+		float speed = 20.0f; // Scroll speed
+
+		double _currentTime = MusicClock.Instance.CurrentTime;		
+
+		float newZ = (float)((_hitSeconds - _currentTime) * speed);
+		Position = new Vector3(Position.X, Position.Y, newZ); // Update Z position
+
+		if(_hitSeconds - _currentTime < -0.5) QueueFree(); // Remove note
+		
+	}
+}

Scripts/GameObjects/NoteObject.cs.uid

@@ -0,0 +1 @@
+uid://budeg56m55hkr