177 lines
7.3 KiB
C#
177 lines
7.3 KiB
C#
using System.Numerics;
|
|
|
|
namespace GamePort.Game;
|
|
|
|
/// <summary>
|
|
/// Recovered player-contact button and vertical-door state machines. Contact
|
|
/// broadphase uses the recovered lookup magnitude; moving-object collision and material pulses
|
|
/// are separate, still incomplete consumers. See analysis/buttons-doors.md.
|
|
/// </summary>
|
|
public sealed class SceneMechanisms
|
|
{
|
|
private sealed class Button(DirectorActor actor)
|
|
{
|
|
public DirectorActor Actor = actor;
|
|
public bool Available;
|
|
public bool Down;
|
|
public float Cooldown;
|
|
}
|
|
private sealed class Door(DirectorActor actor)
|
|
{
|
|
public DirectorActor Actor = actor;
|
|
public Vector3 Origin = actor.SourceGam!.Position;
|
|
public bool Closed;
|
|
public float Remaining;
|
|
public float OpenElapsed;
|
|
public bool Looping;
|
|
public float Duration = actor.SourceGam!.Number("DoorSpeed", 1);
|
|
public float OpenTime = actor.SourceGam!.Number("OpenTime", 3);
|
|
public float Amount = actor.SourceGam!.Number("OpenAmount", 500);
|
|
}
|
|
private readonly SceneDirector director;
|
|
private readonly List<Button> buttons;
|
|
private readonly List<Door> doors;
|
|
private readonly HashSet<int> contacts = [];
|
|
private readonly HashSet<string> unsupported = [];
|
|
|
|
public IReadOnlyCollection<string> Unsupported => unsupported;
|
|
public event Action<DirectorActor, int, bool>? Sound; // Source bank index and loop flag.
|
|
public event Action<DirectorActor>? StopSound;
|
|
|
|
public SceneMechanisms(SceneDirector director)
|
|
{
|
|
this.director = director;
|
|
buttons = director.Actors.Where(a => a.Kind == "3BUT" && a.SourceGam != null).Select(a => new Button(a)).ToList();
|
|
doors = director.Actors.Where(a => a.Kind == "3DUD" && a.SourceGam != null).Select(a => new Door(a)).ToList();
|
|
foreach (var door in doors)
|
|
if (!float.IsFinite(door.Duration) || door.Duration <= 0 || !float.IsFinite(door.Amount)
|
|
|| !float.IsFinite(door.OpenTime)) throw new InvalidDataException("Invalid source door timing or displacement");
|
|
Reset();
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
contacts.Clear();
|
|
foreach (var button in buttons) ResetButton(button);
|
|
foreach (var door in doors)
|
|
{
|
|
if (door.Looping) StopSound?.Invoke(door.Actor);
|
|
door.Closed = door.Actor.SourceGam!.Integer("ItemClosed", 1) != 0;
|
|
door.Remaining = door.OpenElapsed = 0;
|
|
door.Looping = false;
|
|
door.Actor.Position = door.Origin + (door.Closed ? Vector3.Zero : Vector3.UnitY * door.Amount);
|
|
}
|
|
}
|
|
|
|
/// <summary>Player contact-enter only; holding overlap never presses repeatedly.</summary>
|
|
public void Update(Vector3 root, float radius = 60)
|
|
{
|
|
if (!Finite(root) || !float.IsFinite(radius) || radius < 0) throw new ArgumentOutOfRangeException(nameof(root));
|
|
foreach (var button in buttons)
|
|
{
|
|
var source = button.Actor.SourceGam!;
|
|
// EXE411EF0 PostLoad sets current radius300 after InitObject.
|
|
var overlap = button.Actor.Active && OriginalBodySupport.QuickMagnitude(root - button.Actor.Position) < radius + 300;
|
|
if (!overlap) { contacts.Remove(source.Offset); continue; }
|
|
if (contacts.Add(source.Offset)) Press(button);
|
|
}
|
|
}
|
|
|
|
public bool Toggle(DirectorActor actor, int requested)
|
|
{
|
|
var door = doors.Find(d => ReferenceEquals(d.Actor, actor));
|
|
if (door == null) return false;
|
|
var current = door.Closed ? 1 : 0;
|
|
if (current == requested) return true;
|
|
door.Remaining = door.Remaining > 0 ? door.Duration - door.Remaining : door.Duration;
|
|
if (!door.Looping)
|
|
{
|
|
door.Looping = true;
|
|
Sound?.Invoke(actor, 59, true);
|
|
}
|
|
var next = actor.SourceGam!.Text("Next");
|
|
if (!string.IsNullOrEmpty(next) && !Equal(next, "none"))
|
|
{
|
|
var target = director.FindActor(next);
|
|
if (target?.Kind == "3AIT") director.Trigger(next, actor.Tag);
|
|
else unsupported.Add($"Door {actor.Tag}: chained target {next} class execution is unrecovered");
|
|
}
|
|
door.Closed = requested switch { 0 => false, 1 => true, _ => !door.Closed };
|
|
return true;
|
|
}
|
|
|
|
public void Step(float dt)
|
|
{
|
|
if (!float.IsFinite(dt) || dt < 0 || dt > 1) throw new ArgumentOutOfRangeException(nameof(dt));
|
|
foreach (var button in buttons)
|
|
{
|
|
if (!button.Actor.Active || button.Cooldown <= 0) continue;
|
|
button.Cooldown -= dt;
|
|
if (button.Cooldown <= 0) ResetButton(button);
|
|
}
|
|
foreach (var door in doors)
|
|
{
|
|
if (!door.Actor.Active) continue;
|
|
if (door.Remaining > 0)
|
|
{
|
|
door.Remaining -= dt;
|
|
if (door.Remaining <= 0)
|
|
{
|
|
door.Remaining = 0;
|
|
door.Looping = false;
|
|
StopSound?.Invoke(door.Actor);
|
|
Sound?.Invoke(door.Actor, 58, false);
|
|
}
|
|
var fraction = door.Remaining / door.Duration;
|
|
if (!door.Closed) door.OpenElapsed = 0;
|
|
door.Actor.Position = door.Origin + Vector3.UnitY * door.Amount * (door.Closed ? fraction : 1 - fraction);
|
|
}
|
|
else if (!door.Closed)
|
|
{
|
|
door.OpenElapsed += dt;
|
|
if (door.OpenElapsed > door.OpenTime)
|
|
{
|
|
door.OpenElapsed = 0;
|
|
Toggle(door.Actor, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Press(Button button)
|
|
{
|
|
if (!button.Available || button.Cooldown > 0) return;
|
|
if (!button.Down)
|
|
{
|
|
button.Cooldown = 4; // EXE411C35.
|
|
var sound = button.Actor.SourceGam!.Integer("AvailSound", -1);
|
|
if (sound != -1) Sound?.Invoke(button.Actor, sound, false);
|
|
}
|
|
button.Down = !button.Down;
|
|
button.Actor.Animation = button.Down ? "DOWN" : "UP";
|
|
var targetName = button.Actor.SourceGam!.Text("ActivateButton");
|
|
if (string.IsNullOrEmpty(targetName) || Equal(targetName, "none")) return;
|
|
var target = director.FindActor(targetName);
|
|
if (target == null) return; // Original missing-tag lookup quietly returns.
|
|
var toggle = button.Actor.SourceGam.Integer("Toggle", -1);
|
|
if (!Toggle(target, toggle) && target.Kind != "3BUT")
|
|
unsupported.Add($"Button {button.Actor.Tag}: target {targetName} toggle is unrecovered");
|
|
if (button.Down && target.Kind == "3BUT")
|
|
{
|
|
var linked = buttons.Find(b => ReferenceEquals(b.Actor, target))!;
|
|
linked.Available = true;
|
|
button.Available = false;
|
|
}
|
|
}
|
|
|
|
private static void ResetButton(Button button)
|
|
{
|
|
button.Available = button.Actor.SourceGam!.Integer("ButtonAvailable", 1) != 0;
|
|
button.Down = !button.Available;
|
|
button.Cooldown = 0;
|
|
button.Actor.Animation = button.Down ? "DOWN" : "UP";
|
|
}
|
|
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);
|
|
}
|