Example #1
0
        public override double CalculateFitness(BuildingRule model)
        {
            var universities = model.Roads.SelectMany(b => b.Buildings).Count(b => b is University);
            var schools      = model.Roads.SelectMany(b => b.Buildings).Count(b => b is School);

            if (schools / (universities + 1) < 10)
            {
                //("No more than one school per 100 residences");
                return(0);
            }

            return(15);
        }
        public override double CalculateFitness(BuildingRule model)
        {
            var residences = model.Roads.SelectMany(b => b.Buildings).Count(b => b is Residence);
            var schools    = model.Roads.SelectMany(b => b.Buildings).Count(b => b is School);

            if (residences / (schools + 1) < 500)
            {
                //("No more than one school per 500 residences");
                return(0);
            }

            return(7);
        }
        public async Task <BuildingRule> SaveAsync(SimpleUser user, BuildingRule buildingRule, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (user == null)
            {
                throw new ArgumentNullException(nameof(user));
            }

            if (buildingRule == null)
            {
                throw new ArgumentNullException(nameof(buildingRule));
            }

            //查看楼盘是否存在
            if (!Context.Buildings.Any(x => x.Id == buildingRule.Id))
            {
                Buildings buildings = new Buildings()
                {
                    Id             = buildingRule.Id,
                    CreateUser     = user.Id,
                    ResidentUser1  = user.Id,
                    CreateTime     = DateTime.Now,
                    OrganizationId = user.OrganizationId,
                    ExamineStatus  = 0
                };

                Context.Add(buildings);
            }
            //基本信息
            if (!Context.BuildingRules.Any(x => x.Id == buildingRule.Id))
            {
                Context.Add(buildingRule);
            }
            else
            {
                Context.Attach(buildingRule);
                Context.Update(buildingRule);
            }
            try
            {
                await Context.SaveChangesAsync(cancellationToken);
            }
            catch (DbUpdateConcurrencyException) { }

            return(buildingRule);
        }
Example #4
0
        public override double CalculateFitness(BuildingRule model)
        {
            var minDistanceBetweenChurches = 30;
            var churches = model.Roads.SelectMany(b => b.Buildings).Where(b => b != this && b is Church);

            if (!churches.All(m => m.Position.DistanceTo(this.Position) >= minDistanceBetweenChurches))
            {
                return(0);
            }

            var residences = model.Roads.SelectMany(b => b.Buildings).Where(b => b is Residence);

            if (residences.Count(r => r.Position.DistanceTo(this.Position) <= 30) < 500)
            {
                return(0);
            }
            return(5);
        }
Example #5
0
        public override double CalculateFitness(BuildingRule model)
        {
            var maxPortDistanceToWater = 5;
            var field = model.Fields[this.Position.X, this.Position.Y];

            if (field.DistanceToWater > maxPortDistanceToWater)
            {
                return(0);
            }

            var ports = model.Roads.SelectMany(b => b.Buildings).Where(b => b is Port);

            if (ports.Any())
            {
                //("There can be only one port");
                return(0);
            }

            return(15);
        }
Example #6
0
        public override double CalculateFitness(BuildingRule model)
        {
            var maxResidencesPerTavern = Position.DistanceTo(model.SettlementCenter) < 15 ? 60 : 80;

            var residences = model.Roads
                             .SelectMany(b => b.Buildings)
                             .Where(r => r.Position.DistanceTo(this.Position) <= 10)
                             .Count(b => b is Residence);
            var taverns = model.Roads
                          .SelectMany(b => b.Buildings)
                          .Where(r => r.Position.DistanceTo(this.Position) <= 10)
                          .Count(b => b is Tavern);

            if (residences / (taverns + 1) < maxResidencesPerTavern)
            {
                return(0);
            }

            return(3);
        }
Example #7
0
        static IRule CompileNodeForRule(string ruletext, Dictionary <int, RuleCacheItem> ruleSet)
        {
            Function Head, BuildingRule;

            Head = BuildingRule = new AndRule();

            foreach (var item in ruletext.Split(' '))
            {
                if (item.Contains("\""))
                {
                    var nodeToAdd = new StringRule {
                        toMatch = item[1]
                    };;

                    //Comment this line for multi string rule support
                    return(nodeToAdd);

                    BuildingRule.AddNode(nodeToAdd);
                }
                else if (item.Contains("|"))
                {
                    //Split on left and right
                    Head = new OrRule();
                    Head.AddNode(BuildingRule);
                    BuildingRule = new AndRule();
                    Head.AddNode(BuildingRule);
                }
                else
                {
                    var childToExplore = int.Parse(item);
                    //Check if the cached copy hasn't compiled yet and compile it
                    if (ruleSet[childToExplore].CachedRule == null)
                    {
                        ruleSet[childToExplore].CachedRule = CompileNodeForRule(ruleSet[childToExplore].Text, ruleSet);
                    }

                    BuildingRule.AddNode(ruleSet[childToExplore].CachedRule);
                }
            }
            return(Head);
        }
        public override double CalculateFitness(BuildingRule model)
        {
            var maxDistanceToCenter = 10;

            if (Position.DistanceTo(model.SettlementCenter) > maxDistanceToCenter)
            {
                //market is close enough to the settlement center
                return(0);
            }

            var buildings       = model.Roads.SelectMany(b => b.Buildings).Count();
            var administrations = model.Roads.SelectMany(b => b.Buildings).Count(b => b is Administration);

            if (buildings / (administrations + 1) < 2000)
            {
                //("No more than one administration per 2000 buildings");
                return(0);
            }

            return(10);
        }
        public override double CalculateFitness(BuildingRule model)
        {
            var minDistanceBetweenMarkets = 30;
            var markets = model.Roads.SelectMany(b => b.Buildings).Where(b => b != this && b is Market);

            if (!markets.All(m => m.Position.DistanceTo(this.Position) >= minDistanceBetweenMarkets))
            {
                //("Other markets are too close");
                return(0);
            }

            var residences = model.Roads.SelectMany(b => b.Buildings).Where(b => b is Residence);

            if (residences.Count(r => r.Position.DistanceTo(this.Position) <= 20) < 250)
            {
                //("Not enough residences in closest neighborhood");
                return(0);
            }

            return(5);
        }
Example #10
0
 public override double CalculateFitness(BuildingRule model)
 {
     return(0.1);
 }
        public async Task ReportRuleCallbackAsync(ExamineResponse examineResponse)
        {
            var updaterecord = await Context.UpdateRecords.FirstOrDefaultAsync(a => a.Id == examineResponse.SubmitDefineId);

            if (updaterecord == null)
            {
                throw new Exception("未找到动态记录");
            }
            if (examineResponse.ExamineStatus == ExamineStatus.Examined)
            {
                var buildingRule = await Context.BuildingRules.FirstOrDefaultAsync(a => a.Id == examineResponse.ContentId);

                updaterecord.ExamineStatus = Models.ExamineStatusEnum.Approved;
                ReportRuleUpdateModel reportRuleUpdateModel = JsonConvert.DeserializeObject <ReportRuleUpdateModel>(updaterecord.UpdateContent);
                if (buildingRule == null)
                {
                    buildingRule                     = new BuildingRule();
                    buildingRule.Id                  = examineResponse.ContentId;
                    buildingRule.AdvanceTime         = reportRuleUpdateModel.AdvanceTime;
                    buildingRule.BeltProtectDay      = reportRuleUpdateModel.BeltProtectDay;
                    buildingRule.IsCompletenessPhone = reportRuleUpdateModel.IsCompletenessPhone;
                    buildingRule.LiberatingEnd       = reportRuleUpdateModel.LiberatingEnd;
                    buildingRule.LiberatingStart     = reportRuleUpdateModel.LiberatingStart;
                    buildingRule.Mark                = reportRuleUpdateModel.Mark;
                    buildingRule.MaxCustomer         = reportRuleUpdateModel.MaxCustomer;
                    buildingRule.ReportedTemplate    = reportRuleUpdateModel.ReportedTemplate;
                    buildingRule.ReportTime          = reportRuleUpdateModel.ReportTime;
                    buildingRule.ValidityDay         = reportRuleUpdateModel.ValidityDay;
                    buildingRule.IsUse               = reportRuleUpdateModel.IsUse;
                    Context.Update(updaterecord);
                    Context.Add(buildingRule);
                }
                else
                {
                    buildingRule.AdvanceTime         = reportRuleUpdateModel.AdvanceTime;
                    buildingRule.BeltProtectDay      = reportRuleUpdateModel.BeltProtectDay;
                    buildingRule.IsCompletenessPhone = reportRuleUpdateModel.IsCompletenessPhone;
                    buildingRule.LiberatingEnd       = reportRuleUpdateModel.LiberatingEnd;
                    buildingRule.LiberatingStart     = reportRuleUpdateModel.LiberatingStart;
                    buildingRule.Mark             = reportRuleUpdateModel.Mark;
                    buildingRule.MaxCustomer      = reportRuleUpdateModel.MaxCustomer;
                    buildingRule.ReportedTemplate = reportRuleUpdateModel.ReportedTemplate;
                    buildingRule.ReportTime       = reportRuleUpdateModel.ReportTime;
                    buildingRule.ValidityDay      = reportRuleUpdateModel.ValidityDay;
                    buildingRule.IsUse            = reportRuleUpdateModel.IsUse;
                    Context.Update(updaterecord);
                    Context.Update(buildingRule);
                }
            }
            else if (examineResponse.ExamineStatus == ExamineStatus.Reject)
            {
                updaterecord.ExamineStatus = Models.ExamineStatusEnum.Reject;
                Context.Update(updaterecord);
            }
            else
            {
                throw new Exception("审核状态不正确");
            }
            try
            {
                Context.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                throw;
            }
        }
 public void SetFitness(BuildingRule model)
 {
     Fitness = this.CalculateFitness(model);
 }
 public abstract double CalculateFitness(BuildingRule model);