public FleetManager(Empire empire) { this._empire = empire; _currentShipDesignID = 0; _fleets = new List<Fleet>(); CurrentDesigns = new List<Ship>(); //ObsoleteDesigns = new List<Ship>(); }
public void SplitFleet(Empire empire) { Fleet fleet = new Fleet(); fleet.Empire = FleetToSplit.Empire; fleet.GalaxyX = FleetToSplit.GalaxyX; fleet.GalaxyY = FleetToSplit.GalaxyY; fleet.AdjacentSystem = FleetToSplit.AdjacentSystem; foreach (KeyValuePair<Ship, int> ship in FleetToSplit.Ships) { if (ship.Value > 0) { SelectedFleet.SubtractShips(ship.Key, ship.Value); fleet.AddShips(ship.Key, ship.Value); } } foreach (var transport in FleetToSplit.TransportShips) { if (transport.amount > 0) { SelectedFleet.SubtractTransport(transport.raceOnShip, transport.amount); fleet.AddTransport(transport.raceOnShip, transport.amount); } } SelectedFleet.ClearEmptyShips(); fleet.ClearEmptyShips(); fleet.TravelNodes = FleetToSplit.TravelNodes; if (SelectedFleet.Ships.Count == 0 && SelectedFleet.TransportShips.Count == 0) { Fleets.Remove(SelectedFleet); empire.FleetManager.RemoveFleet(SelectedFleet); } if (fleet.Ships.Count > 0 || fleet.TransportShips.Count > 0) { Fleets.Add(fleet); empire.FleetManager.AddFleet(fleet); } SelectedFleet = fleet; }
private bool IsDestinationValid(StarSystem destination, bool hasExtended, Empire whichEmpire) { if (destination.Planets[0].Owner == whichEmpire) { //By default, always true if destination is owned return(true); } int fuelRange = (whichEmpire.TechnologyManager.FuelRange + (hasExtended ? 3 : 0)) * PARSEC_SIZE_IN_PIXELS; fuelRange *= fuelRange; //To avoid square rooting foreach (StarSystem system in starSystems) { if (system.Planets[0].Owner == whichEmpire) { float x = destination.X - system.X; float y = destination.Y - system.Y; if ((x * x) + (y * y) <= fuelRange) { return(true); } } } return(false); }
private void SetValues(string name, string type, int maxPop, StarSystem system, Empire empire, Random r) { _whichSystem = system; this._name = name; _races = new List<Race>(); _racePopulations = new Dictionary<Race, float>(); TransferSystem = new KeyValuePair<TravelNode, int>(new TravelNode(), 0); TransferSystemID = new KeyValuePair<int, int>(); RelocateToSystem = null; Owner = empire; _populationMax = maxPop; switch (type) { case ARCTIC: { _planetType = PLANET_TYPE.ARCTIC; SmallSprite = SpriteManager.GetSprite("ArcticPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("ArcticGround", r); } break; case BADLANDS: { _planetType = PLANET_TYPE.BADLAND; SmallSprite = SpriteManager.GetSprite("BadlandsPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("BadlandsGround", r); } break; case BARREN: { _planetType = PLANET_TYPE.BARREN; SmallSprite = SpriteManager.GetSprite("BarrenPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("BarrenGround", r); } break; case DEAD: { _planetType = PLANET_TYPE.DEAD; SmallSprite = SpriteManager.GetSprite("DeadPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("DeadGround", r); } break; case DESERT: { _planetType = PLANET_TYPE.DESERT; SmallSprite = SpriteManager.GetSprite("DesertPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("DesertGround", r); } break; case JUNGLE: { _planetType = PLANET_TYPE.JUNGLE; SmallSprite = SpriteManager.GetSprite("JunglePlanetSmall", r); GroundSprite = SpriteManager.GetSprite("JungleGround", r); } break; case NONE: { _planetType = PLANET_TYPE.NONE; SmallSprite = SpriteManager.GetSprite("AsteroidsPlanetSmall", r); } break; case OCEANIC: { _planetType = PLANET_TYPE.OCEAN; SmallSprite = SpriteManager.GetSprite("OceanicPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("OceanicGround", r); } break; case RADIATED: { _planetType = PLANET_TYPE.RADIATED; SmallSprite = SpriteManager.GetSprite("RadiatedPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("RadiatedGround", r); } break; case STEPPE: { _planetType = PLANET_TYPE.STEPPE; SmallSprite = SpriteManager.GetSprite("SteppePlanetSmall", r); GroundSprite = SpriteManager.GetSprite("SteppeGround", r); } break; case TERRAN: { _planetType = PLANET_TYPE.TERRAN; SmallSprite = SpriteManager.GetSprite("TerranPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("TerranGround", r); } break; case TOXIC: { _planetType = PLANET_TYPE.TOXIC; SmallSprite = SpriteManager.GetSprite("ToxicPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("ToxicGround", r); } break; case TUNDRA: { _planetType = PLANET_TYPE.TUNDRA; SmallSprite = SpriteManager.GetSprite("TundraPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("TundraGround", r); } break; case VOLCANIC: { _planetType = PLANET_TYPE.VOLCANIC; SmallSprite = SpriteManager.GetSprite("VolcanicPlanetSmall", r); GroundSprite = SpriteManager.GetSprite("VolcanicGround", r); } break; } _planetTypeString = Utility.PlanetTypeToString(_planetType); }
public void RemoveEmpire(Empire empire) { _empires.Remove(empire); }
public StarSystem SetHomeworld(Empire empire, out Planet homePlanet) { lock (_lockGalaxy) //Won't modify anything, but ensures that galaxy is created and won't throw exceptions due to contents being modified { Random r = new Random(); List<StarSystem> potentialSystems = new List<StarSystem>(starSystems); while (true) { if (potentialSystems.Count == 0) { homePlanet = null; return null; } var potentialSystem = potentialSystems[r.Next(potentialSystems.Count)]; if (potentialSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { potentialSystems.Remove(potentialSystem); continue; } //Validation checks bool FourParsecsSystem = false; bool SixParsecsSystem = false; bool AtLeastSixParsecsAwayFromOthers = true; foreach (StarSystem starSystem in starSystems) { if (potentialSystem != starSystem) { int x = potentialSystem.X - starSystem.X; int y = potentialSystem.Y - starSystem.Y; double distance = Math.Sqrt((x * x) + (y * y)); if (distance <= PARSEC_SIZE_IN_PIXELS * 4) { if (!FourParsecsSystem) { FourParsecsSystem = true; } else { //Already have another star system that's within 4 parsecs SixParsecsSystem = true; } if (starSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { AtLeastSixParsecsAwayFromOthers = false; break; } } else if (distance <= PARSEC_SIZE_IN_PIXELS * 6) { SixParsecsSystem = true; if (starSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { AtLeastSixParsecsAwayFromOthers = false; break; } } } } if (FourParsecsSystem && SixParsecsSystem && AtLeastSixParsecsAwayFromOthers) { potentialSystem.SetHomeworld(empire, out homePlanet, r); return potentialSystem; } potentialSystems.Remove(potentialSystem); } } }
public StarSystem SetHomeworld(Empire empire, out Planet homePlanet) { lock (_lockGalaxy) //Won't modify anything, but ensures that galaxy is created and won't throw exceptions due to contents being modified { Random r = new Random(); List <StarSystem> potentialSystems = new List <StarSystem>(starSystems); while (true) { if (potentialSystems.Count == 0) { homePlanet = null; return(null); } var potentialSystem = potentialSystems[r.Next(potentialSystems.Count)]; if (potentialSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { potentialSystems.Remove(potentialSystem); continue; } //Validation checks bool FourParsecsSystem = false; bool SixParsecsSystem = false; bool AtLeastSixParsecsAwayFromOthers = true; foreach (StarSystem starSystem in starSystems) { if (potentialSystem != starSystem) { int x = potentialSystem.X - starSystem.X; int y = potentialSystem.Y - starSystem.Y; double distance = Math.Sqrt((x * x) + (y * y)); if (distance <= PARSEC_SIZE_IN_PIXELS * 4) { if (!FourParsecsSystem) { FourParsecsSystem = true; } else { //Already have another star system that's within 4 parsecs SixParsecsSystem = true; } if (starSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { AtLeastSixParsecsAwayFromOthers = false; break; } } else if (distance <= PARSEC_SIZE_IN_PIXELS * 6) { SixParsecsSystem = true; if (starSystem.EmpiresWithPlanetsInThisSystem.Count > 0) { AtLeastSixParsecsAwayFromOthers = false; break; } } } } if (FourParsecsSystem && SixParsecsSystem && AtLeastSixParsecsAwayFromOthers) { potentialSystem.SetHomeworld(empire, out homePlanet, r); return(potentialSystem); } potentialSystems.Remove(potentialSystem); } } }
public bool SystemHavePlanetOwnedByEmpire(Empire empire) { return(EmpiresWithPlanetsInThisSystem.Contains(empire)); }
public void Load(XElement fleet, FleetManager fleetManager, Empire empire, GameMain gameMain) { _empire = empire; _galaxyX = float.Parse(fleet.Attribute("X").Value); _galaxyY = float.Parse(fleet.Attribute("Y").Value); _adjacentSystem = gameMain.Galaxy.GetStarWithID(int.Parse(fleet.Attribute("AdjacentSystem").Value)); var travelNodes = fleet.Element("TravelNodes"); if (travelNodes != null) { _travelNodes = new List<TravelNode>(); StarSystem startingPlace = null; foreach (var travelNode in travelNodes.Elements()) { var destination = gameMain.Galaxy.GetStarWithID(int.Parse(travelNode.Attribute("Destination").Value)); if (startingPlace == null) { _travelNodes.Add(gameMain.Galaxy.GenerateTravelNode(_galaxyX, _galaxyY, destination)); } else { _travelNodes.Add(gameMain.Galaxy.GenerateTravelNode(startingPlace, destination)); } startingPlace = destination; } } foreach (var ship in fleet.Elements("Ship")) { AddShips(fleetManager.GetShipWithDesignID(int.Parse(ship.Attribute("ShipDesign").Value)), int.Parse(ship.Attribute("NumberOfShips").Value)); } foreach (var transport in fleet.Elements("Transport")) { AddTransport(gameMain.RaceManager.GetRace(transport.Attribute("Race").Value), int.Parse(transport.Attribute("Count").Value)); } }
public void AddEmpire(Empire empire) { _empires.Add(empire); }
public void SetInitialEmpireTurn() { foreach (Empire empire in _empires) { //Reset fleet movement and stuff empire.FleetManager.ResetFleetMovements(); } empireIter = 0; //If first player isn't human, find the next one for (int i = 0; i < _empires.Count; i++) { if (_empires[i].Type != PlayerType.HUMAN) { _empires[i].HandleAIEmpire(); } else { currentEmpire = _empires[i]; empireIter = i; break; } } }
public bool ProcessNextEmpire() { if (empireIter + 1 == _empires.Count) { //It've reached the end return true; } //This will update each empire if they're AI. If an empire is human-controlled, it stops and waits for the player to press end of turn for (int i = empireIter + 1; i < _empires.Count; i++) { empireIter = i; if (_empires[i].Type != PlayerType.HUMAN) { _empires[i].HandleAIEmpire(); if (i + 1 == _empires.Count) { //reached end of list with CPU player as last player return true; } } else { currentEmpire = _empires[i]; break; } } return false; }
public bool Load(XElement root) { _empires = new List<Empire>(); var empires = root.Element("Empires"); foreach (var empire in empires.Elements()) { var newEmpire = new Empire(); newEmpire.Load(empire, _gameMain); _empires.Add(newEmpire); } foreach (var empire in _empires) { empire.SetUpContacts(_empires); //TODO: Update all empires' contacts } SetInitialEmpireTurn(); return true; }
public Planet(string name, string type, int maxPop, Empire owner, StarSystem system, Random r) { SetValues(name, type, maxPop, system, owner, r); }
public void AddEmpireExplored(Empire empire) { exploredBy.Add(empire); }
public void Load(XElement empireDoc, Empire empire, GameMain gameMain) { var currentDesigns = empireDoc.Element("CurrentShipDesigns"); foreach (var currentDesign in currentDesigns.Elements()) { var currentShip = new Ship(); currentShip.Load(currentDesign, gameMain); currentShip.Owner = empire; CurrentDesigns.Add(currentShip); } /*var obsoleteDesigns = empireDoc.Element("ObsoleteShipDesigns"); foreach (var obsoleteDesign in obsoleteDesigns.Elements()) { var obsoleteShip = new Ship(); obsoleteShip.Load(obsoleteDesign, gameMain); obsoleteShip.Owner = empire; ObsoleteDesigns.Add(obsoleteShip); }*/ var fleets = empireDoc.Element("Fleets"); foreach (var fleet in fleets.Elements()) { var newFleet = new Fleet(); newFleet.Load(fleet, this, empire, gameMain); _fleets.Add(newFleet); } }
public bool IsThisSystemExploredByEmpire(Empire empire) { return exploredBy.Contains(empire); }
public bool IsThisSystemExploredByEmpire(Empire empire) { return(exploredBy.Contains(empire)); }
public void SetHomeworld(Empire empire, out Planet homePlanet, Random r) { if (planets.Count == 0) { planets.Add(new Planet(name, r, this)); //planets.Add(new Planet(name + " I", r, this)); planets[0].SetHomeworld(empire, r); homePlanet = planets[0]; } else { int whichPlanet = r.Next(planets.Count); planets[whichPlanet].SetHomeworld(empire, r); homePlanet = planets[whichPlanet]; } Color = Color.Yellow; //Homeworlds always have yellow stars exploredBy.Add(empire); UpdateOwners(); }
public bool SystemHavePlanetOwnedByEmpire(Empire empire) { return EmpiresWithPlanetsInThisSystem.Contains(empire); }
/// <summary> /// Pathfinding function /// </summary> /// <param name="currentX">Fleet's Galaxy X</param> /// <param name="currentY">Fleet's Galaxy Y</param> /// <param name="currentDestination">Fleet's current destination for when empire don't have hyperspace communications</param> /// <param name="newDestination">New destination</param> /// <param name="hasExtended"></param> /// <param name="whichEmpire">For fuel range and other info</param> /// <returns></returns> public List <TravelNode> GetPath(float currentX, float currentY, StarSystem currentDestination, StarSystem newDestination, bool hasExtended, Empire whichEmpire) { // TODO: When Hyperspace communication is implemented, add this /* * if (whichEmpire.HasHyperspaceCommunications()) * { * * } * else * { * } */ // TODO: When adding stargates and wormholes, add actual pathfinding List <TravelNode> nodes = new List <TravelNode>(); if (currentDestination != null) { TravelNode newNode = GenerateTravelNode(currentX, currentY, currentDestination); newNode.IsValid = true; nodes.Add(newNode); newNode = GenerateTravelNode(currentDestination, newDestination); newNode.IsValid = IsDestinationValid(newDestination, hasExtended, whichEmpire); nodes.Add(newNode); } else { TravelNode newNode = GenerateTravelNode(currentX, currentY, newDestination); newNode.IsValid = IsDestinationValid(newDestination, hasExtended, whichEmpire); nodes.Add(newNode); } return(nodes); }
public void Colonize(Empire whichEmpire) { _owner = whichEmpire; whichEmpire.PlanetManager.AddOwnedPlanet(this); _racePopulations = new Dictionary<Race, float>(); _racePopulations.Add(whichEmpire.EmpireRace, 2); _races.Add(whichEmpire.EmpireRace); SetOutputAmount(OUTPUT_TYPE.INFRASTRUCTURE, 100, true); _shipBeingBuilt = whichEmpire.FleetManager.CurrentDesigns[0]; System.UpdateOwners(); }
/// <summary> /// Pathfinding function /// </summary> /// <param name="currentX">Fleet's Galaxy X</param> /// <param name="currentY">Fleet's Galaxy Y</param> /// <param name="currentDestination">Fleet's current destination for when empire don't have hyperspace communications</param> /// <param name="newDestination">New destination</param> /// <param name="hasExtended"></param> /// <param name="whichEmpire">For fuel range and other info</param> /// <returns></returns> public List<TravelNode> GetPath(float currentX, float currentY, StarSystem currentDestination, StarSystem newDestination, bool hasExtended, Empire whichEmpire) { // TODO: When Hyperspace communication is implemented, add this /* if (whichEmpire.HasHyperspaceCommunications()) { } else { } */ // TODO: When adding stargates and wormholes, add actual pathfinding List<TravelNode> nodes = new List<TravelNode>(); if (currentDestination != null) { TravelNode newNode = GenerateTravelNode(currentX, currentY, currentDestination); newNode.IsValid = true; nodes.Add(newNode); newNode = GenerateTravelNode(currentDestination, newDestination); newNode.IsValid = IsDestinationValid(newDestination, hasExtended, whichEmpire); nodes.Add(newNode); } else { TravelNode newNode = GenerateTravelNode(currentX, currentY, newDestination); newNode.IsValid = IsDestinationValid(newDestination, hasExtended, whichEmpire); nodes.Add(newNode); } return nodes; }
//Set this planet as homeworld public void SetHomeworld(Empire owner, Random r) { _owner = owner; _planetType = PLANET_TYPE.TERRAN; _planetTypeString = Utility.PlanetTypeToString(_planetType); SmallSprite = SpriteManager.GetSprite("TerranPlanetSmall", r); _populationMax = 100; _races.Add(owner.EmpireRace); _racePopulations.Add(owner.EmpireRace, 40); Factories = 30; _factoryInvestments = 300; //Start with 300 BCs invested in factories SetOutputAmount(OUTPUT_TYPE.INFRASTRUCTURE, 100, true); ResearchBonus = PLANET_RESEARCH_BONUS.AVERAGE; ConstructionBonus = PLANET_CONSTRUCTION_BONUS.AVERAGE; EnvironmentBonus = PLANET_ENVIRONMENT_BONUS.AVERAGE; }
private bool IsDestinationValid(StarSystem destination, bool hasExtended, Empire whichEmpire) { if (destination.Planets[0].Owner == whichEmpire) { //By default, always true if destination is owned return true; } int fuelRange = (whichEmpire.TechnologyManager.FuelRange + (hasExtended ? 3 : 0)) * PARSEC_SIZE_IN_PIXELS; fuelRange *= fuelRange; //To avoid square rooting foreach (StarSystem system in starSystems) { if (system.Planets[0].Owner == whichEmpire) { float x = destination.X - system.X; float y = destination.Y - system.Y; if ((x * x) + (y * y) <= fuelRange) { return true; } } } return false; }