public bool HasMinorPlanet()
{
return(Planets != null && Planets.Any(p => p.PlanetType == PlanetType.MinorPlanet));
}
public List <string> GetWarnings()
{
var warnings = new List <string>();
var planetIDs = Planets.Select(p => p.ID).ToHashSet();
var playerNames = Players.Select(p => p.Name).ToHashSet();
var factionNames = Factions.Select(f => f.Name).ToHashSet();
var playerFactionNames = Factions.Select(p => p.Name).ToHashSet();
var ownerNames = Planets.Select(p => p.OwnerName).Where(n => n != null).ToHashSet();
if (!ownerNames.IsSubsetOf(playerNames))
{
warnings.Add("Planet owner does not exist.");
}
if (!playerFactionNames.IsSubsetOf(factionNames))
{
warnings.Add("Player faction does not exist.");
}
if (planetIDs.Count != Planets.Count)
{
warnings.Add("Duplicate planet ID.");
}
if (playerNames.Count != Players.Count)
{
warnings.Add("Duplicate player name.");
}
if (factionNames.Count != Factions.Count)
{
warnings.Add("Duplicate faction.");
}
{
var link = Links.FirstOrDefault(l => l[0] == l[1]);
if (link != null)
{
warnings.Add(String.Format("Link has same source and destination: {0} {1}", link[0], link[1]));
}
}
foreach (var link in Links)
{
if (!planetIDs.IsSupersetOf(link.PlanetIDs))
{
warnings.Add("Link points to inexistent planet");
}
Array.Sort(link.PlanetIDs);
}
foreach (var link1 in Links)
{
foreach (var link2 in Links)
{
if (link1 != link2 && link1.PlanetIDs.SequenceEqual(link2.PlanetIDs))
{
warnings.Add("Duplicate Link");
}
}
}
Func <string, Planet, string> format = (s, p) => String.Format("Planet {0} {1} missing.", p.Name ?? String.Empty, s);
foreach (var p in Planets)
{
if (p.OwnerName != null || p.FactionName != null || p.MapName != null)
{
if (p.OwnerName == null)
{
warnings.Add(p.Name + format("owner", p));
}
if (p.FactionName == null)
{
warnings.Add(format("faction", p));
}
if (p.MapName == null)
{
warnings.Add(format("map", p));
}
if (p.Name == null)
{
warnings.Add(format("name", p));
}
}
}
if (Planets.Count(p => p.IsStartingPlanet) != Factions.Count)
{
warnings.Add("Wrong number of starting planets.");
}
if (Round == 0 && Planets.Any(p => p.OwnerName == null) && !playerNames.All(ownerNames.Contains))
{
warnings.Add("Galaxy has free space and a player has no planet.");
}
if (Planets.Count > MapNames.Count)
{
warnings.Add("Not enough maps.");
}
if (Factions.Count < 2)
{
warnings.Add("Not enough factions.");
}
return(warnings);
}
public void Update(DateTime currentTime)
{
if (this.Waiting)
{
if (currentTime > gameStart)
{
if (Players.Count == 2)
{
this.Waiting = false;
}
else
{
if (currentTime > gameQuit)
{
this.Waiting = false;
this.Status = "Nobody joined your game, I guess that means you win.";
GameOver = true;
}
else
{
UpdateTimeInfo(gameStart.AddSeconds(2));
}
}
}
return;
}
if (GameOver)
{
this.Stop();
return;
}
// check if we are in the server window
if (currentTime >= endPlayerTurn)
{
// server processing
Processing = true;
// Grow ships on planets
foreach (var planet in Planets)
{
// if the planet is not controlled by neutral update
if (planet.OwnerId != -1)
{
planet.NumberOfShips += planet.GrowthRate;
}
}
// Send fleets
foreach (var fleet in Fleets)
{
// travel 1 unit distance each turn
fleet.NumberOfTurnsToDestination--;
}
// Resolve planet battles
foreach (var planet in Planets)
{
var combatants = new Dictionary <int, int>();
combatants.Add(planet.OwnerId, planet.NumberOfShips);
// find fleets destined for this planet
var fleets = Fleets.Where(f => f.Destination.Id == planet.Id && f.NumberOfTurnsToDestination <= 0);
foreach (var fleet in fleets)
{
if (combatants.ContainsKey(fleet.OwnerId))
{
combatants[fleet.OwnerId] += fleet.NumberOfShips;
}
else
{
combatants.Add(fleet.OwnerId, fleet.NumberOfShips);
}
}
if (fleets.Count() <= 0)
{
continue;
}
KeyValuePair <int, int> second = new KeyValuePair <int, int>(1, 0);
KeyValuePair <int, int> winner = new KeyValuePair <int, int>(2, 0);
foreach (var keyval in combatants)
{
if (keyval.Value > second.Value)
{
if (keyval.Value > winner.Value)
{
second = winner;
winner = keyval;
}
else
{
second = keyval;
}
}
}
if (winner.Value > second.Value)
{
planet.NumberOfShips = winner.Value - second.Value;
planet.OwnerId = winner.Key;
}
else
{
planet.NumberOfShips = 0;
}
}
// remove finished fleets
lock (synclock)
{
_fleets.RemoveAll(f => f.NumberOfTurnsToDestination <= 0);
}
// Check game over conditions
var player1NoPlanets = !Planets.Any(p => p.OwnerId == 1);
var player1NoShips = !Fleets.Any(f => f.OwnerId == 1);
var player2NoPlanet = !Planets.Any(p => p.OwnerId == 2);
var player2NoShips = !Fleets.Any(f => f.OwnerId == 2);
if (player1NoPlanets && player1NoShips)
{
// player 2 has won
var winner = Players.Values.FirstOrDefault(p => p.Id == 2);
var loser = Players.Values.FirstOrDefault(p => p.Id == 1);
this.Status = $"{winner?.PlayerName} has defeated {loser?.PlayerName}!";
this.GameOver = true;
}
if (player2NoPlanet && player2NoShips)
{
// player 1 has won
var winner = Players.Values.FirstOrDefault(p => p.Id == 1);
var loser = Players.Values.FirstOrDefault(p => p.Id == 2);
this.Status = $"{winner?.PlayerName} has defeated {loser?.PlayerName}!";
this.GameOver = true;
}
PlayerAScoreOverTime.Add(_getPlayerScore(1));
PlayerBScoreOverTime.Add(_getPlayerScore(2));
// Turn complete
Turn++;
endPlayerTurn = currentTime.AddMilliseconds(PLAYER_TURN_LENGTH);
endServerTurn = endPlayerTurn.AddMilliseconds(SERVER_TURN_LENGTH);
Processing = false;
System.Diagnostics.Debug.WriteLine($"Game {Id} : Turn {Turn} : Next Turn Start {endServerTurn.Subtract(DateTime.UtcNow).TotalMilliseconds}ms");
}
if (Turn >= MAX_TURN)
{
var player1 = _getPlayerForId(1)?.PlayerName;
var player2 = _getPlayerForId(2)?.PlayerName;
var player1Score = _getPlayerScore(1);
var player2Score = _getPlayerScore(2);
if (player1Score == player2Score)
{
this.Status = $"{player1} has tied {player2}!";
}
else if (player1Score > player2Score)
{
this.Status = $"{player1} has defeated {player2}!";
}
else
{
this.Status = $"{player2} has defeated {player1}!";
}
this.GameOver = true;
}
}
public override string ToString()
{
var items = new List <string>();
if (TreatyClauses.Any())
{
if (TreatyClauses.Count == 1)
{
items.Add(TreatyClauses.Single().ToString());
}
else
{
items.Add(TreatyClauses.Count + " treaty clauses");
}
}
if (Planets.Any())
{
if (Planets.Count == 1)
{
items.Add(Planets.Single().ToString());
}
else
{
items.Add(Planets.Count + " planets");
}
}
if (Vehicles.Any())
{
if (Vehicles.Count == 1)
{
items.Add(Vehicles.Single().ToString());
}
else
{
items.Add(Vehicles.Count + " vehicles");
}
}
if (Resources.Any(kvp => kvp.Value != 0))
{
items.Add(Resources.ToString());
}
if (Technology.Any())
{
if (Technology.Count == 1)
{
var kvp = Technology.Single();
items.Add(kvp.Key + " to level " + kvp.Value);
}
else
{
items.Add(Technology.Count + " technologies");
}
}
if (StarCharts.Any())
{
if (StarCharts.Count == 1)
{
items.Add("the star chart for " + StarCharts.Single().ToString());
}
else
{
items.Add(StarCharts.Count + " star charts");
}
}
if (CommunicationChannels.Any())
{
if (CommunicationChannels.Count == 1)
{
items.Add("comm channels to " + CommunicationChannels.Single().ToString());
}
else
{
items.Add(CommunicationChannels.Count + " comm channels");
}
}
if (!items.Any())
{
return("nothing");
}
return(string.Join(", ", items.ToArray()));
}