Aetheria/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeSensorSimulation.cs
2026-07-17 09:38:21 +01:00

365 lines
17 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
#nullable enable
namespace GameCult.Aetheria.State.Verse
{
public static class AetheriaRuntimeSensorSimulation
{
public static void StepZone(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
IReadOnlyList<AetheriaRuntimeDaemonSensorPingIntent>? pingIntents,
AetheriaRuntimeCatalogSnapshot? catalog,
double deltaSeconds,
double targetInfoDecay,
double detectionThreshold,
long frameId,
double secureAreaRadiusMultiplier = 0.425)
{
if (catalog == null || deltaSeconds <= 0)
return;
foreach (var observer in entities)
{
if (observer == null || !observer.IsActive)
continue;
var contacts = (observer.Contacts ?? Array.Empty<AetheriaRuntimeEntityContactCommit>())
.Where(contact => contact != null)
.ToDictionary(contact => contact.TargetEntityIndex);
var previouslyVisible = contacts.Values
.Where(contact => contact.Visible)
.Select(contact => contact.TargetEntityIndex)
.ToHashSet();
var sensors = AetheriaRuntimeEquippedBehaviorQueries.FindOperational(
observer, catalog, AetheriaRuntimeBehaviorKinds.Sensor);
var pingRequested = (pingIntents ?? Array.Empty<AetheriaRuntimeDaemonSensorPingIntent>())
.Any(intent => intent != null && ActorMatches(
intent.ActorEntityKey, zone.ZoneIndex, observer.EntityIndex));
if (pingRequested && sensors.Count > 0)
TryStartPing(run, zone, observer, sensors[sensors.Count - 1], catalog, frameId);
foreach (var sensor in sensors)
StepSensor(run, zone, observer, sensor, entities, contacts, catalog,
deltaSeconds, targetInfoDecay, secureAreaRadiusMultiplier, frameId);
observer.Contacts = entities
.Where(target => target != null && target.EntityIndex != observer.EntityIndex)
.Select(target =>
{
contacts.TryGetValue(target.EntityIndex, out var current);
var information = Clamp01(current?.InfoGathered ?? 0);
return new AetheriaRuntimeEntityContactCommit
{
TargetEntityIndex = target.EntityIndex,
InfoGathered = information,
Hostile = Hostile(
run, zone, entities, catalog, observer, target,
secureAreaRadiusMultiplier),
Visible = information > detectionThreshold
};
})
.OrderBy(contact => contact.TargetEntityIndex)
.ToArray();
if (observer.TargetEntityIndex >= 0 &&
previouslyVisible.Contains(observer.TargetEntityIndex) &&
!observer.Contacts.Any(contact =>
contact.TargetEntityIndex == observer.TargetEntityIndex && contact.Visible))
observer.TargetEntityIndex = -1;
}
}
private static void TryStartPing(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
AetheriaRuntimeEntitySnapshotCommit observer,
AetheriaRuntimeEquippedBehavior sensor,
AetheriaRuntimeCatalogSnapshot catalog,
long frameId)
{
if (sensor.State.PingCooldown >= 0)
return;
var thermal = ThermalPerformance(observer, sensor.EquipmentIndex);
if (!AetheriaRuntimeEnergySimulation.TryConsume(
observer, catalog, Math.Max(0, sensor.EvaluateStat(6, thermal))))
return;
sensor.State.Pinging = true;
sensor.State.PingCooldown = 1;
sensor.State.PingLerp = 0;
sensor.State.PingRadius = 0;
sensor.State.PingedEntityIndices = Array.Empty<int>();
sensor.State.PingedEntityCount = 0;
AetheriaRuntimeVisibilitySimulation.SetTransientSource(
observer,
$"sensor:{sensor.EquipmentIndex}:{sensor.BehaviorIndex}",
sensor.EvaluateStat(7, thermal));
AppendPingEvent(run, zone, observer, sensor, frameId, "sensor.ping.started");
}
private static void StepSensor(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
AetheriaRuntimeEntitySnapshotCommit observer,
AetheriaRuntimeEquippedBehavior sensor,
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
IDictionary<int, AetheriaRuntimeEntityContactCommit> contacts,
AetheriaRuntimeCatalogSnapshot catalog,
double deltaSeconds,
double targetInfoDecay,
double secureAreaRadiusMultiplier,
long frameId)
{
var thermal = ThermalPerformance(observer, sensor.EquipmentIndex);
if (sensor.State.Pinging)
{
var duration = Math.Max(0.000001, ReadNumber(sensor, 10, 2));
var exponent = ReadNumber(sensor, 11, 0.5);
sensor.State.PingLerp += deltaSeconds / duration;
sensor.State.PingRadius = Math.Max(0, sensor.EvaluateStat(8, thermal)) *
Math.Pow(Math.Max(0, sensor.State.PingLerp), exponent);
if (sensor.State.PingLerp > 1)
{
sensor.State.Pinging = false;
AppendPingEvent(run, zone, observer, sensor, frameId, "sensor.ping.ended");
}
}
var cooldownDuration = Math.Max(0.000001, sensor.EvaluateStat(9, thermal));
sensor.State.PingCooldown -= deltaSeconds / cooldownDuration;
var pinged = new HashSet<int>(sensor.State.PingedEntityIndices ?? Array.Empty<int>());
var forward = SensorDirection(observer, sensor);
var sensitivity = Math.Max(0, sensor.EvaluateStat(3, thermal));
var pingBoost = Math.Max(0, sensor.EvaluateStat(5, thermal));
var curve = ReadCurveKeys(sensor, 4);
foreach (var target in entities)
{
if (target == null || target.EntityIndex == observer.EntityIndex)
continue;
var dx = target.PositionX - observer.PositionX;
var dz = target.PositionZ - observer.PositionZ;
var distance = Math.Sqrt(dx * dx + dz * dz);
var previous = contacts.TryGetValue(target.EntityIndex, out var contact)
? contact.InfoGathered
: 0;
double next;
if (!pinged.Contains(target.EntityIndex) && distance < sensor.State.PingRadius)
{
pinged.Add(target.EntityIndex);
next = Clamp01(previous + target.Visibility * sensitivity * pingBoost * distance);
}
else
{
var direction = Normalize(dx, dz, forward.X, forward.Y);
var angle = Math.Acos(Clamp(forward.X * direction.X + forward.Y * direction.Y, -1, 1));
var angularSensitivity = curve.Count == 0
? 0
: AetheriaRuntimeDaemonItemStatQueries.SampleCurve(curve, angle / Math.PI);
next = Clamp01(previous + target.Visibility * sensitivity * angularSensitivity *
deltaSeconds / Math.Max(0.000001, distance));
}
next *= 1 - Math.Max(0, targetInfoDecay) * deltaSeconds;
contacts[target.EntityIndex] = new AetheriaRuntimeEntityContactCommit
{
TargetEntityIndex = target.EntityIndex,
InfoGathered = next,
Hostile = Hostile(
run, zone, entities, catalog, observer, target,
secureAreaRadiusMultiplier)
};
}
sensor.State.PingedEntityIndices = pinged.OrderBy(index => index).ToArray();
sensor.State.PingedEntityCount = pinged.Count;
}
private static IReadOnlyList<AetheriaRuntimeCurveKey> ReadCurveKeys(
AetheriaRuntimeEquippedBehavior behavior,
int key)
{
var value = (behavior.Payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
.FirstOrDefault(field => field != null && field.Key == key)?.Value;
return ExtractCurveKeys(value).ToArray();
}
private static IEnumerable<AetheriaRuntimeCurveKey> ExtractCurveKeys(
AetheriaRuntimeBehaviorValue? value)
{
var children = value?.Children ?? Array.Empty<AetheriaRuntimeBehaviorValue>();
if (children.Count >= 4 && children.Take(4).All(child =>
child != null && string.Equals(child.Kind, "number", StringComparison.OrdinalIgnoreCase)))
{
yield return new AetheriaRuntimeCurveKey(
children[0].NumberValue,
children[1].NumberValue,
children[2].NumberValue,
children[3].NumberValue);
yield break;
}
foreach (var child in children)
foreach (var key in ExtractCurveKeys(child))
yield return key;
}
private static (double X, double Y) SensorDirection(
AetheriaRuntimeEntitySnapshotCommit observer,
AetheriaRuntimeEquippedBehavior sensor)
{
var direction = Normalize(observer.DirectionX, observer.DirectionY, 0, 1);
return AetheriaRuntimeEquipmentRotation.RotateQuarter(
direction.X,
direction.Y,
AetheriaRuntimeEquipmentRotation.QuarterTurns(sensor.Slot.Rotation));
}
private static double ReadNumber(
AetheriaRuntimeEquippedBehavior behavior,
int key,
double fallback)
{
var value = (behavior.Payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
.FirstOrDefault(field => field != null && field.Key == key)?.Value;
return value == null || !double.IsFinite(value.NumberValue) ? fallback : value.NumberValue;
}
private static void AppendPingEvent(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
AetheriaRuntimeEntitySnapshotCommit observer,
AetheriaRuntimeEquippedBehavior sensor,
long frameId,
string kind)
{
AetheriaRuntimeGameEvents.Append(run, new AetheriaRuntimeGameEventCommit
{
EventId = $"{kind}:{zone.ZoneIndex}:{observer.EntityIndex}:{sensor.EquipmentIndex}:{frameId}",
Kind = kind,
FrameId = frameId,
ZoneIndex = zone.ZoneIndex,
SourceEntityIndex = observer.EntityIndex,
SubjectKey = sensor.Item.ItemKey
});
}
private static bool ActorMatches(string actorEntityKey, int zoneIndex, int entityIndex) =>
AetheriaRuntimeRunCheckpointCommit.TryParseEntityKey(
actorEntityKey, out var actorZoneIndex, out var actorEntityIndex) &&
actorZoneIndex == zoneIndex && actorEntityIndex == entityIndex;
private static double ThermalPerformance(AetheriaRuntimeEntitySnapshotCommit entity, int equipmentIndex) =>
(entity.EquipmentStates ?? Array.Empty<AetheriaRuntimeEquipmentStateCommit>())
.FirstOrDefault(state => state != null && state.EquipmentIndex == equipmentIndex)?
.ThermalPerformance ?? 1;
private static bool Hostile(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
AetheriaRuntimeCatalogSnapshot catalog,
AetheriaRuntimeEntitySnapshotCommit left,
AetheriaRuntimeEntitySnapshotCommit right,
double secureAreaRadiusMultiplier)
{
var ownerKey = zone.OwnerFactionIndex >= 0 &&
zone.OwnerFactionIndex < (catalog.Corporations?.Count ?? 0)
? catalog.Corporations[zone.OwnerFactionIndex].CorporationKey ?? ""
: "";
if (string.IsNullOrWhiteSpace(ownerKey))
return LegacyHostile(left, right);
return OwnerRejects(run, zone, entities, left, right, ownerKey, secureAreaRadiusMultiplier) ||
OwnerRejects(run, zone, entities, right, left, ownerKey, secureAreaRadiusMultiplier);
}
private static bool OwnerRejects(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
AetheriaRuntimeEntitySnapshotCommit ownerEntity,
AetheriaRuntimeEntitySnapshotCommit visitor,
string ownerKey,
double secureAreaRadiusMultiplier)
{
if (!string.Equals(ownerEntity.FactionKey, ownerKey, StringComparison.OrdinalIgnoreCase))
return false;
var relationship = RelationshipTo(run, zone, visitor, ownerKey);
var security = LocalSecurity(
entities, visitor.PositionX, visitor.PositionZ, ownerKey, secureAreaRadiusMultiplier);
return relationship - security <= 0;
}
private static int RelationshipTo(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeZoneSnapshotCommit zone,
AetheriaRuntimeEntitySnapshotCommit entity,
string factionKey)
{
if (string.Equals(entity.FactionKey, factionKey, StringComparison.OrdinalIgnoreCase))
return 4;
if (AetheriaRuntimeRunCheckpointCommit.TryParseEntityKey(
run.CurrentEntityKey, out var playerZoneIndex, out var playerEntityIndex) &&
playerZoneIndex == zone.ZoneIndex && playerEntityIndex == entity.EntityIndex)
{
var relationship = (run.FactionRelationships ?? Array.Empty<AetheriaRuntimeFactionRelationshipCommit>())
.FirstOrDefault(value => value != null &&
string.Equals(value.FactionKey, factionKey, StringComparison.OrdinalIgnoreCase));
return RelationshipValue(relationship?.Relationship);
}
return 2;
}
private static int LocalSecurity(
IReadOnlyList<AetheriaRuntimeEntitySnapshotCommit> entities,
double positionX,
double positionZ,
string ownerKey,
double secureAreaRadiusMultiplier)
{
var security = 0;
foreach (var entity in entities)
{
if (entity == null || entity.SecurityRadius <= 1 ||
!string.Equals(entity.FactionKey, ownerKey, StringComparison.OrdinalIgnoreCase))
continue;
var dx = entity.PositionX - positionX;
var dz = entity.PositionZ - positionZ;
var radius = entity.SecurityRadius * secureAreaRadiusMultiplier;
if (dx * dx + dz * dz < radius * radius)
security = Math.Max(security, entity.SecurityLevel);
}
return security;
}
private static int RelationshipValue(string? relationship)
{
if (string.Equals(relationship, "Hated", StringComparison.OrdinalIgnoreCase)) return 0;
if (string.Equals(relationship, "Hostile", StringComparison.OrdinalIgnoreCase)) return 1;
if (string.Equals(relationship, "Friendly", StringComparison.OrdinalIgnoreCase)) return 3;
if (string.Equals(relationship, "Beloved", StringComparison.OrdinalIgnoreCase)) return 4;
return 2;
}
private static bool LegacyHostile(
AetheriaRuntimeEntitySnapshotCommit left,
AetheriaRuntimeEntitySnapshotCommit right) =>
string.Equals(left.FactionKey, "player", StringComparison.OrdinalIgnoreCase) !=
string.Equals(right.FactionKey, "player", StringComparison.OrdinalIgnoreCase) &&
(string.Equals(left.FactionKey, "raider", StringComparison.OrdinalIgnoreCase) ||
string.Equals(right.FactionKey, "raider", StringComparison.OrdinalIgnoreCase));
private static (double X, double Y) Normalize(
double x, double y, double fallbackX, double fallbackY)
{
var length = Math.Sqrt(x * x + y * y);
return length <= 0.000001 ? (fallbackX, fallbackY) : (x / length, y / length);
}
private static double Clamp01(double value) => Clamp(value, 0, 1);
private static double Clamp(double value, double minimum, double maximum) =>
value < minimum ? minimum : value > maximum ? maximum : value;
}
}