5dplomacy/MultiversalDiplomacy/Model/World.cs

234 lines
7.4 KiB
C#
Raw Normal View History

using System.Collections.ObjectModel;
using MultiversalDiplomacy.Orders;
namespace MultiversalDiplomacy.Model;
/// <summary>
/// The global game state.
/// </summary>
public class World
{
/// <summary>
/// The map variant of the game.
/// </summary>
public readonly Map Map;
/// <summary>
/// The game map.
/// </summary>
public ReadOnlyCollection<Province> Provinces => this.Map.Provinces;
/// <summary>
/// The game powers.
/// </summary>
public ReadOnlyCollection<Power> Powers => this.Map.Powers;
/// <summary>
/// The state of the multiverse.
/// </summary>
public ReadOnlyCollection<Season> Seasons { get; }
/// <summary>
/// The first season of the game.
/// </summary>
public Season RootSeason { get; }
/// <summary>
/// All units in the multiverse.
/// </summary>
public ReadOnlyCollection<Unit> Units { get; }
/// <summary>
/// All retreating units in the multiverse.
/// </summary>
public ReadOnlyCollection<RetreatingUnit> RetreatingUnits { get; }
/// <summary>
/// Orders given to units in each season.
/// </summary>
2022-11-09 00:25:47 +00:00
public ReadOnlyDictionary<Season, OrderHistory> OrderHistory { get; }
2022-03-13 07:15:26 +00:00
/// <summary>
/// Immutable game options.
/// </summary>
public Options Options { get; }
/// <summary>
/// Create a new World, providing all state data.
/// </summary>
private World(
Map map,
ReadOnlyCollection<Season> seasons,
Season rootSeason,
ReadOnlyCollection<Unit> units,
ReadOnlyCollection<RetreatingUnit> retreatingUnits,
2022-11-09 00:25:47 +00:00
ReadOnlyDictionary<Season, OrderHistory> orderHistory,
2022-03-13 07:15:26 +00:00
Options options)
{
this.Map = map;
this.Seasons = seasons;
this.RootSeason = rootSeason;
this.Units = units;
this.RetreatingUnits = retreatingUnits;
2022-11-09 00:25:47 +00:00
this.OrderHistory = orderHistory;
2022-03-13 07:15:26 +00:00
this.Options = options;
}
/// <summary>
/// Create a new World from a previous one, replacing some state data.
/// </summary>
private World(
World previous,
ReadOnlyCollection<Season>? seasons = null,
ReadOnlyCollection<Unit>? units = null,
ReadOnlyCollection<RetreatingUnit>? retreatingUnits = null,
2022-11-09 00:25:47 +00:00
ReadOnlyDictionary<Season, OrderHistory>? orderHistory = null,
Options? options = null)
: this(
previous.Map,
seasons ?? previous.Seasons,
previous.RootSeason, // Can't change the root season
units ?? previous.Units,
retreatingUnits ?? previous.RetreatingUnits,
2022-11-09 00:25:47 +00:00
orderHistory ?? previous.OrderHistory,
options ?? previous.Options)
{
}
/// <summary>
/// Create a new world with specified provinces and powers and an initial season.
2022-03-13 07:15:26 +00:00
/// </summary>
public static World WithMap(Map map)
{
Season root = Season.MakeRoot();
return new World(
map,
new(new List<Season> { root }),
root,
new(new List<Unit>()),
new(new List<RetreatingUnit>()),
2022-11-09 00:25:47 +00:00
new(new Dictionary<Season, OrderHistory>()),
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,
2022-11-09 00:25:47 +00:00
IEnumerable<KeyValuePair<Season, OrderHistory>>? orders = null)
=> new World(
previous: this,
seasons: seasons == null
? this.Seasons
: new(seasons.ToList()),
units: units == null
? this.Units
: new(units.ToList()),
retreatingUnits: retreats == null
? this.RetreatingUnits
: new(retreats.ToList()),
2022-11-09 00:25:47 +00:00
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,
2022-03-23 04:27:06 +00:00
_ => 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, 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"
);
}
2022-03-13 07:15:26 +00:00
/// <summary>
/// A standard Diplomacy game setup.
2022-03-13 07:15:26 +00:00
/// </summary>
public static World Standard => World
2022-03-13 07:15:26 +00:00
.WithStandardMap()
.AddStandardUnits();
2022-03-13 07:15:26 +00:00
2022-03-30 00:16:00 +00:00
/// <summary>
/// Get a season by coordinate. Throws if the season is not found.
/// </summary>
public Season GetSeason(string timeline, int turn)
2022-03-30 00:16:00 +00:00
{
Season? foundSeason = this.Seasons.SingleOrDefault(
s => s!.Turn == turn && s.Timeline == timeline,
null)
?? throw new KeyNotFoundException($"Season {timeline}@{turn} not found");
2022-03-30 00:16:00 +00:00
return foundSeason;
}
2022-03-13 07:15:26 +00:00
/// <summary>
2022-03-30 00:16:00 +00:00
/// Returns a unit in a province. Throws if there are duplicate units.
2022-03-13 07:15:26 +00:00
/// </summary>
public Unit GetUnitAt(string provinceName, (string timeline, int turn)? seasonCoord = null)
2022-03-13 07:15:26 +00:00
{
Province province = Map.GetProvince(provinceName);
seasonCoord ??= (this.RootSeason.Timeline, this.RootSeason.Turn);
Season season = GetSeason(seasonCoord.Value.timeline, seasonCoord.Value.turn);
Unit? foundUnit = this.Units.SingleOrDefault(
u => u!.Province == province && u.Season == season,
null)
?? throw new KeyNotFoundException($"Unit at {province} at {season} not found");
return foundUnit;
2022-03-13 07:15:26 +00:00
}
}