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; }