c19d6fb321
ResolveOutdoorCellId only resolved outdoor terrain landcells. A player geometrically inside an EnvCell stayed in outdoor-landcell range, so FindEnvCollisions' indoor cell-BSP branch (gated on cellLow >= 0x0100) never fired. Both #84 (blocked by air indoors) and #85 (pass through walls outside→in) are downstream of this — without indoor cell-BSP collision the player gets stuck against outdoor-stab back-faces of the building shell, and walls only block from one side. Adds an indoor-cell-containment check via PhysicsDataCache: at CacheCellStruct time, compute each cell's local AABB from its resolved polygon vertices; at ResolveOutdoorCellId time, transform the world position into each cached cell's local space and return the matched cell's full id when contained. Falls through to the existing outdoor terrain logic when no EnvCell contains the position. Also fixes a pre-existing prefix-preservation bug in the outdoor branch: the function now always applies the matched landblock's high-16 prefix even when the input fallbackCellId arrived bare-low-byte (the L.2e finding from CLAUDE.md). Updated two existing PhysicsEngineTests that encoded the old bare-low-byte output. Evidence: launch-cluster-a-capture.log @ 2026-05-19 — player at worldPos (155.376, 14.010, 94.000) geometrically inside cottage cell 0xA9B40172, but sp.CheckCellId stuck at 0x00000031 (outdoor landcell) across 454 [resolve] lines; zero [indoor-bsp] lines because the gate never opened. Closes #84. Closes #85. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
462 lines
18 KiB
C#
462 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using AcDream.Core.Physics;
|
|
using Xunit;
|
|
|
|
namespace AcDream.Core.Tests.Physics;
|
|
|
|
public class PhysicsEngineTests
|
|
{
|
|
private static float[] LinearHeightTable()
|
|
{
|
|
var table = new float[256];
|
|
for (int i = 0; i < 256; i++) table[i] = i * 1.0f;
|
|
return table;
|
|
}
|
|
|
|
private static byte[] FlatHeightmap(byte value = 50)
|
|
{
|
|
var heights = new byte[81];
|
|
Array.Fill(heights, value);
|
|
return heights;
|
|
}
|
|
|
|
private PhysicsEngine MakeFlatEngine(float terrainZ = 50f)
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(FlatHeightmap((byte)terrainZ), LinearHeightTable());
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(),
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
return engine;
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_FlatTerrain_ZMatchesTerrain()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
|
|
var result = engine.Resolve(
|
|
new Vector3(96f, 96f, 50f), cellId: 0x0001, delta: new Vector3(1f, 0f, 0f),
|
|
stepUpHeight: 2f);
|
|
|
|
Assert.Equal(50f, result.Position.Z, precision: 1);
|
|
Assert.True(result.IsOnGround);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_WalkUpSmallSlope_Accepted()
|
|
{
|
|
// Heights slope from 50 to 52 across X — small enough for step height.
|
|
var heights = new byte[81];
|
|
for (int x = 0; x < 9; x++)
|
|
for (int y = 0; y < 9; y++)
|
|
heights[x * 9 + y] = (byte)(50 + x / 4); // gentle slope
|
|
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(heights, LinearHeightTable());
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(),
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
var result = engine.Resolve(
|
|
new Vector3(48f, 96f, 50f), cellId: 0x0001, delta: new Vector3(48f, 0f, 0f),
|
|
stepUpHeight: 5f);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.True(result.Position.Z >= 50f); // moved uphill
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_StepUpExceedsHeight_MovementBlocked()
|
|
{
|
|
// Heights jump sharply: left half = 50, right half = 100.
|
|
var heights = new byte[81];
|
|
for (int x = 0; x < 9; x++)
|
|
for (int y = 0; y < 9; y++)
|
|
heights[x * 9 + y] = (byte)(x < 5 ? 50 : 100);
|
|
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(heights, LinearHeightTable());
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(),
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
// Try to walk from the low side to the high side.
|
|
var result = engine.Resolve(
|
|
new Vector3(96f, 96f, 50f), cellId: 0x0001, delta: new Vector3(48f, 0f, 0f),
|
|
stepUpHeight: 2f);
|
|
|
|
// Movement should be blocked — Z delta (50→100) exceeds step height (2).
|
|
Assert.Equal(96f, result.Position.X, precision: 1); // didn't move
|
|
Assert.True(result.IsOnGround);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_OutdoorThroughPortal_TransitionsToIndoor()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
|
|
// A CellSurface for the indoor cell with floor at Z=50.
|
|
var cellVerts = new Dictionary<ushort, Vector3>
|
|
{
|
|
[0] = new(40f, 40f, 50f),
|
|
[1] = new(60f, 40f, 50f),
|
|
[2] = new(60f, 60f, 50f),
|
|
[3] = new(40f, 60f, 50f),
|
|
};
|
|
var cellPolys = new List<List<short>> { new() { 0, 1, 2, 3 } };
|
|
var cell = new CellSurface(0x0100, cellVerts, cellPolys);
|
|
|
|
// A portal plane at X=45 (vertical plane facing +X).
|
|
// OwnerCellId = 0x0100 (the indoor cell), TargetCellId = 0xFFFF (faces outdoor).
|
|
// From outside, walking through this portal enters OwnerCellId.
|
|
var portal = PortalPlane.FromVertices(
|
|
new Vector3(45f, 40f, 45f),
|
|
new Vector3(45f, 60f, 45f),
|
|
new Vector3(45f, 60f, 55f),
|
|
targetCellId: 0xFFFF, ownerCellId: 0x0100, flags: 0);
|
|
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, new[] { cell }, new[] { portal },
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
// Walk from X=40 (outdoor) through X=45 (portal) to X=50 (indoor).
|
|
var result = engine.Resolve(
|
|
new Vector3(40f, 50f, 50f), cellId: 0x0001, delta: new Vector3(10f, 0f, 0f),
|
|
stepUpHeight: 5f);
|
|
|
|
// Should have transitioned to indoor cell 0x0100.
|
|
Assert.Equal(0x0100u, result.CellId & 0xFFFFu);
|
|
Assert.True(result.IsOnGround);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_IndoorThroughExitPortal_TransitionsToOutdoor()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
|
|
var cellVerts = new Dictionary<ushort, Vector3>
|
|
{
|
|
[0] = new(40f, 40f, 50f),
|
|
[1] = new(60f, 40f, 50f),
|
|
[2] = new(60f, 60f, 50f),
|
|
[3] = new(40f, 60f, 50f),
|
|
};
|
|
var cellPolys = new List<List<short>> { new() { 0, 1, 2, 3 } };
|
|
var cell = new CellSurface(0x0100, cellVerts, cellPolys);
|
|
|
|
// Same portal geometry — OwnerCellId = 0x0100, TargetCellId = 0xFFFF (outdoor exit).
|
|
var portal = PortalPlane.FromVertices(
|
|
new Vector3(45f, 40f, 45f),
|
|
new Vector3(45f, 60f, 45f),
|
|
new Vector3(45f, 60f, 55f),
|
|
targetCellId: 0xFFFF, ownerCellId: 0x0100, flags: 0);
|
|
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, new[] { cell }, new[] { portal },
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
// Walk from X=50 (indoor) through X=45 (portal) to X=40 (outdoor).
|
|
var result = engine.Resolve(
|
|
new Vector3(50f, 50f, 50f), cellId: 0x0100, delta: new Vector3(-10f, 0f, 0f),
|
|
stepUpHeight: 5f);
|
|
|
|
// Should have transitioned to outdoor.
|
|
Assert.True((result.CellId & 0xFFFFu) < 0x0100u);
|
|
Assert.True(result.IsOnGround);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_LandblockBoundary_PicksAdjacentTerrain()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
|
|
// Landblock A: flat at Z=50, offset at X=0.
|
|
var terrainA = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
engine.AddLandblock(0xA9B4FFFFu, terrainA, Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(), worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
// Landblock B: flat at Z=60, offset at X=192 (adjacent east).
|
|
var terrainB = new TerrainSurface(FlatHeightmap(60), LinearHeightTable());
|
|
engine.AddLandblock(0xAAB4FFFFu, terrainB, Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(), worldOffsetX: 192f, worldOffsetY: 0f);
|
|
|
|
// Walk from X=190 (landblock A) across to X=194 (landblock B).
|
|
var result = engine.Resolve(
|
|
new Vector3(190f, 96f, 50f), cellId: 0x0001, delta: new Vector3(4f, 0f, 0f),
|
|
stepUpHeight: 15f);
|
|
|
|
// Should be at Z=60 (landblock B's terrain) and position X≈194.
|
|
Assert.Equal(60f, result.Position.Z, precision: 1);
|
|
Assert.True(result.Position.X > 192f);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResolveWithTransition_OutdoorCellBoundary_UpdatesLowCellId()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
|
|
var result = engine.ResolveWithTransition(
|
|
currentPos: new Vector3(23f, 10f, 50f),
|
|
targetPos: new Vector3(25f, 10f, 50f),
|
|
cellId: 0x0001u,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.InRange(result.Position.X, 24.9f, 25.1f);
|
|
// Phase D fix: ResolveOutdoorCellId now always applies the matched
|
|
// landblock's high-16 prefix — 0xA9B4 prefix from the registered
|
|
// landblock (0xA9B4FFFF) is now included in the returned CellId.
|
|
Assert.Equal(0xA9B40009u, result.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResolveWithTransition_EdgeSlideFlag_AllowsNormalFlatMovement()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
|
|
var result = engine.ResolveWithTransition(
|
|
currentPos: new Vector3(96f, 96f, 50f),
|
|
targetPos: new Vector3(98f, 96f, 50f),
|
|
cellId: 0x0025u,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true,
|
|
moverFlags: ObjectInfoState.EdgeSlide);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.InRange(result.Position.X, 97.9f, 98.1f);
|
|
// Phase D fix: ResolveOutdoorCellId now always applies the matched
|
|
// landblock's high-16 prefix — 0xA9B4 prefix from the registered
|
|
// landblock (0xA9B4FFFF) is now included in the returned CellId.
|
|
Assert.Equal(0xA9B40025u, result.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResolveWithTransition_EdgeSlideStopsAtLoadedTerrainBoundary()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
var body = new PhysicsBody
|
|
{
|
|
Position = new Vector3(191.25f, 96f, 50f),
|
|
TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable,
|
|
ContactPlaneValid = true,
|
|
ContactPlane = new Plane(Vector3.UnitZ, -50f),
|
|
ContactPlaneCellId = 0x003Du,
|
|
};
|
|
|
|
var result = engine.ResolveWithTransition(
|
|
currentPos: new Vector3(191.25f, 96f, 50f),
|
|
targetPos: new Vector3(193f, 96f, 50f),
|
|
cellId: 0x003Du,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true,
|
|
body: body,
|
|
moverFlags: ObjectInfoState.EdgeSlide);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.InRange(result.Position.X, 190.75f, 192.0001f);
|
|
Assert.Equal(50f, result.Position.Z, precision: 2);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResolveWithTransition_EdgeSlideAtLoadedTerrainBoundary_PreservesTangentMotion()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
var body = new PhysicsBody
|
|
{
|
|
Position = new Vector3(191f, 96f, 50f),
|
|
TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable,
|
|
ContactPlaneValid = true,
|
|
ContactPlane = new Plane(Vector3.UnitZ, -50f),
|
|
ContactPlaneCellId = 0x003Du,
|
|
};
|
|
|
|
var settled = engine.ResolveWithTransition(
|
|
currentPos: new Vector3(191f, 96f, 50f),
|
|
targetPos: new Vector3(191.25f, 96f, 50f),
|
|
cellId: 0x003Du,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true,
|
|
body: body,
|
|
moverFlags: ObjectInfoState.EdgeSlide);
|
|
|
|
Assert.True(body.WalkablePolygonValid);
|
|
Assert.NotNull(body.WalkableVertices);
|
|
|
|
var result = engine.ResolveWithTransition(
|
|
currentPos: settled.Position,
|
|
targetPos: new Vector3(193f, 98f, 50f),
|
|
cellId: 0x003Du,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true,
|
|
body: body,
|
|
moverFlags: ObjectInfoState.EdgeSlide);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.InRange(result.Position.X, 190.75f, 192.0001f);
|
|
Assert.True(result.Position.Y > 96.2f);
|
|
Assert.Equal(50f, result.Position.Z, precision: 2);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResolveWithTransition_LandblockBoundary_UpdatesFullOutdoorCellId()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
|
|
var terrainA = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
engine.AddLandblock(0xA9B4FFFFu, terrainA, Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(), worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
var terrainB = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
engine.AddLandblock(0xAAB4FFFFu, terrainB, Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(), worldOffsetX: 192f, worldOffsetY: 0f);
|
|
|
|
var result = engine.ResolveWithTransition(
|
|
currentPos: new Vector3(191f, 10f, 50f),
|
|
targetPos: new Vector3(193f, 10f, 50f),
|
|
cellId: 0xA9B40039u,
|
|
sphereRadius: 0.5f,
|
|
sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f,
|
|
stepDownHeight: 0.4f,
|
|
isOnGround: true);
|
|
|
|
Assert.True(result.IsOnGround);
|
|
Assert.InRange(result.Position.X, 192.9f, 193.1f);
|
|
Assert.Equal(0xAAB40001u, result.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_LeaveIndoorCell_TransitionsToOutdoor()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
var terrain = new TerrainSurface(FlatHeightmap(50), LinearHeightTable());
|
|
|
|
var cellVerts = new Dictionary<ushort, Vector3>
|
|
{
|
|
[0] = new(40f, 40f, 55f),
|
|
[1] = new(60f, 40f, 55f),
|
|
[2] = new(60f, 60f, 55f),
|
|
[3] = new(40f, 60f, 55f),
|
|
};
|
|
var cellPolys = new List<List<short>> { new() { 0, 1, 2, 3 } };
|
|
var cell = new CellSurface(0x0100, cellVerts, cellPolys);
|
|
|
|
engine.AddLandblock(0xA9B4FFFFu, terrain, new[] { cell }, Array.Empty<PortalPlane>(),
|
|
worldOffsetX: 0f, worldOffsetY: 0f);
|
|
|
|
// Start inside the cell, walk out.
|
|
var result = engine.Resolve(
|
|
new Vector3(50f, 50f, 55f), cellId: 0x0100, delta: new Vector3(-20f, 0f, 0f),
|
|
stepUpHeight: 10f);
|
|
|
|
// Should transition back to outdoor.
|
|
Assert.True(result.CellId < 0x0100u);
|
|
Assert.Equal(50f, result.Position.Z, precision: 1);
|
|
Assert.True(result.IsOnGround);
|
|
}
|
|
|
|
[Fact]
|
|
public void Resolve_NoSurfaceUnderEntity_NotOnGround()
|
|
{
|
|
var engine = new PhysicsEngine();
|
|
// No landblocks loaded — entity is floating in void.
|
|
|
|
var result = engine.Resolve(
|
|
new Vector3(0f, 0f, 100f), cellId: 0x0001, delta: Vector3.Zero,
|
|
stepUpHeight: 2f);
|
|
|
|
Assert.False(result.IsOnGround);
|
|
}
|
|
|
|
/// <summary>
|
|
/// #42 lock — when the moving entity's own ShadowEntry is registered
|
|
/// in <see cref="ShadowObjectRegistry"/> at the body's exact position
|
|
/// (the production pattern from <c>GameWindow.cs:2545</c> spawn → register
|
|
/// + <c>UpdatePosition</c> live tracking), the airborne sweep MUST skip
|
|
/// it. Without the gate, <c>FindObjCollisions</c> sees the cylinder as
|
|
/// a foreign collidable and slides the sphere ~1m horizontally on the
|
|
/// first non-zero-motion frame — the bug observed by the [SWEEP-OBJ]
|
|
/// trace and reported as the post-jump XY drift in #42.
|
|
/// <para>
|
|
/// Mirrors retail's self-skip at <c>CObjCell::find_obj_collisions</c>
|
|
/// (named-retail <c>acclient_2013_pseudo_c.txt:308931</c>):
|
|
/// <c>physobj != arg2->object_info.object</c>.
|
|
/// </para>
|
|
/// </summary>
|
|
[Fact]
|
|
public void ResolveWithTransition_SelfShadowEntry_NotPushedWhenIdMatches()
|
|
{
|
|
var engine = MakeFlatEngine(terrainZ: 50f);
|
|
// FindObjCollisions early-returns when DataCache is null. An empty
|
|
// cache is enough for cylinder objects; only BSP objects look up
|
|
// entries inside.
|
|
engine.DataCache = new PhysicsDataCache();
|
|
|
|
const uint movingEntityId = 0xDEADBEEFu;
|
|
var bodyPos = new Vector3(96f, 96f, 50f);
|
|
var targetPos = bodyPos + new Vector3(0f, 0f, 0.022f); // stationary +Z
|
|
|
|
// Register the moving entity's own ShadowEntry — humanoid Cylinder
|
|
// sized to match the live-spawn registration in production
|
|
// (GameWindow.cs:2545). The gfxObj id 0x02000001 is the standard
|
|
// human setup; radius/height match the [SWEEP-OBJ] trace observed
|
|
// during run #2 of the #42 investigation.
|
|
engine.ShadowObjects.Register(
|
|
entityId: movingEntityId,
|
|
gfxObjId: 0x02000001u,
|
|
worldPos: bodyPos,
|
|
rotation: Quaternion.Identity,
|
|
radius: 0.679f,
|
|
worldOffsetX: 0f, worldOffsetY: 0f,
|
|
landblockId: 0xA9B4FFFFu,
|
|
collisionType: ShadowCollisionType.Cylinder,
|
|
cylHeight: 1.835f);
|
|
|
|
// Without the gate (movingEntityId == 0): the sweep must self-push.
|
|
// This proves the registry actually causes a collision, so the
|
|
// following filtered case is not a vacuous pass.
|
|
var unfiltered = engine.ResolveWithTransition(
|
|
currentPos: bodyPos, targetPos: targetPos,
|
|
cellId: 0xA9B40039u,
|
|
sphereRadius: 0.48f, sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f, stepDownHeight: 0.4f,
|
|
isOnGround: false,
|
|
movingEntityId: 0u);
|
|
|
|
float unfilteredXY = MathF.Sqrt(
|
|
(unfiltered.Position.X - targetPos.X) * (unfiltered.Position.X - targetPos.X) +
|
|
(unfiltered.Position.Y - targetPos.Y) * (unfiltered.Position.Y - targetPos.Y));
|
|
Assert.True(unfilteredXY > 0.5f,
|
|
$"Without movingEntityId, sweep should self-push (got XY drift {unfilteredXY:F3}m)");
|
|
|
|
// With the gate: the sweep must leave XY unchanged.
|
|
var filtered = engine.ResolveWithTransition(
|
|
currentPos: bodyPos, targetPos: targetPos,
|
|
cellId: 0xA9B40039u,
|
|
sphereRadius: 0.48f, sphereHeight: 1.2f,
|
|
stepUpHeight: 0.4f, stepDownHeight: 0.4f,
|
|
isOnGround: false,
|
|
movingEntityId: movingEntityId);
|
|
|
|
float filteredXY = MathF.Sqrt(
|
|
(filtered.Position.X - targetPos.X) * (filtered.Position.X - targetPos.X) +
|
|
(filtered.Position.Y - targetPos.Y) * (filtered.Position.Y - targetPos.Y));
|
|
Assert.InRange(filteredXY, 0f, 0.001f);
|
|
}
|
|
}
|