338 lines
11 KiB
C#
338 lines
11 KiB
C#
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
|
|
namespace MultiversalDiplomacy.Model;
|
|
|
|
/// <summary>
|
|
/// The global game state.
|
|
/// </summary>
|
|
public class World
|
|
{
|
|
public static readonly JsonSerializerOptions JsonOptions = new()
|
|
{
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
};
|
|
|
|
/// <summary>
|
|
/// The map variant of the game.
|
|
/// </summary>
|
|
[JsonIgnore]
|
|
public Map Map { get; }
|
|
|
|
/// <summary>
|
|
/// The map variant of the game.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// While this is serialized to JSON, deserialization uses it to populate <see cref="Map"/>
|
|
/// </remarks>
|
|
public MapType MapType => this.Map.Type;
|
|
|
|
/// <summary>
|
|
/// The game map.
|
|
/// </summary>
|
|
[JsonIgnore]
|
|
public IReadOnlyCollection<Province> Provinces => this.Map.Provinces;
|
|
|
|
/// <summary>
|
|
/// The game powers.
|
|
/// </summary>
|
|
[JsonIgnore]
|
|
public IReadOnlyCollection<Power> Powers => this.Map.Powers;
|
|
|
|
/// <summary>
|
|
/// Lookup for seasons by designation.
|
|
/// </summary>
|
|
public Dictionary<string, Season> Seasons { get; }
|
|
|
|
/// <summary>
|
|
/// The first season of the game.
|
|
/// </summary>
|
|
[JsonIgnore]
|
|
public Season RootSeason => GetSeason("a0");
|
|
|
|
/// <summary>
|
|
/// All units in the multiverse.
|
|
/// </summary>
|
|
public List<Unit> Units { get; }
|
|
|
|
/// <summary>
|
|
/// All retreating units in the multiverse.
|
|
/// </summary>
|
|
public List<RetreatingUnit> RetreatingUnits { get; }
|
|
|
|
/// <summary>
|
|
/// Orders given to units in each season.
|
|
/// </summary>
|
|
public Dictionary<string, OrderHistory> OrderHistory { get; }
|
|
|
|
/// <summary>
|
|
/// The shared timeline number generator.
|
|
/// </summary>
|
|
public TimelineFactory Timelines { get; }
|
|
|
|
/// <summary>
|
|
/// Immutable game options.
|
|
/// </summary>
|
|
public Options Options { get; }
|
|
|
|
[JsonConstructor]
|
|
public World(
|
|
MapType mapType,
|
|
Dictionary<string, Season> seasons,
|
|
List<Unit> units,
|
|
List<RetreatingUnit> retreatingUnits,
|
|
Dictionary<string, OrderHistory> orderHistory,
|
|
TimelineFactory timelines,
|
|
Options options)
|
|
{
|
|
this.Map = Map.FromType(mapType);
|
|
this.Seasons = seasons;
|
|
this.Units = units;
|
|
this.RetreatingUnits = retreatingUnits;
|
|
this.OrderHistory = orderHistory;
|
|
this.Timelines = timelines;
|
|
this.Options = options;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new World, providing all state data.
|
|
/// </summary>
|
|
private World(
|
|
Map map,
|
|
Dictionary<string, Season> seasons,
|
|
List<Unit> units,
|
|
List<RetreatingUnit> retreatingUnits,
|
|
Dictionary<string, OrderHistory> orderHistory,
|
|
TimelineFactory timelines,
|
|
Options options)
|
|
{
|
|
this.Map = map;
|
|
this.Seasons = seasons;
|
|
this.Units = units;
|
|
this.RetreatingUnits = retreatingUnits;
|
|
this.OrderHistory = orderHistory;
|
|
this.Timelines = timelines;
|
|
this.Options = options;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new World from a previous one, replacing some state data.
|
|
/// </summary>
|
|
private World(
|
|
World previous,
|
|
Dictionary<string, Season>? seasons = null,
|
|
List<Unit>? units = null,
|
|
List<RetreatingUnit>? retreatingUnits = null,
|
|
Dictionary<string, OrderHistory>? orderHistory = null,
|
|
Options? options = null)
|
|
: this(
|
|
previous.Map,
|
|
seasons ?? previous.Seasons,
|
|
units ?? previous.Units,
|
|
retreatingUnits ?? previous.RetreatingUnits,
|
|
orderHistory ?? previous.OrderHistory,
|
|
previous.Timelines,
|
|
options ?? previous.Options)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new world with specified provinces and powers and an initial season.
|
|
/// </summary>
|
|
public static World WithMap(Map map)
|
|
{
|
|
TimelineFactory timelines = new();
|
|
Season a0 = new(past: null, Season.FIRST_TURN, timelines.NextTimeline());
|
|
return new World(
|
|
map,
|
|
new() { {a0.Designation, a0} },
|
|
new([]),
|
|
new([]),
|
|
new(new Dictionary<string, OrderHistory>()),
|
|
timelines,
|
|
new Options());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new world with the standard Diplomacy provinces and powers.
|
|
/// </summary>
|
|
public static World WithStandardMap()
|
|
=> WithMap(Map.Classical);
|
|
|
|
public World Update(
|
|
IEnumerable<Season>? seasons = null,
|
|
IEnumerable<Unit>? units = null,
|
|
IEnumerable<RetreatingUnit>? retreats = null,
|
|
IEnumerable<KeyValuePair<string, OrderHistory>>? orders = null)
|
|
=> new(
|
|
previous: this,
|
|
seasons: seasons == null
|
|
? this.Seasons
|
|
: new(seasons.ToDictionary(season => season.Designation)),
|
|
units: units == null
|
|
? this.Units
|
|
: new(units.ToList()),
|
|
retreatingUnits: retreats == null
|
|
? this.RetreatingUnits
|
|
: new(retreats.ToList()),
|
|
orderHistory: orders == null
|
|
? this.OrderHistory
|
|
: new(orders.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)));
|
|
|
|
/// <summary>
|
|
/// Create a new world with new units created from unit specs. Units specs are in the format
|
|
/// "<power> <A/F> <province> [<coast>]". If the province or coast name has a space in it, the
|
|
/// abbreviation should be used. Unit specs always describe units in the root season.
|
|
/// </summary>
|
|
public World AddUnits(params string[] unitSpecs)
|
|
{
|
|
IEnumerable<Unit> units = unitSpecs.Select(spec =>
|
|
{
|
|
string[] splits = spec.Split(' ', 4);
|
|
Power power = Map.GetPower(splits[0]);
|
|
UnitType type = splits[1] switch
|
|
{
|
|
"A" => UnitType.Army,
|
|
"F" => UnitType.Fleet,
|
|
_ => throw new ApplicationException($"Unknown unit type {splits[1]}")
|
|
};
|
|
Location location = type == UnitType.Army
|
|
? Map.GetLand(splits[2])
|
|
: splits.Length == 3
|
|
? Map.GetWater(splits[2])
|
|
: Map.GetWater(splits[2], splits[3]);
|
|
Unit unit = Unit.Build(location.Designation, this.RootSeason, power, type);
|
|
return unit;
|
|
});
|
|
return this.Update(units: units);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new world with standard Diplomacy initial unit placements.
|
|
/// </summary>
|
|
public World AddStandardUnits()
|
|
{
|
|
return this.AddUnits(
|
|
"Austria A Bud",
|
|
"Austria A Vir",
|
|
"Austria F Tri",
|
|
"England A Lvp",
|
|
"England F Edi",
|
|
"England F Lon",
|
|
"France A Mar",
|
|
"France A Par",
|
|
"France F Bre",
|
|
"Germany A Ber",
|
|
"Germany A Mun",
|
|
"Germany F Kie",
|
|
"Italy A Rom",
|
|
"Italy A Ven",
|
|
"Italy F Nap",
|
|
"Russia A Mos",
|
|
"Russia A War",
|
|
"Russia F Sev",
|
|
"Russia F Stp wc",
|
|
"Turkey A Con",
|
|
"Turkey A Smy",
|
|
"Turkey F Ank"
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a continuation of this season if it has no futures, otherwise create a fork.
|
|
/// </summary>
|
|
public Season ContinueOrFork(Season season)
|
|
=> GetFutures(season).Any()
|
|
? new(season.Designation, season.Turn + 1, Timelines.NextTimeline())
|
|
: new(season.Designation, season.Turn + 1, season.Timeline);
|
|
|
|
/// <summary>
|
|
/// A standard Diplomacy game setup.
|
|
/// </summary>
|
|
public static World Standard => WithStandardMap().AddStandardUnits();
|
|
|
|
/// <summary>
|
|
/// Get a season by coordinate. Throws if the season is not found.
|
|
/// </summary>
|
|
public Season GetSeason(string timeline, int turn)
|
|
=> GetSeason($"{timeline}{turn}");
|
|
|
|
/// <summary>
|
|
/// Get a season by designation.
|
|
/// </summary>
|
|
public Season GetSeason(string designation)
|
|
=> Seasons[designation];
|
|
|
|
/// <summary>
|
|
/// Get all seasons that are immediate futures of a season.
|
|
/// </summary>
|
|
/// <param name="present">A season designation.</param>
|
|
/// <returns>The immediate futures of the designated season.</returns>
|
|
public IEnumerable<Season> GetFutures(string present)
|
|
=> Seasons.Values.Where(future => future.Past == present);
|
|
|
|
/// <summary>
|
|
/// Get all seasons that are immediate futures of a season.
|
|
/// </summary>
|
|
/// <param name="present">A season.</param>
|
|
/// <returns>The immediate futures of the season.</returns>
|
|
public IEnumerable<Season> GetFutures(Season present) => GetFutures(present.Designation);
|
|
|
|
/// <summary>
|
|
/// Returns the first season in this season's timeline. The first season is the
|
|
/// root of the first timeline. The earliest season in each alternate timeline is
|
|
/// the root of that timeline.
|
|
/// </summary>
|
|
public Season GetTimelineRoot(Season season)
|
|
{
|
|
if (season.Past is null) {
|
|
return season;
|
|
}
|
|
Season past = Seasons[season.Past];
|
|
return season.Timeline == past.Timeline
|
|
? GetTimelineRoot(past)
|
|
: season;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether this season is in an adjacent timeline to another season.
|
|
/// Seasons are considered to be in adjacent timelines if they are in the same timeline,
|
|
/// one is in a timeline that branched from the other's timeline, or both are in timelines
|
|
/// that branched from the same point.
|
|
/// </summary>
|
|
public bool InAdjacentTimeline(Season one, Season two)
|
|
{
|
|
// Timelines are adjacent to themselves. Early out in that case.
|
|
if (one == two) return true;
|
|
|
|
// If the timelines aren't identical, one of them isn't the initial trunk.
|
|
// They can still be adjacent if one of them branched off of the other, or
|
|
// if they both branched off of the same point.
|
|
Season rootOne = GetTimelineRoot(one);
|
|
Season rootTwo = GetTimelineRoot(two);
|
|
bool oneForked = rootOne.Past != null && GetSeason(rootOne.Past).Timeline == two.Timeline;
|
|
bool twoForked = rootTwo.Past != null && GetSeason(rootTwo.Past).Timeline == one.Timeline;
|
|
bool bothForked = rootOne.Past == rootTwo.Past;
|
|
return oneForked || twoForked || bothForked;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a unit in a province. Throws if there are duplicate units.
|
|
/// </summary>
|
|
public Unit GetUnitAt(string provinceName, Season? season = null)
|
|
{
|
|
Province province = Map.GetProvince(provinceName);
|
|
season ??= RootSeason;
|
|
Unit? foundUnit = this.Units.SingleOrDefault(
|
|
u => Map.GetLocation(u!).Province == province && u!.Season == season,
|
|
null)
|
|
?? throw new KeyNotFoundException($"Unit at {province} at {season} not found");
|
|
return foundUnit;
|
|
}
|
|
|
|
public Unit GetUnitByDesignation(string designation)
|
|
=> Units.SingleOrDefault(u => u!.Designation == designation, null)
|
|
?? throw new KeyNotFoundException($"Unit {designation} not found");
|
|
}
|