public static bool Exists(this CustomMilestoneModel customMilestone, string name, string category = "")
        {
            switch (category)
            {
            case "Feature":
                return(customMilestone.Milestones.Any(m => m.Features.Any(n => n.Name == name)));

            case "Service":
                return(customMilestone.Milestones.Any(m => m.Services.Any(n => n.Name == name)));

            case "Policy":
                return(customMilestone.Milestones.Any(m => m.Policies.Any(n => n.Name == name)));

            case "InfoView":
                return(customMilestone.Milestones.Any(m => m.Policies.Any(n => n.Name == name)));

            default:
                return(customMilestone.Milestones.Any(m => m.Roads.Any(n => n.Name == name)) || customMilestone.Milestones.Any(m => m.Buildings.Any(n => n.Name == name)));
            }
        }
        public override void OnCreated(IMilestones milestones)
        {
            base.OnCreated(milestones);

            #region 读取/创建Xml文件

            CustomMilestoneModel customMilestone = XmlHelper.FromXmlFile <CustomMilestoneModel>(_xmlFilePath);
            if (customMilestone == null || customMilestone.Rebuild)
            {
                customMilestone = new CustomMilestoneModel()
                {
                    Rebuild    = true,
                    Milestones = new MilestoneModel[]
                    {
                        new MilestoneModel()
                        {
                            Level = 0, PurchaseAreasCount = 1
                        },
                        new MilestoneModel()
                        {
                            Level = 1
                        },
                        new MilestoneModel()
                        {
                            Level = 2
                        },
                        new MilestoneModel()
                        {
                            Level = 3
                        },
                        new MilestoneModel()
                        {
                            Level = 4
                        },
                        new MilestoneModel()
                        {
                            Level = 5
                        },
                        new MilestoneModel()
                        {
                            Level = 6
                        },
                        new MilestoneModel()
                        {
                            Level = 7
                        },
                        new MilestoneModel()
                        {
                            Level = 8
                        },
                        new MilestoneModel()
                        {
                            Level = 9
                        },
                        new MilestoneModel()
                        {
                            Level = 10
                        },
                        new MilestoneModel()
                        {
                            Level = 11
                        },
                        new MilestoneModel()
                        {
                            Level = 12
                        },
                        new MilestoneModel()
                        {
                            Level = 13
                        }
                    }
                };

                if (Singleton <UnlockManager> .exists)
                {
                    foreach (var milestone in Singleton <UnlockManager> .instance.m_properties.m_progressionMilestones)
                    {
                        int purchaseAreasCount = Singleton <UnlockManager> .instance.m_properties.m_AreaMilestones.Count(m => m.GetLevel() == milestone.GetLevel());

                        customMilestone.Milestones[milestone.GetLevel()].LocalizedName      = milestone.GetLocalizedName();
                        customMilestone.Milestones[milestone.GetLevel()].RewardCash         = milestone.m_rewardCash;
                        customMilestone.Milestones[milestone.GetLevel()].PurchaseAreasCount = purchaseAreasCount;
                    }
                }
                XmlHelper.ToXmlFile(customMilestone, _xmlFilePath);
            }

            #endregion
        }
        public void RefreshMilestones(ModConfigModel config)
        {
            CustomMilestoneModel customMilestone = XmlHelper.FromXmlFile <CustomMilestoneModel>(_xmlFilePath);

            if (customMilestone.Rebuild)
            {
                customMilestone.Rebuild = false;

                //读取默认道路信息
                for (uint index = 0; index < PrefabCollection <NetInfo> .LoadedCount(); index++)
                {
                    NetInfo net = PrefabCollection <NetInfo> .GetLoaded(index);

                    if (config.RoadIncludes.Contains(config.Renames.GetRename(net.name)) && !customMilestone.Exists(config.Renames.GetRename(net.name)))
                    {
                        if (config.BuildingExistsRoads.Contains(config.Renames.GetRename(net.name)))
                        {
                            customMilestone.Milestones[net.GetUnlockMilestone().GetLevel()].Buildings.Add(new ItemModel()
                            {
                                Name          = config.Renames.GetRename(net.name),
                                LocalizedName = net.GetLocalizedTitle(),
                                Expansions    = net.m_class.m_service.ToString() + "|" + net.m_class.m_subService.ToString() + "|" + net.category
                            });
                        }
                        else
                        {
                            customMilestone.Milestones[net.GetUnlockMilestone().GetLevel()].Roads.Add(new ItemModel()
                            {
                                Name          = config.Renames.GetRename(net.name),
                                LocalizedName = net.GetLocalizedTitle(),
                                Expansions    = net.m_class.m_service.ToString() + "|" + net.m_class.m_subService.ToString() + "|" + net.category
                            });
                        }
                    }
                }

                //读取默认建筑信息
                for (uint index = 0; index < PrefabCollection <BuildingInfo> .LoadedCount(); index++)
                {
                    BuildingInfo building = PrefabCollection <BuildingInfo> .GetLoaded(index);

                    if (config.BuildingIncludes.Contains(config.Renames.GetRename(building.name)) && !customMilestone.Exists(config.Renames.GetRename(building.name)))
                    {
                        if (config.RoadExistsBuildings.Contains(config.Renames.GetRename(building.name)))
                        {
                            customMilestone.Milestones[building.GetUnlockMilestone().GetLevel()].Roads.Add(new ItemModel()
                            {
                                Name          = config.Renames.GetRename(building.name),
                                LocalizedName = building.GetLocalizedTitle(),
                                Expansions    = building.m_class.m_service.ToString() + "|" + building.m_class.m_subService.ToString() + "|" + building.category
                            });
                        }
                        else
                        {
                            customMilestone.Milestones[building.GetUnlockMilestone().GetLevel()].Buildings.Add(new ItemModel()
                            {
                                Name          = config.Renames.GetRename(building.name),
                                LocalizedName = building.GetLocalizedTitle(),
                                Expansions    = building.m_class.m_service.ToString() + "|" + building.m_class.m_subService.ToString() + "|" + building.category
                            });
                        }
                    }
                }

                //读取默认功能信息
                foreach (var featureEnum in Utils.GetOrderedEnumData <UnlockManager.Feature>())
                {
                    if (config.Features.Contains(featureEnum.enumName) && !customMilestone.Exists(featureEnum.enumName, "Feature"))
                    {
                        var level = Singleton <UnlockManager> .instance.m_properties.m_FeatureMilestones[(int)featureEnum.enumValue].GetLevel();
                        if (config.ServiceExistsFeatures.Contains(featureEnum.enumName))
                        {
                            customMilestone.Milestones[level].Services.Add(new ItemModel()
                            {
                                Name          = featureEnum.enumName,
                                LocalizedName = featureEnum.GetLocalizedName(),
                            });
                        }
                        else
                        {
                            customMilestone.Milestones[level].Features.Add(new ItemModel()
                            {
                                Name          = featureEnum.enumName,
                                LocalizedName = featureEnum.GetLocalizedName(),
                            });
                        }
                    }
                }

                //读取默认服务信息
                foreach (var serviceEnum in Utils.GetOrderedEnumData <ItemClass.Service>())
                {
                    if (config.Services.Contains(serviceEnum.enumName) && !customMilestone.Exists(serviceEnum.enumName, "Service"))
                    {
                        var level = Singleton <UnlockManager> .instance.m_properties.m_ServiceMilestones[(int)serviceEnum.enumValue].GetLevel();
                        customMilestone.Milestones[level].Services.Add(new ItemModel()
                        {
                            Name          = serviceEnum.enumName,
                            LocalizedName = serviceEnum.GetLocalizedName(),
                        });
                    }
                }

                //读取默认服务政策信息
                foreach (var policyEnum in Utils.GetOrderedEnumData <DistrictPolicies.Policies>("Services"))
                {
                    var index = (int)(policyEnum.enumValue & (DistrictPolicies.Policies) 31);
                    var level = Singleton <UnlockManager> .instance.m_properties.m_ServicePolicyMilestones[index].GetLevel();
                    customMilestone.Milestones[level].Policies.Add(new ItemModel()
                    {
                        Name          = policyEnum.enumName,
                        LocalizedName = policyEnum.GetLocalizedName(),
                        Expansions    = policyEnum.enumCategory
                    });
                }

                //读取默认税收政策信息
                foreach (var policyEnum in Utils.GetOrderedEnumData <DistrictPolicies.Policies>("Taxation"))
                {
                    var index = (int)(policyEnum.enumValue & (DistrictPolicies.Policies) 31);
                    var level = Singleton <UnlockManager> .instance.m_properties.m_TaxationPolicyMilestones[index].GetLevel();
                    customMilestone.Milestones[level].Policies.Add(new ItemModel()
                    {
                        Name          = policyEnum.enumName,
                        LocalizedName = policyEnum.GetLocalizedName(),
                        Expansions    = policyEnum.enumCategory
                    });
                }

                //读取默认城市规划政策信息
                foreach (var policyEnum in Utils.GetOrderedEnumData <DistrictPolicies.Policies>("CityPlanning"))
                {
                    var index = (int)(policyEnum.enumValue & (DistrictPolicies.Policies) 31);
                    var level = Singleton <UnlockManager> .instance.m_properties.m_CityPlanningPolicyMilestones[index].GetLevel();
                    customMilestone.Milestones[level].Policies.Add(new ItemModel()
                    {
                        Name          = policyEnum.enumName,
                        LocalizedName = policyEnum.GetLocalizedName(),
                        Expansions    = policyEnum.enumCategory
                    });
                }

                //读取默认信息面板信息
                foreach (var infoMode in Utils.GetOrderedEnumData <InfoManager.InfoMode>())
                {
                    var level = Singleton <UnlockManager> .instance.m_properties.m_InfoModeMilestones[(int)infoMode.enumValue].GetLevel();
                    customMilestone.Milestones[level].InfoViews.Add(new ItemModel()
                    {
                        Name          = infoMode.enumName,
                        LocalizedName = Locale.Get("INFOVIEWS", infoMode.enumName)
                    });
                }

                XmlHelper.ToXmlFile(customMilestone, _xmlFilePath);
            }
            else
            {
                MilestoneInfo[] progressionMilestones = Singleton <UnlockManager> .instance.m_properties.m_progressionMilestones;

                //根据配置文件刷新里程碑信息
                foreach (MilestoneModel milestoneModel in customMilestone.Milestones)
                {
                    MilestoneInfo milestoneInfo = milestoneModel.Level > 0 ? progressionMilestones[milestoneModel.Level - 1] : null;

                    //刷新里程碑奖金、地块
                    var count = (milestoneModel.Level == 0 && milestoneModel.PurchaseAreasCount == 0) ? 1 : milestoneModel.PurchaseAreasCount;
                    var total = customMilestone.Milestones.Take(Array.IndexOf(customMilestone.Milestones, milestoneModel)).Sum(m => m.PurchaseAreasCount);
                    for (int i = total; i < total + count && i < 9; i++)
                    {
                        Singleton <UnlockManager> .instance.m_properties.m_AreaMilestones[i] = milestoneInfo;
                    }
                    if (milestoneInfo != null)
                    {
                        milestoneInfo.m_rewardCash = milestoneModel.RewardCash.Value;
                    }

                    //刷新道路
                    foreach (var roadModel in milestoneModel.Roads)
                    {
                        if (config.RoadIncludes.Contains(roadModel.Name) || config.RoadExistsBuildings.Contains(roadModel.Name))
                        {
                            RefreshRoadMilestone(roadModel.Name, milestoneInfo, config);
                        }
                    }

                    //刷新建筑
                    foreach (var buildingModel in milestoneModel.Buildings)
                    {
                        if (config.BuildingIncludes.Contains(buildingModel.Name) || config.BuildingExistsRoads.Contains(buildingModel.Name))
                        {
                            RefreshBuildingMilestone(buildingModel.Name, milestoneInfo, config);
                        }
                    }

                    //刷新功能
                    foreach (var featureModel in milestoneModel.Features)
                    {
                        if (config.Features.Contains(featureModel.Name))
                        {
                            RefreshFeatureMilestones(featureModel.Name, milestoneInfo, config);
                        }
                    }

                    //刷新服务
                    foreach (var serviceModel in milestoneModel.Services)
                    {
                        if (config.Services.Contains(serviceModel.Name) || config.ServiceExistsFeatures.Contains(serviceModel.Name))
                        {
                            RefreshServiceMilestones(serviceModel.Name, milestoneInfo, config);
                        }
                    }

                    //刷新政策
                    foreach (var policyModel in milestoneModel.Policies)
                    {
                        RefreshPolicyMilestones(policyModel.Name, milestoneInfo);
                    }
                }
            }
        }