public void DecomposeUnits(SerializableMapData mapData)
{
foreach (var unitData in mapData.Units)
{
var unitLocation = Grid.GetCellAtCoordinates(unitData.Location);
var templateToBuild = AvailableUnitTemplates.Where(template => template.name.Equals(unitData.Template)).First();
var unitOwner = CivilizationFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(unitData.Owner)).First();
var promotionTree = PromotionTreeComposer.DecomposePromotionTree(unitData.PromotionTree);
var newUnit = UnitFactory.BuildUnit(unitLocation, templateToBuild, unitOwner, promotionTree);
newUnit.CurrentMovement = unitData.CurrentMovement;
newUnit.CurrentHitpoints = unitData.Hitpoints;
newUnit.Experience = unitData.Experience;
newUnit.Level = unitData.Level;
if (unitData.CurrentPath != null)
{
newUnit.CurrentPath = unitData.CurrentPath.Select(coord => Grid.GetCellAtCoordinates(coord)).ToList();
}
if (unitData.IsSetUpToBombard)
{
newUnit.SetUpToBombard();
}
}
}
public void DecomposeDataIntoRuntime(SerializableMapData mapData, Action performAfterDecomposition = null)
{
if (DecomposeCoroutine == null)
{
DecomposeCoroutine = CoroutineInvoker.StartCoroutine(DecomposeDataIntoRuntime_Coroutine(mapData, performAfterDecomposition));
}
}
public void ComposeUnits(SerializableMapData mapData)
{
mapData.Units = new List <SerializableUnitData>();
foreach (var unit in UnitFactory.AllUnits)
{
if (unit.Type == UnitType.City)
{
continue;
}
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var unitData = new SerializableUnitData()
{
Location = unitLocation.Coordinates,
Template = unit.Template.name,
Owner = unitOwner.Template.Name,
CurrentMovement = unit.CurrentMovement,
Hitpoints = unit.CurrentHitpoints,
CurrentPath = unit.CurrentPath != null?unit.CurrentPath.Select(cell => cell.Coordinates).ToList() : null,
IsSetUpToBombard = unit.IsSetUpToBombard,
Experience = unit.Experience,
Level = unit.Level,
PromotionTree = PromotionTreeComposer.ComposePromotionTree(unit.PromotionTree)
};
mapData.Units.Add(unitData);
}
}
public void WriteMapDataToFile(SerializableMapData mapData, string filename)
{
WriteMapToFile(mapData, string.Format(
"{0}\\{1}\\{2}.xml",
Application.persistentDataPath, MapPath, filename
));
}
public void DecomposePlayers(SerializableMapData mapData)
{
foreach (var playerData in mapData.Players)
{
var controlledCiv = CivFactory.AllCivilizations.FirstOrDefault(
civ => civ.Template.Name.Equals(playerData.ControlledCiv)
);
if (controlledCiv == null)
{
throw new InvalidOperationException("Could not find a civ of template " + playerData.ControlledCiv);
}
var playerBrain = BrainPile.AllBrains.FirstOrDefault(
brain => brain.Name.Equals(playerData.Brain)
);
if (playerBrain == null)
{
throw new InvalidOperationException("Could not find a brain of name " + playerData.Brain);
}
PlayerFactory.CreatePlayer(controlledCiv, playerBrain);
}
GameCore.ActivePlayer = mapData.ActivePlayer != null
? PlayerFactory.AllPlayers.First(player => player.Name.Equals(mapData.ActivePlayer))
: null;
}
public void ComposeDiplomacy(SerializableMapData mapData)
{
var diplomacyData = new SerializableDiplomacyData();
foreach (var war in WarCanon.GetAllActiveWars())
{
diplomacyData.ActiveWars.Add(
new Tuple <string, string>(war.Attacker.Template.Name, war.Defender.Template.Name)
);
}
foreach (var fromCiv in CivFactory.AllCivilizations)
{
foreach (var proposalFrom in DiplomacyCore.GetProposalsSentFromCiv(fromCiv))
{
diplomacyData.ActiveProposals.Add(ProposalComposer.ComposeProposal(proposalFrom));
}
foreach (var ongoingDealFrom in DiplomacyCore.GetOngoingDealsSentFromCiv(fromCiv))
{
diplomacyData.ActiveOngoingDeals.Add(OngoingDealComposer.ComposeOngoingDeal(ongoingDealFrom));
}
}
mapData.DiplomacyData = diplomacyData;
}
private void WriteMapToFile(SerializableMapData map, string path)
{
using (var fileStream = new FileStream(path, FileMode.Create)) {
using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(fileStream)) {
var serializer = new DataContractSerializer(typeof(SerializableMapData), KnownSerializableTypes);
serializer.WriteObject(fileStream, map);
}
}
}
public void DecomposeBarbarians(SerializableMapData mapData)
{
foreach (var encampmentData in mapData.Encampments)
{
var location = Grid.GetCellAtCoordinates(encampmentData.Location);
var newEncampment = EncampmentFactory.CreateEncampment(location);
newEncampment.SpawnProgress = encampmentData.SpawnProgress;
}
}
public void DecomposeCivilizations(SerializableMapData mapData)
{
foreach (var civData in mapData.Civilizations)
{
var civTemplate = AvailableCivTemplates.Where(template => template.Name.Equals(civData.TemplateName)).FirstOrDefault();
var newCiv = CivilizationFactory.Create(civTemplate);
newCiv.GoldStockpile = civData.GoldStockpile;
newCiv.CultureStockpile = civData.CultureStockpile;
PolicyComposer.DecomposePoliciesIntoCiv(civData.SocialPolicies, newCiv);
DecomposeTechs(civData, newCiv);
if (civData.ExploredCells != null)
{
foreach (var exploredCoords in civData.ExploredCells)
{
var exploredCell = Grid.GetCellAtCoordinates(exploredCoords);
ExplorationCanon.SetCellAsExploredByCiv(exploredCell, newCiv);
}
}
DecomposeFreeBuildings(civData, newCiv);
GoldenAgeCanon.SetGoldenAgeProgressForCiv(newCiv, civData.GoldenAgeProgress);
GoldenAgeCanon.SetPreviousGoldenAgesForCiv(newCiv, civData.PreviousGoldenAges);
if (civData.GoldenAgeTurnsLeft > 0)
{
GoldenAgeCanon.StartGoldenAgeForCiv(newCiv, civData.GoldenAgeTurnsLeft);
}
}
foreach (var discoveryPair in mapData.CivDiscoveryPairs)
{
var civOne = CivilizationFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(discoveryPair.Item1)).FirstOrDefault();
var civTwo = CivilizationFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(discoveryPair.Item2)).FirstOrDefault();
if (CivDiscoveryCanon.CanEstablishDiscoveryBetweenCivs(civOne, civTwo))
{
CivDiscoveryCanon.EstablishDiscoveryBetweenCivs(civOne, civTwo);
}
else
{
throw new InvalidOperationException(
string.Format("Invalid discovery for civs of template names {0} and {1}", discoveryPair.Item1, discoveryPair.Item2)
);
}
}
}
public void DecomposeDiplomacy(SerializableMapData mapData)
{
var diplomacyData = mapData.DiplomacyData;
if (diplomacyData == null)
{
return;
}
var allCivs = CivFactory.AllCivilizations;
foreach (var warData in diplomacyData.ActiveWars)
{
var attacker = allCivs.Where(civ => civ.Template.Name.Equals(warData.Item1)).FirstOrDefault();
if (attacker == null)
{
throw new InvalidOperationException("Could not find a civ with name " + warData.Item1);
}
var defender = allCivs.Where(civ => civ.Template.Name.Equals(warData.Item2)).FirstOrDefault();
if (defender == null)
{
throw new InvalidOperationException("Could not find a civ with name " + warData.Item2);
}
if (!WarCanon.CanDeclareWar(attacker, defender))
{
throw new InvalidOperationException(string.Format(
"Cannot declare the specified war between {0} and {1}",
attacker.Template.Name, defender.Template.Name
));
}
WarCanon.DeclareWar(attacker, defender);
}
foreach (var proposalData in diplomacyData.ActiveProposals)
{
var proposal = ProposalComposer.DecomposeProposal(proposalData);
DiplomacyCore.SendProposal(proposal);
}
foreach (var ongoingDealData in diplomacyData.ActiveOngoingDeals)
{
var ongoingDeal = OngoingDealComposer.DecomposeOngoingDeal(ongoingDealData);
DiplomacyCore.SubscribeOngoingDeal(ongoingDeal);
}
}
public void DecomposeImprovements(SerializableMapData mapData)
{
foreach (var improvementData in mapData.Improvements)
{
var templateToBuild = AvailableImprovementTemplates.Where(
template => template.name.Equals(improvementData.Template)
).First();
var locationToBuild = Grid.GetCellAtCoordinates(improvementData.Location);
ImprovementFactory.BuildImprovement(
templateToBuild, locationToBuild, improvementData.WorkInvested,
improvementData.IsConstructed, improvementData.IsPillaged
);
}
}
public void ComposeBarbarians(SerializableMapData mapData)
{
mapData.Encampments = new List <SerializableEncampmentData>();
foreach (var encampment in EncampmentFactory.AllEncampments)
{
var location = EncampmentLocationCanon.GetOwnerOfPossession(encampment);
var encampmentData = new SerializableEncampmentData()
{
Location = location.Coordinates,
SpawnProgress = encampment.SpawnProgress
};
mapData.Encampments.Add(encampmentData);
}
}
public void ComposePlayers(SerializableMapData mapData)
{
mapData.Players = new List <SerializablePlayerData>();
foreach (var player in PlayerFactory.AllPlayers)
{
var playerData = new SerializablePlayerData()
{
ControlledCiv = player.ControlledCiv.Template.Name,
Brain = player.Brain.Name
};
mapData.Players.Add(playerData);
}
mapData.ActivePlayer = GameCore.ActivePlayer != null ? GameCore.ActivePlayer.Name : null;
}
public void DecomposeCapitalCities(SerializableMapData mapData)
{
for (int i = 0; i < mapData.Civilizations.Count; i++)
{
var civ = CivFactory.AllCivilizations[i];
var civData = mapData.Civilizations[i];
if (civData.CapitalLocation != null)
{
var capitalLocation = Grid.GetCellAtCoordinates(civData.CapitalLocation.Value);
var capitalCity = CityLocationCanon.GetPossessionsOfOwner(capitalLocation).FirstOrDefault();
CapitalCityCanon.SetCapitalOfCiv(civ, capitalCity);
}
}
}
public SerializableMapData ComposeRuntimeIntoData()
{
var mapData = new SerializableMapData();
HexCellComposer.ComposeCells(mapData);
CivilizationComposer.ComposeCivilizations(mapData);
PlayerComposer.ComposePlayers(mapData);
CityComposer.ComposeCities(mapData);
BuildingComposer.ComposeBuildings(mapData);
UnitComposer.ComposeUnits(mapData);
ImprovementComposer.ComposeImprovements(mapData);
ResourceComposer.ComposeResources(mapData);
DiplomacyComposer.ComposeDiplomacy(mapData);
CapitalCityComposer.ComposeCapitalCities(mapData);
BarbarianComposer.ComposeBarbarians(mapData);
return(mapData);
}
public void ComposeBuildings(SerializableMapData mapData)
{
mapData.Buildings = new List <SerializableBuildingData>();
foreach (var building in BuildingFactory.AllBuildings)
{
var buildingOwner = BuildingPossessionCanon.GetOwnerOfPossession(building);
var ownerLocation = CityLocationCanon.GetOwnerOfPossession(buildingOwner);
var buildingData = new SerializableBuildingData();
buildingData.Template = building.Template.name;
buildingData.CityLocation = ownerLocation.Coordinates;
buildingData.IsSlotLocked = building.Slots.Select(slot => slot.IsLocked).ToList();
buildingData.IsSlotOccupied = building.Slots.Select(slot => slot.IsOccupied).ToList();
mapData.Buildings.Add(buildingData);
}
}
public void DecomposeBuildings(SerializableMapData mapData)
{
foreach (var buildingData in mapData.Buildings)
{
var templateToBuild = AllBuildingTemplates.Where(template => template.name.Equals(buildingData.Template)).First();
var cellAtCoords = Grid.GetCellAtCoordinates(buildingData.CityLocation);
var cityAtLocation = CityLocationCanon.GetPossessionsOfOwner(cellAtCoords).First();
var newBuilding = BuildingFactory.BuildBuilding(templateToBuild, cityAtLocation);
for (int i = 0; i < newBuilding.Slots.Count; i++)
{
var slot = newBuilding.Slots[i];
slot.IsOccupied = buildingData.IsSlotOccupied[i];
slot.IsLocked = buildingData.IsSlotLocked [i];
}
}
}
public void ComposeImprovements(SerializableMapData mapData)
{
mapData.Improvements = new List <SerializableImprovementData>();
foreach (var improvement in ImprovementFactory.AllImprovements)
{
var improvementLocation = ImprovementLocationCanon.GetOwnerOfPossession(improvement);
var newImprovementData = new SerializableImprovementData()
{
Location = improvementLocation.Coordinates,
Template = improvement.Template.name,
WorkInvested = improvement.WorkInvested,
IsConstructed = improvement.IsConstructed,
IsPillaged = improvement.IsPillaged
};
mapData.Improvements.Add(newImprovementData);
}
}
public void DecomposeCities(SerializableMapData mapData)
{
foreach (var cityData in mapData.Cities)
{
var owner = CivilizationFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(cityData.Owner)).FirstOrDefault();
var location = Grid.GetCellAtCoordinates(cityData.Location);
var newCity = CityFactory.Create(location, owner, cityData.Name);
newCity.Population = cityData.Population;
newCity.FoodStockpile = cityData.FoodStockpile;
newCity.CultureStockpile = cityData.CultureStockpile;
newCity.YieldFocus = cityData.YieldFocus;
newCity.CombatFacade.CurrentHitpoints = cityData.Hitpoints;
newCity.CombatFacade.CurrentMovement = cityData.CurrentMovement;
DecomposeActiveProject(cityData, newCity);
DecomposeAppliedTemplates(cityData, newCity);
}
}
public void ComposeCapitalCities(SerializableMapData mapData)
{
for (int i = 0; i < CivFactory.AllCivilizations.Count; i++)
{
var civ = CivFactory.AllCivilizations[i];
var civData = mapData.Civilizations[i];
var civCapital = CapitalCityCanon.GetCapitalOfCiv(civ);
if (civCapital != null)
{
var capitalLocation = CityLocationCanon.GetOwnerOfPossession(civCapital);
civData.CapitalLocation = capitalLocation.Coordinates;
}
else
{
civData.CapitalLocation = null;
}
}
}
public void ComposeCells(SerializableMapData mapData)
{
mapData.CellCountX = Grid.CellCountX;
mapData.CellCountZ = Grid.CellCountZ;
mapData.HexCells = new List <SerializableHexCellData>();
foreach (var cell in Grid.Cells)
{
var newCellData = new SerializableHexCellData()
{
Coordinates = cell.Coordinates,
Terrain = cell.Terrain,
Shape = cell.Shape,
Vegetation = cell.Vegetation,
Feature = cell.Feature,
SuppressSlot = cell.SuppressSlot,
HasRoads = cell.HasRoads,
IsSlotOccupied = cell.WorkerSlot.IsOccupied,
IsSlotLocked = cell.WorkerSlot.IsLocked,
HasRiverAtEdge = new List <bool>(new bool[6]),
DirectionOfRiverAtEdge = new List <RiverFlow>(new RiverFlow[6])
};
//We only need to compose rivers on three sides of the cell.
//The other three will be handled by the cell's neighbors.
//It's guaranteed to have a neighbor in any rivered direction
//because rivers cannot be placed along an edge without two
//living neighbors.
foreach (var edgeWithRiver in RiverCanon.GetEdgesWithRivers(cell).Intersect(RiverDirections))
{
newCellData.HasRiverAtEdge[(int)edgeWithRiver] = true;
newCellData.DirectionOfRiverAtEdge[(int)edgeWithRiver]
= RiverCanon.GetFlowOfRiverAtEdge(cell, edgeWithRiver);
}
mapData.HexCells.Add(newCellData);
}
}
public void ComposeCities(SerializableMapData mapData)
{
mapData.Cities = new List <SerializableCityData>();
foreach (var city in CityFactory.AllCities)
{
var cityData = new SerializableCityData()
{
Name = city.Name,
Location = CityLocationCanon.GetOwnerOfPossession(city).Coordinates,
Owner = CityPossessionCanon.GetOwnerOfPossession(city).Template.Name,
Population = city.Population,
FoodStockpile = city.FoodStockpile,
CultureStockpile = city.CultureStockpile,
YieldFocus = city.YieldFocus,
Hitpoints = city.CombatFacade.CurrentHitpoints,
CurrentMovement = city.CombatFacade.CurrentMovement
};
var activeProject = city.ActiveProject;
if (activeProject != null)
{
cityData.ActiveProject = new SerializableProjectData()
{
BuildingToConstruct = activeProject.BuildingToConstruct != null ? activeProject.BuildingToConstruct.name : null,
UnitToConstruct = activeProject.UnitToConstruct != null ? activeProject.UnitToConstruct.name : null,
Progress = activeProject.Progress
};
}
cityData.AppliedFreeBuildings = FreeBuildingApplier.GetTemplatesAppliedToCity(city)
.Select(template => template.name)
.ToList();
mapData.Cities.Add(cityData);
}
}
private IEnumerator DecomposeDataIntoRuntime_Coroutine(SerializableMapData mapData, Action performAfterDecomposition)
{
yield return(ClearRuntime_Coroutine(false));
HexCellComposer.DecomposeCells(mapData);
yield return(new WaitForEndOfFrame());
CapitalCitySynchronizer.SetCapitalUpdating(false);
foreach (var element in PlayModeSensitiveElements)
{
element.IsActive = false;
}
CivilizationComposer.DecomposeCivilizations(mapData);
PlayerComposer.DecomposePlayers(mapData);
CityComposer.DecomposeCities(mapData);
BuildingComposer.DecomposeBuildings(mapData);
UnitComposer.DecomposeUnits(mapData);
ResourceComposer.DecomposeResources(mapData);
ImprovementComposer.DecomposeImprovements(mapData);
BarbarianComposer.DecomposeBarbarians(mapData);
CapitalCitySynchronizer.SetCapitalUpdating(true);
yield return(new WaitForEndOfFrame());
DiplomacyComposer.DecomposeDiplomacy(mapData);
CapitalCityComposer.DecomposeCapitalCities(mapData);
if (performAfterDecomposition != null)
{
performAfterDecomposition();
}
DecomposeCoroutine = null;
}
public void DecomposeCells(SerializableMapData mapData)
{
Grid.Build(mapData.CellCountX, mapData.CellCountZ);
foreach (var cellData in mapData.HexCells)
{
var cellToModify = Grid.GetCellAtCoordinates(cellData.Coordinates);
CellModificationLogic.ChangeTerrainOfCell(cellToModify, cellData.Terrain);
CellModificationLogic.ChangeShapeOfCell(cellToModify, cellData.Shape);
CellModificationLogic.ChangeVegetationOfCell(cellToModify, cellData.Vegetation);
CellModificationLogic.ChangeFeatureOfCell(cellToModify, cellData.Feature);
CellModificationLogic.ChangeHasRoadsOfCell(cellToModify, cellData.HasRoads);
cellToModify.SuppressSlot = cellData.SuppressSlot;
//Converging rivers (where two rivers combine and flow into a third) have
//order-sensitive creation, since attempting to place both of the inflow
//rivers before the outflow river has been created is invalid. To account for
//this, we delay the creation of any invalid rivers (since those represent
//an inflow being attached to another inflow) until after all other rivers
//have been placed.
var delayedRivers = new List <System.Tuple <IHexCell, HexDirection, RiverFlow> >();
for (int i = 0; i < 6; i++)
{
var edge = (HexDirection)i;
if (cellData.HasRiverAtEdge[i] && !RiverCanon.HasRiverAlongEdge(cellToModify, edge))
{
if (RiverCanon.CanAddRiverToCell(cellToModify, edge, cellData.DirectionOfRiverAtEdge[i]))
{
RiverCanon.AddRiverToCell(cellToModify, edge, cellData.DirectionOfRiverAtEdge[i]);
}
else
{
delayedRivers.Add(new System.Tuple <IHexCell, HexDirection, RiverFlow>(
cellToModify, edge, cellData.DirectionOfRiverAtEdge[i]
));
}
}
}
foreach (var river in delayedRivers)
{
if (RiverCanon.CanAddRiverToCell(river.Item1, river.Item2, river.Item3))
{
RiverCanon.AddRiverToCell(river.Item1, river.Item2, river.Item3);
}
else
{
throw new InvalidOperationException(string.Format(
"Failed to decompose river ({0}, {1}, {2})",
river.Item1, river.Item2, river.Item3
));
}
}
cellToModify.WorkerSlot.IsOccupied = cellData.IsSlotOccupied;
cellToModify.WorkerSlot.IsLocked = cellData.IsSlotLocked;
}
foreach (var chunk in Grid.Chunks)
{
chunk.Refresh(MapRendering.TerrainRefreshType.All);
}
}
public void ComposeCivilizations(SerializableMapData mapData)
{
mapData.Civilizations = new List <SerializableCivilizationData>();
foreach (var civilization in CivilizationFactory.AllCivilizations)
{
var civData = new SerializableCivilizationData()
{
TemplateName = civilization.Template.Name,
GoldStockpile = civilization.GoldStockpile,
CultureStockpile = civilization.CultureStockpile,
DiscoveredTechs = TechCanon.GetTechsDiscoveredByCiv(civilization).Select(tech => tech.Name).ToList(),
SocialPolicies = PolicyComposer.ComposePoliciesFromCiv(civilization),
};
if (civilization.TechQueue != null && civilization.TechQueue.Count > 0)
{
civData.TechQueue = civilization.TechQueue.Select(tech => tech.Name).ToList();
}
else
{
civData.TechQueue = null;
}
var availableTechs = TechCanon.GetTechsAvailableToCiv(civilization);
if (availableTechs.Count() > 0)
{
foreach (var availableTech in availableTechs)
{
int progress = TechCanon.GetProgressOnTechByCiv(availableTech, civilization);
if (progress != 0)
{
if (civData.ProgressOnTechs == null)
{
civData.ProgressOnTechs = new Dictionary <string, int>();
}
civData.ProgressOnTechs[availableTech.Name] = progress;
}
}
}
else
{
civData.ProgressOnTechs = null;
}
var exploredCells = Grid.Cells.Where(cell => ExplorationCanon.IsCellExploredByCiv(cell, civilization));
civData.ExploredCells = exploredCells.Select(cell => cell.Coordinates).ToList();
civData.FreeBuildings = FreeBuildingsCanon
.GetFreeBuildingsForCiv(civilization)
.Select(buildingList => buildingList.Select(buildingTemplate => buildingTemplate.name).ToList())
.ToList();
civData.GoldenAgeTurnsLeft = GoldenAgeCanon.GetTurnsLeftOnGoldenAgeForCiv(civilization);
civData.GoldenAgeProgress = GoldenAgeCanon.GetGoldenAgeProgressForCiv(civilization);
civData.PreviousGoldenAges = GoldenAgeCanon.GetPreviousGoldenAgesForCiv(civilization);
mapData.Civilizations.Add(civData);
}
mapData.CivDiscoveryPairs = CivDiscoveryCanon.GetDiscoveryPairs().Select(
pair => new Tuple <string, string>(pair.Item1.Template.Name, pair.Item2.Template.Name)
).ToList();
}
public MapFileData(SerializableMapData mapData, string fileName, DateTime lastModified)
{
MapData = mapData;
FileName = fileName;
LastModified = lastModified;
}
