示例#1
0
        private static List<IPerson> GeneratePopulation(int id, ICivilization civilization, int popCount)
        {
            List<IPerson> population = new List<IPerson>();
            for (int n = 0; n < popCount; n++)
            {
                //Thread.Sleep(_Random.Next(200, 700));
                PersonHelper personHelper = new PersonHelper();
                personHelper.Civilization = civilization;
                personHelper.Race = civilization.Race;
                personHelper.Mythology = civilization.Race.Mythos;

                // maybe we should check the population levels before starting the next loop? First thing in the for loop?
                IPopulationCenters popCenter = civilization.PopulationCenters.First(pc => pc.Population.Count < pc.MaxPopulation);
                personHelper.OriginatesFrom = popCenter; // WHAT HAPPENS WHEN WE RUN OUT OF CITIES!?
                personHelper.Father = new Person();
                personHelper.Mother = new Person();
                personHelper.Partner = new Person();

                PersonGen personGen = new PersonGen();

                IPerson person = personGen.GenerateSingle(personHelper);
                population.Add(person);
                popCenter.Population.Add(person);

                if (n < 9) person.SocialStatus = CoreEnums.Status.Highborne;
                WriteToConsole("ID: " + id + "Name: " + population.Last().Name + "; Race: " + population.Last().Race.Name);
            }
            return population;
        }
        /// <summary>
        /// Generates a single Hamlet.
        /// </summary>
        /// <returns></returns>
        public IPopulationCenters GenerateSingle(ICivilization civilization)
        {
            IPopulationCenters center = null;
            if (!civilization.RegionsOwned.Last().CanSupportAdditionalPopulationCenters()) return center; // as long as the last region has available centers we can keep going

            center = new Hamlet(); // we start with a hamlet and move up as population increases
            return CreateCenter(civilization, center);
        }
示例#3
0
文件: Player.cs 项目: eske/INSAWars
 public Player(ICivilization civilization, string name)
 {
     isDead = false;
     cities = new List<City>();
     units = new List<Unit>();
     this.civilization = civilization;
     Name = name;
     Head = null;
     OnPropertyChanged("CitiesCount");
     OnPropertyChanged("Units");
 }
示例#4
0
        public static void CreateGame(int difficulty, int competition, ICivilization tribe, string leaderName = null, string tribeName = null, string tribeNamePlural = null)
        {
            if (_instance != null)
            {
                Log("ERROR: Game instance already exists");
                return;
            }
            _instance = new Game(difficulty, competition, tribe, leaderName, tribeName, tribeNamePlural);

            foreach (IUnit unit in _instance._units)
            {
                unit.Explore();
            }
        }
示例#5
0
 public bool AreAtWar(ICivilization civOne, ICivilization civTwo)
 {
     if (civOne.Template.IsBarbaric || civTwo.Template.IsBarbaric)
     {
         return(true);
     }
     else
     {
         return(ActiveWars.Where(data =>
                                 (data.Attacker == civOne && data.Defender == civTwo) ||
                                 (data.Attacker == civTwo && data.Defender == civOne)
                                 ).Count() > 0);
     }
 }
        private IOngoingDeal BuildOngoingDeal(
            ICivilization sender, ICivilization receiver, out Mock <IOngoingDeal> mock
            )
        {
            mock = new Mock <IOngoingDeal>();

            mock.SetupAllProperties();
            mock.Setup(deal => deal.Sender).Returns(sender);
            mock.Setup(deal => deal.Receiver).Returns(receiver);

            var newDeal = mock.Object;

            return(newDeal);
        }
        private IPlayer BuildPlayer(ICivilization controlledCiv, IPlayerBrain brain)
        {
            var mockPlayer = new Mock <IPlayer>();

            mockPlayer.Setup(player => player.ControlledCiv).Returns(controlledCiv);
            mockPlayer.Setup(player => player.Brain).Returns(brain);
            mockPlayer.Setup(player => player.Name).Returns(controlledCiv.Template.Name);

            var newPlayer = mockPlayer.Object;

            AllPlayers.Add(newPlayer);

            return(newPlayer);
        }
示例#8
0
        private void InputLeaderName()
        {
            if (Common.HasScreenType <Input>())
            {
                return;
            }

            ICivilization civ   = _tribesAvailable[_tribe];
            Input         input = new Input(Palette, civ.Leader.Name, 6, 5, 11, OffsetX + 168, OffsetY + 105, 109, 10, 13);

            input.Accept += LeaderName_Accept;
            input.Cancel += LeaderName_Accept;
            Common.AddScreen(input);
        }
        public YieldSummary GetYieldOfCell(IHexCell cell, ICivilization perspectiveCiv)
        {
            if (cell == null)
            {
                throw new ArgumentNullException("cell");
            }

            YieldSummary retval         = YieldSummary.Empty;
            ICity        cityOwningCell = CellPossessionCanon.GetOwnerOfPossession(cell);

            retval += InherentYieldLogic.GetInherentCellYield(cell, false);

            var nodeAtLocation = NodePositionCanon.GetPossessionsOfOwner(cell).FirstOrDefault();

            var visibleResources = TechCanon.GetResourcesVisibleToCiv(perspectiveCiv);

            var improvementOnCell = ImprovementLocationCanon.GetPossessionsOfOwner(cell).FirstOrDefault();

            var discoveredTechs = TechCanon.GetTechsDiscoveredByCiv(perspectiveCiv);

            bool hasFreshWater = FreshWaterCanon.HasAccessToFreshWater(cell);

            if (cityOwningCell != null)
            {
                var buildingsOnCell = BuildingPossessionCanon.GetPossessionsOfOwner(cityOwningCell)
                                      .Select(building => building.Template);

                retval += BuildingYieldLogic.GetBonusCellYieldFromBuildings(cell, buildingsOnCell);
            }

            if (nodeAtLocation != null)
            {
                retval += NodeYieldLogic.GetYieldFromNode(nodeAtLocation, visibleResources, improvementOnCell);
            }

            if (improvementOnCell != null)
            {
                retval += ImprovementYieldLogic.GetYieldOfImprovement(
                    improvementOnCell, nodeAtLocation, visibleResources, discoveredTechs, hasFreshWater
                    );
            }

            if (perspectiveCiv != null && GoldenAgeCanon.IsCivInGoldenAge(perspectiveCiv) && retval[YieldType.Gold] > 0f)
            {
                retval[YieldType.Gold] += CivConfig.GoldenAgeBonusGoldOnCells;
            }

            return(retval);
        }
        private void DecomposeTechs(SerializableCivilizationData civData, ICivilization newCiv)
        {
            if (civData.TechQueue != null)
            {
                for (int i = 0; i < civData.TechQueue.Count; i++)
                {
                    var techName = civData.TechQueue[i];

                    var techOfName = AvailableTechs.Where(tech => tech.Name.Equals(techName)).FirstOrDefault();
                    if (techOfName == null)
                    {
                        throw new InvalidOperationException(string.Format("CivData.TechQueue had invalid tech name {0} in it", techName));
                    }
                    newCiv.TechQueue.Enqueue(techOfName);
                }
            }

            if (civData.DiscoveredTechs != null)
            {
                foreach (var discoveredTechName in civData.DiscoveredTechs)
                {
                    var techOfName = AvailableTechs.Where(tech => tech.Name.Equals(discoveredTechName)).FirstOrDefault();
                    if (techOfName == null)
                    {
                        throw new InvalidOperationException(
                                  string.Format("CivData.DiscoveredTechs had invalid tech name {0} in it", discoveredTechName)
                                  );
                    }

                    TechCanon.SetTechAsDiscoveredForCiv(techOfName, newCiv);
                }
            }

            if (civData.ProgressOnTechs != null)
            {
                foreach (var techInProgressName in civData.ProgressOnTechs.Keys)
                {
                    var techOfName = AvailableTechs.Where(tech => tech.Name.Equals(techInProgressName)).FirstOrDefault();
                    if (techOfName == null)
                    {
                        throw new InvalidOperationException(
                                  string.Format("CivData.ProgressOnTechs had invalid tech name {0} in it", techInProgressName)
                                  );
                    }

                    TechCanon.SetProgressOnTechByCiv(techOfName, newCiv, civData.ProgressOnTechs[techInProgressName]);
                }
            }
        }
示例#11
0
        private bool HasDomesticPortCity(IHexCell cell, ICivilization domesticCiv)
        {
            var cityAtCell = CityLocationCanon.GetPossessionsOfOwner(cell).FirstOrDefault();

            if (cityAtCell != null && CityPossessionCanon.GetOwnerOfPossession(cityAtCell) == domesticCiv)
            {
                var buildingsInCity = BuildingPossessionCanon.GetPossessionsOfOwner(cityAtCell);

                return(buildingsInCity.Any(building => building.Template.ProvidesOverseaConnection));
            }
            else
            {
                return(false);
            }
        }
        public YieldSummary GetYieldOfCellForCity(IHexCell cell, ICity city)
        {
            if (cell == null)
            {
                throw new ArgumentNullException("slot");
            }
            else if (city == null)
            {
                throw new ArgumentNullException("city");
            }

            ICivilization owner = CityPossessionCanon.GetOwnerOfPossession(city);

            return(CellYieldLogic.GetYieldOfCell(cell, owner) * GetMultiplier(city));
        }
示例#13
0
        public IEnumerable <ISocialPolicyBonusesData> GetPolicyBonusesForCiv(ICivilization civ)
        {
            var retval = GetPoliciesUnlockedFor(civ).Select(policy => policy.Bonuses);

            retval = retval.Concat(
                GetTreesUnlockedFor(civ).Select(tree => tree.UnlockingBonuses)
                );

            retval = retval.Concat(
                GetTreesUnlockedFor(civ).Where(tree => IsTreeCompletedByCiv(tree, civ))
                .Select(tree => tree.CompletionBonuses)
                );

            return(retval);
        }
        private bool DoAllCitiesHaveTemplate(IBuildingTemplate template, ICivilization owner)
        {
            var allCities = CityPossessionCanon.GetPossessionsOfOwner(owner);

            foreach (var city in allCities)
            {
                var templatesOf = BuildingPossessionCanon.GetPossessionsOfOwner(city).Select(building => building.Template);

                if (!templatesOf.Contains(template))
                {
                    return(false);
                }
            }
            return(true);
        }
示例#15
0
        private IUnit BuildUnit(UnitPositionCanonTestData.UnitData unitData, ICivilization domesticCiv, ICivilization foreignCiv)
        {
            var mockUnit = new Mock <IUnit>();

            mockUnit.Setup(unit => unit.Type).Returns(unitData.Type);
            mockUnit.Setup(unit => unit.MaxMovement).Returns(unitData.MaxMovement);
            mockUnit.Setup(unit => unit.MovementSummary).Returns(unitData.MovementSummary);

            var newUnit = mockUnit.Object;

            MockUnitPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newUnit))
            .Returns(unitData.BelongsToDomesticCiv ? domesticCiv : foreignCiv);

            return(newUnit);
        }
        private void ExecuteLockingSequence(
            ResourceLockingCanon lockingCanon, List <LockingType> sequence,
            IResourceDefinition resource, ICivilization civ
            )
        {
            foreach (var lockingOperation in sequence)
            {
                switch (lockingOperation)
                {
                case LockingType.Lock:   lockingCanon.LockCopyOfResourceForCiv(resource, civ); break;

                case LockingType.Unlock: lockingCanon.UnlockCopyOfResourceForCiv(resource, civ); break;
                }
            }
        }
示例#17
0
        public void SetCellAsExploredByCiv(IHexCell cell, ICivilization civ)
        {
            HashSet <ICivilization> explorationData;

            if (!CivsHavingExploredCell.TryGetValue(cell, out explorationData))
            {
                explorationData = new HashSet <ICivilization>();
                CivsHavingExploredCell[cell] = explorationData;
            }

            if (explorationData.Add(civ))
            {
                VisibilitySignals.CellBecameExploredByCiv.OnNext(new Tuple <IHexCell, ICivilization>(cell, civ));
            }
        }
        private IUnit BuildUnit(ICivilization owner, int hitpoints, UnitType type, out Mock <IUnit> unitMock)
        {
            unitMock = new Mock <IUnit>();

            unitMock.SetupAllProperties();

            unitMock.Setup(unit => unit.CurrentHitpoints).Returns(hitpoints);
            unitMock.Setup(unit => unit.Type).Returns(type);

            var newUnit = unitMock.Object;

            MockUnitPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newUnit)).Returns(owner);

            return(newUnit);
        }
示例#19
0
        private IUnit BuildUnit(IHexCell location, ICivilization owner, int currentMovement)
        {
            var mockUnit = new Mock <IUnit>();

            mockUnit.SetupAllProperties();

            var newUnit = mockUnit.Object;

            newUnit.CurrentMovement = currentMovement;

            MockUnitPositionCanon.Setup(canon => canon.GetOwnerOfPossession(newUnit)).Returns(location);
            MockUnitPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newUnit)).Returns(owner);

            return(newUnit);
        }
示例#20
0
        private IHexCell BuildHexCell(
            FocusedHexCellTestData testData, ICivilization domesticCiv, ICivilization foreignCiv
            )
        {
            var newCell = new Mock <IHexCell>().Object;

            MockCivTerritoryLogic.Setup(logic => logic.GetCivClaimingCell(newCell))
            .Returns(testData.OwnedByDomesticCiv ? domesticCiv : foreignCiv);

            if (testData.HasCity)
            {
                BuildCity(newCell);
            }

            return(newCell);
        }
        public override IOngoingDiplomaticExchange ExecuteBetweenCivs(ICivilization fromCiv, ICivilization toCiv)
        {
            if (!CanExecuteBetweenCivs(fromCiv, toCiv))
            {
                throw new InvalidOperationException("CanExecuteBetweenCivs must return true for the given arguments");
            }

            var ongoingExchange = Container.Instantiate <ResourceOngoingDiplomaticExchange>();

            ongoingExchange.ResourceInput = ResourceInput;
            ongoingExchange.IntegerInput  = IntegerInput;
            ongoingExchange.Sender        = fromCiv;
            ongoingExchange.Receiver      = toCiv;

            return(ongoingExchange);
        }
        private IUnit BuildUnit(ICivilization owner, int currentHipoints, int maxHitpoints, UnitType type)
        {
            var mockUnit = new Mock <IUnit>();

            mockUnit.SetupAllProperties();
            mockUnit.Setup(unit => unit.MaxHitpoints).Returns(maxHitpoints);
            mockUnit.Setup(unit => unit.Type).Returns(type);

            var newUnit = mockUnit.Object;

            newUnit.CurrentHitpoints = currentHipoints;

            MockUnitPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newUnit)).Returns(owner);

            return(newUnit);
        }
        public IPopulationCenters Upgrade(ICivilization civilization, IPopulationCenters center)
        {
            IPopulationCenters upgrade = null;
            if (!civilization.RegionsOwned.Last().CanSupportAdditionalPopulationCenters()) return upgrade; // as long as the last region has available centers we can keep going

            if (!center.GetType().Name.ToLower().Equals("metropolis"))
            {
                upgrade = PopulationCenterFactory.Get(center.GetType().Name);
            }
            else // we have a metropolis. Generate a new Hamlet now.
            {
                return GenerateSingle(civilization);
            }

            return CreateCenter(civilization, upgrade);
        }
示例#24
0
        private IHexCell BuildCell(bool hasRoads, ICivilization owner, IEnumerable <IImprovement> improvements)
        {
            var mockCell = new Mock <IHexCell>();

            mockCell.SetupAllProperties();

            var newCell = mockCell.Object;

            newCell.HasRoads = hasRoads;

            MockImprovementLocationCanon.Setup(canon => canon.GetPossessionsOfOwner(newCell)).Returns(improvements);

            MockCivTerritoryLogic.Setup(logic => logic.GetCivClaimingCell(newCell)).Returns(owner);

            return(newCell);
        }
示例#25
0
        public int GetProgressOnTechByCiv(ITechDefinition tech, ICivilization civilization)
        {
            if (!ProgressByCivAndTech.ContainsKey(civilization))
            {
                ProgressByCivAndTech[civilization] = new Dictionary <ITechDefinition, int>();
            }

            var civProgressDict = ProgressByCivAndTech[civilization];

            if (!civProgressDict.ContainsKey(tech))
            {
                civProgressDict[tech] = 0;
            }

            return(civProgressDict[tech]);
        }
示例#26
0
        private ICity BuildCity(int population, ICivilization owner, List <IBuilding> buildings = null)
        {
            var mockCity = new Mock <ICity>();

            mockCity.SetupAllProperties();

            var newCity = mockCity.Object;

            newCity.Population = population;

            MockCityPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newCity)).Returns(owner);

            MockBuildingPossessionCanon.Setup(canon => canon.GetPossessionsOfOwner(newCity)).Returns(buildings);

            return(newCity);
        }
        private void SetVisibility(IHexCell cell, ICivilization civ, int value)
        {
            Dictionary <ICivilization, int> visibilityDictForCell;

            if (!VisibilityOfCellToCiv.ContainsKey(cell))
            {
                visibilityDictForCell       = new Dictionary <ICivilization, int>();
                VisibilityOfCellToCiv[cell] = visibilityDictForCell;
            }
            else
            {
                visibilityDictForCell = VisibilityOfCellToCiv[cell];
            }

            visibilityDictForCell[civ] = value;
        }
        public int GetUnhappinessOfCiv(ICivilization civ)
        {
            if (civ == null)
            {
                throw new ArgumentNullException("civ");
            }

            int retval = 0;

            foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
            {
                retval += CityHappinessLogic.GetUnhappinessOfCity(city);
            }

            return(retval);
        }
示例#29
0
        public ResourceTransfer ExportCopiesOfResource(
            IResourceDefinition resource, int copies,
            ICivilization exporter, ICivilization importer
            )
        {
            if (!CanExportCopiesOfResource(resource, copies, exporter, importer))
            {
                throw new InvalidOperationException("CanExportCopiesOfResource must return true on the given arguments");
            }

            var newTransfer = new ResourceTransfer(exporter, importer, resource, copies);

            AllActiveTransfers.Add(newTransfer);

            return(newTransfer);
        }
示例#30
0
        public IEnumerable <IResourceDefinition> GetResourcesVisibleToCiv(ICivilization civilization)
        {
            var retval = new HashSet <IResourceDefinition>(AvailableResources);

            foreach (var tech in AvailableTechs)
            {
                if (!IsTechDiscoveredByCiv(tech, civilization))
                {
                    foreach (var resource in tech.RevealedResources)
                    {
                        retval.Remove(resource);
                    }
                }
            }

            return(retval);
        }
示例#31
0
        public void SetTechAsUndiscoveredForCiv(ITechDefinition tech, ICivilization civilization)
        {
            if (tech == null)
            {
                throw new ArgumentNullException("tech");
            }
            else if (civilization == null)
            {
                throw new ArgumentNullException("civilization");
            }

            if (IsTechDiscoveredByCiv(tech, civilization))
            {
                TechsResearchedByCiv[civilization].Remove(tech);
                CivSignals.CivUndiscoveredTech.OnNext(new System.Tuple <ICivilization, ITechDefinition>(civilization, tech));
            }
        }
        private ICity BuildCity(CityTestData cityData, IHexCell location, ICivilization owner)
        {
            var newCity = new Mock <ICity>().Object;

            MockBuildingPossessionCanon.Setup(canon => canon.GetPossessionsOfOwner(newCity))
            .Returns(cityData.Buildings.Select(buildingData => BuildBuilding(buildingData)));

            MockCityLocationCanon.Setup(canon => canon.GetOwnerOfPossession(newCity)).Returns(location);
            MockCityLocationCanon.Setup(canon => canon.GetPossessionsOfOwner(location)).Returns(new List <ICity>()
            {
                newCity
            });

            MockCityPossessionCanon.Setup(canon => canon.GetOwnerOfPossession(newCity)).Returns(owner);

            return(newCity);
        }
        private void AddUnitProjects(ICivilization cityOwner)
        {
            foreach (var unitTemplate in TechCanon.GetResearchedUnits(cityOwner))
            {
                var newRecord = BuildRecord();

                newRecord.UnitTemplate = unitTemplate;
                newRecord.SelectionButton.interactable = UnitValidityLogic.IsTemplateValidForCity(unitTemplate, ObjectToDisplay);
                newRecord.SelectionButton.onClick.AddListener(
                    () => ObjectToDisplay.ActiveProject = ProjectFactory.ConstructProject(unitTemplate)
                    );

                newRecord.Refresh();

                InstantiatedProjectRecords.Add(newRecord);
            }
        }
示例#34
0
        private IHexCell BuildHexCell(
            NeighboringHexCellTestData testData, ICivilization domesticCiv, ICivilization foreignCiv
            )
        {
            var newCell = new Mock <IHexCell>().Object;

            var unitsAt = new List <IUnit>();

            foreach (var unitData in testData.UnitsAtCell)
            {
                unitsAt.Add(BuildUnit(unitData, newCell, unitData.BelongsToDomesticCiv ? domesticCiv : foreignCiv));
            }

            MockUnitPositionCanon.Setup(canon => canon.GetPossessionsOfOwner(newCell)).Returns(unitsAt);

            return(newCell);
        }
 private IPopulationCenters CreateCenter(ICivilization civilization, IPopulationCenters center)
 {
     center.Id = Random.Next(0, 423645245);
     center.Name = Names.SingleName(CoreEnums.Word.HumanPlace); // TODO: named according to race
     center.Description = "DESCRIPTION";
     center.Civilization = civilization;
     center.Region = civilization.RegionsOwned.First(r => r.CanSupportAdditionalPopulationCenters());
     center.Population = new List<IPerson>();
     center.HasPort = false; // TODO: hard coded
     center.HasMarket = true; // TODO: hard coded
     return center;
 }