/// <Summary>
/// Display a planet Summary
/// </Summary>
/// <param name="Item"></param>
private void DisplayPlanet(StarIntel report)
{
if (empireState.StarReports[report.Name].Year == Global.Unset)
{
this.summaryFrame.Text = report.Name + " is unexplored";
summaryItem = null;
PlanetSummary.Hide();
FleetSummary.Hide();
Invalidate();
return;
}
// If we are displaying a fleet clear it out and add the planet
// Summary display.
if (summaryItem is FleetIntel || summaryItem == null)
{
PlanetSummary.Show();
FleetSummary.Hide();
Invalidate();
}
summaryItem = report;
this.summaryFrame.Text = "Summary of " + report.Name;
PlanetSummary.Location = new Point(5, 15);
PlanetSummary.Value = report;
}
/// <Summary>
/// Add an indication of a starbase (circle) or orbiting fleets (smaller
/// circle) or both.
/// </Summary>
/// <param name="Star">The Star being drawn.</param>
private void DrawOrbitingFleets(Graphics g, StarIntel report)
{
NovaPoint position = LogicalToDevice(report.Position);
if (report == null)
{
return;
}
if (report.Starbase != null)
{
g.FillEllipse(
Brushes.Yellow,
position.X + 6,
position.Y - 6,
4,
4);
}
if (report.HasFleetsInOrbit)
{
int size = 12;
g.DrawEllipse(
Pens.White,
position.X - (size / 2),
position.Y - (size / 2),
size,
size);
}
}
private void HandleScouting()
{
List <Fleet> scoutFleets = new List <Fleet>();
foreach (Fleet fleet in clientState.EmpireState.OwnedFleets.Values)
{
if (fleet.Name.Contains("Scout") == true)
{
scoutFleets.Add(fleet);
}
}
// Find the stars we do not need to scout (eg home world)
List <StarIntel> excludedStars = new List <StarIntel>();
foreach (StarIntel report in turnData.EmpireState.StarReports.Values)
{
if (report.Year != Global.Unset)
{
excludedStars.Add(report);
}
}
if (scoutFleets.Count > 0)
{
foreach (Fleet fleet in scoutFleets)
{
StarIntel starToScout = fleetAIs[fleet.Id].Scout(excludedStars);
if (starToScout != null)
{
excludedStars.Add(starToScout);
}
}
}
}
public StarIntel Scout(List <StarIntel> excludedStars)
{
bool missionAccepted = false;
// Find a star to scout
StarIntel starToScout = CloesestStar(this.fleet, excludedStars);
if (starToScout != null)
{
// Do we need fuel first?
double fuelRequired = 0.0;
Fleet nearestFuel = ClosestFuel(fleet);
if (!fleet.CanRefuel)
{
// Can not make fuel, so how much fuel is required to scout and then refuel?
if (nearestFuel != null)
{
int bestWarp = 6; // FIXME (priority 4) - what speed to scout at?
double bestSpeed = bestWarp * bestWarp;
double speedSquared = bestSpeed * bestSpeed;
double fuelConsumption = fleet.FuelConsumption(bestWarp, clientState.EmpireState.Race);
double distanceSquared = PointUtilities.DistanceSquare(fleet.Position, starToScout.Position); // to the stars
distanceSquared += PointUtilities.DistanceSquare(starToScout.Position, nearestFuel.Position); // and back to fuel (minimum)
double time = Math.Sqrt(distanceSquared / speedSquared);
fuelRequired = time * fuelConsumption;
}
else
{
// OMG there is no fuel! - just keep scouting then?
}
}
if (fleet.FuelAvailable > fuelRequired)
{
// Fuel is no problem
SendFleet(starToScout, fleet, new NoTask());
missionAccepted = true;
}
else
{
// Refuel before scouting further
SendFleet(nearestFuel, fleet, new NoTask());
}
}
if (missionAccepted)
{
return(starToScout);
}
else
{
return(null);
}
}
/// <summary>
/// Send the fleet to colonise a planet.
/// </summary>
/// <param name="targetStar">The <see cref="StarIntel"/> for the target star to colonise.</param>
public void Colonise(StarIntel targetStar)
{
// ensure we take some colonists, maybe some Germainium
if (this.fleet.Cargo.ColonistsInKilotons < 1)
{
if (this.fleet.InOrbit != null && this.fleet.InOrbit.Owner == this.fleet.Owner)
{
// there is one of our planets here, so try to beam up colonists
Star ourStar = (Star)this.fleet.InOrbit;
// How much germanium to load to seed factory production?
// 1/4 of cargo capacity, so long as we can load 100 kT of colonists
int germaniumToLoad = System.Math.Min(this.fleet.TotalCargoCapacity / 4, this.fleet.TotalCargoCapacity - 100);
// but leave at least 50 G behind
germaniumToLoad = System.Math.Min(germaniumToLoad, ourStar.ResourcesOnHand.Germanium - 50);
// do not try to load a negative number of G
germaniumToLoad = System.Math.Max(germaniumToLoad, 0);
// How many colonists to load?
// fill up space left after G
int colonistsToLoadKt = this.fleet.TotalCargoCapacity - germaniumToLoad;
// but do not take the Star below 250,000 (max % growth)
colonistsToLoadKt = System.Math.Min(colonistsToLoadKt, (ourStar.Colonists - 250000) / Nova.Common.Global.ColonistsPerKiloton);
// ensure we load at least 1 kT of colonists
colonistsToLoadKt = System.Math.Max(colonistsToLoadKt, 1);
// load up
CargoTask wpTask = new CargoTask();
wpTask.Mode = CargoMode.Load;
wpTask.Amount.ColonistsInKilotons = colonistsToLoadKt;
wpTask.Amount.Germanium = germaniumToLoad;
Waypoint wp = new Waypoint();
wp.Task = wpTask;
wp.Position = ourStar.Position;
wp.WarpFactor = this.fleet.FreeWarpSpeed;
wp.Destination = ourStar.Name;
WaypointCommand loadCommand = new WaypointCommand(CommandMode.Add, wp, this.fleet.Key);
loadCommand.ApplyToState(clientState.EmpireState);
clientState.Commands.Push(loadCommand);
SendFleet(targetStar, this.fleet, new ColoniseTask());
}
else
{
// TODO (priority 5) - go get some colonists
}
}
else
{
// Already has colonists
SendFleet(targetStar, this.fleet, new ColoniseTask());
}
}
private void SendFleet(StarIntel star, Fleet fleet, IWaypointTask task)
{
Waypoint w = new Waypoint();
w.Position = star.Position;
w.Destination = star.Name;
w.Task = task;
WaypointCommand command = new WaypointCommand(CommandMode.Add, w, fleet.Key);
command.ApplyToState(clientState.EmpireState);
clientState.Commands.Push(command);
}
/// <summary>
/// Return closest star to current fleet.
/// </summary>
/// <param name="fleet"></param>
/// <returns></returns>
private StarIntel CloesestStar(Fleet fleet, List <StarIntel> excludedStars)
{
StarIntel target = null;
double distance = double.MaxValue;
foreach (StarIntel report in clientState.EmpireState.StarReports.Values)
{
if (excludedStars.Contains(report) != true)
{
if (distance > Math.Sqrt(Math.Pow(fleet.Position.X - report.Position.X, 2) + Math.Pow(fleet.Position.Y - report.Position.Y, 2)))
{
target = report;
distance = Math.Sqrt(Math.Pow(fleet.Position.X - target.Position.X, 2) + Math.Pow(fleet.Position.Y - target.Position.Y, 2));
}
}
}
return(target);
}
/// <Summary>
/// Draw a Star. The Star is just a small circle which is a bit bigger if we've
/// explored it.
/// </Summary>
/// <remarks>
/// The color of the Star symbol is based on its Star report (reports for stars
/// owned by the current player are always up-to-date). Unoccupied stars are
/// white. Stars colonised by the player are green. Stars owned by other races
/// are red.
/// </remarks>
/// <param name="Star">The Star sytem to draw.</param>
private void DrawStar(Graphics g, StarIntel report)
{
NovaPoint position = LogicalToDevice(report.Position);
int size = 2;
Brush starBrush = Brushes.White;
// Bigger symbol for explored stars.
if (report.Year > Global.Unset)
{
size = 4;
}
// Our stars are greenish, other's are red, unknown or uncolonised
// stars are white.
if (report.Owner == clientState.EmpireState.Id)
{
starBrush = Brushes.GreenYellow;
}
else
{
if (report.Owner != Global.Nobody)
{
starBrush = Brushes.Red;
}
}
FillCircle(g, starBrush, (Point)position, size);
// If the Star name display is turned on then add the name
if (this.displayStarNames && zoomFactor > 0.5)
{
StringFormat format = new StringFormat();
format.Alignment = StringAlignment.Center;
g.DrawString(report.Name, this.nameFont, Brushes.White, position.X, position.Y + 5, format);
}
}
public void Update(Star star)
{
this.Value = star.GenerateReport(ScanLevel.Owned, empireState.TurnYear);
}
