NINI
682 lines
58 KiB
C#
682 lines
58 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using MagnetismHeroes.Core;
|
|
using MagnetismHeroes.UnityRuntime.Bootstrap;
|
|
using MagnetismHeroes.UnityRuntime.Presentation;
|
|
using NUnit.Framework;
|
|
using UnityEditor;
|
|
using UnityEditor.SceneManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.Profiling;
|
|
using UnityEngine.SceneManagement;
|
|
using UnityEngine.TestTools;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace MagnetismHeroes.Tests
|
|
{
|
|
public sealed class VisualUpgradePlayTests
|
|
{
|
|
private sealed class Store : IProgressStore
|
|
{
|
|
public ProgressSave Saved = new ProgressSave { completedStageIds = Enumerable.Range(1, 30).ToArray(), seenTutorialIds = new[] { "merge", "split" } };
|
|
public bool TryLoad(out ProgressSave save, out string error) { save = Saved; error = null; return true; }
|
|
public bool TrySave(ProgressSave save, out string error) { Saved = save; error = null; return true; }
|
|
}
|
|
[Serializable] private sealed class CaptureRecord
|
|
{
|
|
public string name, sourceCommit, sourceDirty, boardOrigin, theme, utc, method;
|
|
public int width, height, stage, balls, groups, equipmentAssemblies, meshInstances, triangles, sharedMaterials;
|
|
public long textureMemory, allocatedMemory;
|
|
public float editorCameraRenderMilliseconds, fieldOfView;
|
|
public Vector3 cameraPosition;
|
|
public Quaternion cameraRotation;
|
|
}
|
|
private GameApp _app;
|
|
[Serializable] private sealed class NativeFixtures
|
|
{
|
|
public string sourceCommit, sourceDirty, utc, origin;
|
|
public NativeStage[] stages;
|
|
public NativeRestore[] restores;
|
|
public NativeDrag[] drags;
|
|
}
|
|
[Serializable] private sealed class NativeStage
|
|
{
|
|
public int stage;
|
|
public string theme;
|
|
public Vector3 min, max;
|
|
public PuzzleState initial;
|
|
}
|
|
[Serializable] private sealed class NativeRestore
|
|
{
|
|
public string name, slot, origin;
|
|
public int stage;
|
|
public PuzzleState puzzleSource, puzzleExpected;
|
|
public FreePlayState freeSource, freeExpected;
|
|
public float editorEntryMilliseconds;
|
|
}
|
|
[Serializable] private sealed class NativeDrag
|
|
{
|
|
public string name, ballId, kind = "boundary";
|
|
public FreePlayState source, expected;
|
|
public Vector3 requested, grabOffset, pointerDelta;
|
|
public string firstHitId;
|
|
public Vector2 start, end;
|
|
}
|
|
private Store _store;
|
|
[Serializable] private sealed class MatchedBenchmark
|
|
{
|
|
public string sourceCommit, sourceDirty, utc, method, loadOrder;
|
|
public int stage, balls, groups, activeProps, width = 2400, height = 1080, warmups = 8, sampleCount = 30;
|
|
public Vector3 cameraPosition;
|
|
public Quaternion cameraRotation;
|
|
public float fieldOfView;
|
|
public double[] renderCpuMilliseconds;
|
|
public long allocatedMemory, textureMemory;
|
|
}
|
|
[Serializable] private sealed class BenchmarkSceneryScan { public int stage, activeProps, renderers, residentTriangles; }
|
|
[Serializable] private sealed class BenchmarkSceneryReport { public string sourceCommit, utc; public BenchmarkSceneryScan[] stages; public int[] maximumPropStages; }
|
|
|
|
[UnityTest] public IEnumerator MatchedPlaygroundResourceBenchmark()
|
|
{
|
|
string directory = Environment.GetEnvironmentVariable("MAGNETISM_BENCHMARK_EVIDENCE") ?? Path.GetFullPath("artifacts/verification/PlaygroundInteraction/EditorBenchmark");
|
|
Directory.CreateDirectory(directory);
|
|
var scans = new System.Collections.Generic.List<BenchmarkSceneryScan>();
|
|
foreach (int stage in Enumerable.Range(1, 30))
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null; yield return null;
|
|
var filters = _app.Environment.GetComponentsInChildren<MeshFilter>();
|
|
scans.Add(new BenchmarkSceneryScan { stage = stage,
|
|
activeProps = _app.Environment.transform.Cast<Transform>().Count(child => child.gameObject.activeInHierarchy && child.name != "PlacementSafetySphere"),
|
|
renderers = _app.Environment.GetComponentsInChildren<Renderer>().Count(value => value.enabled),
|
|
residentTriangles = filters.Sum(value => Enumerable.Range(0, value.sharedMesh.subMeshCount).Sum(index => (int)value.sharedMesh.GetIndexCount(index)) / 3) });
|
|
}
|
|
var maximumPropStages = scans.Where(value => value.activeProps == scans.Max(item => item.activeProps)).Select(value => value.stage).ToArray();
|
|
File.WriteAllText(Path.Combine(directory, "actual-thirty-scenery-scan.json"), JsonUtility.ToJson(new BenchmarkSceneryReport { sourceCommit = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_COMMIT"), utc = DateTime.UtcNow.ToString("O"), stages = scans.ToArray(), maximumPropStages = maximumPropStages }, true));
|
|
Assert.That(maximumPropStages.Intersect(new[] { 1, 16, 21 }), Is.Not.Empty, "Fixed matched stages must include an actually observed maximum-prop scene.");
|
|
var camera = _app.Presenter.Camera; var canvas = _app.GetComponentInChildren<Canvas>();
|
|
var target = RenderTexture.GetTemporary(2400, 1080, 24);
|
|
var previousTarget = camera.targetTexture; var previousMode = canvas.renderMode; var previousCamera = canvas.worldCamera; float previousPlane = canvas.planeDistance, previousAspect = camera.aspect;
|
|
try
|
|
{
|
|
camera.targetTexture = target; camera.aspect = 2400f / 1080; canvas.renderMode = RenderMode.ScreenSpaceCamera; canvas.worldCamera = camera; canvas.planeDistance = .5f;
|
|
foreach (int stage in new[] { 1, 16, 21 }) foreach (bool singles in new[] { true, false })
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null; yield return null;
|
|
var balls = Enumerable.Range(0, 10).Select(index => new BallState { id = "benchmark-" + index, position = new Position3((index % 5 - 2) * 1.6f, .8f + index / 5 * 1.8f, 0) }).ToArray();
|
|
var groups = singles ? balls.Select(ball => new GroupState { id = ball.id, ballIds = new[] { ball.id } }).ToArray() : new[] { new GroupState { id = "benchmark-ten", ballIds = balls.Select(ball => ball.id).ToArray() } };
|
|
_app.Presenter.Render(BoardRules.CreateFreePlay(new FreePlayState { sourceStageId = stage, balls = balls, groups = groups }));
|
|
var rotation = Quaternion.Euler(25, 30, 0); _app.Orbit.Apply(new CameraState { target = new Position3(0, .6f, 0), distance = 12, rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w) });
|
|
yield return null; yield return null; Canvas.ForceUpdateCanvases();
|
|
for (int index = 0; index < 8; index++) { camera.Render(); yield return null; }
|
|
var samples = new double[30];
|
|
for (int index = 0; index < samples.Length; index++) { var watch = System.Diagnostics.Stopwatch.StartNew(); camera.Render(); watch.Stop(); samples[index] = watch.Elapsed.TotalMilliseconds; yield return null; }
|
|
Assert.That(samples.All(value => value > 0), Is.True); Assert.That(_app.Presenter.Balls.Count, Is.EqualTo(10));
|
|
File.WriteAllText(Path.Combine(directory, "stage" + stage + (singles ? "-ten-singles" : "-ten-group") + ".json"), JsonUtility.ToJson(new MatchedBenchmark {
|
|
sourceCommit = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_COMMIT"), sourceDirty = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_DIRTY"), utc = DateTime.UtcNow.ToString("O"),
|
|
method = "Standalone matched PlayMode filter; actual Main scene. 8 warmups and 30 Camera.Render CPU wall samples separated by frames; allocated/texture memory includes Editor. These values are not Android frame timing, GPU time or real-device performance.",
|
|
loadOrder = "Main, scan original stages1..30, stage1 singles/group, stage16 singles/group, stage21 singles/group; actual-thirty-scenery-scan.json proves maximum-prop coverage",
|
|
stage = stage, balls = balls.Length, groups = groups.Length, activeProps = _app.Environment.transform.Cast<Transform>().Count(child => child.gameObject.activeInHierarchy && child.name != "PlacementSafetySphere"),
|
|
cameraPosition = camera.transform.position, cameraRotation = camera.transform.rotation, fieldOfView = camera.fieldOfView, renderCpuMilliseconds = samples,
|
|
allocatedMemory = Profiler.GetTotalAllocatedMemoryLong(), textureMemory = Resources.FindObjectsOfTypeAll<Texture>().Sum(item => Profiler.GetRuntimeMemorySizeLong(item)) }, true));
|
|
}
|
|
}
|
|
finally { camera.targetTexture = previousTarget; camera.aspect = previousAspect; canvas.renderMode = previousMode; canvas.worldCamera = previousCamera; canvas.planeDistance = previousPlane; RenderTexture.ReleaseTemporary(target); }
|
|
}
|
|
private string _evidence;
|
|
[UnitySetUp] public IEnumerator SetUp()
|
|
{
|
|
EditorSceneManager.LoadSceneInPlayMode("Assets/MagnetismHeroes/Scenes/Main.unity", new LoadSceneParameters(LoadSceneMode.Single));
|
|
yield return null;
|
|
_app = Object.FindFirstObjectByType<GameApp>();
|
|
Assert.That(_app, Is.Not.Null, "Actual Main scene must initialize its app.");
|
|
_store = new Store(); _app.Initialize(_store);
|
|
_app.Presenter.BindEnvironment(_app.Environment); _app.Orbit.BindEnvironment(_app.Environment);
|
|
_evidence = Environment.GetEnvironmentVariable("MAGNETISM_VISUAL_EVIDENCE") ?? Path.GetFullPath("artifacts/verification/VisualUpgrade/editor-play");
|
|
Directory.CreateDirectory(_evidence);
|
|
yield return null;
|
|
}
|
|
[UnityTearDown] public IEnumerator TearDown() { Object.Destroy(_app.gameObject); yield return null; }
|
|
|
|
private Vector2 NativePoint(Vector3 world)
|
|
{
|
|
var viewport = _app.Orbit.Camera.WorldToViewportPoint(world);
|
|
return new Vector2((float)Math.Round(viewport.x * 2400), (float)Math.Round((1 - viewport.y) * 1080));
|
|
}
|
|
private Vector2 PlayerPoint(Vector2 native) => _app.Orbit.Camera.ViewportToScreenPoint(new Vector3(native.x / 2400, 1 - native.y / 1080));
|
|
private NativeDrag ExerciseNativeDrag(string name, string kind, FreePlayState source, Vector3 requested)
|
|
{
|
|
var id = source.balls[0].id; var origin = BoardPresenter.ToVector(source.balls[0].position);
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Camera), Is.EqualTo(JsonUtility.ToJson(source.camera)), "Exported camera must be the actual confirmed manual pose.");
|
|
Assert.That(JsonUtility.ToJson(_app.Orbit.Snapshot()), Is.EqualTo(JsonUtility.ToJson(source.camera)));
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Session.Camera)), Is.EqualTo(JsonUtility.ToJson(source)), "Entry must preserve every fixture ID, position and group.");
|
|
var start = NativePoint(origin); Physics.SyncTransforms();
|
|
var ray = _app.Orbit.Camera.ScreenPointToRay(PlayerPoint(start));
|
|
var nativeRay = _app.Orbit.Camera.ViewportPointToRay(new Vector3(start.x / 2400, 1 - start.y / 1080));
|
|
Assert.That(Vector3.Distance(ray.origin, nativeRay.origin), Is.LessThan(.00001f));
|
|
Assert.That(Vector3.Distance(ray.direction, nativeRay.direction), Is.LessThan(.00001f), "Editor pixelRect must preserve the same native viewport ray.");
|
|
Assert.That(Physics.Raycast(ray, out var hit, 100), Is.True);
|
|
Assert.That(hit.collider.TryGetComponent<BallView>(out var ball) ? ball.BallId : hit.collider.name, Is.EqualTo(id), name + " actual first hit must select the requested sphere.");
|
|
var grabOffset = hit.point - origin;
|
|
var end = NativePoint(origin + requested + grabOffset);
|
|
foreach (var point in new[] { start, end })
|
|
Assert.That(point.x >= 530 && point.x <= 1850 && point.y >= 280 && point.y <= 750, Is.True, name + " integer native pointer must stay in the phone world UI-safe region.");
|
|
var plane = new Plane(_app.Orbit.Camera.transform.forward, hit.point);
|
|
var endRay = _app.Orbit.Camera.ScreenPointToRay(PlayerPoint(end));
|
|
Assert.That(plane.Raycast(ray, out var from), Is.True); Assert.That(plane.Raycast(endRay, out var to), Is.True);
|
|
var pointerDelta = endRay.GetPoint(to) - ray.GetPoint(from);
|
|
var saved = JsonUtility.ToJson(_store.Saved);
|
|
_app.Input.Begin(PlayerPoint(start), false); _app.Input.Move(PlayerPoint(end));
|
|
Assert.That(_app.Orbit.IsAssisting, Is.True, "Actual BoardInput must acquire and move this friend.");
|
|
Assert.That(JsonUtility.ToJson(_store.Saved), Is.EqualTo(saved), "Preview and assistance cannot save intermediate state.");
|
|
var actual = _app.Presenter.DropDelta; var merge = _app.Presenter.MergeCandidate;
|
|
if (kind == "boundary") Assert.That(actual.magnitude, Is.InRange(1.19f, 1.21f), "Actual pointer must stop at the .5 sphere margin.");
|
|
if (kind == "foliage-pass")
|
|
{
|
|
Assert.That(Vector3.Distance(actual, pointerDelta), Is.LessThan(.001f), "The entire actual integer-pointer movement through foliage must pass without clipping.");
|
|
Assert.That(actual.x, Is.GreaterThan(3.9f));
|
|
}
|
|
if (kind == "thin-obstacle") { Assert.That(actual.x, Is.GreaterThan(.1f).And.LessThan(requested.x - 1)); Assert.That(merge, Is.Null); }
|
|
if (kind == "two-plus-three") Assert.That(merge, Is.EqualTo("native-contact-target"));
|
|
var preview = _app.Presenter.Balls.ToDictionary(pair => pair.Key, pair => pair.Value.transform.position);
|
|
var members = source.groups.Single(group => group.ballIds.Contains(id)).ballIds;
|
|
foreach (var value in source.balls)
|
|
Assert.That(Vector3.Distance(preview[value.id], BoardPresenter.ToVector(value.position) + (members.Contains(value.id) ? actual : Vector3.zero)), Is.LessThan(.001f), "Only the whole grabbed group may translate; all relative offsets and other friends are preserved.");
|
|
_app.Input.End(PlayerPoint(end));
|
|
Assert.That(_app.Session.Board.Balls.Select(value => value.id), Is.EquivalentTo(source.balls.Select(value => value.id)));
|
|
foreach (var value in _app.Session.Board.Balls) Assert.That(Vector3.Distance(BoardPresenter.ToVector(value.position), preview[value.id]), Is.LessThan(.001f), "Drop must equal the actual input preview for every ID.");
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Camera), Is.EqualTo(JsonUtility.ToJson(source.camera)));
|
|
if (kind != "two-plus-three") Assert.That(_app.Session.Board.Groups.Select(group => JsonUtility.ToJson(group)), Is.EqualTo(source.groups.Select(group => JsonUtility.ToJson(group))));
|
|
else Assert.That(_app.Session.Board.Groups.Single().ballIds, Is.EquivalentTo(source.balls.Select(value => value.id)));
|
|
return new NativeDrag { name = name, kind = kind, ballId = id, source = source, requested = requested, start = start, end = end,
|
|
grabOffset = grabOffset, pointerDelta = pointerDelta, firstHitId = ball.BallId, expected = _app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()) };
|
|
}
|
|
|
|
[UnityTest] public IEnumerator ExportActualMainPlaygroundNativeBoundaryFixtures()
|
|
{
|
|
var stages = new System.Collections.Generic.List<NativeStage>();
|
|
var restores = new System.Collections.Generic.List<NativeRestore>();
|
|
var drags = new System.Collections.Generic.List<NativeDrag>();
|
|
foreach (int stage in Enumerable.Range(1, 30))
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null;
|
|
stages.Add(new NativeStage { stage = stage, theme = _app.Environment.Theme,
|
|
min = _app.Environment.PlaygroundBounds.min, max = _app.Environment.PlaygroundBounds.max,
|
|
initial = new BoardRules(_app.Session.Definitions.Single(value => value.Id == stage)).ToPuzzleState(GameSession.DefaultCamera()) });
|
|
if (new[] {1, 2, 6, 7, 11, 12, 16, 17, 21, 22, 26, 27}.Contains(stage))
|
|
CaptureViews("playground-stage" + stage, "Actual Main initial board; labelled unlocked-stage fixture, not normal progression");
|
|
}
|
|
foreach (var entry in new[] { (name: "safe-free", stage: 1, point: new Vector3(0, 4, 0)),
|
|
(name: "boundary-free", stage: 1, point: new Vector3(30, 4, 0)),
|
|
(name: "tree-interior", stage: 6, point: Vector3.zero), (name: "rock-interior", stage: 21, point: Vector3.zero) })
|
|
{
|
|
_app.StartStage(entry.stage); yield return null; Physics.SyncTransforms();
|
|
Vector3 point = entry.point;
|
|
if (entry.point == Vector3.zero)
|
|
{
|
|
string asset = entry.name.StartsWith("tree") ? "RoundCanopyTree" : "SlateBoulder";
|
|
var meshes = _app.Environment.GetComponentsInChildren<MeshCollider>().Where(value => value.enabled && value.transform.GetComponentsInParent<Transform>().Any(parent => parent.name.Contains(asset))).ToArray();
|
|
Assert.That(meshes, Is.Not.Empty, "Native interior fixture must use an actual scenery collider.");
|
|
var collider = meshes.OrderByDescending(value => value.bounds.size.sqrMagnitude).First();
|
|
Assert.That(collider.sharedMesh.isReadable, Is.False);
|
|
point = collider.bounds.center;
|
|
Assert.That(_app.Presenter.IsSafePosition(BoardPresenter.ToPosition(point)), Is.False, "Actual approved mesh interior starts unsafe.");
|
|
}
|
|
var source = new FreePlayState { sourceStageId = entry.stage, camera = GameSession.DefaultCamera(),
|
|
balls = new[] { new BallState { id = "native-" + entry.name, position = BoardPresenter.ToPosition(point) } },
|
|
groups = new[] { new GroupState { id = "native-group", ballIds = new[] { "native-" + entry.name } } } };
|
|
_store.Saved.latestFreePlay = source; _app.Initialize(_store);
|
|
var watch = System.Diagnostics.Stopwatch.StartNew(); _app.ContinueFreePlay(); watch.Stop(); yield return null;
|
|
Assert.That(_app.Session.Screen, Is.EqualTo(SessionScreen.FreePlay)); Assert.That(_app.Presenter.IsSafeBoard(_app.Session.Board), Is.True);
|
|
restores.Add(new NativeRestore { name = entry.name, stage = entry.stage, slot = "free", freeSource = source,
|
|
freeExpected = _app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()), editorEntryMilliseconds = (float)watch.Elapsed.TotalMilliseconds,
|
|
origin = "Actual unchanged Main scenery; injected position only; original imports remain unreadable; expected result observed through GameApp entry" });
|
|
}
|
|
var legacy = new FreePlayState { sourceStageId = 9,
|
|
camera = new CameraState { target = new Position3(0, .6f, 0), distance = 11, rotation = new Rotation4(-.022557568f, .96225017f, .08418597f, .2578342f) },
|
|
balls = new[] { new BallState { id = "s09-b01", position = new Position3(-1.0351909f, .8f, .60371524f) },
|
|
new BallState { id = "s09-b02", position = new Position3(-.03519098f, .8f, .60371524f) },
|
|
new BallState { id = "s09-b03", position = new Position3(-3.9800465f, .8f, 1.649168f) },
|
|
new BallState { id = "s09-b04", position = new Position3(.964809f, .8f, .60371524f) },
|
|
new BallState { id = "s09-b05", position = new Position3(-2.9800465f, .8f, 1.649168f) } },
|
|
groups = new[] { new GroupState { id = "s09-g01", ballIds = new[] { "s09-b01", "s09-b02", "s09-b04" } }, new GroupState { id = "s09-g01-split", ballIds = new[] { "s09-b03", "s09-b05" } } } };
|
|
var wide = new FreePlayState { sourceStageId = 6, camera = GameSession.DefaultCamera(),
|
|
balls = new[] { new BallState { id = "wide-a", position = new Position3(-30, 4, 0) }, new BallState { id = "wide-b", position = new Position3(30, 4, 0) } },
|
|
groups = new[] { new GroupState { id = "wide-group", ballIds = new[] { "wide-a", "wide-b" } } } };
|
|
var multi = JsonUtility.FromJson<FreePlayState>(JsonUtility.ToJson(wide));
|
|
multi.sourceStageId = 1; multi.groups = new[] { new GroupState { id = "left", ballIds = new[] { "wide-a" } }, new GroupState { id = "right", ballIds = new[] { "wide-b" } } };
|
|
foreach (var entry in new[] { (name: "legacy-nine", source: legacy), (name: "impossible-free", source: wide), (name: "multiple-repairs", source: multi) })
|
|
{
|
|
_store.Saved.latestFreePlay = entry.source; _app.Initialize(_store);
|
|
var watch = System.Diagnostics.Stopwatch.StartNew(); _app.ContinueFreePlay(); watch.Stop(); yield return null;
|
|
Assert.That(_app.Session.Screen, Is.EqualTo(SessionScreen.FreePlay)); Assert.That(_app.Presenter.IsSafeBoard(_app.Session.Board), Is.True);
|
|
restores.Add(new NativeRestore { name = entry.name, stage = entry.source.sourceStageId, slot = "free", freeSource = entry.source,
|
|
freeExpected = _app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()), editorEntryMilliseconds = (float)watch.Elapsed.TotalMilliseconds,
|
|
origin = entry.name == "legacy-nine" ? "Exact original Content stage9 3+2 record and underground camera; original failure retained in T4 integration-fix" : "Separate injected boundary record; impossible variant exceeds rigid domain, multiple variant has two independent repairable friends" });
|
|
}
|
|
var puzzle = new PuzzleState { stageId = 2, camera = GameSession.DefaultCamera(),
|
|
balls = new[] { new BallState { id = "native-count-a", position = new Position3(30, 4, 0) }, new BallState { id = "native-count-b", position = new Position3(31, 4, 0) } },
|
|
groups = new[] { new GroupState { id = "native-count-group", ballIds = new[] { "native-count-a", "native-count-b" } } },
|
|
collectedBallIds = new[] { "native-count-a" }, countedBallIds = new[] { "native-count-a" } };
|
|
foreach (bool impossible in new[] { false, true })
|
|
{
|
|
if (impossible) { puzzle = JsonUtility.FromJson<PuzzleState>(JsonUtility.ToJson(puzzle)); puzzle.balls[0].position.x = -30; puzzle.balls[1].position.x = 30; }
|
|
_store.Saved.puzzleStates = new[] { puzzle }; _app.Initialize(_store); _app.StartStage(2); yield return null;
|
|
Assert.That(_app.Session.Screen, Is.EqualTo(SessionScreen.Puzzle)); Assert.That(_app.Presenter.IsSafeBoard(_app.Session.Board), Is.True);
|
|
restores.Add(new NativeRestore { name = impossible ? "impossible-puzzle" : "counting-position-only", stage = 2, slot = "puzzle", puzzleSource = puzzle,
|
|
puzzleExpected = _app.Session.Board.ToPuzzleState(_app.Orbit.Snapshot()), origin = "Separate injected two-ball Counting record; preserved partial collect/count; impossible variant changes x span to 60" });
|
|
}
|
|
_store.Saved.puzzleStates = Array.Empty<PuzzleState>();
|
|
foreach (int count in new[] { 1, 10 }) foreach (int axis in Enumerable.Range(0, 3)) foreach (int sign in new[] { -1, 1 })
|
|
{
|
|
_app.StartStage(1); yield return null;
|
|
var bounds = _app.Environment.PlaygroundBounds;
|
|
var points = Enumerable.Range(0, count).Select(index => new Vector3((index % 5 - (count == 1 ? 0 : 2)), 4, index / 5)).ToArray();
|
|
var lower = points.Aggregate(Vector3.Min); var upper = points.Aggregate(Vector3.Max);
|
|
float offset = sign < 0 ? bounds.min[axis] + .5f + 1.2f - lower[axis] : bounds.max[axis] - .5f - 1.2f - upper[axis];
|
|
var translation = Vector3.zero; translation[axis] = offset;
|
|
points = points.Select(point => point + translation).ToArray();
|
|
Assert.That(points.All(point => _app.Presenter.IsSafePosition(BoardPresenter.ToPosition(point))), Is.True);
|
|
string id = "native-drag-0"; var rotation = Quaternion.Euler(0, axis == 2 ? 90 : 0, 0);
|
|
var focus = points[0] - Vector3.up * .65f;
|
|
var camera = new CameraState { target = BoardPresenter.ToPosition(focus), distance = 14, rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w) };
|
|
var source = new FreePlayState { sourceStageId = 1, camera = camera,
|
|
balls = points.Select((point, index) => new BallState { id = "native-drag-" + index, position = BoardPresenter.ToPosition(point) }).ToArray(),
|
|
groups = new[] { new GroupState { id = "native-drag-group", ballIds = Enumerable.Range(0, count).Select(index => "native-drag-" + index).ToArray() } } };
|
|
_store.Saved.latestFreePlay = source; _app.Initialize(_store); _app.ContinueFreePlay(); yield return null;
|
|
_app.Orbit.Camera.aspect = 2400f / 1080;
|
|
var requested = Vector3.zero; requested[axis] = sign * 3;
|
|
drags.Add(ExerciseNativeDrag("boundary-" + count + "-" + axis + "-" + sign, "boundary", source, requested));
|
|
yield return null;
|
|
}
|
|
_app.StartStage(1); yield return null; Physics.SyncTransforms();
|
|
var arch = _app.Environment.GetComponentsInChildren<MeshCollider>().First(value => value.enabled && value.GetComponentsInParent<Transform>().Any(parent => parent.name.Contains("OpenStoneArch")));
|
|
var foliage = _app.Environment.transform.Cast<Transform>().Where(value => value.gameObject.activeInHierarchy && value.name.Contains("GrassTuftMint") && value.GetComponentsInChildren<Collider>().Length == 0).ToArray();
|
|
Assert.That(foliage, Is.Not.Empty);
|
|
foreach (string kind in new[] { "thin-obstacle", "foliage-pass", "two-plus-three" })
|
|
{
|
|
var sourcePoint = new Vector3(-3, 3, 0); var requested = Vector3.right * 4;
|
|
if (kind == "thin-obstacle") { sourcePoint = new Vector3(arch.bounds.min.x - 1.5f, 1.5f, arch.bounds.center.z); requested = Vector3.right * (arch.bounds.size.x + 3); }
|
|
if (kind == "foliage-pass")
|
|
{
|
|
bool found = false;
|
|
foreach (var plant in foliage)
|
|
{
|
|
var center = plant.GetComponentInChildren<Renderer>().bounds.center; sourcePoint = new Vector3(center.x - 2, .8f, center.z);
|
|
if (!_app.Presenter.IsSafePosition(BoardPresenter.ToPosition(sourcePoint))) continue;
|
|
if (Vector3.Distance(_app.Environment.ConstrainTranslation(new[] { sourcePoint }, requested, _app.Presenter.transform), requested) > .001f) continue;
|
|
found = true; break;
|
|
}
|
|
Assert.That(found, Is.True, "Actual small foliage path must cross visible plant and remain unobstructed.");
|
|
}
|
|
var balls = new System.Collections.Generic.List<BallState> { new BallState { id = "native-contact-a", position = BoardPresenter.ToPosition(sourcePoint) } };
|
|
var groups = new System.Collections.Generic.List<GroupState> { new GroupState { id = "native-contact-source", ballIds = new[] { "native-contact-a" } } };
|
|
if (kind == "thin-obstacle")
|
|
{
|
|
balls.Add(new BallState { id = "native-contact-b", position = BoardPresenter.ToPosition(sourcePoint + requested) });
|
|
groups.Add(new GroupState { id = "native-contact-target", ballIds = new[] { "native-contact-b" } });
|
|
}
|
|
if (kind == "two-plus-three")
|
|
{
|
|
balls = Enumerable.Range(0, 5).Select(index => new BallState { id = "native-contact-" + index, position = new Position3(index - 3, 3, 0) }).ToList();
|
|
groups = new System.Collections.Generic.List<GroupState> { new GroupState { id = "native-contact-source", ballIds = balls.Take(2).Select(ball => ball.id).ToArray() }, new GroupState { id = "native-contact-target", ballIds = balls.Skip(2).Select(ball => ball.id).ToArray() } };
|
|
// Source/target begin separated rather than already touching.
|
|
foreach (var ball in balls.Skip(2)) ball.position.x += 1;
|
|
}
|
|
var camera = new CameraState { target = BoardPresenter.ToPosition(sourcePoint - Vector3.up * .65f), distance = 14 };
|
|
var source = new FreePlayState { sourceStageId = 1, camera = camera, balls = balls.ToArray(), groups = groups.ToArray() };
|
|
_store.Saved.latestFreePlay = source; _app.Initialize(_store); _app.ContinueFreePlay(); yield return null;
|
|
Assert.That(_app.Presenter.IsSafeBoard(_app.Session.Board), Is.True); _app.Orbit.Camera.aspect = 2400f / 1080;
|
|
if (kind == "thin-obstacle")
|
|
{
|
|
bool visible = false;
|
|
foreach (float pitch in new[] { 0f, 15f, 30f, 45f, 60f })
|
|
{
|
|
var rotation = Quaternion.Euler(pitch, 0, 0);
|
|
camera.rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w); _app.Orbit.Apply(camera);
|
|
Physics.SyncTransforms(); var ray = _app.Orbit.Camera.ScreenPointToRay(PlayerPoint(NativePoint(sourcePoint)));
|
|
if (!Physics.Raycast(ray, out var hit, 100) || !hit.collider.TryGetComponent<BallView>(out var ball) || ball.BallId != source.balls[0].id) continue;
|
|
Assert.That(Quaternion.Angle(_app.Orbit.Camera.transform.rotation, rotation), Is.LessThan(.001f), "Chosen pitch must already be a valid manual pose.");
|
|
source.camera = _app.Orbit.Snapshot(); _app.Session.CommitCamera(source.camera); visible = true; break;
|
|
}
|
|
Assert.That(visible, Is.True, "The same thin-arch source must have an actually selectable supported pitch.");
|
|
}
|
|
Capture(kind + "-native-pointer-source", "Actual Editor-selected first hit and preserved source; integer native pointer oracle, not Android pass", 2400, 1080);
|
|
drags.Add(ExerciseNativeDrag(kind, kind, source, requested)); yield return null;
|
|
}
|
|
var directory = Environment.GetEnvironmentVariable("MAGNETISM_NATIVE_FIXTURES") ?? Path.GetFullPath("artifacts/verification/PlaygroundInteraction/NativeFixtures");
|
|
Directory.CreateDirectory(directory);
|
|
File.WriteAllText(Path.Combine(directory, "native-fixtures.json"), JsonUtility.ToJson(new NativeFixtures {
|
|
sourceCommit = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_COMMIT"), sourceDirty = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_DIRTY"),
|
|
utc = DateTime.UtcNow.ToString("O"), origin = "Actual Main scene, unchanged geometry, separately labelled boundary fixtures. Editor oracle is not Android pass.",
|
|
stages = stages.ToArray(), restores = restores.ToArray(), drags = drags.ToArray() }, true));
|
|
Assert.That(stages.Count, Is.EqualTo(30)); Assert.That(restores.Count, Is.EqualTo(9)); Assert.That(drags.Count, Is.EqualTo(15));
|
|
}
|
|
|
|
private void AssertEquipmentFollowsRepresentatives(BoardRules board)
|
|
{
|
|
_app.Presenter.SendMessage("LateUpdate");
|
|
var badges = _app.Presenter.GetComponentsInChildren<GroupBadge>();
|
|
Assert.That(badges.Length, Is.EqualTo(board.Groups.Length));
|
|
Assert.That(_app.Presenter.Balls.Keys, Is.EquivalentTo(board.Balls.Select(ball => ball.id)));
|
|
Assert.That(board.Groups.SelectMany(group => group.ballIds), Is.EquivalentTo(board.Balls.Select(ball => ball.id)));
|
|
Assert.That(_app.Presenter.GetComponentsInChildren<SpriteRenderer>().Length, Is.EqualTo(board.Groups.Length));
|
|
Assert.That(_app.Presenter.GetComponentsInChildren<TMPro.TextMeshPro>().Select(label => label.text),
|
|
Is.EqualTo(board.Groups.Select(group => group.ballIds.Length.ToString())));
|
|
for (int index = 0; index < badges.Length; index++)
|
|
{
|
|
var gear = badges[index].transform.Find("KnightEquipment");
|
|
Assert.That(gear, Is.Not.Null);
|
|
var representative = board.Groups[index].ballIds.Select(id => _app.Presenter.Balls[id].transform.position)
|
|
.OrderBy(point => Vector3.Dot(point - _app.Presenter.Camera.transform.position, _app.Presenter.Camera.transform.forward)).First();
|
|
Assert.That(Vector3.Distance(gear.position, representative), Is.LessThan(.0001f));
|
|
Assert.That(Quaternion.Angle(gear.rotation, _app.Presenter.Camera.transform.rotation), Is.LessThan(.001f));
|
|
Assert.That(gear.GetComponentsInChildren<Collider>(), Is.Empty);
|
|
Assert.That(badges[index].transform.Find("RibbonCape"), Is.Not.Null);
|
|
foreach (string id in board.Groups[index].ballIds)
|
|
Assert.That(_app.Presenter.Balls[id].GroupId, Is.EqualTo(board.Groups[index].id));
|
|
}
|
|
}
|
|
|
|
private void CaptureViews(string name, string origin)
|
|
{
|
|
var saved = _app.Orbit.Snapshot();
|
|
Capture(name + "-phone-default", origin, 2400, 1080);
|
|
Capture(name + "-tablet-default", origin, 1600, 1000);
|
|
var rotation = Quaternion.Euler(25, 95, 0);
|
|
_app.Orbit.Apply(new CameraState { target = saved.target, distance = 9,
|
|
rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w) });
|
|
Capture(name + "-phone-orbitzoom", origin, 2400, 1080);
|
|
Capture(name + "-tablet-orbitzoom", origin, 1600, 1000);
|
|
_app.Orbit.Apply(saved);
|
|
}
|
|
|
|
[UnityTest] public IEnumerator DistantTerrainHasContinuousApronAcrossItsVisibleFootInsteadOfSkyGaps()
|
|
{
|
|
var report = new System.Collections.Generic.List<string>();
|
|
foreach (int stage in new[] { 1, 11, 21 })
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null;
|
|
CaptureViews("horizon-world" + stage, "Actual Main board, unchanged default/orbitzoom cameras; terrain continuity regression");
|
|
var horizon = _app.Environment.GetComponentsInChildren<Transform>().Where(item => item.name == "FarHorizon(Clone)").ToArray();
|
|
var originalPositions = horizon.Select(item => item.position).ToArray();
|
|
var savedCamera = _app.Orbit.Snapshot(); var closeRotation = Quaternion.Euler(25, 95, 0);
|
|
_app.Orbit.Apply(new CameraState { target = savedCamera.target, distance = 9,
|
|
rotation = new Rotation4(closeRotation.x, closeRotation.y, closeRotation.z, closeRotation.w) });
|
|
var camera = _app.Presenter.Camera; float fieldOfView = camera.fieldOfView;
|
|
try
|
|
{
|
|
// Real camera renders of the reproduced (+X, z12) foot gap; no screenshot cropping/editing.
|
|
camera.fieldOfView = 14; camera.transform.LookAt(new Vector3(28, -.45f, 12));
|
|
Capture("horizon-world" + stage + "-foot-current", "Actual Main terrain foot; temporary narrow camera FOV only", 2400, 1080);
|
|
foreach (var far in horizon)
|
|
{
|
|
var direction = new Vector3(far.position.x, 0, far.position.z).normalized;
|
|
far.position = new Vector3(direction.x * 35, far.position.y, direction.z * 35);
|
|
}
|
|
Capture("horizon-world" + stage + "-foot-legacy-radius35", "Same actual Main board, materials and close camera; temporary previous radius35 placement control", 2400, 1080);
|
|
}
|
|
finally
|
|
{
|
|
for (int index = 0; index < horizon.Length; index++) horizon[index].position = originalPositions[index];
|
|
camera.fieldOfView = fieldOfView; _app.Orbit.Apply(savedCamera);
|
|
}
|
|
string board = JsonUtility.ToJson(_app.Session.Board.ToPuzzleState(_app.Orbit.Snapshot()));
|
|
var collisionBefore = _app.GetComponentsInChildren<Collider>();
|
|
var probeScene = SceneManager.CreateScene("TerrainGeometryProbe", new CreateSceneParameters(LocalPhysicsMode.Physics3D));
|
|
var probes = new System.Collections.Generic.List<MeshCollider>();
|
|
try
|
|
{
|
|
var terrain = _app.Environment.GetComponentsInChildren<Transform>().Where(item =>
|
|
item.name == "MeadowClearing(Clone)" || item.name == "GentleHill(Clone)" ||
|
|
item.name == "DistantRidge(Clone)" || item.name == "FarHorizon(Clone)").ToArray();
|
|
foreach (var surface in terrain.SelectMany(item => item.GetComponentsInChildren<MeshFilter>()))
|
|
{
|
|
var probe = new GameObject("GeometryOnly-" + surface.name);
|
|
SceneManager.MoveGameObjectToScene(probe, probeScene);
|
|
probe.transform.SetPositionAndRotation(surface.transform.position, surface.transform.rotation);
|
|
probe.transform.localScale = surface.transform.lossyScale;
|
|
probes.Add(probe.AddComponent<MeshCollider>()); probes.Last().sharedMesh = surface.sharedMesh;
|
|
report.Add($"stage={stage}; terrain={surface.name}; actualRendererBounds={surface.GetComponent<Renderer>().bounds}; meshBounds={surface.sharedMesh.bounds}; rootPosition={surface.transform.position}");
|
|
}
|
|
probeScene.GetPhysicsScene().Simulate(.001f);
|
|
int missing = 0;
|
|
foreach (var far in terrain.Where(item => item.name == "FarHorizon(Clone)"))
|
|
{
|
|
var direction = new Vector3(far.position.x, 0, far.position.z).normalized;
|
|
var right = Vector3.Cross(Vector3.up, direction);
|
|
float distance = new Vector2(far.position.x, far.position.z).magnitude;
|
|
// Traverse the apron to the far mound crown across its central 24m foot.
|
|
// A positive gap is real missing geometry, independent of lighting/material colors.
|
|
for (float lateral = -12; lateral <= 12; lateral += 2)
|
|
for (float radial = 0; radial <= distance; radial += .25f)
|
|
{
|
|
var point = direction * radial + right * lateral;
|
|
var ray = new Ray(point + Vector3.up * 20, Vector3.down);
|
|
if (probes.Any(probe => probe.Raycast(ray, out _, 40))) continue;
|
|
missing++;
|
|
if (missing <= 24) report.Add($"stage={stage}; unsupportedApron={point}; farCrown={far.position}");
|
|
}
|
|
}
|
|
report.Add($"stage={stage}; missingApronSamples={missing}; probe=separate local PhysicsScene using actual shared mesh geometry, no product collider edits");
|
|
File.WriteAllLines(Path.Combine(_evidence, "horizon-geometry.txt"), report);
|
|
Assert.That(missing, Is.Zero, "Far terrain foot must join the actual clearing/hills/ridge without open geometry gaps.");
|
|
}
|
|
finally { SceneManager.UnloadSceneAsync(probeScene); }
|
|
yield return null;
|
|
Assert.That(_app.GetComponentsInChildren<Collider>(), Is.EqualTo(collisionBefore));
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToPuzzleState(_app.Orbit.Snapshot())), Is.EqualTo(board));
|
|
}
|
|
}
|
|
|
|
[UnityTest] public IEnumerator FiveBallMergeDisconnectedSplitAndZeroResupplyKeepActualIdsAcrossAllWorlds()
|
|
{
|
|
foreach (int stage in new[] { 9, 11, 21 })
|
|
{
|
|
// Boundary fixture: a completed-stage store with a validated five-ball free board,
|
|
// not evidence of normal puzzle progression. All operations below use the real app/session.
|
|
var balls = Enumerable.Range(0, 5).Select(index => new BallState { id = "five-" + index,
|
|
position = new Position3(index - 2, .8f, 0) }).ToArray();
|
|
_store.Saved.latestFreePlay = new FreePlayState { sourceStageId = stage,
|
|
camera = _app.Orbit.Snapshot(), balls = balls,
|
|
groups = new[] { new GroupState { id = "two", ballIds = balls.Take(2).Select(ball => ball.id).ToArray() },
|
|
new GroupState { id = "three", ballIds = balls.Skip(2).Select(ball => ball.id).ToArray() } } };
|
|
_app.Initialize(_store); _app.ContinueFreePlay(); _app.Voice.Clear(); yield return null;
|
|
var ids = _app.Session.Board.Balls.Select(ball => ball.id).ToArray();
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
CaptureViews("world" + stage + "-two-plus-three", "Validated five-ball 2+3 free-play store fixture; actual Main app/session");
|
|
var before = JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()));
|
|
_app.Presenter.PreviewGroup("two", new Vector3(.3f, .2f, 0));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board); _app.Presenter.CancelPreview();
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot())), Is.EqualTo(before));
|
|
_app.CommitMove("two", new Position3(.1f, 0, 0), "three"); yield return null;
|
|
Assert.That(_app.Session.Board.Groups.Single().ballIds.Length, Is.EqualTo(5));
|
|
Assert.That(_app.Session.Board.Balls.Select(ball => ball.id), Is.EquivalentTo(ids));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
CaptureViews("world" + stage + "-merged-five", "Actual app/session 2+3 merge from labeled boundary fixture");
|
|
var selected = new[] { ids[0], ids[4] };
|
|
var points = selected.Select(id => BoardPresenter.ToVector(_app.Session.Board.Balls.Single(ball => ball.id == id).position)).ToArray();
|
|
Assert.That(Vector3.Distance(points[0], points[1]), Is.GreaterThan(2f), "Selected endpoints are disconnected.");
|
|
var merged = _app.Session.Board.Groups.Single();
|
|
before = JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()));
|
|
Assert.That(_app.Presenter.PreviewSplit(merged.id, selected, new Vector3(0, 1.5f, 0)), Is.True);
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board); _app.Presenter.CancelPreview();
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot())), Is.EqualTo(before));
|
|
Assert.That(_app.CommitSplit(merged.id, selected, new Position3(0, 1.5f, 0)), Is.True); yield return null;
|
|
Assert.That(_app.Session.Board.Groups.Select(group => group.ballIds.Length), Is.EquivalentTo(new[] { 2, 3 }));
|
|
Assert.That(_app.Session.Board.Groups.Single(group => group.ballIds.Length == 2).ballIds, Is.EquivalentTo(selected));
|
|
Assert.That(_app.Session.Board.Balls.Select(ball => ball.id), Is.EquivalentTo(ids));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
CaptureViews("world" + stage + "-disconnected-split-two-three", "Actual app/session split of disconnected five-group endpoints");
|
|
before = JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot()));
|
|
_app.ShowHome(); yield return null;
|
|
Assert.That(_app.Presenter.GetComponentsInChildren<GroupBadge>(), Is.Empty);
|
|
_app.ContinueFreePlay(); yield return null;
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToFreePlayState(_app.Orbit.Snapshot())), Is.EqualTo(before));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
foreach (var group in _app.Session.Board.Groups) Assert.That(_app.Session.ReturnGroup(group.id).Accepted, Is.True);
|
|
_app.ContinueFreePlay(); yield return null;
|
|
Assert.That(_app.Session.Board.BallCount, Is.Zero); AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
CaptureViews("world" + stage + "-zero", "Actual app/session return of both groups; empty free play");
|
|
_app.SpawnFriend(); yield return null;
|
|
Assert.That(_app.Session.Board.BallCount, Is.EqualTo(1)); AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
CaptureViews("world" + stage + "-single-resupplied", "Actual app/session resupply after empty board");
|
|
}
|
|
}
|
|
|
|
[UnityTest] public IEnumerator UndergroundViewIsCorrectedAboveGroundWithoutChangingActualBoard()
|
|
{
|
|
_app.StartStage(21); _app.Voice.Clear(); yield return null;
|
|
var balls = _app.Session.Board.Balls.Select(ball => (ball.id, ball.position)).ToArray();
|
|
var groups = _app.Session.Board.Groups.Select(group => (group.id, ids: group.ballIds.ToArray())).ToArray();
|
|
var rotation = Quaternion.Euler(-45, 210, 0);
|
|
_app.Orbit.Apply(new CameraState { target = _app.Orbit.Snapshot().target, distance = 15,
|
|
rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w) });
|
|
yield return null; Physics.SyncTransforms();
|
|
Assert.That(_app.Presenter.Camera.transform.position.y, Is.GreaterThan(_app.Environment.PlaygroundBounds.min.y));
|
|
Assert.That(_app.Session.Board.Balls.Select(ball => (ball.id, ball.position)), Is.EqualTo(balls));
|
|
Assert.That(_app.Session.Board.Groups.Select(group => group.id), Is.EqualTo(groups.Select(group => group.id)));
|
|
for (int index = 0; index < groups.Length; index++) Assert.That(_app.Session.Board.Groups[index].ballIds, Is.EqualTo(groups[index].ids));
|
|
Capture("corrected-underground-view", "Actual stage21; legacy below-ground saved view corrected above clearing; board IDs, groups and positions unchanged");
|
|
}
|
|
|
|
[UnityTest] public IEnumerator AllWorldsProduceActualSoftShadowPixelsWithUnchangedBoardAndMaterials()
|
|
{
|
|
var sun = _app.transform.Find("Sun").GetComponent<Light>();
|
|
_app.ShowHome(); yield return null;
|
|
Capture("home-cyan-readiness", "Actual Main home UI for Android sky readiness predicate", 2400, 1080);
|
|
foreach (int stage in new[] { 1, 11, 21 })
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null;
|
|
string before = JsonUtility.ToJson(_app.Session.Board.ToPuzzleState(_app.Orbit.Snapshot()));
|
|
Capture("world" + stage + "-soft-shadow", "Actual Main daylight with soft shadows");
|
|
try { sun.shadows = LightShadows.None; Capture("world" + stage + "-shadow-off", "Same board/camera/materials; light shadow toggle comparison only"); }
|
|
finally { sun.shadows = LightShadows.Soft; }
|
|
var on = new Texture2D(2, 2); var off = new Texture2D(2, 2);
|
|
try
|
|
{
|
|
on.LoadImage(File.ReadAllBytes(Path.Combine(_evidence, "world" + stage + "-soft-shadow.png")));
|
|
off.LoadImage(File.ReadAllBytes(Path.Combine(_evidence, "world" + stage + "-shadow-off.png")));
|
|
var a = on.GetPixels32(); var b = off.GetPixels32(); int darker = 0;
|
|
// The central lower ground excludes the board, badge labels, scenery crowns and HUD.
|
|
for (int y = 140; y < 300; y++) for (int x = 350; x < 1000; x++)
|
|
{
|
|
int index = y * on.width + x;
|
|
if (a[index].r + a[index].g + a[index].b + 12 < b[index].r + b[index].g + b[index].b) darker++;
|
|
}
|
|
File.WriteAllText(Path.Combine(_evidence, "world" + stage + "-shadow-pixels.txt"), $"same-board/camera/materials; shadow-on darker ground ROI pixels={darker}; groundROI=350,140,650,160; viewport=1280x720; Editor RT only");
|
|
Assert.That(darker, Is.GreaterThan(100), "Actual rendered soft shadows must darken a meaningful ground area.");
|
|
}
|
|
finally { Object.Destroy(on); Object.Destroy(off); }
|
|
Assert.That(JsonUtility.ToJson(_app.Session.Board.ToPuzzleState(_app.Orbit.Snapshot())), Is.EqualTo(before));
|
|
}
|
|
}
|
|
[UnityTest] public IEnumerator ActualMainShowsThreeThemesAndEquipmentFollowsPreviewCancelMergeSplitAndReentry()
|
|
{
|
|
foreach (int stage in new[] { 1, 11, 21 })
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null;
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
Capture("stage" + stage.ToString("D2"), "Actual Main GameApp.Session.Board; unlocked-stage fixture store");
|
|
}
|
|
var normalView = _app.Orbit.Snapshot();
|
|
foreach (var view in new[] { (name: "orbit95-pitch45-distance6", yaw: 95f, pitch: 45f, distance: 6f),
|
|
(name: "orbit210-pitch25-distance15", yaw: 210f, pitch: 25f, distance: 15f) })
|
|
{
|
|
var rotation = Quaternion.Euler(view.pitch, view.yaw, 0);
|
|
_app.Orbit.Apply(new CameraState { target = normalView.target, distance = view.distance,
|
|
rotation = new Rotation4(rotation.x, rotation.y, rotation.z, rotation.w) });
|
|
yield return null; AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
Capture(view.name, "Actual Main session; camera-only orbit/pitch/distance exploration fixture");
|
|
}
|
|
_app.Orbit.Apply(normalView);
|
|
_app.StartStage(6); _app.Voice.Clear(); yield return null;
|
|
var original = _app.Session.Board.Balls.Select(ball => ball.position).ToArray();
|
|
var groups = _app.Session.Board.Groups;
|
|
_app.Presenter.PreviewGroup(groups[0].id, new Vector3(.3f, .2f, 0));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
_app.Presenter.CancelPreview();
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
for (int index = 0; index < original.Length; index++)
|
|
Assert.That(_app.Presenter.Balls[_app.Session.Board.Balls[index].id].transform.position, Is.EqualTo(BoardPresenter.ToVector(original[index])));
|
|
_app.Presenter.ShowSelection(new[] { groups[0].ballIds[0] }); yield return null;
|
|
Capture("selected-two-groups", "Actual Main session, visual selection only");
|
|
_app.CommitMove(groups[0].id, new Position3(.1f, 0, 0), groups[1].id); yield return null;
|
|
Assert.That(_app.Session.Board.Groups.Length, Is.EqualTo(1));
|
|
AssertEquipmentFollowsRepresentatives(_app.Session.Board); Capture("merged-single-group", "Actual Main session merge -> free play");
|
|
var merged = _app.Session.Board.Groups[0];
|
|
Assert.That(_app.CommitSplit(merged.id, new[] { merged.ballIds[0] }, new Position3(1.5f, 0, 0)), Is.True); yield return null;
|
|
Assert.That(_app.Session.Board.Groups.Length, Is.EqualTo(2)); AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
_app.ShowHome(); _app.ContinueFreePlay(); yield return null;
|
|
Assert.That(_app.Session.Board.BallCount, Is.EqualTo(2));
|
|
Assert.That(_app.Environment.Theme, Is.EqualTo("Garden")); AssertEquipmentFollowsRepresentatives(_app.Session.Board);
|
|
Capture("split-reentered-two-groups", "Actual Main session free play split and home/reentry");
|
|
}
|
|
[UnityTest] public IEnumerator TenSingleGroupsAndOneTenBallGroupRenderActualImportedResourceCounts()
|
|
{
|
|
var balls = Enumerable.Range(0, 10).Select(index => new BallState { id = "render-" + index,
|
|
position = new Position3((index % 5 - 2) * 1.6f, .8f + index / 5 * 1.8f, 0) }).ToArray();
|
|
foreach (int stage in new[] { 1, 11, 21 })
|
|
{
|
|
_app.StartStage(stage); _app.Voice.Clear(); yield return null;
|
|
foreach (bool singles in new[] { true, false })
|
|
{
|
|
var groups = singles ? balls.Select(ball => new GroupState { id = ball.id, ballIds = new[] { ball.id } }).ToArray()
|
|
: new[] { new GroupState { id = "ten", ballIds = balls.Select(ball => ball.id).ToArray() } };
|
|
var board = BoardRules.CreateFreePlay(new FreePlayState { sourceStageId = stage, balls = balls, groups = groups });
|
|
_app.Presenter.Render(board); yield return null;
|
|
AssertEquipmentFollowsRepresentatives(board);
|
|
CaptureViews("world" + stage + (singles ? "-ten-single-groups" : "-ten-one-group"), "Validated synthetic Core FreePlay render fixture; session UI remains underlying stage " + stage);
|
|
}
|
|
}
|
|
}
|
|
private void Capture(string name, string origin, int width = 1280, int height = 720)
|
|
{
|
|
var camera = _app.Presenter.Camera; var canvas = _app.GetComponentInChildren<Canvas>();
|
|
var oldTarget = camera.targetTexture; var oldActive = RenderTexture.active; var oldMode = canvas.renderMode;
|
|
var oldCamera = canvas.worldCamera; float oldPlane = canvas.planeDistance, oldAspect = camera.aspect;
|
|
var target = new RenderTexture(width, height, 24); var image = new Texture2D(width, height, TextureFormat.RGB24, false);
|
|
try
|
|
{
|
|
camera.targetTexture = target; camera.aspect = (float)width / height;
|
|
canvas.renderMode = RenderMode.ScreenSpaceCamera; canvas.worldCamera = camera; canvas.planeDistance = .5f;
|
|
foreach (var ball in _app.Presenter.Balls.Values) ball.SendMessage("Update");
|
|
if (_app.Presenter.gameObject.activeInHierarchy) _app.Presenter.SendMessage("LateUpdate");
|
|
Canvas.ForceUpdateCanvases();
|
|
var timer = System.Diagnostics.Stopwatch.StartNew(); camera.Render(); timer.Stop();
|
|
RenderTexture.active = target; image.ReadPixels(new Rect(0, 0, width, height), 0, 0); image.Apply();
|
|
File.WriteAllBytes(Path.Combine(_evidence, name + ".png"), image.EncodeToPNG());
|
|
var meshes = _app.GetComponentsInChildren<MeshFilter>();
|
|
var badges = _app.Presenter.GetComponentsInChildren<GroupBadge>();
|
|
var record = new CaptureRecord { name = name, sourceCommit = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_COMMIT"),
|
|
sourceDirty = Environment.GetEnvironmentVariable("MAGNETISM_PROOF_DIRTY"), utc = DateTime.UtcNow.ToString("o"),
|
|
boardOrigin = origin, theme = _app.Environment.Theme, stage = _app.Session.Board?.StageId ?? 0,
|
|
width = width, height = height, balls = _app.Presenter.Balls.Count, groups = badges.Length,
|
|
equipmentAssemblies = badges.Count(item => item.transform.Find("KnightEquipment") != null), meshInstances = meshes.Length,
|
|
triangles = meshes.Sum(item => Enumerable.Range(0, item.sharedMesh.subMeshCount).Sum(submesh => (int)item.sharedMesh.GetIndexCount(submesh) / 3)),
|
|
sharedMaterials = _app.GetComponentsInChildren<Renderer>().SelectMany(item => item.sharedMaterials).Where(item => item != null).Distinct().Count(),
|
|
editorCameraRenderMilliseconds = (float)timer.Elapsed.TotalMilliseconds,
|
|
fieldOfView = camera.fieldOfView,
|
|
textureMemory = Resources.FindObjectsOfTypeAll<Texture>().Sum(item => Profiler.GetRuntimeMemorySizeLong(item)),
|
|
allocatedMemory = Profiler.GetTotalAllocatedMemoryLong(), cameraPosition = camera.transform.position, cameraRotation = camera.transform.rotation,
|
|
method = "Actual Main scene PlayMode Camera.Render to RT, ScreenSpaceCamera canvas; simulated viewport, not Android capture. Triangles are resident index counts for active mesh instances, including the retained floor with its Renderer disabled; they are not submitted GPU triangles. Camera.Render elapsed is Editor CPU wall time, not GPU time or device FPS. Texture memory includes all Editor-loaded textures." };
|
|
File.WriteAllText(Path.Combine(_evidence, name + ".json"), JsonUtility.ToJson(record, true));
|
|
if (name == "world21-ten-single-groups-phone-default")
|
|
File.WriteAllLines(Path.Combine(_evidence, "editor-loaded-textures.txt"), Resources.FindObjectsOfTypeAll<Texture>()
|
|
.Select(item => $"{AssetDatabase.GetAssetPath(item)};name={item.name};dimensions={item.width}x{item.height};format={(item is Texture2D texture ? texture.format.ToString() : item.GetType().Name)};runtimeBytes={Profiler.GetRuntimeMemorySizeLong(item)}"));
|
|
}
|
|
finally
|
|
{
|
|
camera.targetTexture = oldTarget; camera.aspect = oldAspect; RenderTexture.active = oldActive;
|
|
canvas.renderMode = oldMode; canvas.worldCamera = oldCamera; canvas.planeDistance = oldPlane;
|
|
Object.DestroyImmediate(image); target.Release(); Object.DestroyImmediate(target);
|
|
if (_app.Presenter.gameObject.activeInHierarchy) _app.Presenter.SendMessage("LateUpdate");
|
|
Canvas.ForceUpdateCanvases();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|