1115 lines
45 KiB
C#
1115 lines
45 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace AnotherReplayReader.Utils
|
|
{
|
|
internal enum AIValidationSeverity
|
|
{
|
|
Info,
|
|
WeakEvidence,
|
|
Warning,
|
|
Contradiction,
|
|
Fatal
|
|
}
|
|
|
|
internal enum AIValidationIssueKind
|
|
{
|
|
InvalidMachineReadableClaims,
|
|
MissingMachineReadableClaims,
|
|
MissingAlternative,
|
|
WeakEvidence,
|
|
MissingEvidence,
|
|
InvalidEvidenceLevel,
|
|
UnitCapabilityContradiction,
|
|
UnitTimelineContradiction,
|
|
UnsupportedGameKnowledge,
|
|
OwnershipMissingEvidence,
|
|
OwnershipConflict,
|
|
OwnershipWeakConflict
|
|
}
|
|
|
|
internal enum AIEvidenceLevel
|
|
{
|
|
Confirmed,
|
|
HighlyLikely,
|
|
Possible,
|
|
Uncertain,
|
|
RuledOut
|
|
}
|
|
|
|
internal sealed record AIUnitClaim(
|
|
string UnitId,
|
|
string Player,
|
|
string Claim,
|
|
AIEvidenceLevel EvidenceLevel,
|
|
ImmutableArray<string> Evidence,
|
|
ImmutableArray<string> Alternatives,
|
|
ImmutableArray<string> NeedsConfirmation);
|
|
|
|
internal sealed record AIEventClaim(
|
|
string Claim,
|
|
AIEvidenceLevel EvidenceLevel,
|
|
ImmutableArray<string> Evidence);
|
|
|
|
internal sealed record AITimelineClaim(
|
|
string Claim,
|
|
AIEvidenceLevel EvidenceLevel,
|
|
ImmutableArray<string> Evidence);
|
|
|
|
internal sealed record AIMachineReadableClaims(
|
|
ImmutableArray<AIUnitClaim> UnitClaims,
|
|
ImmutableArray<AIEventClaim> EventClaims,
|
|
ImmutableArray<AITimelineClaim> TimelineClaims)
|
|
{
|
|
public static AIMachineReadableClaims Empty { get; } = new(
|
|
ImmutableArray<AIUnitClaim>.Empty,
|
|
ImmutableArray<AIEventClaim>.Empty,
|
|
ImmutableArray<AITimelineClaim>.Empty);
|
|
}
|
|
|
|
internal sealed record AIValidationIssue(
|
|
AIValidationSeverity Severity,
|
|
AIValidationIssueKind Kind,
|
|
string Message,
|
|
string? UnitId = null,
|
|
TimeSpan? Time = null);
|
|
|
|
internal sealed record AIValidationResult(
|
|
AIMachineReadableClaims Claims,
|
|
ImmutableArray<AIValidationIssue> Issues)
|
|
{
|
|
public static AIValidationResult Empty { get; } =
|
|
new(AIMachineReadableClaims.Empty, ImmutableArray<AIValidationIssue>.Empty);
|
|
|
|
// 除 Info 外，任何需要模型修正/降级的验证问题都触发一次隐藏修订；
|
|
// 一次修订后仍遗留的问题只记录，不再循环请求。
|
|
public bool RequiresRevision =>
|
|
Issues.Any(i => i.Severity is AIValidationSeverity.Contradiction
|
|
or AIValidationSeverity.Fatal
|
|
or AIValidationSeverity.Warning
|
|
or AIValidationSeverity.WeakEvidence);
|
|
|
|
public bool HasIssues => !Issues.IsEmpty;
|
|
}
|
|
|
|
internal static class AIAnalysisValidation
|
|
{
|
|
private static readonly Regex _jsonFenceRegex = new(
|
|
@"```(?:json)?\s*(\{[\s\S]*?\})\s*```",
|
|
RegexOptions.IgnoreCase | RegexOptions.Compiled);
|
|
|
|
public static AIValidationResult ValidateMachineReadableClaims(
|
|
string response,
|
|
ReplayFactIndex? factIndex = null,
|
|
IReadOnlyDictionary<string, int>? aiNameToPlayerIndex = null,
|
|
StructuredKnowledge? structuredKnowledge = null)
|
|
{
|
|
var issues = ImmutableArray.CreateBuilder<AIValidationIssue>();
|
|
var jsonBlocks = ExtractAllJsonObjects(response);
|
|
if (jsonBlocks.IsEmpty)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.MissingMachineReadableClaims,
|
|
"AI 未输出机器可读声明，无法进行自动验证。"));
|
|
return new AIValidationResult(AIMachineReadableClaims.Empty, issues.ToImmutable());
|
|
}
|
|
|
|
var claims = ParseClaims(jsonBlocks, issues);
|
|
if (claims is null)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Fatal,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
"所有机器可读声明块都无法解析，当前输出不可用于自动验证。"));
|
|
return new AIValidationResult(AIMachineReadableClaims.Empty, issues.ToImmutable());
|
|
}
|
|
|
|
ValidateClaimSelfConsistency(claims, issues);
|
|
ValidateUnpackAmbiguity(claims, issues);
|
|
if (factIndex is not null)
|
|
{
|
|
ValidateTimelineConsistency(claims, factIndex, aiNameToPlayerIndex, structuredKnowledge, issues);
|
|
ValidateSimpleClaimEvidence(claims, factIndex, issues);
|
|
}
|
|
return new AIValidationResult(claims, issues.ToImmutable());
|
|
}
|
|
|
|
public static string FormatIssues(ImmutableArray<AIValidationIssue> issues)
|
|
{
|
|
if (issues.IsEmpty)
|
|
{
|
|
return "未发现机器可读声明问题。";
|
|
}
|
|
|
|
var sb = new StringBuilder();
|
|
foreach (var issue in issues)
|
|
{
|
|
var unitText = string.IsNullOrWhiteSpace(issue.UnitId)
|
|
? string.Empty
|
|
: $" UnitId={issue.UnitId}";
|
|
sb.AppendLine($"[{issue.Severity}/{issue.Kind}]{unitText} {issue.Message}");
|
|
}
|
|
return sb.ToString().TrimEnd();
|
|
}
|
|
|
|
private static ImmutableArray<string> ExtractAllJsonObjects(string response)
|
|
{
|
|
var result = ImmutableArray.CreateBuilder<string>();
|
|
var markerIndex = response.LastIndexOf("[机器可读声明]", StringComparison.OrdinalIgnoreCase);
|
|
var searchText = markerIndex >= 0 ? response.Substring(markerIndex) : response;
|
|
|
|
var matches = _jsonFenceRegex.Matches(searchText);
|
|
if (matches.Count > 0)
|
|
{
|
|
foreach (Match match in matches)
|
|
{
|
|
result.Add(match.Groups[1].Value);
|
|
}
|
|
return result.ToImmutable();
|
|
}
|
|
|
|
// 回退：整段响应中所有 fenced JSON
|
|
var allMatches = _jsonFenceRegex.Matches(response);
|
|
if (allMatches.Count > 0)
|
|
{
|
|
foreach (Match match in allMatches)
|
|
{
|
|
result.Add(match.Groups[1].Value);
|
|
}
|
|
return result.ToImmutable();
|
|
}
|
|
|
|
var start = searchText.LastIndexOf('{');
|
|
var end = searchText.LastIndexOf('}');
|
|
if (start >= 0 && end > start)
|
|
{
|
|
result.Add(searchText.Substring(start, end - start + 1));
|
|
return result.ToImmutable();
|
|
}
|
|
|
|
return ImmutableArray<string>.Empty;
|
|
}
|
|
|
|
private static AIMachineReadableClaims? ParseClaims(
|
|
ImmutableArray<string> jsonBlocks,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
var mergedUnits = new Dictionary<string, AIUnitClaim>(StringComparer.OrdinalIgnoreCase);
|
|
var mergedEvents = new List<AIEventClaim>();
|
|
var mergedTimelines = new List<AITimelineClaim>();
|
|
var parsedAny = false;
|
|
|
|
foreach (var json in jsonBlocks)
|
|
{
|
|
try
|
|
{
|
|
using var doc = JsonDocument.Parse(json, new JsonDocumentOptions
|
|
{
|
|
AllowTrailingCommas = true,
|
|
CommentHandling = JsonCommentHandling.Skip
|
|
});
|
|
|
|
var root = doc.RootElement;
|
|
if (root.ValueKind != JsonValueKind.Object)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
"机器可读声明不是 JSON object。"));
|
|
continue;
|
|
}
|
|
|
|
parsedAny = true;
|
|
foreach (var unitClaim in ReadUnitClaims(root, issues))
|
|
{
|
|
mergedUnits[unitClaim.UnitId] = unitClaim;
|
|
}
|
|
foreach (var claim in ReadSimpleClaims(root, "eventClaims", issues)
|
|
.Select(c => new AIEventClaim(c.Claim, c.EvidenceLevel, c.Evidence)))
|
|
{
|
|
mergedEvents.Add(claim);
|
|
}
|
|
foreach (var claim in ReadSimpleClaims(root, "timelineClaims", issues)
|
|
.Select(c => new AITimelineClaim(c.Claim, c.EvidenceLevel, c.Evidence)))
|
|
{
|
|
mergedTimelines.Add(claim);
|
|
}
|
|
}
|
|
catch (JsonException ex)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"机器可读声明 JSON 解析失败：{ex.Message}"));
|
|
}
|
|
}
|
|
|
|
if (!parsedAny)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new AIMachineReadableClaims(
|
|
mergedUnits.Values.Take(MaxUnitClaims).ToImmutableArray(),
|
|
mergedEvents.Take(MaxEventClaims).ToImmutableArray(),
|
|
mergedTimelines.Take(MaxTimelineClaims).ToImmutableArray());
|
|
}
|
|
|
|
private const int MaxUnitClaims = 10;
|
|
private const int MaxEventClaims = 5;
|
|
private const int MaxTimelineClaims = 3;
|
|
|
|
private static ImmutableArray<AIUnitClaim> ReadUnitClaims(JsonElement root, ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
if (!TryGetArray(root, "unitClaims", out var unitClaims))
|
|
{
|
|
return ImmutableArray<AIUnitClaim>.Empty;
|
|
}
|
|
|
|
var result = ImmutableArray.CreateBuilder<AIUnitClaim>();
|
|
var totalCount = 0;
|
|
foreach (var item in unitClaims.EnumerateArray())
|
|
{
|
|
if (item.ValueKind != JsonValueKind.Object)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
totalCount++;
|
|
if (result.Count >= MaxUnitClaims)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
result.Add(new AIUnitClaim(
|
|
ReadFlexibleString(item, "unitId"),
|
|
ReadFlexibleString(item, "player"),
|
|
ReadFlexibleString(item, "claim"),
|
|
ReadEvidenceLevel(item, issues),
|
|
ReadStringArray(item, "evidence"),
|
|
ReadStringArray(item, "alternatives"),
|
|
ReadStringArray(item, "needsConfirmation")));
|
|
}
|
|
|
|
if (totalCount > MaxUnitClaims)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Info,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"unitClaims 包含 {totalCount} 条声明，仅处理前 {MaxUnitClaims} 条，其余已忽略。"));
|
|
}
|
|
|
|
return result.ToImmutable();
|
|
}
|
|
|
|
private sealed record SimpleClaim(
|
|
string Claim,
|
|
AIEvidenceLevel EvidenceLevel,
|
|
ImmutableArray<string> Evidence);
|
|
|
|
private static ImmutableArray<SimpleClaim> ReadSimpleClaims(JsonElement root, string propertyName, ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
if (!TryGetArray(root, propertyName, out var claims))
|
|
{
|
|
return ImmutableArray<SimpleClaim>.Empty;
|
|
}
|
|
|
|
var result = ImmutableArray.CreateBuilder<SimpleClaim>();
|
|
var maxClaims = propertyName switch
|
|
{
|
|
"eventClaims" => MaxEventClaims,
|
|
"timelineClaims" => MaxTimelineClaims,
|
|
_ => 50,
|
|
};
|
|
var totalCount = 0;
|
|
foreach (var item in claims.EnumerateArray())
|
|
{
|
|
if (item.ValueKind != JsonValueKind.Object)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
totalCount++;
|
|
if (result.Count >= maxClaims)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var claim = ReadFlexibleString(item, "claim");
|
|
if (string.IsNullOrWhiteSpace(claim) && propertyName == "eventClaims")
|
|
{
|
|
claim = ReadFlexibleString(item, "event");
|
|
}
|
|
|
|
result.Add(new SimpleClaim(
|
|
claim,
|
|
ReadEvidenceLevel(item, issues),
|
|
ReadStringArray(item, "evidence")));
|
|
}
|
|
|
|
if (totalCount > maxClaims)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Info,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"{propertyName} 包含 {totalCount} 条声明，仅处理前 {maxClaims} 条，其余已忽略。"));
|
|
}
|
|
|
|
return result.ToImmutable();
|
|
}
|
|
|
|
private static void ValidateClaimSelfConsistency(
|
|
AIMachineReadableClaims claims,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
foreach (var claim in claims.UnitClaims)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(claim.UnitId))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
"Unit claim 缺少 unitId。"));
|
|
}
|
|
if (string.IsNullOrWhiteSpace(claim.Claim))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
"Unit claim 缺少 claim。",
|
|
claim.UnitId));
|
|
}
|
|
if (claim.EvidenceLevel is AIEvidenceLevel.Confirmed or AIEvidenceLevel.HighlyLikely
|
|
&& claim.Evidence.IsEmpty)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.MissingEvidence,
|
|
"高置信 UnitId 推测缺少 evidence。",
|
|
claim.UnitId));
|
|
}
|
|
if (claim.EvidenceLevel is AIEvidenceLevel.Possible or AIEvidenceLevel.Uncertain
|
|
&& claim.Alternatives.IsEmpty
|
|
&& claim.NeedsConfirmation.IsEmpty)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.MissingAlternative,
|
|
"低置信 UnitId 推测应提供 alternatives 或 needsConfirmation。",
|
|
claim.UnitId));
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Structured evidence parsing
|
|
|
|
internal enum AIEvidenceType
|
|
{
|
|
Build,
|
|
Place,
|
|
Produce,
|
|
Sell,
|
|
Select,
|
|
Move,
|
|
Power,
|
|
Protocol,
|
|
Unknown
|
|
}
|
|
|
|
internal sealed record StructuredEvidence(
|
|
AIEvidenceType Type,
|
|
string Time,
|
|
ImmutableArray<string> Parameters,
|
|
string Raw)
|
|
{
|
|
public string? GetSpecialPowerName() =>
|
|
Type == AIEvidenceType.Power && Parameters.Length >= 1 ? Parameters[0] : null;
|
|
|
|
public string? GetTechName() =>
|
|
Type == AIEvidenceType.Protocol && Parameters.Length >= 1 ? Parameters[0] : null;
|
|
|
|
public string? GetUnitId() => Type switch
|
|
{
|
|
AIEvidenceType.Build or AIEvidenceType.Place when Parameters.Length >= 2 => Parameters[1],
|
|
AIEvidenceType.Produce when Parameters.Length >= 2 => Parameters[1],
|
|
AIEvidenceType.Power when Parameters.Length >= 2 => Parameters[1],
|
|
AIEvidenceType.Sell when Parameters.Length >= 1 => Parameters[0],
|
|
AIEvidenceType.Select when Parameters.Length >= 1 => Parameters[0],
|
|
_ => null,
|
|
};
|
|
|
|
public string? GetAssetName() => Type switch
|
|
{
|
|
AIEvidenceType.Build or AIEvidenceType.Place or AIEvidenceType.Produce
|
|
when Parameters.Length >= 1 => Parameters[0],
|
|
_ => null,
|
|
};
|
|
}
|
|
|
|
private static readonly Regex _structuredEvidenceRegex = new(
|
|
@"^(build|place|produce|sell|select|move|power|protocol)\|([^|]+(?:\|(?!\|).*)?)$",
|
|
RegexOptions.IgnoreCase | RegexOptions.Compiled);
|
|
|
|
internal static StructuredEvidence ParseStructuredEvidence(string text)
|
|
{
|
|
var match = _structuredEvidenceRegex.Match(text.Trim());
|
|
if (!match.Success)
|
|
{
|
|
return new StructuredEvidence(AIEvidenceType.Unknown, string.Empty, ImmutableArray<string>.Empty, text);
|
|
}
|
|
|
|
var type = match.Groups[1].Value.ToLowerInvariant() switch
|
|
{
|
|
"build" => AIEvidenceType.Build,
|
|
"place" => AIEvidenceType.Place,
|
|
"produce" => AIEvidenceType.Produce,
|
|
"sell" => AIEvidenceType.Sell,
|
|
"select" => AIEvidenceType.Select,
|
|
"move" => AIEvidenceType.Move,
|
|
"power" => AIEvidenceType.Power,
|
|
"protocol" => AIEvidenceType.Protocol,
|
|
_ => AIEvidenceType.Unknown,
|
|
};
|
|
|
|
var rest = match.Groups[2].Value;
|
|
var parts = rest.Split('|');
|
|
var time = parts.Length >= 1 ? parts[0].Trim() : string.Empty;
|
|
var parameters = parts.Skip(1).Select(p => p.Trim()).ToImmutableArray();
|
|
|
|
return new StructuredEvidence(type, time, parameters, text);
|
|
}
|
|
|
|
internal static ImmutableArray<StructuredEvidence> ParseAllEvidence(ImmutableArray<string> evidenceStrings)
|
|
{
|
|
return evidenceStrings
|
|
.Select(ParseStructuredEvidence)
|
|
.ToImmutableArray();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Validation rules
|
|
|
|
private static void ValidateUnpackAmbiguity(
|
|
AIMachineReadableClaims claims,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
foreach (var claim in claims.UnitClaims)
|
|
{
|
|
if (claim.EvidenceLevel is not (AIEvidenceLevel.Confirmed or AIEvidenceLevel.HighlyLikely))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var evidence = ParseAllEvidence(claim.Evidence);
|
|
var hasUnpack = evidence.Any(e =>
|
|
e.GetSpecialPowerName() is string p &&
|
|
p.IndexOf("UnpackReplaceSelf", StringComparison.OrdinalIgnoreCase) >= 0);
|
|
if (!hasUnpack)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var hasPack = evidence.Any(e =>
|
|
e.GetSpecialPowerName() is string p &&
|
|
p.IndexOf("PackReplaceSelf", StringComparison.OrdinalIgnoreCase) >= 0);
|
|
if (hasPack)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// 只有“基地车/主基地”这类同时具备 pack/unpack 的实体才存在 MCV vs 矿车的歧义；
|
|
// 矿车本身只有 unpack，不应被这条规则误伤。
|
|
if (!LooksLikeUnpackAmbiguousUnit(claim.Claim))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.MissingAlternative,
|
|
$"UnitId {claim.UnitId} 使用了 UnpackReplaceSelf 但证据中无对应 PackReplaceSelf。UnpackReplaceSelf 可能对应基地车展开或矿车展开成指挥中心，建议降低置信度或添加 alternative。",
|
|
claim.UnitId));
|
|
}
|
|
}
|
|
|
|
private static bool LooksLikeUnpackAmbiguousUnit(string claimText)
|
|
{
|
|
if (claimText.IndexOf("MCV", StringComparison.OrdinalIgnoreCase) >= 0
|
|
|| claimText.IndexOf("基地车", StringComparison.OrdinalIgnoreCase) >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var structured = StructuredKnowledge.Instance;
|
|
if (structured is not null)
|
|
{
|
|
foreach (var entity in structured.EntitiesWithTag(KnowledgeTag.Pack))
|
|
{
|
|
if (claimText.IndexOf(entity.AssetName, StringComparison.OrdinalIgnoreCase) >= 0
|
|
|| (!string.IsNullOrWhiteSpace(entity.DisplayName)
|
|
&& claimText.IndexOf(entity.DisplayName, StringComparison.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static void ValidateTimelineConsistency(
|
|
AIMachineReadableClaims claims,
|
|
ReplayFactIndex factIndex,
|
|
IReadOnlyDictionary<string, int>? aiNameToPlayerIndex,
|
|
StructuredKnowledge? structuredKnowledge,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
foreach (var claim in claims.UnitClaims)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(claim.UnitId))
|
|
{
|
|
continue;
|
|
}
|
|
if (!uint.TryParse(claim.UnitId, out var unitId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check 1: UnitId referenced in claim exists in the replay
|
|
if (!factIndex.UnitIdFirstObservedTime.ContainsKey(unitId))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"UnitId {claim.UnitId} 在回放数据中从未出现过，AI 可能编造了不存在的 UnitId。",
|
|
claim.UnitId));
|
|
continue;
|
|
}
|
|
|
|
var playerIndex = TryParsePlayerIndex(claim.Player, aiNameToPlayerIndex, out var parsed)
|
|
? parsed
|
|
: -1;
|
|
if (playerIndex < 0)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Info,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
"Unit claim 缺少可识别的 player，无法校验所有权与生产时间线。",
|
|
claim.UnitId));
|
|
}
|
|
|
|
// Check 2: Verify special power evidence against fact index
|
|
var evidence = ParseAllEvidence(claim.Evidence);
|
|
foreach (var ev in evidence)
|
|
{
|
|
if (ev.Type == AIEvidenceType.Protocol && playerIndex >= 0)
|
|
{
|
|
var techName = ev.GetTechName();
|
|
if (techName is not null
|
|
&& factIndex.PlayerTechChoices.TryGetValue(playerIndex, out var chosen)
|
|
&& !chosen.Contains(techName))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Contradiction,
|
|
AIValidationIssueKind.UnitCapabilityContradiction,
|
|
$"玩家 {claim.Player} 在回放中选择过的协议为：{string.Join(", ", chosen.OrderBy(x => x))}，但 AI 声称其选择了“{techName}”——该协议未观察到。",
|
|
claim.UnitId));
|
|
}
|
|
continue;
|
|
}
|
|
if (ev.Type != AIEvidenceType.Power)
|
|
{
|
|
continue;
|
|
}
|
|
var evUnitIdStr = ev.GetUnitId();
|
|
if (evUnitIdStr is null || !uint.TryParse(evUnitIdStr, out var evUnitId))
|
|
{
|
|
continue;
|
|
}
|
|
var powerName = ev.GetSpecialPowerName();
|
|
if (powerName is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Does this UnitId exist in the fact index?
|
|
if (!factIndex.UnitIdFirstObservedTime.ContainsKey(evUnitId))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Info,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"证据引用了回放中不存在的 UnitId {evUnitIdStr}。",
|
|
claim.UnitId));
|
|
continue;
|
|
}
|
|
|
|
// Did this UnitId actually use this special power?
|
|
if (factIndex.UnitIdSpecialPowers.TryGetValue(evUnitId, out var actualPowers))
|
|
{
|
|
if (!actualPowers.Contains(powerName))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Contradiction,
|
|
AIValidationIssueKind.UnitCapabilityContradiction,
|
|
$"UnitId {evUnitIdStr} 在回放中使用过以下特殊能力：{string.Join(", ", actualPowers.OrderBy(x => x))}，但 AI 声称其使用了“{powerName}”——此能力未在该 UnitId 上观察到。",
|
|
claim.UnitId));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.WeakEvidence,
|
|
$"UnitId {evUnitIdStr} 在回放中未观察到任何特殊能力，但 AI 声称其使用了“{powerName}”，证据不足。",
|
|
claim.UnitId));
|
|
}
|
|
}
|
|
|
|
// Check 3: UnitId used as builder vs claim
|
|
var isBuilderInReplay = factIndex.BuilderUnitIds.Contains(unitId);
|
|
var claimLooksLikeBuilder = ClaimLooksLikeBuilder(claim.Claim, structuredKnowledge);
|
|
if (claimLooksLikeBuilder && !isBuilderInReplay)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.UnitCapabilityContradiction,
|
|
$"AI 推测 UnitId {claim.UnitId} 是“{claim.Claim}”（推测是建造单位），但该 UnitId 在回放中从未作为建造者（建造建筑）出现。",
|
|
claim.UnitId));
|
|
}
|
|
|
|
// Check 4: 所有权证据（强/弱分层）
|
|
if (playerIndex >= 0)
|
|
{
|
|
ValidateOwnership(claim, unitId, playerIndex, factIndex, issues);
|
|
}
|
|
|
|
// Check 5: move 证据不能单独支撑高置信
|
|
if (claim.EvidenceLevel is AIEvidenceLevel.Confirmed or AIEvidenceLevel.HighlyLikely
|
|
&& !claim.Evidence.IsEmpty)
|
|
{
|
|
var parsedEvidence = ParseAllEvidence(claim.Evidence);
|
|
if (parsedEvidence.All(e => e.Type == AIEvidenceType.Move))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.WeakEvidence,
|
|
$"UnitId {claim.UnitId} 的高置信推测只使用 move 证据（不携带 UnitId，无法验证），建议降级或补充其他证据。",
|
|
claim.UnitId));
|
|
}
|
|
}
|
|
|
|
// Check 6: 首次出兵时间线（轰炸机类）
|
|
if (playerIndex >= 0)
|
|
{
|
|
ValidateFirstProductionTimeline(claim, unitId, playerIndex, factIndex, structuredKnowledge, issues);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>事件/时间线声明只有 claim + evidence，没有 player，因此只校验不依赖归属的事实。</summary>
|
|
private static void ValidateSimpleClaimEvidence(
|
|
AIMachineReadableClaims claims,
|
|
ReplayFactIndex factIndex,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
foreach (var claim in claims.EventClaims)
|
|
{
|
|
ValidateSimpleClaim(claim.Claim, claim.Evidence, "事件声明", factIndex, issues);
|
|
}
|
|
foreach (var claim in claims.TimelineClaims)
|
|
{
|
|
ValidateSimpleClaim(claim.Claim, claim.Evidence, "时间线声明", factIndex, issues);
|
|
}
|
|
}
|
|
|
|
private static void ValidateSimpleClaim(
|
|
string claimText,
|
|
ImmutableArray<string> evidenceStrings,
|
|
string kind,
|
|
ReplayFactIndex factIndex,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
foreach (var ev in ParseAllEvidence(evidenceStrings))
|
|
{
|
|
if (ev.Type == AIEvidenceType.Protocol)
|
|
{
|
|
var techName = ev.GetTechName();
|
|
if (string.IsNullOrWhiteSpace(techName))
|
|
{
|
|
continue;
|
|
}
|
|
var allTechChoices = new HashSet<string>(
|
|
factIndex.PlayerTechChoices.Values.SelectMany(set => set),
|
|
StringComparer.OrdinalIgnoreCase);
|
|
if (allTechChoices.Count > 0 && !allTechChoices.Contains(techName))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"{kind}“{claimText}”引用了未在任何玩家选择中观察到的协议“{techName}”。"));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (ev.Type == AIEvidenceType.Power)
|
|
{
|
|
var unitIdText = ev.GetUnitId();
|
|
if (unitIdText is null || !uint.TryParse(unitIdText, out var unitId))
|
|
{
|
|
continue;
|
|
}
|
|
var powerName = ev.GetSpecialPowerName();
|
|
if (string.IsNullOrWhiteSpace(powerName))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!factIndex.UnitIdFirstObservedTime.ContainsKey(unitId))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"{kind}“{claimText}”的证据引用了回放中不存在的 UnitId {unitIdText}。",
|
|
unitIdText));
|
|
continue;
|
|
}
|
|
|
|
if (factIndex.UnitIdSpecialPowers.TryGetValue(unitId, out var actualPowers))
|
|
{
|
|
if (!actualPowers.Contains(powerName))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Contradiction,
|
|
AIValidationIssueKind.UnitCapabilityContradiction,
|
|
$"{kind}“{claimText}”声称 UnitId {unitIdText} 使用了“{powerName}”，但该 UnitId 在回放中使用过：{string.Join("、", actualPowers.OrderBy(x => x))}。",
|
|
unitIdText));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.WeakEvidence,
|
|
$"{kind}“{claimText}”声称 UnitId {unitIdText} 使用了“{powerName}”，但该 UnitId 未观察到任何特殊能力。",
|
|
unitIdText));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (ev.Type is AIEvidenceType.Build
|
|
or AIEvidenceType.Place
|
|
or AIEvidenceType.Produce
|
|
or AIEvidenceType.Select
|
|
or AIEvidenceType.Sell)
|
|
{
|
|
var unitIdText = ev.GetUnitId();
|
|
if (unitIdText is null || !uint.TryParse(unitIdText, out var unitId))
|
|
{
|
|
continue;
|
|
}
|
|
if (!factIndex.UnitIdFirstObservedTime.ContainsKey(unitId))
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.InvalidMachineReadableClaims,
|
|
$"{kind}“{claimText}”的证据引用了回放中不存在的 UnitId {unitIdText}。",
|
|
unitIdText));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ValidateOwnership(
|
|
AIUnitClaim claim,
|
|
uint unitId,
|
|
int playerIndex,
|
|
ReplayFactIndex factIndex,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
var myStrong = factIndex.PlayerStrongOwnershipUnitIds.TryGetValue(playerIndex, out var strong)
|
|
&& strong.Contains(unitId);
|
|
var myWeak = factIndex.PlayerWeakOwnershipUnitIds.TryGetValue(playerIndex, out var weak)
|
|
&& weak.Contains(unitId);
|
|
|
|
// 规则 1：高置信但无任何所有权证据
|
|
if (claim.EvidenceLevel is AIEvidenceLevel.Confirmed or AIEvidenceLevel.HighlyLikely
|
|
&& !myStrong && !myWeak)
|
|
{
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.WeakEvidence,
|
|
AIValidationIssueKind.OwnershipMissingEvidence,
|
|
$"UnitId {claim.UnitId} 声称属于玩家 {claim.Player}，但回放中该玩家对它的强/弱所有权证据（编队、建造者、维修、出售、施法者、选择）均未观察到，建议降级。",
|
|
claim.UnitId));
|
|
}
|
|
|
|
// 规则 2/4：其他玩家的强证据 → 冲突
|
|
foreach (var kv in factIndex.PlayerStrongOwnershipUnitIds)
|
|
{
|
|
if (kv.Key == playerIndex || !kv.Value.Contains(unitId))
|
|
{
|
|
continue;
|
|
}
|
|
var message = myStrong
|
|
? $"UnitId {claim.UnitId} 同时存在玩家 {claim.Player} 与玩家 {kv.Key} 的强所有权证据（异常/作弊操作），无法判定归属。"
|
|
: $"UnitId {claim.UnitId} 声称属于玩家 {claim.Player}，但玩家 {kv.Key} 对它有强所有权证据（编队/建造者/维修/出售/施法者）。";
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Contradiction,
|
|
AIValidationIssueKind.OwnershipConflict,
|
|
message,
|
|
claim.UnitId));
|
|
break;
|
|
}
|
|
|
|
// 规则 3：仅其他玩家的弱证据，且己方无证据 → 警告
|
|
if (!myStrong && !myWeak)
|
|
{
|
|
foreach (var kv in factIndex.PlayerWeakOwnershipUnitIds)
|
|
{
|
|
if (kv.Key == playerIndex || !kv.Value.Contains(unitId))
|
|
{
|
|
continue;
|
|
}
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Warning,
|
|
AIValidationIssueKind.OwnershipWeakConflict,
|
|
$"UnitId {claim.UnitId} 声称属于玩家 {claim.Player}，但玩家 {kv.Key} 选中过它（可能只是点击敌方单位查看血量，不能完全排除），建议降置信度。",
|
|
claim.UnitId));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ValidateFirstProductionTimeline(
|
|
AIUnitClaim claim,
|
|
uint unitId,
|
|
int playerIndex,
|
|
ReplayFactIndex factIndex,
|
|
StructuredKnowledge? structuredKnowledge,
|
|
ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
if (claim.EvidenceLevel is not (AIEvidenceLevel.Confirmed or AIEvidenceLevel.HighlyLikely))
|
|
{
|
|
return;
|
|
}
|
|
if (!factIndex.UnitIdFirstObservedTime.TryGetValue(unitId, out var firstObserved))
|
|
{
|
|
return;
|
|
}
|
|
if (!factIndex.PlayerFirstProductionTime.TryGetValue(playerIndex, out var productions)
|
|
|| productions.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var claimedBombers = GetBomberAssetNames(claim.Claim, structuredKnowledge);
|
|
if (claimedBombers.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
var wildcard = claimedBombers.Contains("*");
|
|
var relevant = productions
|
|
.Where(kv => claimedBombers.Contains(kv.Key)
|
|
|| (wildcard && IsBomberLikeName(kv.Key)))
|
|
.Select(kv => kv.Value)
|
|
.ToList();
|
|
if (relevant.Count == 0 || !relevant.All(t => t > firstObserved))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var firstTime = $"{(int)firstObserved.TotalMinutes}:{firstObserved:ss\\.ff}";
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Contradiction,
|
|
AIValidationIssueKind.UnitTimelineContradiction,
|
|
$"UnitId {claim.UnitId} 首次出现于 {firstTime}，早于玩家 {claim.Player} 首次生产轰炸机类单位的时间，声称其为“{claim.Claim}”与回放时间线矛盾。",
|
|
claim.UnitId));
|
|
}
|
|
|
|
private static HashSet<string> GetBomberAssetNames(
|
|
string claimText,
|
|
StructuredKnowledge? structuredKnowledge)
|
|
{
|
|
var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var structured = structuredKnowledge ?? StructuredKnowledge.Instance;
|
|
if (structured is not null)
|
|
{
|
|
foreach (var entity in structured.EntitiesWithTag("bomber"))
|
|
{
|
|
if (claimText.IndexOf(entity.AssetName, StringComparison.OrdinalIgnoreCase) >= 0)
|
|
{
|
|
result.Add(entity.AssetName);
|
|
}
|
|
}
|
|
}
|
|
if (result.Count == 0
|
|
&& (claimText.IndexOf("轰炸机", StringComparison.OrdinalIgnoreCase) >= 0
|
|
|| claimText.IndexOf("bomber", StringComparison.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
result.Add("*");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static bool IsBomberLikeName(string assetName) =>
|
|
assetName.IndexOf("Bomber", StringComparison.OrdinalIgnoreCase) >= 0
|
|
|| assetName.IndexOf("轰炸", StringComparison.OrdinalIgnoreCase) >= 0;
|
|
|
|
private static bool TryParsePlayerIndex(
|
|
string playerText,
|
|
IReadOnlyDictionary<string, int>? aiNameToPlayerIndex,
|
|
out int playerIndex)
|
|
{
|
|
playerIndex = -1;
|
|
if (string.IsNullOrWhiteSpace(playerText))
|
|
{
|
|
return false;
|
|
}
|
|
var trimmed = playerText.Trim();
|
|
if (aiNameToPlayerIndex is not null && aiNameToPlayerIndex.TryGetValue(trimmed, out playerIndex))
|
|
{
|
|
return true;
|
|
}
|
|
if (trimmed.StartsWith("Player", StringComparison.OrdinalIgnoreCase)
|
|
&& int.TryParse(trimmed.Substring("Player".Length), out playerIndex))
|
|
{
|
|
return true;
|
|
}
|
|
if (trimmed.StartsWith("AI_", StringComparison.OrdinalIgnoreCase)
|
|
&& int.TryParse(trimmed.Substring("AI_".Length), out playerIndex))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
private static bool TryGetArray(JsonElement root, string propertyName, out JsonElement array)
|
|
{
|
|
if (root.TryGetProperty(propertyName, out array)
|
|
&& array.ValueKind == JsonValueKind.Array)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
array = default;
|
|
return false;
|
|
}
|
|
|
|
private static AIEvidenceLevel ReadEvidenceLevel(JsonElement item, ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
var value = ReadFlexibleString(item, "evidenceLevel");
|
|
return NormalizeEvidenceLevel(value, issues);
|
|
}
|
|
|
|
private static AIEvidenceLevel NormalizeEvidenceLevel(string value, ImmutableArray<AIValidationIssue>.Builder issues)
|
|
{
|
|
value = value.Trim().Replace("_", "").Replace("-", "").Replace(" ", "");
|
|
var result = value.ToLowerInvariant() switch
|
|
{
|
|
"confirmed" or "确定" => AIEvidenceLevel.Confirmed,
|
|
"highlylikely" or "high" or "高度可能" => AIEvidenceLevel.HighlyLikely,
|
|
"possible" or "可能" => AIEvidenceLevel.Possible,
|
|
"ruledout" or "excluded" or "已排除" => AIEvidenceLevel.RuledOut,
|
|
_ => (AIEvidenceLevel?)null,
|
|
};
|
|
|
|
if (result is not null)
|
|
{
|
|
return result.Value;
|
|
}
|
|
|
|
issues.Add(new AIValidationIssue(
|
|
AIValidationSeverity.Info,
|
|
AIValidationIssueKind.InvalidEvidenceLevel,
|
|
$"无法识别的证据等级 \"{value.Trim()}\"，已降级为不确定。"));
|
|
return AIEvidenceLevel.Uncertain;
|
|
}
|
|
|
|
private static string ReadFlexibleString(JsonElement item, string propertyName)
|
|
{
|
|
if (!item.TryGetProperty(propertyName, out var value))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return value.ValueKind switch
|
|
{
|
|
JsonValueKind.String => value.GetString() ?? string.Empty,
|
|
JsonValueKind.Number => value.GetRawText(),
|
|
JsonValueKind.True => "true",
|
|
JsonValueKind.False => "false",
|
|
_ => string.Empty,
|
|
};
|
|
}
|
|
|
|
private static ImmutableArray<string> ReadStringArray(JsonElement item, string propertyName)
|
|
{
|
|
if (!item.TryGetProperty(propertyName, out var value))
|
|
{
|
|
return ImmutableArray<string>.Empty;
|
|
}
|
|
|
|
if (value.ValueKind == JsonValueKind.String)
|
|
{
|
|
var text = value.GetString();
|
|
return string.IsNullOrWhiteSpace(text)
|
|
? ImmutableArray<string>.Empty
|
|
: ImmutableArray.Create(text!);
|
|
}
|
|
|
|
if (value.ValueKind != JsonValueKind.Array)
|
|
{
|
|
return ImmutableArray<string>.Empty;
|
|
}
|
|
|
|
var result = new List<string>();
|
|
foreach (var element in value.EnumerateArray())
|
|
{
|
|
var text = element.ValueKind == JsonValueKind.String
|
|
? element.GetString()
|
|
: element.GetRawText();
|
|
if (!string.IsNullOrWhiteSpace(text))
|
|
{
|
|
result.Add(text!);
|
|
}
|
|
}
|
|
return result.ToImmutableArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if a claim text describes a builder unit (MCV, Nanocore, etc.).
|
|
/// Uses structured knowledge (knowledge_units.json) when available, falls
|
|
/// back to heuristic string matching for backward compatibility.
|
|
/// </summary>
|
|
private static bool ClaimLooksLikeBuilder(
|
|
string claimText,
|
|
StructuredKnowledge? structuredKnowledge)
|
|
{
|
|
// Primary: structured knowledge lookup
|
|
var structured = structuredKnowledge ?? StructuredKnowledge.Instance;
|
|
if (structured is not null)
|
|
{
|
|
foreach (var entity in structured.AllEntities)
|
|
{
|
|
if (entity.HasTag(KnowledgeTag.Builder) &&
|
|
claimText.IndexOf(entity.AssetName, StringComparison.OrdinalIgnoreCase) >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fallback: heuristic string matching
|
|
var keywords = new[] { "MCV", "基地车", "Nanocore", "纳米核心", "builder", "建造者" };
|
|
return keywords.Any(kw => claimText.IndexOf(kw, StringComparison.OrdinalIgnoreCase) >= 0);
|
|
}
|
|
}
|
|
}
|