366 lines
13 KiB
C#
366 lines
13 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Text.RegularExpressions;
|
|
|
|
using MultiversalDiplomacy.Orders;
|
|
|
|
namespace MultiversalDiplomacy.Model;
|
|
|
|
/// <summary>
|
|
/// This class defines the regular expressions that are used to build up larger expressions for matching orders
|
|
/// and other script inputs. It also provides helper functions to extract the captured order elements as tuples,
|
|
/// which function as the structured intermediate representation between raw user input and full Order objects.
|
|
/// </summary>
|
|
public class OrderParser(World world)
|
|
{
|
|
public const string Type = "(A|F|Army|Fleet)";
|
|
|
|
public const string Timeline = "([A-Za-z]+)";
|
|
|
|
public const string Turn = "([0-9]+)";
|
|
|
|
public const string SlashLocation = "(?:/([A-Za-z]+))";
|
|
|
|
public const string ParenLocation = "(?:\\(([A-Za-z ]+)\\))";
|
|
|
|
public string FullLocation => $"(?:{Timeline}-)?{world.Map.ProvinceRegex}(?:{SlashLocation}|{ParenLocation})?(?:@{Turn})?";
|
|
|
|
public string UnitSpec => $"(?:{Type} )?{FullLocation}";
|
|
|
|
public const string HoldVerb = "(h|hold|holds)";
|
|
|
|
public const string MoveVerb = "(-|(?:->)|(?:=>)|(?:attack(?:s)?)|(?:move(?:s)?(?: to)?))";
|
|
|
|
public const string SupportVerb = "(s|support|supports)";
|
|
|
|
public const string ViaConvoy = "(convoy|via convoy|by convoy)";
|
|
|
|
public Regex UnitDeclaration = new(
|
|
$"^{world.Map.PowerRegex} {Type} {world.Map.ProvinceRegex}(?:{SlashLocation}|{ParenLocation})?$",
|
|
RegexOptions.IgnoreCase);
|
|
|
|
public static (
|
|
string power,
|
|
string type,
|
|
string province,
|
|
string location)
|
|
ParseUnitDeclaration(Match match) => (
|
|
match.Groups[1].Value,
|
|
match.Groups[2].Value,
|
|
match.Groups[3].Value,
|
|
match.Groups[4].Value.Length > 0
|
|
? match.Groups[4].Value
|
|
: match.Groups[5].Value);
|
|
|
|
public Regex Hold => new(
|
|
$"^{UnitSpec} {HoldVerb}$",
|
|
RegexOptions.IgnoreCase);
|
|
|
|
public static (
|
|
string type,
|
|
string timeline,
|
|
string province,
|
|
string location,
|
|
string turn,
|
|
string holdVerb)
|
|
ParseHold(Match match) => (
|
|
match.Groups[1].Value,
|
|
match.Groups[2].Value,
|
|
match.Groups[3].Value,
|
|
match.Groups[4].Length > 0
|
|
? match.Groups[4].Value
|
|
: match.Groups[5].Value,
|
|
match.Groups[6].Value,
|
|
match.Groups[7].Value);
|
|
|
|
public Regex Move => new(
|
|
$"^{UnitSpec} {MoveVerb} {FullLocation}(?: {ViaConvoy})?$",
|
|
RegexOptions.IgnoreCase);
|
|
|
|
public static (
|
|
string type,
|
|
string timeline,
|
|
string province,
|
|
string location,
|
|
string turn,
|
|
string moveVerb,
|
|
string destTimeline,
|
|
string destProvince,
|
|
string destLocation,
|
|
string destTurn,
|
|
string viaConvoy)
|
|
ParseMove(Match match) => (
|
|
match.Groups[1].Value,
|
|
match.Groups[2].Value,
|
|
match.Groups[3].Value,
|
|
match.Groups[4].Length > 0
|
|
? match.Groups[4].Value
|
|
: match.Groups[5].Value,
|
|
match.Groups[6].Value,
|
|
match.Groups[7].Value,
|
|
match.Groups[8].Value,
|
|
match.Groups[9].Value,
|
|
match.Groups[10].Length > 0
|
|
? match.Groups[10].Value
|
|
: match.Groups[11].Value,
|
|
match.Groups[12].Value,
|
|
match.Groups[13].Value);
|
|
|
|
public Regex SupportHold => new(
|
|
$"^{UnitSpec} {SupportVerb} {UnitSpec}$",
|
|
RegexOptions.IgnoreCase);
|
|
|
|
public static (
|
|
string type,
|
|
string timeline,
|
|
string province,
|
|
string location,
|
|
string turn,
|
|
string supportVerb,
|
|
string targetType,
|
|
string targetTimeline,
|
|
string targetProvince,
|
|
string targetLocation,
|
|
string targetTurn)
|
|
ParseSupportHold(Match match) => (
|
|
match.Groups[1].Value,
|
|
match.Groups[2].Value,
|
|
match.Groups[3].Value,
|
|
match.Groups[4].Length > 0
|
|
? match.Groups[4].Value
|
|
: match.Groups[5].Value,
|
|
match.Groups[6].Value,
|
|
match.Groups[7].Value,
|
|
match.Groups[8].Value,
|
|
match.Groups[9].Value,
|
|
match.Groups[10].Value,
|
|
match.Groups[11].Length > 0
|
|
? match.Groups[11].Value
|
|
: match.Groups[12].Value,
|
|
match.Groups[13].Value);
|
|
|
|
public Regex SupportMove => new(
|
|
$"{UnitSpec} {SupportVerb} {UnitSpec} {MoveVerb} {FullLocation}$",
|
|
RegexOptions.IgnoreCase);
|
|
|
|
public static (
|
|
string type,
|
|
string timeline,
|
|
string province,
|
|
string location,
|
|
string turn,
|
|
string supportVerb,
|
|
string targetType,
|
|
string targetTimeline,
|
|
string targetProvince,
|
|
string targetLocation,
|
|
string targetTurn,
|
|
string moveVerb,
|
|
string destTimeline,
|
|
string destProvince,
|
|
string destLocation,
|
|
string destTurn)
|
|
ParseSupportMove(Match match) => (
|
|
match.Groups[1].Value,
|
|
match.Groups[2].Value,
|
|
match.Groups[3].Value,
|
|
match.Groups[4].Length > 0
|
|
? match.Groups[4].Value
|
|
: match.Groups[5].Value,
|
|
match.Groups[6].Value,
|
|
match.Groups[7].Value,
|
|
match.Groups[8].Value,
|
|
match.Groups[9].Value,
|
|
match.Groups[10].Value,
|
|
match.Groups[11].Length > 0
|
|
? match.Groups[11].Value
|
|
: match.Groups[12].Value,
|
|
match.Groups[13].Value,
|
|
match.Groups[14].Value,
|
|
match.Groups[15].Value,
|
|
match.Groups[16].Value,
|
|
match.Groups[17].Length > 0
|
|
? match.Groups[17].Value
|
|
: match.Groups[18].Value,
|
|
match.Groups[19].Value);
|
|
|
|
public static bool TryParseUnit(World world, string unitSpec, [NotNullWhen(true)] out Unit? newUnit)
|
|
{
|
|
newUnit = null;
|
|
OrderParser re = new(world);
|
|
|
|
Match match = re.UnitDeclaration.Match(unitSpec);
|
|
if (!match.Success) return false;
|
|
var unit = ParseUnitDeclaration(match);
|
|
|
|
string power = world.Map.Powers.First(p => p.EqualsAnyCase(unit.power));
|
|
|
|
string typeName = Enum.GetNames<UnitType>().First(name => name.StartsWithAnyCase(unit.type));
|
|
UnitType type = Enum.Parse<UnitType>(typeName);
|
|
|
|
Province province = world.Map.Provinces.First(prov => prov.Is(unit.province));
|
|
Location? location;
|
|
if (unit.location.Length > 0) {
|
|
location = province.Locations.FirstOrDefault(loc => loc!.Is(unit.location), null);
|
|
} else {
|
|
location = type switch {
|
|
UnitType.Army => province.Locations.FirstOrDefault(loc => loc.Type == LocationType.Land),
|
|
UnitType.Fleet => province.Locations.FirstOrDefault(loc => loc.Type == LocationType.Water),
|
|
_ => null,
|
|
};
|
|
}
|
|
if (location is null) return false;
|
|
|
|
newUnit = Unit.Build(location.Key, Season.First, power, type);
|
|
return true;
|
|
}
|
|
|
|
public static bool TryParseOrder(World world, string power, string command, [NotNullWhen(true)] out Order? order) {
|
|
order = null;
|
|
OrderParser re = new(world);
|
|
|
|
if (re.Hold.Match(command) is Match holdMatch && holdMatch.Success) {
|
|
return TryParseHoldOrder(world, power, holdMatch, out order);
|
|
} else if (re.Move.Match(command) is Match moveMatch && moveMatch.Success) {
|
|
return TryParseMoveOrder(world, power, moveMatch, out order);
|
|
} else if (re.SupportHold.Match(command) is Match sholdMatch && sholdMatch.Success) {
|
|
return TryParseSupportHoldOrder(world, power, sholdMatch, out order);
|
|
} else if (re.SupportMove.Match(command) is Match smoveMatch && smoveMatch.Success) {
|
|
return TryParseSupportMoveOrder(world, power, smoveMatch, out order);
|
|
} else {
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public static bool TryParseOrderSubject(
|
|
World world,
|
|
string parsedTimeline,
|
|
string parsedTurn,
|
|
string parsedProvince,
|
|
[NotNullWhen(true)] out Unit? subject)
|
|
{
|
|
subject = null;
|
|
|
|
string timeline = parsedTimeline.Length > 0
|
|
? parsedTimeline
|
|
// If timeline is unspecified, use the root timeline
|
|
: Season.First.Timeline;
|
|
var seasonsInTimeline = world.Timelines.Seasons.Where(season => season.Timeline == timeline);
|
|
if (!seasonsInTimeline.Any()) return false;
|
|
|
|
int turn = parsedTurn.Length > 0
|
|
? int.Parse(parsedTurn)
|
|
// If turn is unspecified, use the latest turn in the timeline
|
|
: seasonsInTimeline.Max(season => season.Turn);
|
|
|
|
Province province = world.Map.Provinces.Single(province => province.Is(parsedProvince));
|
|
|
|
// Because only one unit can be in a province at a time, the province is sufficient to identify the subject
|
|
// and the location is ignored. This also satisfies DATC 4.B.5, which requires that a wrong coast for the
|
|
// subject be ignored.
|
|
subject = world.Units.FirstOrDefault(unit
|
|
=> world.Map.GetLocation(unit!.Location).ProvinceName == province.Name
|
|
&& unit!.Season.Timeline == timeline
|
|
&& unit!.Season.Turn == turn,
|
|
null);
|
|
return subject is not null;
|
|
}
|
|
|
|
public static bool TryParseHoldOrder(
|
|
World world,
|
|
string power,
|
|
Match match,
|
|
[NotNullWhen(true)] out Order? order)
|
|
{
|
|
order = null;
|
|
var hold = ParseHold(match);
|
|
|
|
if (!TryParseOrderSubject(world, hold.timeline, hold.turn, hold.province, out Unit? subject)) {
|
|
return false;
|
|
}
|
|
|
|
order = new HoldOrder(power, subject);
|
|
return true;
|
|
}
|
|
|
|
public static bool TryParseMoveOrder(
|
|
World world,
|
|
string power,
|
|
Match match,
|
|
[NotNullWhen(true)] out Order? order)
|
|
{
|
|
order = null;
|
|
var move = ParseMove(match);
|
|
|
|
if (!TryParseOrderSubject(world, move.timeline, move.turn, move.province, out Unit? subject)) {
|
|
return false;
|
|
}
|
|
|
|
string destTimeline = move.destTimeline.Length > 0
|
|
? move.destTimeline
|
|
// If the destination is unspecified, use the unit's
|
|
: subject.Season.Timeline;
|
|
|
|
int destTurn = move.destTurn.Length > 0
|
|
? int.Parse(move.destTurn)
|
|
// If the destination is unspecified, use the unit's
|
|
: subject.Season.Turn;
|
|
|
|
var destProvince = world.Map.Provinces.Single(province => province.Is(move.destProvince));
|
|
|
|
// DATC 4.B.6 requires that "irrelevant" locations like army to Spain nc be ignored.
|
|
// To satisfy this, any location of the wrong type is categorically ignored, so for an army the
|
|
// "north coast" location effectively doesn't exist here.
|
|
var unitLocations = destProvince.Locations.Where(loc => loc.Type switch {
|
|
LocationType.Land => subject.Type == UnitType.Army,
|
|
LocationType.Water => subject.Type == UnitType.Fleet,
|
|
_ => false,
|
|
});
|
|
// DATC 4.6.B also requires that unknown coasts be ignored. To satisfy this, an additional filter by name.
|
|
// Doing both of these filters means "A - Spain/nc" is as meaningful as "F - Spain/wc".
|
|
var matchingLocations = unitLocations.Where(loc => loc.Is(move.destLocation));
|
|
|
|
// If one location matched, use that location. If the coast is inaccessible to the subject, the order will
|
|
// be invalidated by a path check later to satisfy DATC 4.B.3.
|
|
string? destLocationKey = matchingLocations.FirstOrDefault(defaultValue: null)?.Key;
|
|
|
|
if (destLocationKey is null) {
|
|
// If no location matched, location was omitted, nonexistent, or the wrong type.
|
|
// If one location is accessible, DATC 4.B.2 requires that it be used.
|
|
// If more than one location is accessible, DATC 4.B.1 requires the order fail.
|
|
|
|
// TODO check which locations are accessible per the above
|
|
destLocationKey = unitLocations.First().Key;
|
|
|
|
// return false;
|
|
}
|
|
|
|
order = new MoveOrder(power, subject, new(destTimeline, destTurn), destLocationKey);
|
|
return true;
|
|
}
|
|
|
|
public static bool TryParseSupportHoldOrder(
|
|
World world,
|
|
string power,
|
|
Match match,
|
|
[NotNullWhen(true)] out Order? order)
|
|
{
|
|
order = null;
|
|
var support = ParseSupportHold(match);
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public static bool TryParseSupportMoveOrder(
|
|
World world,
|
|
string power,
|
|
Match match,
|
|
[NotNullWhen(true)] out Order? order)
|
|
{
|
|
order = null;
|
|
var support = ParseSupportMove(match);
|
|
throw new NotImplementedException();
|
|
|
|
// It is possible to support a move to an inaccessible coast if another coast is accessible to the subject.
|
|
// DATC 4.B.4 prefers that automatic adjudicators strictly require matching coasts in supports.
|
|
}
|
|
}
|