acdream/src/AcDream.App/Rendering/EntityPhysicsHost.cs

using System;
using System.Numerics;
using AcDream.Core.Physics;
using AcDream.Core.Physics.Motion;

namespace AcDream.App.Rendering;

/// <summary>
/// R5-V2 — the App-side <see cref="IPhysicsObjHost"/> per entity: acdream's
/// stand-in for retail's <c>CPhysicsObj</c> as the movement managers see it.
/// One is built per entity (a remote <c>RemoteMotion</c> or the local player)
/// in <c>GameWindow.EnsureRemoteMotionBindings</c> / <c>EnterPlayerModeNow</c>
/// and registered in <c>GameWindow._physicsHosts</c> (guid → host), so
/// <see cref="GetObjectA"/> can resolve OTHER entities' hosts — the
/// cross-entity delivery path the <see cref="TargetManager"/> voyeur system
/// needs.
///
/// <para>Owns a <see cref="TargetManager"/> (retail
/// <c>CPhysicsObj::target_manager</c>). Its <c>set_target</c>/<c>clear_target</c>/
/// <c>add_voyeur</c>/<c>remove_voyeur</c>/<c>receive_target_update</c> seams
/// forward to it exactly as retail's CPhysicsObj does; the movement managers'
/// target seams are repointed here, replacing the AP-79 poll adapter. The
/// per-entity accessors (position/velocity/radius/contact/clocks) and the
/// <see cref="HandleUpdateTarget"/> fan-out are injected by GameWindow so this
/// class stays free of GameWindow's internals (code-structure rule #1).</para>
///
/// <para>R5-V3: owns a <see cref="PositionManager"/> too (retail
/// <c>CPhysicsObj::position_manager</c> — retail creates it lazily via
/// <c>get_position_manager</c>; acdream constructs it eagerly, which is
/// behaviorally identical because the empty facade no-ops until its first
/// <c>StickTo</c>/<c>ConstrainTo</c>). <see cref="HandleUpdateTarget"/> fans
/// deliveries to the injected MoveToManager fan FIRST, then the
/// PositionManager — retail <c>CPhysicsObj::HandleUpdateTarget</c> order
/// (0x00512bc0: MovementManager @0x00512bf0, PositionManager
/// @0x00512c1a).</para>
/// </summary>
public sealed class EntityPhysicsHost : IPhysicsObjHost
{
    private readonly Func<Position> _getPosition;
    private readonly Func<Vector3> _getVelocity;
    private readonly Func<float> _getRadius;
    private readonly Func<bool> _inContact;
    private readonly Func<float?> _minterpMaxSpeed;
    private readonly Func<double> _curTime;
    private readonly Func<double> _physicsTimerTime;
    private readonly Func<uint, IPhysicsObjHost?> _getObjectA;
    private readonly Action<TargetInfo> _handleUpdateTarget;
    private readonly Action _interruptCurrentMovement;
    private readonly TargetManager _targetManager;

    public EntityPhysicsHost(
        uint id,
        Func<Position> getPosition,
        Func<Vector3> getVelocity,
        Func<float> getRadius,
        Func<bool> inContact,
        Func<float?> minterpMaxSpeed,
        Func<double> curTime,
        Func<double> physicsTimerTime,
        Func<uint, IPhysicsObjHost?> getObjectA,
        Action<TargetInfo> handleUpdateTarget,
        Action interruptCurrentMovement)
    {
        Id = id;
        _getPosition = getPosition ?? throw new ArgumentNullException(nameof(getPosition));
        _getVelocity = getVelocity ?? throw new ArgumentNullException(nameof(getVelocity));
        _getRadius = getRadius ?? throw new ArgumentNullException(nameof(getRadius));
        _inContact = inContact ?? throw new ArgumentNullException(nameof(inContact));
        _minterpMaxSpeed = minterpMaxSpeed ?? throw new ArgumentNullException(nameof(minterpMaxSpeed));
        _curTime = curTime ?? throw new ArgumentNullException(nameof(curTime));
        _physicsTimerTime = physicsTimerTime ?? throw new ArgumentNullException(nameof(physicsTimerTime));
        _getObjectA = getObjectA ?? throw new ArgumentNullException(nameof(getObjectA));
        _handleUpdateTarget = handleUpdateTarget ?? throw new ArgumentNullException(nameof(handleUpdateTarget));
        _interruptCurrentMovement = interruptCurrentMovement
            ?? throw new ArgumentNullException(nameof(interruptCurrentMovement));
        _targetManager = new TargetManager(this);
        PositionManager = new PositionManager(this);
    }

    // ── IPhysicsObjHost accessors ──────────────────────────────────────────
    public uint Id { get; }
    public Position Position => _getPosition();
    public Vector3 Velocity => _getVelocity();
    public float Radius => _getRadius();
    public bool InContact => _inContact();
    public float? MinterpMaxSpeed => _minterpMaxSpeed();
    public double CurTime => _curTime();
    public double PhysicsTimerTime => _physicsTimerTime();

    /// <summary>The owned voyeur manager (retail
    /// <c>CPhysicsObj::target_manager</c>).</summary>
    public TargetManager TargetManager => _targetManager;

    /// <summary>R5-V3 — the owned <see cref="PositionManager"/> facade (retail
    /// <c>CPhysicsObj::position_manager</c>): sticky follow + (unarmed)
    /// constraint leash. Seam targets: <c>MoveToManager.StickTo/Unstick</c>,
    /// <c>MotionInterpreter.UnstickFromObject</c>, the per-tick
    /// <c>AdjustOffset</c>/<c>UseTime</c> drivers.</summary>
    public PositionManager PositionManager { get; }

    // ── IPhysicsObjHost fan-out / target-tracking seams ────────────────────
    public IPhysicsObjHost? GetObjectA(uint id) => _getObjectA(id);

    public void HandleUpdateTarget(TargetInfo info)
    {
        // Retail CPhysicsObj::HandleUpdateTarget (0x00512bc0) fan order:
        // MovementManager (the injected MoveToManager fan) first, then
        // PositionManager (@0x00512c1a — the R5-V3 sticky consumer).
        _handleUpdateTarget(info);
        PositionManager.HandleUpdateTarget(info);
    }
    public void InterruptCurrentMovement() => _interruptCurrentMovement();

    public void SetTarget(uint contextId, uint objectId, float radius, double quantum)
        => _targetManager.SetTarget(contextId, objectId, radius, quantum);

    public void ClearTarget() => _targetManager.ClearTarget();
    public void ReceiveTargetUpdate(TargetInfo info) => _targetManager.ReceiveUpdate(info);
    public void AddVoyeur(uint watcherId, float radius, double quantum)
        => _targetManager.AddVoyeur(watcherId, radius, quantum);
    public void RemoveVoyeur(uint watcherId) => _targetManager.RemoveVoyeur(watcherId);

    // ── per-tick driver + lifecycle (called by GameWindow) ─────────────────

    /// <summary>Retail <c>TargetManager::HandleTargetting</c> — the per-tick
    /// voyeur sweep (self-throttled to 0.5 s). Retail runs it unconditionally
    /// for every entity in <c>UpdateObjectInternal</c>, BEFORE the movement
    /// managers' <c>UseTime</c>.</summary>
    public void HandleTargetting() => _targetManager.HandleTargetting();

    /// <summary>Retail <c>CPhysicsObj::exit_world</c>'s
    /// <c>TargetManager::NotifyVoyeurOfEvent(ExitWorld)</c> — tell every
    /// watcher of this entity that it left the world (they drop the
    /// stick/moveto). Called on despawn before the host is removed from the
    /// registry.</summary>
    public void NotifyExitWorld() => _targetManager.NotifyVoyeurOfEvent(TargetStatus.ExitWorld);

    /// <summary>
    /// A Hidden object remains logically alive but is removed from the cell
    /// lookup/interaction surface. Retail's DetectionManager sends
    /// <c>LeftDetection</c> from <c>CObjCell::hide_object</c>; that manager is
    /// not ported yet, so the App bridges the same unavailability edge through
    /// the existing target fan-out. The non-Ok update tears down watcher
    /// MoveTo/Sticky consumers, and the watched-role table is cleared so an
    /// UnHide re-subscription receives a fresh initial snapshot. The object's
    /// own watcher role is deliberately preserved.
    /// </summary>
    public void NotifyHidden() =>
        _targetManager.NotifyVoyeurOfEventAndClear(TargetStatus.ExitWorld);

    /// <summary>R5-V3 (#171): retail <c>CPhysicsObj::teleport_hook</c>'s tail
    /// (0x00514ed0 @0x00514f1b-0x00514f28) — <c>TargetManager::ClearTarget</c>
    /// (drop this entity's OWN subscription) then
    /// <c>NotifyVoyeurOfEvent(Teleported)</c> (every entity watching THIS one
    /// drops its stick/moveto — <c>StickyManager::HandleUpdateTarget</c>'s
    /// non-Ok teardown path). Called after a teleport placement.</summary>
    public void NotifyTeleported()
    {
        _targetManager.ClearTarget();
        _targetManager.NotifyVoyeurOfEvent(TargetStatus.Teleported);
    }
}