punish v6.8.18.0

Questionable/Questionable.Validation/EIssueSeverity.cs

@@ -0,0 +1,7 @@
+namespace Questionable.Validation;
+
+internal enum EIssueSeverity
+{
+	None,
+	Error
+}

Questionable/Questionable.Validation/EIssueType.cs

@@ -0,0 +1,24 @@
+namespace Questionable.Validation;
+
+public enum EIssueType
+{
+	None,
+	InvalidJsonSchema,
+	MissingSequence0,
+	MissingSequence,
+	DuplicateSequence,
+	MissingQuestAccept,
+	MissingQuestComplete,
+	InstantQuestWithMultipleSteps,
+	DuplicateCompletionFlags,
+	InvalidNextQuestId,
+	QuestDisabled,
+	UnexpectedAcceptQuestStep,
+	UnexpectedCompleteQuestStep,
+	InvalidAethernetShortcut,
+	InvalidExcelRef,
+	ClassQuestWithoutAetheryteShortcut,
+	DuplicateSinglePlayerInstance,
+	UnusedSinglePlayerInstance,
+	InvalidChatMessage
+}

Questionable/Questionable.Validation/IQuestValidator.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using Questionable.Model;
+
+namespace Questionable.Validation;
+
+internal interface IQuestValidator
+{
+	IEnumerable<ValidationIssue> Validate(Quest quest);
+
+	void Reset()
+	{
+	}
+}

Questionable/Questionable.Validation/QuestValidator.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Questionable.Model;
+using Questionable.Model.Questing;
+
+namespace Questionable.Validation;
+
+internal sealed class QuestValidator
+{
+	private readonly IReadOnlyList<IQuestValidator> _validators;
+
+	private readonly ILogger<QuestValidator> _logger;
+
+	private List<ValidationIssue> _validationIssues = new List<ValidationIssue>();
+
+	public IReadOnlyList<ValidationIssue> Issues => _validationIssues;
+
+	public int IssueCount => _validationIssues.Count;
+
+	public int ErrorCount => _validationIssues.Count((ValidationIssue x) => x.Severity == EIssueSeverity.Error);
+
+	public QuestValidator(IEnumerable<IQuestValidator> validators, ILogger<QuestValidator> logger)
+	{
+		_validators = validators.ToList();
+		_logger = logger;
+		_logger.LogInformation("Validators: {Validators}", string.Join(", ", _validators.Select((IQuestValidator x) => x.GetType().Name)));
+	}
+
+	public void Reset()
+	{
+		foreach (IQuestValidator validator in _validators)
+		{
+			validator.Reset();
+		}
+		_validationIssues.Clear();
+	}
+
+	public void Validate(IEnumerable<Quest> quests)
+	{
+		Task.Factory.StartNew(delegate
+		{
+			try
+			{
+				_validationIssues.Clear();
+				List<ValidationIssue> list = new List<ValidationIssue>();
+				Dictionary<EAlliedSociety, int> dictionary = new Dictionary<EAlliedSociety, int>();
+				foreach (Quest quest in quests)
+				{
+					foreach (IQuestValidator validator in _validators)
+					{
+						foreach (ValidationIssue item in validator.Validate(quest))
+						{
+							if (item.Type == EIssueType.QuestDisabled && quest.Info.AlliedSociety != EAlliedSociety.None)
+							{
+								dictionary.TryAdd(quest.Info.AlliedSociety, 0);
+								dictionary[quest.Info.AlliedSociety]++;
+							}
+							else
+							{
+								list.Add(item);
+							}
+						}
+					}
+				}
+				List<ElementId> disabledQuests = (from x in list
+					where x.Type == EIssueType.QuestDisabled
+					select x.ElementId).ToList();
+				_validationIssues = (from x in list
+					where !disabledQuests.Contains(x.ElementId) || x.Type == EIssueType.QuestDisabled
+					orderby x.ElementId, x.Sequence, x.Step, x.Description
+					select x).Concat(DisabledTribesAsIssues(dictionary)).ToList();
+			}
+			catch (Exception exception)
+			{
+				_logger.LogError(exception, "Unable to validate quests");
+			}
+		}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+	}
+
+	public List<ValidationIssue> GetIssues(ElementId elementId)
+	{
+		return _validationIssues.Where((ValidationIssue x) => x.ElementId == elementId).ToList();
+	}
+
+	private static IEnumerable<ValidationIssue> DisabledTribesAsIssues(Dictionary<EAlliedSociety, int> disabledTribeQuests)
+	{
+		return from x in disabledTribeQuests
+			orderby x.Key
+			select new ValidationIssue
+			{
+				ElementId = null,
+				Sequence = null,
+				Step = null,
+				AlliedSociety = x.Key,
+				Type = EIssueType.QuestDisabled,
+				Severity = EIssueSeverity.None,
+				Description = $"{x.Value} disabled quest(s)"
+			};
+	}
+}

Questionable/Questionable.Validation/ValidationIssue.cs

@@ -0,0 +1,40 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using Questionable.Model;
+using Questionable.Model.Questing;
+
+namespace Questionable.Validation;
+
+internal sealed record ValidationIssue
+{
+	public required ElementId? ElementId { get; init; }
+
+	public required byte? Sequence { get; init; }
+
+	public required int? Step { get; init; }
+
+	public EAlliedSociety AlliedSociety { get; init; }
+
+	public required EIssueType Type { get; init; }
+
+	public required EIssueSeverity Severity { get; init; }
+
+	public required string Description { get; init; }
+
+	[CompilerGenerated]
+	[SetsRequiredMembers]
+	private ValidationIssue(ValidationIssue original)
+	{
+		ElementId = original.ElementId;
+		Sequence = original.Sequence;
+		Step = original.Step;
+		AlliedSociety = original.AlliedSociety;
+		Type = original.Type;
+		Severity = original.Severity;
+		Description = original.Description;
+	}
+
+	public ValidationIssue()
+	{
+	}
+}