();
+ var currentType = CommandType.NodeA;
+ var value = TryParseDigit(code[0]);
+ if (value < 0) throw new ArgumentException($"invalid char '{code[0]}'");
+
+ commands.Add(new Command(currentType, value));
+
+ for (var ptr = 1; ptr < code.Length; ptr++)
+ {
+ var ch = code[ptr];
+ if (CommandChars.Contains(ch))
+ {
+ currentType = (CommandType)Array.IndexOf(CommandChars, ch);
+ if (currentType == CommandType.NodeC)
+ {
+ commands.Add(new Command(CommandType.NodeC, 0));
+ }
+ }
+ else
+ {
+ value = TryParseDigit(ch);
+ if (value < 0) throw new ArgumentException($"invalid char '{ch}'");
+ if (currentType == CommandType.NodeC)
+ {
+ throw new ArgumentException($"digit should not follow 'C'");
+ }
+ commands.Add(new Command(currentType, value));
+ }
+ }
+ return commands;
+ }
+
+ public static Complex GetNodePosition(Command cmd)
+ {
+ switch (cmd.Type)
+ {
+ case CommandType.NodeA:
+ case CommandType.NodeEnd:
+ return SlideGeo.PointGroupA(cmd.Value);
+ case CommandType.NodeB:
+ return SlideGeo.PointGroupB(cmd.Value);
+ case CommandType.NodeC:
+ return SlideGeo.PointCenter();
+ default:
+ throw new ArgumentException($"invalid type for node: {cmd.Type}");
+ }
+ }
+
+ public static void NodeToNode(SlidePathConstructor constructor, Command last, Command current)
+ {
+ if (Command.IsSame(last, current)) return;
+ constructor.LineToPoint(GetNodePosition(current));
+ }
+
+ public static void NodeToOrbit(SlidePathConstructor constructor, Command last, Command current)
+ {
+ var isCcw = (current.Type == CommandType.OrbitCcw);
+ var node = GetNodePosition(last);
+ var orbit = SlideGeo.GetCircle(current.Value);
+ var diff = node - orbit.Center;
+ if (Math.Abs(diff.Magnitude - orbit.Radius) < 0.1)
+ {
+ if (last.Type == CommandType.NodeA && current.Value == 9)
+ {
+ constructor.TrySetLastParseMarker(SlideParseMarker.ForceAlign);
+ }
+ return; // node on circle, do nothing
+ }
+
+ if (diff.Magnitude < orbit.Radius)
+ throw new ArgumentException($"impossible: {last.Type}{last.Value} -> Orbit{current.Value}");
+
+ constructor.TangentToCircle(orbit, isCcw);
+ }
+
+ public static void OrbitToNode(SlidePathConstructor constructor, Command last, Command current)
+ {
+ var isCcw = (last.Type == CommandType.OrbitCcw);
+ var node = GetNodePosition(current);
+ var orbit = SlideGeo.GetCircle(last.Value);
+ var diff = node - orbit.Center;
+ if (Math.Abs(diff.Magnitude - orbit.Radius) < 0.1)
+ {
+ constructor.ArcToAngle(orbit.Center, diff.Phase, isCcw, false);
+ return;
+ }
+
+ if (diff.Magnitude < orbit.Radius)
+ throw new ArgumentException($"impossible: Orbit{last.Value} -> {current.Type}{current.Value}");
+
+ constructor.ArcToTangentTowards(node, orbit.Center, isCcw).LineToPoint(node);
+ }
+
+ public static void OrbitToOrbit(SlidePathConstructor constructor, Command last, Command current)
+ {
+ if (current.Type != last.Type) throw new ArgumentException($"orbit type mismatch");
+
+ var isCcw = (last.Type == CommandType.OrbitCcw);
+ var lastOrbit = SlideGeo.GetCircle(last.Value);
+ var currentOrbit = SlideGeo.GetCircle(current.Value);
+ if (current.Value == last.Value)
+ {
+ constructor.FullCircle(lastOrbit.Center, isCcw);
+ return;
+ }
+
+ if (last.Value == 0 && current.Value == 9 || last.Value == 9 && current.Value == 0)
+ throw new ArgumentException($"impossible: Orbit{last.Value} -> Orbit{current.Value}");
+
+ if (current.Value == 9)
+ {
+ var data = SlideGeo.TransferOutData(last.Value, isCcw);
+ constructor.ArcToAngle(lastOrbit.Center, data.Item2, isCcw, false)
+ .ArcToAngle(data.Item1.Center, data.Item3, isCcw, false)
+ .TrySetLastParseMarker(SlideParseMarker.SmoothAlign);
+ return;
+ }
+
+ if (last.Value == 9)
+ {
+ var data = SlideGeo.TransferOutData(current.Value, !isCcw);
+ constructor.ArcToAngle(lastOrbit.Center, data.Item3, isCcw, true)
+ .ArcToAngle(data.Item1.Center, data.Item2, isCcw, false);
+ return;
+ }
+
+ constructor.ExternTangentTransfer(lastOrbit.Center, currentOrbit, isCcw);
+ }
+
+ ///
+ /// Parse a specific slide-code into a path object
+ ///
+ /// Slide-code string
+ /// Generated slide path
+ /// The slide-code contains some invalid command sequence
+ /// Command type overflow
+ public static ParametricSlidePath Parse(string code)
+ {
+ var commands = ParseCommands(code);
+ var lastCmd = commands[0];
+ // The first command is guarantee to be 'A'
+ var generator = SlidePathConstructor.BeginAt(SlideGeo.PointGroupA(lastCmd.Value));
+
+ for (var i = 1; i < commands.Count; i++)
+ {
+ var cmd = commands[i];
+ switch (cmd.Type)
+ {
+ case CommandType.NodeA:
+ case CommandType.NodeB:
+ case CommandType.NodeC:
+ case CommandType.NodeEnd:
+ {
+ switch (lastCmd.Type)
+ {
+ case CommandType.NodeA:
+ case CommandType.NodeB:
+ case CommandType.NodeC:
+ NodeToNode(generator, lastCmd, cmd);
+ break;
+ case CommandType.OrbitCcw:
+ case CommandType.OrbitCw:
+ OrbitToNode(generator, lastCmd, cmd);
+ break;
+ case CommandType.NodeEnd:
+ throw new ArgumentException($"'K' should be the last command");
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ break;
+ }
+ case CommandType.OrbitCcw:
+ case CommandType.OrbitCw:
+ {
+ switch (lastCmd.Type)
+ {
+ case CommandType.NodeA:
+ case CommandType.NodeB:
+ case CommandType.NodeC:
+ NodeToOrbit(generator, lastCmd, cmd);
+ break;
+ case CommandType.OrbitCcw:
+ case CommandType.OrbitCw:
+ OrbitToOrbit(generator, lastCmd, cmd);
+ break;
+ case CommandType.NodeEnd:
+ throw new ArgumentException($"'K' should be the last command");
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ break;
+ }
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+
+ lastCmd = cmd;
+ }
+
+ return generator.GeneratePath();
+ }
+ }
+}
diff --git a/Runtime/MajSimaiAdapter/FallbackGeometry/SlideGeo.cs b/Runtime/MajSimaiAdapter/FallbackGeometry/SlideGeo.cs
new file mode 100644
index 0000000..216ae8f
--- /dev/null
+++ b/Runtime/MajSimaiAdapter/FallbackGeometry/SlideGeo.cs
@@ -0,0 +1,146 @@
+// Adapted from TeamMajdata/MajdataPlay, commit acd295d3f878f53ecd412d150936a465ed2e3d28.
+// GPL-3.0; see Documentation~/FallbackGeometry.md for provenance and parity tests.
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Text;
+
+namespace MajRadar.MajSimaiAdapter.FallbackGeometry
+{
+ internal static class SlideGeo
+ {
+ // Math.IEEERemainder 可以在burst直接用啊
+
+ ///
+ /// 这个参数定义了整个几何模型的长度单位
+ ///
+ public const double MainRadius = 4.80;
+ public const double Epsilon = 0.0001;
+ public const double EpsilonRad = 0.002;
+
+ public static readonly double CenterRadius = MainRadius * Math.Cos(Math.PI * 3 / 8);
+ public static readonly double GroupBRadius = CenterRadius / Math.Cos(Math.PI / 8);
+
+ private static readonly double _b = Math.Cos(Math.PI / 8) / 2;
+ private static readonly double _a = 1 - _b;
+ private static readonly double _theta = Math.PI / 4;
+ private static readonly double _s = (_a * _a + _b * _b - 2 * _a * _b * Math.Cos(_theta)) /
+ (2 * _a - 2 * _b * Math.Cos(_theta));
+
+ public static readonly double PPQQRadius = MainRadius * _b;
+ public static readonly double TransferRadius = MainRadius * (_b + _s);
+ public static readonly double EdgeTransferRadian = _theta;
+ public static readonly double PPQQTransferRadian =
+ Math.Acos((_s * _s + _b * _b - (_a - _s) * (_a - _s)) / (2 * _b * _s));
+
+ public static readonly double DefaultDistance = MainRadius * Math.PI / 32;
+
+ ///
+ /// A 区节点坐标（判定线上的八个点）
+ /// Note: idx is 1-based, not 0-based
+ ///
+ public static Complex PointGroupA(int idx)
+ {
+ var radian = Math.PI * (5.0 / 8.0 - idx / 4.0);
+ return Complex.FromPolarCoordinates(MainRadius, radian);
+ }
+
+ ///
+ /// B 区节点坐标（不是 B 区 Touch 的位置）
+ /// Note: idx is 1-based, not 0-based
+ ///
+ public static Complex PointGroupB(int idx)
+ {
+ var radian = Math.PI * (5.0 / 8.0 - idx / 4.0);
+ return Complex.FromPolarCoordinates(GroupBRadius, radian);
+ }
+
+ ///
+ /// C 区节点坐标（正中心）
+ ///
+ public static Complex PointCenter()
+ {
+ return Complex.Zero;
+ }
+
+ ///
+ /// 获取指定判定区对应节点的坐标，判定区符合SensorType的定义，可取范围 0~16
+ ///
+ public static Complex GetPoint(int sensorIdx)
+ {
+ switch (sensorIdx)
+ {
+ case >= 0 and <= 7:
+ return PointGroupA(sensorIdx + 1);
+ case >= 8 and <= 15:
+ return PointGroupB(sensorIdx - 7);
+ case 16:
+ return PointCenter();
+ default:
+ return Complex.Zero;
+ }
+ }
+
+ ///
+ /// 10 个圆的圆心坐标和半径
+ /// idx 0 is center circle (pq circle),
+ /// idx 1~8 are ppqq circles passing D[idx] panel,
+ /// idx 9 is outer circle (judge circle / <> circle)
+ ///
+ public static ComplexCircle GetCircle(int idx)
+ {
+ if (idx == 0)
+ {
+ return new ComplexCircle(Complex.Zero, CenterRadius);
+ }
+
+ if (idx == 9)
+ {
+ return new ComplexCircle(Complex.Zero, MainRadius);
+ }
+
+ var radian = Math.PI * (3.0 / 4.0 - idx / 4.0);
+ var center = Complex.FromPolarCoordinates(PPQQRadius, radian);
+ return new ComplexCircle(center, PPQQRadius);
+ }
+
+ ///
+ /// 计算指定点进入指定圆的切线
+ ///
+ public static double CalcTangentAngle(Complex point, ComplexCircle circle, bool isCcw)
+ {
+ var hypot = point - circle.Center;
+ var deltaRad = Math.Acos(circle.Radius / hypot.Magnitude);
+ var tanRad = hypot.Phase + (isCcw ? deltaRad : -deltaRad);
+ return Math.IEEERemainder(tanRad, Math.PI * 2.0);
+ }
+
+ ///
+ /// ppqq 圆到判定线大圆的转移路径（slidecode 专用）
+ /// Note: idx is 1-based, not 0-based
+ ///
+ /// CircleStruct TransferCircle, double TransferStartAngle, double TransferEndAngle
+ public static (ComplexCircle, double, double) TransferOutData(int idx, bool isCcw)
+ {
+ var ppqqRad = Math.PI * (3.0 / 4.0 - idx / 4.0);
+ double startRad, endRad;
+ if (isCcw)
+ {
+ startRad = ppqqRad - PPQQTransferRadian;
+ endRad = ppqqRad + EdgeTransferRadian;
+ }
+ else
+ {
+ startRad = ppqqRad + PPQQTransferRadian;
+ endRad = ppqqRad - EdgeTransferRadian;
+ }
+ var d = MainRadius - TransferRadius;
+ var center = Complex.FromPolarCoordinates(d, endRad);
+ return (
+ new ComplexCircle(center, TransferRadius),
+ Math.IEEERemainder(startRad, Math.PI * 2),
+ Math.IEEERemainder(endRad, Math.PI * 2)
+ );
+ }
+ }
+}
diff --git a/Runtime/MajSimaiAdapter/IExtendedSlideBarCountProvider.cs b/Runtime/MajSimaiAdapter/IExtendedSlideBarCountProvider.cs
index dbede2f..6430ab3 100644
--- a/Runtime/MajSimaiAdapter/IExtendedSlideBarCountProvider.cs
+++ b/Runtime/MajSimaiAdapter/IExtendedSlideBarCountProvider.cs
@@ -3,6 +3,9 @@ namespace MajRadar.MajSimaiAdapter;
///
/// Supplies the gameplay arrow count for a normalized extended K Slide code.
/// Standard Slides continue to use MajRadar's fixed reference table.
+/// When no provider is supplied, the adapter uses
+/// . An explicit provider is
+/// authoritative: its errors are reported without retrying the fallback.
/// Implementations used by a shared RadarRuntime must be thread-safe and
/// must not access Unity main-thread-only objects.
///
diff --git a/Runtime/MajSimaiAdapter/MajSimaiChartAdapter.cs b/Runtime/MajSimaiAdapter/MajSimaiChartAdapter.cs
index 3cdc6cb..b0184d7 100644
--- a/Runtime/MajSimaiAdapter/MajSimaiChartAdapter.cs
+++ b/Runtime/MajSimaiAdapter/MajSimaiChartAdapter.cs
@@ -27,7 +27,7 @@ public sealed class MajSimaiChartAdapter
public MajSimaiChartAdapter(IExtendedSlideBarCountProvider? extendedSlides = null)
{
- _slidePaths = new SlidePathResolver(extendedSlides);
+ _slidePaths = new SlidePathResolver(extendedSlides ?? DefaultExtendedSlideBarCountProvider.Instance);
}
public async Task ParseAndAdaptAsync(
diff --git a/Runtime/Regression/RegressionBetaModel.cs b/Runtime/Regression/RegressionBetaModel.cs
index e64b2f7..e57132f 100644
--- a/Runtime/Regression/RegressionBetaModel.cs
+++ b/Runtime/Regression/RegressionBetaModel.cs
@@ -6,6 +6,10 @@ namespace MajRadar.Regression;
public sealed class RegressionBetaModel
{
+ // Output limits can be tuned independently of the fitted coefficients.
+ internal const double MinimumFittedConstant = 0;
+ internal const double MaximumFittedConstant = 18;
+
public IReadOnlyList InputFeatures => RadarFeatureNames.ModelInputOrder;
public double Predict(IReadOnlyList rawValues)
@@ -32,7 +36,7 @@ public double Predict(IReadOnlyList rawValues)
result += coefficients[coefficientIndex++] * normalized[left] * normalized[right];
if (coefficientIndex != coefficients.Length || double.IsNaN(result) || double.IsInfinity(result))
throw new InvalidOperationException("Regression prediction is invalid.");
- return result;
+ return Math.Clamp(result, MinimumFittedConstant, MaximumFittedConstant);
}
public double Predict(IReadOnlyDictionary rawFeatures)
diff --git a/Runtime/Runtime/RadarRuntime.cs b/Runtime/Runtime/RadarRuntime.cs
index 2ad6233..e7fa82e 100644
--- a/Runtime/Runtime/RadarRuntime.cs
+++ b/Runtime/Runtime/RadarRuntime.cs
@@ -81,6 +81,7 @@ FittedConstant is not null && MappingVersion is not null &&
/// Unity-free public entry point for Play and standalone callers. Instances do
/// not retain chart or result state and may be reused concurrently when the
/// injected extended-Slide provider is thread-safe.
+/// Without an injected provider, the built-in Play geometry snapshot is used.
///
public sealed class RadarRuntime
{
diff --git a/Samples~/MajdataPlay/README.md b/Samples~/MajdataPlay/README.md
index d59a643..cf9978f 100644
--- a/Samples~/MajdataPlay/README.md
+++ b/Samples~/MajdataPlay/README.md
@@ -6,7 +6,21 @@ wires the single Play geometry implementation directly into one reusable
```csharp
var snapshot = await ChartRadarService.AnalyzeAsync(chart, cancellationToken);
+
+var noteScore = snapshot.GetScore(RadarOutputDimension.Note);
+var trickyRaw = snapshot.GetRawValue(RadarOutputDimension.SlideTricky);
```
Play remains responsible for selection generation, cancellation ownership,
logging, UI updates, and caching the lightweight `ChartRadarSnapshot`.
+
+The explicitly injected Play provider takes precedence over MajRadar's built-in
+fallback. A host without Play geometry can use `new RadarRuntime()` directly;
+the fallback is selected only when no provider is supplied. Exceptions or
+non-positive results from an injected provider remain structured failures.
+
+Existing string access remains available for dynamic UI code:
+
+```csharp
+var noteScore = snapshot.Scores["note"];
+```
diff --git a/Tests~/MajRadar.Tests/AnalysisAndRegressionTests.cs b/Tests~/MajRadar.Tests/AnalysisAndRegressionTests.cs
index e183d12..246abdf 100644
--- a/Tests~/MajRadar.Tests/AnalysisAndRegressionTests.cs
+++ b/Tests~/MajRadar.Tests/AnalysisAndRegressionTests.cs
@@ -284,7 +284,7 @@ public async Task UngroupedNoHeadSlideContributesToIntensityButNotSlideGroupFeat
[Theory]
[InlineData("(0){4}1,E", "non-finite or non-positive")]
- [InlineData("(120){4}1K5[4:1],E", "Extended K Slides")]
+ [InlineData("(120){4}1P0Q0K5[4:1],E", "orbit type mismatch")]
public async Task AdaptationFailuresReturnDataWithoutLeakingExceptions(
string inote,
string expectedError)
@@ -360,14 +360,19 @@ public void FeatureFailuresAreIsolatedInsideRadarAnalyzer()
[Theory]
[MemberData(nameof(RegressionVectors))]
- public void EmbeddedRegressionMatchesFrozenPythonVectors(double[] raw, double expected)
+ public void EmbeddedRegressionMatchesPythonVectorsWithinOutputLimits(double[] raw, double expected)
{
var actual = new RegressionBetaModel().Predict(raw);
- Assert.Equal(expected, actual, 9);
+ Assert.Equal(Math.Clamp(expected,
+ RegressionBetaModel.MinimumFittedConstant,
+ RegressionBetaModel.MaximumFittedConstant), actual, 9);
}
public static IEnumerable RegressionVectors()
{
+ // Unbounded Python oracle outputs exercise both ends of the configured range.
+ yield return Vector(new[] { 8.0, 15.0, 20000.0, 10.0, 3.0, 10.0, 1.0 }, -136224.7610705242);
+ yield return Vector(new[] { 8.0, 15.0, 20.0, 10.0, 3.0, 10.0, 1000.0 }, 435992.9429645393);
yield return Vector(new[] { 6.727708533441772, 10.213333333333333, 0.0, 3.500000000000045, 2.3435703486210016, 5.223136339994041, 0.32687803060913356 }, 13.18826234659077);
yield return Vector(new[] { 5.3448652850017435, 9.373333333333333, 5.151860505357921, 3.8688372913206157, 1.527537949608422, 3.4463156768134153, 0.5098107142089721 }, 13.04867082557079);
yield return Vector(new[] { 6.556341447489688, 9.728309501643864, 2.7754445459480404, 4.146342997793008, 1.977721867042476, 10.365354504785971, 0.276398788581657 }, 13.335359785629928);
diff --git a/Tests~/MajRadar.Tests/DefaultExtendedSlideBarCountProviderTests.cs b/Tests~/MajRadar.Tests/DefaultExtendedSlideBarCountProviderTests.cs
new file mode 100644
index 0000000..d714ddf
--- /dev/null
+++ b/Tests~/MajRadar.Tests/DefaultExtendedSlideBarCountProviderTests.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using MajRadar.Core;
+using MajRadar.MajSimaiAdapter;
+using MajRadar.Runtime;
+using Xunit;
+
+namespace MajRadar.Tests;
+
+public sealed class DefaultExtendedSlideBarCountProviderTests
+{
+ [Theory]
+ [InlineData("1K3", 14)]
+ [InlineData("1K5", 20)]
+ [InlineData("1CK5", 20)]
+ [InlineData("1B3K5", 22)]
+ [InlineData("1P0K5", 21)]
+ [InlineData("1Q0K5", 21)]
+ [InlineData("1P6K7", 46)]
+ [InlineData("1Q6K7", 35)]
+ [InlineData("1P99K3", 111)]
+ [InlineData("1Q99K3", 80)]
+ [InlineData("1A3P9K5", 62)]
+ [InlineData("1P69K7", 72)]
+ [InlineData("1Q69K7", 35)]
+ public void RepresentativeGeometryMatchesPlayCounts(string code, int expected)
+ {
+ Assert.Equal(expected, DefaultExtendedSlideBarCountProvider.Instance.ResolveBarCount(code));
+ }
+
+ [Theory]
+ [InlineData("8Q69K4", 76, 77)]
+ [InlineData("4P39K1", 22, 23)]
+ [InlineData("8Q69K8", 44, 45)]
+ [InlineData("1Q39K4", 22, 23)]
+ public void AlignmentBoundaryCountsAllowPlatformRounding(string code, int minimum, int maximum)
+ {
+ // These specific SmoothAlign paths land within a few ULPs of a segment
+ // boundary or endpoint. Math's native implementation varies by OS/CPU,
+ // so the retained Play comparisons can include one extra arrow sample.
+ // The two observed macOS/Ubuntu outcomes are allowed only for these cases;
+ // ordinary geometry above still requires an exact count.
+ Assert.InRange(DefaultExtendedSlideBarCountProvider.Instance.ResolveBarCount(code), minimum, maximum);
+ }
+
+ [Theory]
+ [InlineData("1K5")]
+ [InlineData("1P6K7")]
+ [InlineData("1P69K7")]
+ [InlineData("1A3P9K5")]
+ public async Task RuntimeSupportsExtendedSlidesWithoutHostGeometry(string code)
+ {
+ var result = await new RadarRuntime().ParseAndAnalyzeAsync($"(120){{4}}{code}[4:1],2,E");
+
+ Assert.True(result.IsSuccess, string.Join("; ", result.Errors));
+ Assert.NotNull(result.FittedConstant);
+ var slide = Assert.Single(result.ChartInput!.Events, item => item.Kind == RadarEventKind.Slide);
+ Assert.True(Assert.Single(slide.SlidePath!).BarCount > 0);
+ }
+
+ [Fact]
+ public async Task HostProviderIsAuthoritative()
+ {
+ var provider = new RecordingProvider(1234);
+ var result = await new RadarRuntime(provider).ParseAndAnalyzeAsync("(120){4}1K5[4:1],E");
+
+ Assert.True(result.IsSuccess, string.Join("; ", result.Errors));
+ var slide = Assert.Single(result.ChartInput!.Events, item => item.Kind == RadarEventKind.Slide);
+ Assert.Equal(1234, Assert.Single(slide.SlidePath!).BarCount);
+ Assert.Equal(1, provider.Calls);
+ }
+
+ [Theory]
+ [InlineData(0)]
+ [InlineData(-1)]
+ public async Task InvalidHostResultDoesNotSwitchToFallback(int value)
+ {
+ var provider = new RecordingProvider(value);
+ var result = await new RadarRuntime(provider).ParseAndAnalyzeAsync("(120){4}1K5[4:1],E");
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains("Non-positive arrow count", Assert.Single(result.Errors));
+ Assert.Equal(1, provider.Calls);
+ }
+
+ [Fact]
+ public async Task HostFailureDoesNotSwitchToFallback()
+ {
+ var provider = new RecordingProvider(1) { Throw = true };
+ var result = await new RadarRuntime(provider).ParseAndAnalyzeAsync("(120){4}1K5[4:1],E");
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains("host geometry unavailable", Assert.Single(result.Errors));
+ Assert.Equal(1, provider.Calls);
+ }
+
+ [Fact]
+ public async Task StandardSlidesDoNotCallExtendedProvider()
+ {
+ var provider = new RecordingProvider(1) { Throw = true };
+ var result = await new RadarRuntime(provider).ParseAndAnalyzeAsync("(120){4}1-5[4:1],E");
+
+ Assert.True(result.IsSuccess, string.Join("; ", result.Errors));
+ Assert.Equal(0, provider.Calls);
+ }
+
+ [Fact]
+ public async Task ConcurrentCallsDoNotShareMutableAlignmentState()
+ {
+ var provider = DefaultExtendedSlideBarCountProvider.Instance;
+ // Compare parallel calls with this platform's sequential results, rather
+ // than importing floating-point boundary decisions from another machine.
+ var cases = new[] { "1P69K7", "1A3P9K5", "8Q69K4", "4P39K1", "8Q69K8", "1Q39K4" }
+ .Select(code => (Code: code, Count: provider.ResolveBarCount(code))).ToArray();
+ var runtime = new RadarRuntime();
+ await Task.WhenAll(Enumerable.Range(0, 32).Select(async index =>
+ {
+ var item = cases[index % cases.Length];
+ var result = await runtime.ParseAndAnalyzeAsync($"(120){{4}}{item.Code}[4:1],2,E");
+ Assert.True(result.IsSuccess, string.Join("; ", result.Errors));
+ var slide = Assert.Single(result.ChartInput!.Events, x => x.Kind == RadarEventKind.Slide);
+ Assert.Equal(item.Count, Assert.Single(slide.SlidePath!).BarCount);
+ }));
+ }
+
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData("1")]
+ [InlineData("1K")]
+ [InlineData("0K5")]
+ [InlineData("1K9")]
+ [InlineData("1Z5K7")]
+ [InlineData("1K1")]
+ [InlineData("1C1K5")]
+ [InlineData("1P0Q0K5")]
+ [InlineData("1P09K5")]
+ public void InvalidGeometryIsRejected(string? code)
+ {
+ Assert.ThrowsAny(() =>
+ DefaultExtendedSlideBarCountProvider.Instance.ResolveBarCount(code!));
+ }
+
+ private sealed class RecordingProvider : IExtendedSlideBarCountProvider
+ {
+ private readonly int _value;
+ public int Calls { get; private set; }
+ public bool Throw { get; init; }
+ public RecordingProvider(int value) => _value = value;
+
+ public int ResolveBarCount(string slideCode)
+ {
+ Calls++;
+ if (Throw) throw new InvalidOperationException("host geometry unavailable");
+ return _value;
+ }
+ }
+}
diff --git a/Tests~/MajRadar.Tests/MajSimaiChartAdapterTests.cs b/Tests~/MajRadar.Tests/MajSimaiChartAdapterTests.cs
index bc7c721..e06061c 100644
--- a/Tests~/MajRadar.Tests/MajSimaiChartAdapterTests.cs
+++ b/Tests~/MajRadar.Tests/MajSimaiChartAdapterTests.cs
@@ -285,15 +285,15 @@ public void InterpretsOnlyTheSlidePathRetainedByMajSimai(
}
[Fact]
- public async Task ExtendedSlideReturnsFailureWithoutThrowingAcrossThePublicBoundary()
+ public async Task ExtendedSlideUsesFallbackWhenNoProviderIsSupplied()
{
var adapter = new MajSimaiChartAdapter();
var result = await adapter.ParseAndAdaptAsync("(120){4}1K5[4:1],E");
- Assert.False(result.IsSuccess);
- Assert.Null(result.Chart);
- Assert.NotEmpty(result.Errors);
+ Assert.True(result.IsSuccess, string.Join("; ", result.Errors));
+ var slide = Assert.Single(result.Chart!.Events, item => item.Kind == RadarEventKind.Slide);
+ Assert.True(Assert.Single(slide.SlidePath!).BarCount > 0);
}
[Fact]
diff --git a/Tests~/MajRadar.Tests/PlayIntegrationSampleTests.cs b/Tests~/MajRadar.Tests/PlayIntegrationSampleTests.cs
index 48ee5a7..c494883 100644
--- a/Tests~/MajRadar.Tests/PlayIntegrationSampleTests.cs
+++ b/Tests~/MajRadar.Tests/PlayIntegrationSampleTests.cs
@@ -1,4 +1,5 @@
using MajRadar.MajSimaiAdapter;
+using MajRadar.Runtime;
using Xunit;
namespace MajdataPlay.Utils.ChartRadar
@@ -15,6 +16,21 @@ namespace MajRadar.Tests
public sealed class PlayIntegrationSampleTests
{
+ [Theory]
+ [InlineData(RadarOutputDimension.Note, "note")]
+ [InlineData(RadarOutputDimension.Peak, "peak")]
+ [InlineData(RadarOutputDimension.Sweep, "sweep")]
+ [InlineData(RadarOutputDimension.SlideTricky, "slide_tricky")]
+ [InlineData(RadarOutputDimension.SlideSequence, "slide_sequence")]
+ [InlineData(RadarOutputDimension.Jack, "jack")]
+ [InlineData(RadarOutputDimension.FittedConstant, "fitted_constant")]
+ public void EnumMapsToExistingPublicKey(
+ RadarOutputDimension dimension,
+ string expectedKey)
+ {
+ Assert.Equal(expectedKey, RadarOutputDimensions.Key(dimension));
+ }
+
[Fact]
public async Task ThinServiceReturnsLightweightSuccessfulSnapshot()
{
@@ -25,6 +41,15 @@ public async Task ThinServiceReturnsLightweightSuccessfulSnapshot()
Assert.Equal("ok", snapshot.Status);
Assert.NotNull(snapshot.FittedConstant);
Assert.All(snapshot.Scores.Values, value => Assert.NotNull(value));
+ Assert.Equal(
+ snapshot.Scores[RadarOutputDimensions.Note],
+ snapshot.GetScore(RadarOutputDimension.Note));
+ Assert.Equal(
+ snapshot.RawValues[RadarOutputDimensions.SlideTricky],
+ snapshot.GetRawValue(RadarOutputDimension.SlideTricky));
+ Assert.Equal(
+ snapshot.FittedConstant,
+ snapshot.GetScore(RadarOutputDimension.FittedConstant));
}
[Fact]