677 lines
17 KiB
C#
677 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace IdleSpectator;
|
|
|
|
/// <summary>Evaluates whether an interest scene is still "live" for protection.</summary>
|
|
public static class InterestCompletion
|
|
{
|
|
public static bool IsActive(InterestCandidate candidate, float sessionStartedAt, float now)
|
|
{
|
|
if (candidate == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (candidate.ForceActive)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!candidate.HasValidPosition)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float age = now - sessionStartedAt;
|
|
if (age >= candidate.MaxWatch)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (candidate.Completion)
|
|
{
|
|
case InterestCompletionKind.Manual:
|
|
return age < candidate.MaxWatch;
|
|
|
|
case InterestCompletionKind.FixedDwell:
|
|
// Hold the authored MaxWatch window (director floors this to minCameraDwell).
|
|
return age < Mathf.Max(candidate.MinWatch, candidate.MaxWatch);
|
|
|
|
case InterestCompletionKind.CombatActive:
|
|
return CombatStillActive(candidate);
|
|
|
|
case InterestCompletionKind.WarFront:
|
|
return WarFrontStillActive(candidate);
|
|
|
|
case InterestCompletionKind.PlotActive:
|
|
return PlotStillActive(candidate);
|
|
|
|
case InterestCompletionKind.FamilyPack:
|
|
return FamilyPackStillActive(candidate);
|
|
|
|
case InterestCompletionKind.StatusOutbreak:
|
|
return StatusOutbreakStillActive(candidate);
|
|
|
|
case InterestCompletionKind.ActivityActive:
|
|
return ActivityStillActive(candidate);
|
|
|
|
case InterestCompletionKind.HappinessGrief:
|
|
return GriefStillActive(candidate);
|
|
|
|
case InterestCompletionKind.StatusPhase:
|
|
return StatusStillActive(candidate);
|
|
|
|
case InterestCompletionKind.CharacterVignette:
|
|
return VignetteStillActive(candidate, age);
|
|
|
|
default:
|
|
return age < candidate.MinWatch;
|
|
}
|
|
}
|
|
|
|
private static bool CombatStillActive(InterestCandidate c)
|
|
{
|
|
Actor unit = c.FollowUnit;
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float now = Time.unscaledTime;
|
|
bool hot = false;
|
|
try
|
|
{
|
|
if (unit.has_attack_target)
|
|
{
|
|
hot = true;
|
|
}
|
|
else if (unit.hasTask() && unit.ai?.task != null
|
|
&& (unit.ai.task.in_combat || unit.ai.task.is_fireman))
|
|
{
|
|
hot = true;
|
|
}
|
|
else if (RelatedStillFightingUs(c, unit))
|
|
{
|
|
hot = true;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
if (!hot && c.AssetId == "live_battle")
|
|
{
|
|
InterestEvent battle = WorldActivityScanner.FindHottestBattle();
|
|
hot = battle != null;
|
|
}
|
|
|
|
if (hot)
|
|
{
|
|
// Refresh so brief attack_target gaps do not clear reason / open quiet grace.
|
|
c.LastSeenAt = now;
|
|
return true;
|
|
}
|
|
|
|
// Hysteresis: WorldBox clears attack_target between swings.
|
|
const float combatHysteresisSeconds = 8f;
|
|
return now - c.LastSeenAt < combatHysteresisSeconds;
|
|
}
|
|
|
|
private static bool WarFrontStillActive(InterestCandidate c)
|
|
{
|
|
if (c == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float now = Time.unscaledTime;
|
|
if (!c.HasStickyCombatSides)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Promote path may briefly clear follow; keep hot while sides resolve.
|
|
if (!c.HasFollowUnit)
|
|
{
|
|
return now - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
Kingdom a = LiveEnsemble.FindKingdomByKey(c.CombatSideAKey);
|
|
Kingdom b = LiveEnsemble.FindKingdomByKey(c.CombatSideBKey);
|
|
bool sidesLive = (a != null || b != null);
|
|
if (!sidesLive && !string.IsNullOrEmpty(c.CorrelationKey))
|
|
{
|
|
sidesLive = TryResolveWarStillActive(c.CorrelationKey);
|
|
}
|
|
|
|
if (sidesLive)
|
|
{
|
|
c.LastSeenAt = now;
|
|
return true;
|
|
}
|
|
|
|
return now - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
private static bool PlotStillActive(InterestCandidate c)
|
|
{
|
|
if (c == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float now = Time.unscaledTime;
|
|
if (!c.HasStickyCombatSides)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!c.HasFollowUnit)
|
|
{
|
|
return now - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
// PlotCell sticky needs a real conspiracy cell (2+ plotters). Solo leftovers end.
|
|
int plotters = 0;
|
|
LiveSceneStickyState sticky = c.Sticky;
|
|
if (sticky != null)
|
|
{
|
|
for (int i = 0; i < sticky.SideAIds.Count; i++)
|
|
{
|
|
Actor unit = LiveEnsemble.FindTrackedActor(sticky.SideAIds[i]);
|
|
if (unit != null && unit.isAlive())
|
|
{
|
|
plotters++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (plotters < 2 && !string.IsNullOrEmpty(c.CorrelationKey))
|
|
{
|
|
plotters = Math.Max(plotters, CountLivePlotters(c.CorrelationKey));
|
|
}
|
|
|
|
// Harness may pin SideACount above the enrolled roster size.
|
|
if (plotters < 2 && sticky != null && sticky.SideACount >= 2 && sticky.SideAIds.Count >= 2)
|
|
{
|
|
plotters = sticky.SideACount;
|
|
}
|
|
|
|
if (plotters >= 2)
|
|
{
|
|
c.LastSeenAt = now;
|
|
return true;
|
|
}
|
|
|
|
return now - c.LastSeenAt < 4f;
|
|
}
|
|
|
|
private static bool FamilyPackStillActive(InterestCandidate c)
|
|
{
|
|
if (c == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float now = Time.unscaledTime;
|
|
if (!c.HasStickyCombatSides)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!c.HasFollowUnit)
|
|
{
|
|
return now - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
// Pack scenes need a real pack (2+). Solo leftovers end into quiet grace.
|
|
int members = CountLivingPackMembers(c);
|
|
if (members < 2 && !string.IsNullOrEmpty(c.CorrelationKey))
|
|
{
|
|
members = TryResolveFamilyMemberCount(c.CorrelationKey);
|
|
}
|
|
|
|
if (members >= 2)
|
|
{
|
|
c.LastSeenAt = now;
|
|
return true;
|
|
}
|
|
|
|
return now - c.LastSeenAt < 4f;
|
|
}
|
|
|
|
private static int CountLivingPackMembers(InterestCandidate c)
|
|
{
|
|
LiveSceneStickyState sticky = c?.Sticky;
|
|
if (sticky == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int members = 0;
|
|
for (int i = 0; i < sticky.SideAIds.Count; i++)
|
|
{
|
|
Actor unit = LiveEnsemble.FindTrackedActor(sticky.SideAIds[i]);
|
|
if (unit != null && unit.isAlive())
|
|
{
|
|
members++;
|
|
}
|
|
}
|
|
|
|
return members;
|
|
}
|
|
|
|
private static int TryResolveFamilyMemberCount(string familyKey)
|
|
{
|
|
if (string.IsNullOrEmpty(familyKey) || World.world?.families == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (Family family in World.world.families)
|
|
{
|
|
if (family == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string id = "";
|
|
try
|
|
{
|
|
id = family.getID().ToString();
|
|
}
|
|
catch
|
|
{
|
|
id = "";
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(id) || familyKey.IndexOf(id, StringComparison.Ordinal) < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
return family.countUnits();
|
|
}
|
|
catch
|
|
{
|
|
var members = new System.Collections.Generic.List<Actor>(4);
|
|
LiveEnsemble.CollectFamilyUnits(family, members);
|
|
return members.Count;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static bool TryResolvePlotStillActive(string plotKey)
|
|
{
|
|
if (string.IsNullOrEmpty(plotKey) || World.world?.plots == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (Plot plot in World.world.plots)
|
|
{
|
|
if (plot == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string id = "";
|
|
try
|
|
{
|
|
id = plot.getID().ToString();
|
|
}
|
|
catch
|
|
{
|
|
id = "";
|
|
}
|
|
|
|
string assetId = "";
|
|
try
|
|
{
|
|
PlotAsset asset = plot.getAsset();
|
|
if (asset != null)
|
|
{
|
|
assetId = asset.id ?? "";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
assetId = "";
|
|
}
|
|
|
|
bool match = (!string.IsNullOrEmpty(id) && plotKey.IndexOf(id, StringComparison.Ordinal) >= 0)
|
|
|| (!string.IsNullOrEmpty(assetId)
|
|
&& plotKey.IndexOf(assetId, StringComparison.OrdinalIgnoreCase) >= 0);
|
|
if (!match)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!plot.isActive())
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// treat as active when isActive is unavailable
|
|
}
|
|
|
|
return CountPlotUnits(plot) >= 2;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static int CountLivePlotters(string plotKey)
|
|
{
|
|
if (string.IsNullOrEmpty(plotKey) || World.world?.plots == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (Plot plot in World.world.plots)
|
|
{
|
|
if (plot == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string id = "";
|
|
try
|
|
{
|
|
id = plot.getID().ToString();
|
|
}
|
|
catch
|
|
{
|
|
id = "";
|
|
}
|
|
|
|
string assetId = "";
|
|
try
|
|
{
|
|
PlotAsset asset = plot.getAsset();
|
|
if (asset != null)
|
|
{
|
|
assetId = asset.id ?? "";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
assetId = "";
|
|
}
|
|
|
|
bool match = (!string.IsNullOrEmpty(id) && plotKey.IndexOf(id, StringComparison.Ordinal) >= 0)
|
|
|| (!string.IsNullOrEmpty(assetId)
|
|
&& plotKey.IndexOf(assetId, StringComparison.OrdinalIgnoreCase) >= 0);
|
|
if (!match)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return CountPlotUnits(plot);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static int CountPlotUnits(Plot plot)
|
|
{
|
|
if (plot == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var units = new List<Actor>(8);
|
|
LiveEnsemble.CollectPlotUnits(plot, units);
|
|
try
|
|
{
|
|
Actor author = plot.getAuthor();
|
|
if (author != null && author.isAlive() && !units.Contains(author))
|
|
{
|
|
units.Add(author);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
int n = 0;
|
|
for (int i = 0; i < units.Count; i++)
|
|
{
|
|
if (units[i] != null && units[i].isAlive())
|
|
{
|
|
n++;
|
|
}
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
private static bool TryResolveWarStillActive(string warKey)
|
|
{
|
|
if (string.IsNullOrEmpty(warKey) || World.world?.wars == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (War war in World.world.wars)
|
|
{
|
|
if (war == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string id = "";
|
|
try
|
|
{
|
|
id = war.getID().ToString();
|
|
}
|
|
catch
|
|
{
|
|
id = "";
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(id) && warKey.IndexOf(id, StringComparison.Ordinal) >= 0)
|
|
{
|
|
try
|
|
{
|
|
return war.isAlive();
|
|
}
|
|
catch
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool RelatedStillFightingUs(InterestCandidate c, Actor unit)
|
|
{
|
|
Actor foe = c.RelatedUnit;
|
|
if (foe == null || !foe.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!foe.has_attack_target || foe.attack_target == null || !foe.attack_target.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!foe.attack_target.isActor())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return foe.attack_target.a == unit;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool ActivityStillActive(InterestCandidate c)
|
|
{
|
|
Actor unit = c.FollowUnit;
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ActivityBand band = ActivityInterestTable.Classify(unit);
|
|
return band >= ActivityBand.Warm || unit.has_attack_target;
|
|
}
|
|
|
|
private static bool GriefStillActive(InterestCandidate c)
|
|
{
|
|
Actor survivor = c.FollowUnit;
|
|
if (survivor == null || !survivor.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(c.StatusId) && HasStatus(survivor, c.StatusId))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Short grief window after the happiness signal.
|
|
return Time.unscaledTime - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
private static bool StatusStillActive(InterestCandidate c)
|
|
{
|
|
Actor unit = c.FollowUnit;
|
|
if (unit == null || !unit.isAlive() || string.IsNullOrEmpty(c.StatusId))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return HasStatus(unit, c.StatusId);
|
|
}
|
|
|
|
private static bool StatusOutbreakStillActive(InterestCandidate c)
|
|
{
|
|
if (c == null || string.IsNullOrEmpty(c.StatusId))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float now = Time.unscaledTime;
|
|
if (!c.HasStickyCombatSides)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!c.HasFollowUnit)
|
|
{
|
|
return now - c.LastSeenAt < 8f;
|
|
}
|
|
|
|
// Outbreak stickies need a real cluster (2+). Solo leftovers end into quiet grace.
|
|
int carriers = 0;
|
|
LiveSceneStickyState sticky = c.Sticky;
|
|
if (sticky != null)
|
|
{
|
|
for (int i = 0; i < sticky.SideAIds.Count; i++)
|
|
{
|
|
Actor unit = LiveEnsemble.FindTrackedActor(sticky.SideAIds[i]);
|
|
if (unit != null && unit.isAlive() && HasStatus(unit, c.StatusId))
|
|
{
|
|
carriers++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (carriers < 2 && c.FollowUnit != null && HasStatus(c.FollowUnit, c.StatusId))
|
|
{
|
|
carriers = Math.Max(carriers, 1);
|
|
}
|
|
|
|
if (carriers >= 2)
|
|
{
|
|
c.LastSeenAt = now;
|
|
return true;
|
|
}
|
|
|
|
return now - c.LastSeenAt < 4f;
|
|
}
|
|
|
|
private static bool VignetteStillActive(InterestCandidate c, float age)
|
|
{
|
|
if (age < c.MinWatch)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Actor unit = c.FollowUnit;
|
|
if (unit == null || !unit.isAlive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Stay while still warm; cold ends after min watch.
|
|
return !WorldActivityScanner.IsFocusActivityCold(unit);
|
|
}
|
|
|
|
private static bool HasStatus(Actor actor, string statusId)
|
|
{
|
|
if (actor == null || string.IsNullOrEmpty(statusId))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
return actor.hasStatus(statusId);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|