Files

250 lines
11 KiB
C#

using System.Numerics;
namespace GamePort.Game;
/// <summary>Root state exchanged with the separately implemented body solver.</summary>
public readonly record struct PatrolBodyState(Vector3 Position, Vector3 Velocity);
/// <summary>
/// Goddard/Carl's ordinary state3 patrol and state7 waypoint wait. The original base
/// update consumes the preceding velocity/heading before choosing the next ones.
/// Physical collision/gravity are supplied by the caller. Magnitude uses the
/// recovered OMT table algorithm; flat atan2 heading and modern table-generation
/// trig still require comparison against original angle/x87 results.
/// See docs/analysis/patrol.md for recovered order, addresses and limitations.
/// </summary>
public sealed class ActorPatrol
{
public const float ArrivalDistance = 110;
public const float YawFactor = 3.2f;
private readonly DirectorActor actor;
private readonly Func<string, DirectorActor?> findActor;
private readonly Func<PatrolBodyState, float, PatrolBodyState> integrateBody;
private readonly Func<Vector3, float> magnitude;
private readonly float yawFactor;
private readonly string movingAnimation, waitingAnimation;
private DirectorActor? waypoint;
private DirectorActor? previousWaypoint;
private Vector3 publishedPosition, publishedRotation;
private string? publishedPatrol;
private int publishedState, previousState;
private float desiredYaw;
public Vector3 Velocity { get; private set; }
public Vector3 DestinationDelta { get; private set; }
public float DestinationDistance { get; private set; }
public bool Arrived { get; private set; }
public float WaitRemaining { get; private set; }
public string? CurrentWaypoint => waypoint?.Tag;
public string? PreviousWaypoint => previousWaypoint?.Tag;
public bool FollowPlayer {get;set;}
public bool SupportedState => actor.AIstate is 1 or 3 or 7 or 9 || actor.Kind == "3CAR" && actor.AIstate == 6 || FollowPlayer&&actor.Kind=="3DOG"&&actor.AIstate==4;
public ActorPatrol(DirectorActor actor, Func<string, DirectorActor?> findActor,
Func<PatrolBodyState, float, PatrolBodyState> integrateBody,
Func<Vector3, float>? magnitude = null)
{
ArgumentNullException.ThrowIfNull(actor);
ArgumentNullException.ThrowIfNull(findActor);
ArgumentNullException.ThrowIfNull(integrateBody);
if (actor.Kind is not ("3DOG" or "3CAR")) throw new ArgumentException("Recovered patrol requires Goddard or Carl", nameof(actor));
this.actor = actor;
this.findActor = findActor;
this.integrateBody = integrateBody;
this.magnitude = magnitude ?? OriginalBodySupport.QuickMagnitude;
// Carl413BFC..43 installs WALK/STOP; his Y factor remains3 (407CF8).
yawFactor = actor.Kind == "3DOG" ? YawFactor : 3;
movingAnimation = actor.Kind == "3DOG" ? "RUN" : "WALK";
waitingAnimation = actor.Kind == "3DOG" ? "WAG" : "STOP";
desiredYaw = actor.Rotation.Y;
Publish();
}
/// <summary>
/// Observe authored AI/teleport actions without changing their animation.
/// Teleports reset the port body's motion/route cache; their full original
/// physics bookkeeping is not yet recovered. Camera-only animation changes
/// leave the body and waypoint intact. Internal patrol changes emit no event.
/// </summary>
public void SynchronizeAuthoredState()
{
if (actor.Position != publishedPosition)
{
Velocity = Vector3.Zero;
ResetRoute();
desiredYaw = actor.Rotation.Y;
}
if (actor.Rotation != publishedRotation) desiredYaw = actor.Rotation.Y;
if (!Equal(actor.Patrol, publishedPatrol)
|| actor.AIstate != publishedState && actor.AIstate == 3)
ResetRoute();
Publish();
}
/// <returns>False when the current AI state lies outside this recovered subset.</returns>
public bool Step(float dt)
{
if (!float.IsFinite(dt) || dt < 0 || dt > 1) throw new ArgumentOutOfRangeException(nameof(dt));
SynchronizeAuthoredState();
if (!SupportedState) return false;
if (!actor.Active||!actor.MovementEnabled) return true;
if (!float.IsFinite(actor.Speed)) throw new InvalidOperationException("Nonfinite Goddard speed");
// EXE408023->40E050: the body consumes the *previous* velocity first.
var body = actor.BodyEnabled ? integrateBody(new(actor.Position, Velocity), dt) : new PatrolBodyState(actor.Position, Velocity);
if (!Finite(body.Position) || !Finite(body.Velocity))
throw new InvalidOperationException("Goddard body solver produced nonfinite state");
actor.Position = body.Position;
Velocity = body.Velocity;
if(FollowPlayer&&actor.Kind=="3DOG")
actor.Rotation=GoddardFacing(actor.Rotation,desiredYaw,dt);
else
{
var yawError = (desiredYaw - actor.Rotation.Y) % 360;
if (yawError > 180) yawError -= 360;
if (yawError < -180) yawError += 360;
actor.Rotation = actor.Rotation with { Y = actor.Rotation.Y + yawError * yawFactor * dt };
}
switch (actor.AIstate)
{
case 1: Velocity = Vector3.Zero; break; // EXE40835D, after body integration.
case 3: StepPatrol(); break;
case 4: StepFollow(); break;
case 7: StepWait(dt); break;
// State9 jumps directly to the common finisher408911. State6 calls
// sensing409CC0 first; source player-contact dispatch is implemented
// by SceneInteractions, while general FOV/visibility sensing is open.
case 6: case 9: break;
}
// States1/6/7 return before selecting a destination angle (409186..19B).
// Retain the old destination on a waypoint change, as the source does.
if (actor.AIstate is 3 or 4 && DestinationDelta.X * DestinationDelta.X + DestinationDelta.Z * DestinationDelta.Z > 0)
desiredYaw = MathF.Atan2(-DestinationDelta.X, DestinationDelta.Z) * (180 / MathF.PI);
Publish();
return true;
}
/// <summary>4096E0 with41C8DB Goddard factors and the ordinary supported
/// follow target (pitch/roll0). Dismount copies tilt; this later AI phase
/// gradually levels it. Full airborne AI target selection remains separate.</summary>
public static Vector3 GoddardFacing(Vector3 rotation,float yaw,float dt)
{
static float Arc(float delta)=>delta>180?delta-360:delta< -180?delta+360:delta;
var delta=new Vector3(Arc(-rotation.X)*.3f*dt,Arc(yaw-rotation.Y)*3.2f*dt,Arc(-rotation.Z)*.3f*dt);
return RocketOrientation.Add(rotation,delta);
}
private void StepFollow()
{
var target=findActor("JIM1");if(target==null||!target.Active)return;
DestinationDelta=target.Position-actor.Position;DestinationDistance=DestinationDelta.Length();
var length=magnitude(DestinationDelta);
float multiplier=DestinationDistance>=2000?3:DestinationDistance>=1000?1.7f:1;
Velocity=Arrived||length==0?Vector3.Zero:DestinationDelta/length*(actor.Speed*multiplier);
if(DestinationDistance<ArrivalDistance)Arrived=true;
else if(DestinationDistance>ArrivalDistance*1.5f)Arrived=false;
actor.Speed=DestinationDistance>440?600:450;
if(DestinationDistance>1500)
{
actor.Position=target.Position+RocketOrientation.Rotate(new(0,0,-800),target.Rotation);
Velocity=Vector3.Zero;
}
actor.Animation=magnitude(Velocity)>20?"RUN":"WAG";
}
private void StepPatrol()
{
waypoint ??= findActor(actor.Patrol ?? "none");
if (waypoint == null)
{
SetState(1);
Velocity = new(0, Velocity.Y, 0); // Missing initial waypoint preserves Y.
}
else
{
DestinationDelta = waypoint.Position - actor.Position;
DestinationDistance = DestinationDelta.Length();
if (!float.IsFinite(DestinationDistance)) throw new InvalidOperationException("Patrol destination exceeds finite arithmetic range");
}
// This remains after the waypoint resolver even if it changed state1.
actor.Animation = movingAnimation;
if (waypoint == null) return;
if (Arrived)
{
Velocity = Vector3.Zero;
actor.Animation = waitingAnimation;
}
else if (DestinationDelta == Vector3.Zero) Velocity = Vector3.Zero;
else
{
var length = magnitude(DestinationDelta);
if (!float.IsFinite(length) || length <= 0) throw new InvalidOperationException("Invalid patrol magnitude");
Velocity = DestinationDelta / length * actor.Speed;
}
// EXE408BC0 compares distance only after selecting the next velocity.
if (DestinationDistance < ArrivalDistance) Arrived = true;
else if (DestinationDistance > ArrivalDistance) Arrived = false;
if (!Arrived || waypoint.Kind != "3PAT" || waypoint.SourceGam is not { } point) return;
var wait = point.Number("WaitTime");
if (wait > 0)
{
SetState(7);
actor.Animation = point.Text("WaitAnim") ?? "none";
WaitRemaining = wait;
Velocity = Vector3.Zero;
return;
}
previousWaypoint = waypoint;
var next = point.Text("NextPatrolPoint") ?? "none";
waypoint = findActor(next);
if (waypoint != null) return;
if (Equal(next, "WAIT")) SetState(1);
else if (Equal(next, "SCAN")) SetState(6);
// Ordinary unresolved names, including "none", retain state3. Next tick
// resolves the initial PatrolPoint; there is no terminal-route snap.
}
private void StepWait(float dt)
{
Velocity = Vector3.Zero;
if (WaitRemaining <= 0) return; // Source checks positivity before subtract.
WaitRemaining -= dt;
if (WaitRemaining > 0) return; // Equality expires: EXE4083B0 testah41/je.
SetState(previousState);
Arrived = false;
// The timed-wait branch does not interpret WAIT/SCAN specially.
waypoint = waypoint?.SourceGam is { } point && waypoint.Kind == "3PAT"
? findActor(point.Text("NextPatrolPoint") ?? "none") : null;
}
private void SetState(int state)
{
previousState = actor.AIstate;
actor.AIstate = state;
if (state == 1) actor.Animation = waitingAnimation;
else if (state == 3) actor.Animation = movingAnimation;
}
private void ResetRoute()
{
waypoint = previousWaypoint = null;
Arrived = false;
WaitRemaining = 0;
DestinationDelta = Vector3.Zero;
DestinationDistance = 0;
}
private void Publish()
{
publishedPosition = actor.Position;
publishedRotation = actor.Rotation;
publishedPatrol = actor.Patrol;
publishedState = actor.AIstate;
}
private static bool Equal(string? a, string? b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
private static bool Finite(Vector3 v) => float.IsFinite(v.X) && float.IsFinite(v.Y) && float.IsFinite(v.Z);
}