f961d70023
Restore the named-retail object update order across local, remote, static, projectile, animation, shadow, teleport, and effect lifetimes. Separate authoritative root commits from spatial rebucketing, preserve per-owner hook/FIFO ordering, and remove update-path allocations with exact lifecycle and residency gates. Add deterministic conformance, adversarial lifetime, GUID-reuse, pending-cell, quaternion, timestamp, and allocation coverage. Release build is warning-free and all 6,446 tests pass with five intentional skips; retail, architecture, and adversarial reviews are clean. Co-authored-by: OpenAI Codex <codex@openai.com>
192 lines
8.5 KiB
C#
192 lines
8.5 KiB
C#
using System.Numerics;
|
|
|
|
namespace AcDream.Core.Physics;
|
|
|
|
/// <summary>
|
|
/// Verbatim port of the collision-response tail of retail
|
|
/// <c>CPhysicsObj::UpdateObjectInternal</c>: the velocity decision that
|
|
/// <c>SetPositionInternal</c> (0x00515330) drives through
|
|
/// <c>handle_all_collisions</c> (0x00514780, pc:282647). Kept as a pure function over a
|
|
/// <see cref="PhysicsBody"/> + the resolve outcome so the whole decision is unit-testable
|
|
/// in Core, independent of the App per-frame loop. The transition INTERNALS
|
|
/// (<c>ResolveWithTransition</c> and below) are untouched.
|
|
/// </summary>
|
|
public static class PhysicsObjUpdate
|
|
{
|
|
/// <summary>
|
|
/// Retail <c>SetPositionInternal</c> walkability comparison at
|
|
/// <c>0x00515465-0x0051548E</c>. Equality with FloorZ is walkable.
|
|
/// </summary>
|
|
public static bool IsWalkableContact(bool inContact, Vector3 contactNormal)
|
|
=> inContact && contactNormal.Z >= PhysicsGlobals.FloorZ;
|
|
|
|
/// <summary>
|
|
/// Applies the two independent transient facts written by retail
|
|
/// <c>CPhysicsObj::SetPositionInternal</c> at <c>0x00515430-0x0051549F</c>.
|
|
/// Contact comes from contact-plane validity; OnWalkable additionally
|
|
/// requires a walkable plane normal. A steep contact therefore remains in
|
|
/// contact without becoming grounded.
|
|
/// </summary>
|
|
public static void ApplySetPositionContact(
|
|
PhysicsBody body,
|
|
bool inContact,
|
|
bool onWalkable)
|
|
{
|
|
if (inContact)
|
|
body.TransientState |= TransientStateFlags.Contact;
|
|
else
|
|
body.TransientState &= ~TransientStateFlags.Contact;
|
|
|
|
if (inContact && onWalkable)
|
|
body.TransientState |= TransientStateFlags.OnWalkable;
|
|
else
|
|
body.TransientState &= ~TransientStateFlags.OnWalkable;
|
|
|
|
body.calc_acceleration();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Commits the contact/walkable/collision-response tail of retail
|
|
/// <c>CPhysicsObj::SetPositionInternal</c> (<c>0x00515330</c>) in its
|
|
/// original order. The pre-transition flags are explicit because a
|
|
/// deferred placement may temporarily park the body without contact while
|
|
/// still needing the source edge when its destination cell becomes ready.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Retail writes Contact and recalculates acceleration, calls
|
|
/// <c>set_on_walkable</c> (which invokes HitGround/LeaveGround), then calls
|
|
/// <c>handle_all_collisions</c> at <c>0x005154FE</c>. Collision response
|
|
/// must therefore observe any velocity change made by the movement
|
|
/// callback; moving that callback after reflection changes the result.
|
|
/// </remarks>
|
|
public static bool CommitSetPositionTransition(
|
|
PhysicsBody body,
|
|
bool inContact,
|
|
bool onWalkable,
|
|
bool collisionNormalValid,
|
|
Vector3 collisionNormal,
|
|
bool previousContact,
|
|
bool previousOnWalkable,
|
|
Action? hitGround = null,
|
|
Action? leaveGround = null,
|
|
Func<bool>? isCurrent = null,
|
|
Func<bool>? isVelocityCurrent = null)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(body);
|
|
|
|
// SetPositionInternal replaces Contact first but retains the source
|
|
// OnWalkable bit through its first calc_acceleration call. A deferred
|
|
// teleport may have parked the live body with both bits cleared, so
|
|
// restore the captured source bit explicitly before reproducing that
|
|
// ordering.
|
|
if (previousOnWalkable)
|
|
body.TransientState |= TransientStateFlags.OnWalkable;
|
|
else
|
|
body.TransientState &= ~TransientStateFlags.OnWalkable;
|
|
|
|
if (inContact)
|
|
body.TransientState |= TransientStateFlags.Contact;
|
|
else
|
|
body.TransientState &= ~TransientStateFlags.Contact;
|
|
body.calc_acceleration();
|
|
|
|
bool finalOnWalkable = inContact && onWalkable;
|
|
if (finalOnWalkable)
|
|
body.TransientState |= TransientStateFlags.OnWalkable;
|
|
else
|
|
body.TransientState &= ~TransientStateFlags.OnWalkable;
|
|
|
|
if (!previousOnWalkable && finalOnWalkable)
|
|
{
|
|
hitGround?.Invoke();
|
|
if (isCurrent?.Invoke() == false)
|
|
return false;
|
|
}
|
|
else if (previousOnWalkable && !finalOnWalkable)
|
|
{
|
|
leaveGround?.Invoke();
|
|
if (isCurrent?.Invoke() == false)
|
|
return false;
|
|
}
|
|
body.calc_acceleration();
|
|
|
|
// Position, Vector, and Movement are independently timestamped but
|
|
// can all install m_velocityVector. If a later one arrived from a
|
|
// callback above, retain its vector and finish the non-overlapping
|
|
// contact/pose commit without applying this older collision response.
|
|
if (isVelocityCurrent?.Invoke() == false)
|
|
return isCurrent?.Invoke() ?? true;
|
|
|
|
HandleAllCollisions(
|
|
body,
|
|
collisionNormalValid,
|
|
collisionNormal,
|
|
previousContact,
|
|
previousOnWalkable,
|
|
finalOnWalkable);
|
|
return isCurrent?.Invoke() ?? true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// retail <c>handle_all_collisions</c> (0x00514780). Reflects or zeros the body's
|
|
/// <see cref="PhysicsBody.Velocity"/> (retail m_velocityVector) based on
|
|
/// <see cref="PhysicsBody.FramesStationaryFall"/>:
|
|
/// <list type="bullet">
|
|
/// <item>fsf ≤ 1 → reflect the into-surface component
|
|
/// (<c>v += -(v·n)(elasticity+1)·n</c>, pc:282712) when we should reflect and a
|
|
/// collision normal is valid; an INELASTIC mover zeros instead (pc:282720).</item>
|
|
/// <item>fsf > 1 → <c>v = 0</c> entirely (pc:282729) — the "bleed on block" that
|
|
/// lets gravity resume so a blocked jump falls/glides off (fixes the #182
|
|
/// airborne-stuck wedge).</item>
|
|
/// </list>
|
|
/// The Stationary* transient-bit round-trip (pc:282737-758) is owned by the Core resolve
|
|
/// writeback (<c>PhysicsEngine.ResolveWithTransition</c>), not re-encoded here.
|
|
/// </summary>
|
|
/// <param name="body">The mover.</param>
|
|
/// <param name="collisionNormalValid">Was a wall/creature collision normal recorded this resolve.</param>
|
|
/// <param name="collisionNormal">Outward collision normal (points away from the surface).</param>
|
|
/// <param name="prevContact">Whether the body had Contact BEFORE this resolve committed
|
|
/// (retail arg3 — reserved for environment-collision reporting; unused today).</param>
|
|
/// <param name="prevOnWalkable">Whether the body was OnWalkable before this resolve (retail arg4).</param>
|
|
/// <param name="nowOnWalkable">Whether the body is OnWalkable after this resolve.</param>
|
|
public static void HandleAllCollisions(
|
|
PhysicsBody body,
|
|
bool collisionNormalValid, Vector3 collisionNormal,
|
|
bool prevContact, bool prevOnWalkable, bool nowOnWalkable)
|
|
{
|
|
// var_10_1 (pc:282653-282657): reflect UNLESS the mover stays on walkable ground
|
|
// (and is not sledding). This restores retail's broader rule — the AD-25 airborne-only
|
|
// suppression is retired: the landing-snap fragility it guarded is gone (landing state
|
|
// is now owned by the SetPositionInternal-derived contact flags, not a Velocity.Z<=0
|
|
// gate). A grounded corridor wall-slide keeps its tangential velocity (should_reflect
|
|
// false), exactly as retail.
|
|
bool sledding = body.State.HasFlag(PhysicsStateFlags.Sledding);
|
|
bool shouldReflect = !(prevOnWalkable && nowOnWalkable && !sledding);
|
|
|
|
if (body.FramesStationaryFall <= 1)
|
|
{
|
|
if (shouldReflect && collisionNormalValid)
|
|
{
|
|
if (body.State.HasFlag(PhysicsStateFlags.Inelastic))
|
|
{
|
|
body.Velocity = Vector3.Zero; // pc:282720-282722
|
|
}
|
|
else
|
|
{
|
|
float dot = Vector3.Dot(body.Velocity, collisionNormal);
|
|
if (dot < 0f) // moving INTO the surface
|
|
{
|
|
float k = -(dot * (body.Elasticity + 1f)); // pc:282712
|
|
body.Velocity += collisionNormal * k;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
body.Velocity = Vector3.Zero; // fsf>1 → THE BLEED (pc:282729)
|
|
}
|
|
|
|
_ = prevContact; // retail report_environment_collision(arg3) — weenie collision events, later.
|
|
}
|
|
}
|