示例#1
0
    public void BuyWall()
    {
        BuildingIdentity buildingIdentity = LogicController.Instance.BuyWall(this.BuildingBehavior.FirstZoneIndex);

        this.BuildingLogicData = LogicController.Instance.GetBuildingObject(buildingIdentity);
        SceneManager.Instance.EnableCreateWallContinuation = true;

        this.ConstructBuilding();
        SceneManager.Instance.LastWallTilePosition = this.BuildingBehavior.FirstZoneIndex;
        //if (this.BuildingLogicData.BuildingType == BuildingType.Wall)
        // {
        int upperLimitCount = ConfigInterface.Instance.BuildingNumberRestrictionsConfigHelper.GetBuildingNumberRestrictions(LogicController.Instance.CurrentCityHallLevel).RestrictionDict[this.BuildingLogicData.BuildingType];
        int hasCount        = LogicController.Instance.GetBuildingCount(this.BuildingLogicData.BuildingType);

        if (hasCount < upperLimitCount)
        {
            int initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(this.BuildingLogicData.BuildingType);
            BuildingConfigData buildingConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(this.BuildingLogicData.BuildingType, initialLevel);
            SceneManager.Instance.ConstructBuilding(buildingConfigData, this.BuildingLogicData.BuildingType, false);
        }
        else
        {
            UIErrorMessage.Instance.ErrorMessage(2);
        }
        // }
    }
    public void FinishUpgradeWithoutCommunication()
    {
        this.m_Data.UpgradeRemainingWorkload = null;
        this.m_Data.BuilderBuildingNO        = null;

        int nextLevel = this.m_Data.Level == 0 ? this.m_Data.ConfigData.InitialLevel :
                        this.m_Data.Level + this.m_Data.ConfigData.UpgradeStep;

        this.m_Data.Level = nextLevel;
        BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.
                                        GetBuildingData(this.m_Data.BuildingID.buildingType, this.m_Data.Level);

        this.m_Data.ConfigData = configData;

        if (this.m_Data.Level > 0)
        {
            if (this.m_Data.ConfigData.CanProduceGold)
            {
                this.m_Data.LastCollectedGoldTick = LogicTimer.Instance.GetServerTick();
            }
            if (this.m_Data.ConfigData.CanProduceFood)
            {
                this.m_Data.LastCollectedFoodTick = LogicTimer.Instance.GetServerTick();
            }
            if (this.m_Data.ConfigData.CanProduceOil)
            {
                this.m_Data.LastCollectedOilTick = LogicTimer.Instance.GetServerTick();
            }
        }

        this.AddComponentAccordingToConfigData(configData, ((int)BuildingFunction.All));
    }
示例#3
0
    public void FinishBuildingUpgrade(BuildingIdentity id)
    {
        BuildingLogicData building = this.m_BuildingModule.GetBuildingObject(id);

        BuildingConfigData oldData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, building.Level);
        BuildingConfigData newData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, building.Level + oldData.UpgradeStep);

        if (!newData.CanProduceGold)
        {
            this.m_PlayerModule.AddGoldCapacity(newData.StoreGoldCapacity, oldData.StoreGoldCapacity);
        }
        if (!newData.CanProduceFood)
        {
            this.m_PlayerModule.AddFoodCapacity(newData.StoreFoodCapacity, oldData.StoreFoodCapacity);
        }
        if (!newData.CanProduceOil)
        {
            this.m_PlayerModule.AddOilCapacity(newData.StoreOilCapacity, oldData.StoreOilCapacity);
        }
        if (newData.CanStoreProps)
        {
            this.m_PlayerModule.AddPropsCapacity(newData.StorePropsCapacity, oldData.StorePropsCapacity);
        }
        this.m_BuildingModule.FinishBuildingUpgrade(id);

        this.RewardResource(oldData.UpgradeRewardGold, oldData.UpgradeRewardFood, oldData.UpgradeRewardOil, oldData.UpgradeRewardGem,
                            oldData.UpgradeRewardExp);

        this.TaskManager.OnUpgradeBuilding(id.buildingType, this.m_BuildingModule.GetBuildingObject(id).Level);
    }
示例#4
0
    public void FinishBuildingConstruct(BuildingIdentity id)
    {
        int initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(id.buildingType);

        BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, initialLevel);

        if (!configData.CanProduceGold)
        {
            this.m_PlayerModule.AddGoldCapacity(configData.StoreGoldCapacity);
        }
        if (!configData.CanProduceFood)
        {
            this.m_PlayerModule.AddFoodCapacity(configData.StoreFoodCapacity);
        }
        if (!configData.CanProduceOil)
        {
            this.m_PlayerModule.AddOilCapacity(configData.StoreOilCapacity);
        }
        if (configData.CanStoreProps)
        {
            this.m_PlayerModule.AddPropsCapacity(configData.StorePropsCapacity);
        }
        this.m_BuildingModule.FinishBuildingConstruct(id);

        BuildingConfigData initialConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, 0);

        this.RewardResource(initialConfigData.UpgradeRewardGold, initialConfigData.UpgradeRewardFood, initialConfigData.UpgradeRewardOil, initialConfigData.UpgradeRewardGem, initialConfigData.UpgradeRewardExp);

        this.m_TaskModule.OnConstructBuilding(id.buildingType);
    }
示例#5
0
    public void ConstructBuilding(BuildingType type, int level)
    {
        BuildingConfigData configData     = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(type, level);
        TilePosition       centerPosition = PositionConvertor.GetBuildingTileIndexFromWorldPosition(this.m_SceneCamare.position);
        TilePosition       position       = this.FindValidBuildingPosition(centerPosition, configData.BuildingObstacleList);

        if (position != null)
        {
            this.ConstructBuilding(type, level, position);
        }
    }
示例#6
0
    void ShowSelectBuilderWindow(BuilderMenuType builderMenuType)
    {
        BuildingConfigData buildingConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(this.BuildingBehavior.BuildingType, 0);

        UIManager.Instance.UIWindowSelectBuilder.BuildingConfigData = buildingConfigData;

        UIManager.Instance.UIWindowSelectBuilder.BuildingLogicData = this.BuildingLogicData;
        UIManager.Instance.UIWindowSelectBuilder.BuilderMenuType   = builderMenuType;
        UIManager.Instance.UIWindowSelectBuilder.BuildingBehavior  = this.BuildingBehavior;
        UIManager.Instance.UIWindowSelectBuilder.ShowWindow();
        this.BuildingBehavior.ActiveButton(false);
    }
示例#7
0
    public BuildingIdentity ConstructBuilding(BuildingType type, int builderBuildingNO, TilePosition position)
    {
        BuildingData       data       = new BuildingData();
        BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(type, 0);

        //int builderHutLevel = this.m_Buildings[BuildingType.BuilderHut][builderBuildingNO].Level;
        //BuilderConfigData builderData = ConfigInterface.Instance.BuilderConfigHelper.GetBuilderData(builderHutLevel);

        data.ConfigData = configData;
        int NO = this.m_Buildings.ContainsKey(type) ? this.m_Buildings[type].Count : 0;

        data.BuildingID = new BuildingIdentity(type, NO);
        data.Level      = 0;
        data.UpgradeRemainingWorkload = configData.UpgradeWorkload;
        data.BuilderBuildingNO        = builderBuildingNO;
        data.BuildingPosition         = position;

        if (type == BuildingType.Tavern)
        {
            List <MercenaryType> mercenaryTypes = ConfigInterface.Instance.MercenaryConfigHelper.GetAvailableMercenaries(configData.InitialLevel);
            Dictionary <MercenaryType, MercenaryProductData> dict = new Dictionary <MercenaryType, MercenaryProductData>();
            foreach (MercenaryType mercenaryType in mercenaryTypes)
            {
                MercenaryProductData productData = new MercenaryProductData();
                MercenaryConfigData  config      = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(mercenaryType);

                productData.ConfigData  = config;
                productData.ReadyNumber = config.MaxProduceNumber;
                dict.Add(mercenaryType, productData);
            }
            data.ProduceMercenary = new MercenaryProductCollectionLogicObject(dict);
        }

        if (!this.m_Buildings.ContainsKey(type))
        {
            this.m_Buildings.Add(type, new Dictionary <int, BuildingLogicObject>());
        }

        this.m_Buildings[type].Add(data.BuildingID.buildingNO, this.ConstructBuildingLogicObject(data));
        this.m_BuilderManager.SendBuilder(builderBuildingNO, this.GetBuildingObject(data.BuildingID));
        this.m_CommunicationHelper.SendConstructBuildingRequest(data.BuildingID, position, builderBuildingNO);

        BuildingIdentity result = new BuildingIdentity();

        result.buildingType = type;
        result.buildingNO   = data.BuildingID.buildingNO;
        return(result);
    }
    private void AddComponentAccordingToConfigData(BuildingConfigData configData, int functionMask)
    {
        if (configData.CanProduceArmy && (functionMask & ((int)BuildingFunction.ProduceArmy)) != 0 &&
            this.m_ArmyProduceComponent == null)
        {
            ArmyProduceComponent comp = new ArmyProduceComponent();
            this.InitialComponent(comp);
            comp.ProduceFinished       += this.ArmyProduced;
            this.m_ArmyProduceComponent = comp;
        }
        if (configData.CanProduceItem && (functionMask & ((int)BuildingFunction.ProduceItem)) != 0 &&
            this.m_ItemProduceComponent == null)
        {
            ItemProduceComponent comp = new ItemProduceComponent();
            this.InitialComponent(comp);
            comp.ProduceFinished       += this.ItemProduced;
            this.m_ItemProduceComponent = comp;
        }

        if (configData.CanUpgradeArmy && (functionMask & ((int)BuildingFunction.UpgradeArmy)) != 0 &&
            this.m_ArmyUpgradeComponent == null)
        {
            ArmyUpgradeComponent comp = new ArmyUpgradeComponent();
            this.InitialComponent(comp);
            comp.ProduceFinished       += this.ArmyUpgraded;
            this.m_ArmyUpgradeComponent = comp;
        }
        if (configData.CanUpgradeItem && (functionMask & ((int)BuildingFunction.UpgradeItem)) != 0 &&
            this.m_ItemUpgradeComponent == null)
        {
            ItemUpgradeComponent comp = new ItemUpgradeComponent();
            this.InitialComponent(comp);
            comp.ProduceFinished       += this.ItemUpgraded;
            this.m_ItemUpgradeComponent = comp;
        }
        if (this.m_Data.ProduceMercenary != null && (functionMask & ((int)BuildingFunction.ProduceMercenary)) != 0 &&
            this.m_MercenaryComponents == null)
        {
            this.m_MercenaryComponents = new Dictionary <MercenaryType, MercenaryProduceComponent>();
            foreach (MercenaryType type in this.m_Data.ProduceMercenary.Products.Keys)
            {
                MercenaryProduceComponent comp = new MercenaryProduceComponent(type);
                this.InitialComponent(comp);
                this.m_MercenaryComponents.Add(type, comp);
            }
        }
    }
示例#9
0
    public void RecordPlunderResource(int gold, int food, int oil, BuildingPropertyBehavior property)
    {
        this.m_GoldTrophy += gold;
        this.m_FoodTrophy += food;
        this.m_OilTrophy  += oil;

        BattleSceneHelper.Instance.Plunder(gold, food, oil);

        if (BattleDirector.Instance != null)
        {
            LogicController.Instance.PlunderResource(gold, food, oil);

            PlunderResourceRequestParameter request = new PlunderResourceRequestParameter();
            request.OperateTime = TimeTickRecorder.Instance.CurrentTimeTick - BattleDirector.Instance.MatchStartTick;
            BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(property.BuildingType, property.Level);
            if (gold > 0)
            {
                request.PlunderGold = gold;
                if (configData.CanProduceGold)
                {
                    request.BuildingType = property.BuildingType;
                    request.BuildingNO   = property.BuildingNO;
                }
            }
            if (food > 0)
            {
                request.PlunderFood = food;
                if (configData.CanProduceFood)
                {
                    request.BuildingType = property.BuildingType;
                    request.BuildingNO   = property.BuildingNO;
                }
            }
            if (oil > 0)
            {
                request.PlunderOil = oil;
                if (configData.CanProduceOil)
                {
                    request.BuildingType = property.BuildingType;
                    request.BuildingNO   = property.BuildingNO;
                }
            }
            CommunicationUtility.Instance.PlunderResource(request);
        }
    }
示例#10
0
    void ConstructEvent(Action function)
    {
        BuildingConfigData         buildingConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(this.BuildingBehavior.BuildingType, 0);
        Dictionary <CostType, int> costBalance        = this.BuildingBehavior.Created ? SystemFunction.UpgradeCostBalance(this.BuildingLogicData) : SystemFunction.UpgradeCosBalance(buildingConfigData);
        Dictionary <CostType, int> costTotal          = this.BuildingBehavior.Created ? SystemFunction.UpgradeTotalCost(this.BuildingLogicData) : SystemFunction.UpgradeTotalCost(buildingConfigData);
        int costGem = this.BuildingBehavior.Created ? this.BuildingLogicData.UpgradeGem : buildingConfigData.UpgradeGem;

        if (costBalance.Count > 0)
        {
            int costBalanceGem = SystemFunction.ResourceConvertToGem(costBalance);
            //int costResourceToGem = SystemFunction.ResourceConvertToGem(costTotal) - costGem;

            string resourceContext = SystemFunction.BuyReusoureContext(costBalance);
            UIManager.Instance.UIWindowCostPrompt.ShowWindow(costBalanceGem, resourceContext, SystemFunction.BuyReusoureTitle(costBalance));
            UIManager.Instance.UIWindowCostPrompt.UnRegistDelegate();
            UIManager.Instance.UIWindowCostPrompt.Click += () =>
            {
                if (SystemFunction.CostUplimitCheck(costTotal[CostType.Gold], costTotal[CostType.Food], costTotal[CostType.Oil]))
                {
                    if (LogicController.Instance.PlayerData.CurrentStoreGem - costBalanceGem /*costResourceToGem*/ < costGem)
                    {
                        print("宝石不足,去商店");
                        UIManager.Instance.UIWindowFocus = null;
                        //UIManager.Instance.UIButtonShopping.GoShopping();
                        UIManager.Instance.UISelectShopMenu.GoShopping();
                    }
                    else
                    {
                        print("宝石换资源!");
                        SystemFunction.BuyResources(costBalance);
                        function.Invoke();
                    }
                }
                else
                {
                    UIErrorMessage.Instance.ErrorMessage(16);
                }
            };
        }
        else
        {
            function.Invoke();
        }
    }
示例#11
0
    private void BuyBuilding(BuildingType type, int buildingNO, TilePosition position)
    {
        BuildingData       data         = new BuildingData();
        int                initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(type);
        BuildingConfigData configData   = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(type, initialLevel);

        data.ConfigData       = configData;
        data.BuildingID       = new BuildingIdentity(type, buildingNO);
        data.Level            = initialLevel;
        data.BuildingPosition = position;

        if (!this.m_Buildings.ContainsKey(type))
        {
            this.m_Buildings.Add(type, new Dictionary <int, BuildingLogicObject>());
        }

        this.m_Buildings[type].Add(data.BuildingID.buildingNO, this.ConstructBuildingLogicObject(data));
        this.ReCalculateResource();
    }
示例#12
0
    public void ConstructBuilding(BuildingType type, int level, TilePosition position)
    {
        BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(type, level);

        string prefabName = string.Format("{0}{1}{2}", ClientStringConstants.BATTLE_SCENE_RESOURCE_PREFAB_PREFIX_NAME,
                                          ClientStringConstants.BUILDING_OBJECT_PREFAB_PREFIX_NAME, configData.BuildingPrefabName);
        GameObject buildingPrefab = Resources.Load(prefabName) as GameObject;
        GameObject newBuilding    = GameObject.Instantiate(buildingPrefab) as GameObject;

        GameObject.DestroyImmediate(newBuilding.GetComponent <BuildingAI>());
        GameObject.DestroyImmediate(newBuilding.GetComponent <BuildingHPBehavior>());

        ResourceStoreBehavior storeBehavior = newBuilding.GetComponent <ResourceStoreBehavior>();

        if (storeBehavior != null)
        {
            GameObject.DestroyImmediate(storeBehavior);
        }
        WallUtility wall = newBuilding.GetComponent <WallUtility>();

        if (wall != null)
        {
            GameObject.DestroyImmediate(wall);
            newBuilding.AddComponent <EditorWallUtility>();
        }

        EditorBuildingBehavior buildingBehavior = newBuilding.AddComponent <EditorBuildingBehavior>();

        buildingBehavior.Position     = position;
        buildingBehavior.BuildingType = type;
        buildingBehavior.Level        = level;

        newBuilding.transform.position = PositionConvertor.GetWorldPositionByBuildingTileIndex(position);
        newBuilding.transform.parent   = this.m_SceneParent;
        this.PopulateMapData(position, configData.BuildingObstacleList, newBuilding);
    }
示例#13
0
    public void InitialWithResponseData(FriendResponseParameter parameter, string friendName)
    {
        UserData userData = new UserData();

        userData.Name             = friendName;
        userData.Honour           = parameter.Honour;
        userData.Level            = parameter.Level;
        userData.CurrentStoreGold = parameter.PlayerGold;
        userData.CurrentStoreFood = parameter.PlayerFood;
        userData.CurrentStoreOil  = parameter.PlayerOil;
        userData.ConfigData       = ConfigInterface.Instance.PlayerConfigHelper.GetPlayerData(parameter.Level);

        this.m_FriendData           = new PlayerLogicData(userData);
        this.m_LogicObjects         = new Dictionary <BuildingType, Dictionary <int, BuildingLogicObject> >();
        this.m_ArmyObjects          = new Dictionary <ArmyType, Dictionary <int, FriendArmyParameter> >();
        this.m_Mercenaries          = new Dictionary <MercenaryType, int>();
        this.m_ItemObjects          = new Dictionary <ItemType, Dictionary <int, FriendItemParameter> >();
        this.m_AchievementBuildings = new Dictionary <int, AchievementBuildingLogicData>();
        this.m_Buffs           = new List <BuffLogicData>();
        this.m_Props           = new List <PropsLogicData>();
        this.m_ResourceManager = new ResourceManager();

        this.m_ArmyLevels = new Dictionary <ArmyType, int>();

        Dictionary <BuildingType, Dictionary <int, BuildingData> > datas =
            new Dictionary <BuildingType, Dictionary <int, BuildingData> >();

        this.m_RemovableObjects = new Dictionary <long, RemovableObjectLogicData>();

        int objectID = 0;

        foreach (FriendObjectParameter param in parameter.Objects)
        {
            RemovableObjectData data = new RemovableObjectData();
            data.BuilderBuildingNO = param.BuilderBuildingNO;
            data.Position          = new TilePosition(param.PositionColumn, param.PositionRow);

            if (param.IsRemoving)
            {
                if (param.BuilderBuildingNO.HasValue)
                {
                    data.RemainingWorkload = 0;
                }
                else
                {
                    data.RemainingWorkload = 1;
                }
            }
            data.RemovableObjectNo   = objectID;
            data.RemovableObjectType = param.ObjectType;
            data.ConfigData          = ConfigInterface.Instance.RemovableConfigHelper.GetRemovableObjectData(param.ObjectType);
            this.m_RemovableObjects.Add(objectID, new RemovableObjectLogicData(data));
            objectID++;
        }

        int buildingNo = 0;

        foreach (FriendAchievementBuildingParameter param in parameter.AchievementBuildings)
        {
            AchievementBuildingData data = new AchievementBuildingData();
            data.AchievementBuildingType = param.AchievementBuildingType;
            data.BuildingNo       = buildingNo++;
            data.BuildingPosition = new TilePosition(param.PositionColumn, param.PositionRow);
            data.Life             = param.Life;
            data.ConfigData       = ConfigInterface.Instance.AchievementBuildingConfigHelper.GetAchievementBuildingData(param.AchievementBuildingType);
            this.m_AchievementBuildings.Add(data.BuildingNo, new AchievementBuildingLogicData(data));
        }

        foreach (FriendBuffParameter buff in parameter.Buffs)
        {
            BuffData b = new BuffData();
            b.RelatedPropsType = buff.PropsType;
            b.RemainingCD      = 10;
            b.BuffConfigData   = ConfigInterface.Instance.PropsConfigHelper.GetPropsData(buff.PropsType).FunctionConfigData as PropsBuffConfigData;
            BuffLogicData data = new BuffLogicData(b);

            this.m_Buffs.Add(data);
        }

        int tempPropsID = 0;

        foreach (FriendPropsParameter props in parameter.Props)
        {
            PropsData       p = new PropsData();
            PropsConfigData propsConfigData = ConfigInterface.Instance.PropsConfigHelper.GetPropsData(props.PropsType);
            p.PropsConfigData  = propsConfigData;
            p.PropsNo          = tempPropsID++;
            p.PropsType        = props.PropsType;
            p.RemainingCD      = 10;
            p.RemainingUseTime = propsConfigData.MaxUseTimes;
            PropsLogicData data = new PropsLogicData(p);

            this.m_Props.Add(data);
        }

        foreach (FriendBuildingParameter param in parameter.Buildings)
        {
            BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(param.BuildingTypeID, param.Level);

            BuildingData data = new BuildingData();
            data.BuilderBuildingNO = param.BuilderBuildingNO;
            data.BuildingID        = new BuildingIdentity(param.BuildingTypeID, param.BuildingNO);
            data.BuildingPosition  = new TilePosition(param.PositionColumn, param.PositionRow);
            data.Level             = param.Level;
            if (param.IsUpgrading)
            {
                if (param.BuilderBuildingNO.HasValue)
                {
                    data.UpgradeRemainingWorkload = 1;
                }
                else
                {
                    data.UpgradeRemainingWorkload = 0;
                }
            }
            if (param.IsResourceAccelerate)
            {
                data.RemainResourceAccelerateTime = 1;
            }
            if (param.IsArmyAccelerate)
            {
                data.RemainArmyAccelerateTime = 1;
            }
            if (param.IsItemAccelerate)
            {
                data.RemainItemAccelerateTime = 1;
            }

            data.ConfigData = configData;

            if (param.CurrentStoreGold.HasValue)
            {
                data.CurrentStoreGold = param.CurrentStoreGold.Value;
            }
            else if (configData.CanStoreGold)
            {
                this.m_ResourceManager.AddStorage(ResourceType.Gold, data.BuildingID, configData.StoreGoldCapacity);
            }
            if (param.CurrentStoreFood.HasValue)
            {
                data.CurrentStoreFood = param.CurrentStoreFood.Value;
            }
            else if (configData.CanStoreFood)
            {
                this.m_ResourceManager.AddStorage(ResourceType.Food, data.BuildingID, configData.StoreFoodCapacity);
            }
            if (param.CurrentStoreOil.HasValue)
            {
                data.CurrentStoreOil = param.CurrentStoreOil.Value;
            }
            else if (configData.CanStoreOil)
            {
                this.m_ResourceManager.AddStorage(ResourceType.Oil, data.BuildingID, configData.StoreOilCapacity);
            }

            if (!this.m_LogicObjects.ContainsKey(param.BuildingTypeID))
            {
                this.m_LogicObjects.Add(param.BuildingTypeID, new Dictionary <int, BuildingLogicObject>());
            }
            if (!datas.ContainsKey(param.BuildingTypeID))
            {
                datas.Add(param.BuildingTypeID, new Dictionary <int, BuildingData>());
            }
            this.m_LogicObjects[param.BuildingTypeID].Add(param.BuildingNO,
                                                          new BuildingLogicObject(data, (int)BuildingFunction.ProduceResource, false));
            datas[param.BuildingTypeID].Add(param.BuildingNO, data);

            data.AvailableMercenary = new List <MercenaryIdentity>();
            if (param.Mercenaries != null)
            {
                foreach (KeyValuePair <MercenaryType, int> mercenary in param.Mercenaries)
                {
                    MercenaryConfigData mercenaryConfigData = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(mercenary.Key);
                    this.m_AlreadyArmyCapacity += mercenaryConfigData.CapcityCost * mercenary.Value;

                    for (int i = 0; i < mercenary.Value; i++)
                    {
                        data.AvailableMercenary.Add(new MercenaryIdentity(mercenary.Key, i));
                        if (!this.m_Mercenaries.ContainsKey(mercenary.Key))
                        {
                            this.m_Mercenaries.Add(mercenary.Key, 0);
                        }
                        this.m_Mercenaries[mercenary.Key]++;
                    }
                }
            }

            data.AvailableArmy = new List <ArmyIdentity>();
            if (param.Armies != null)
            {
                foreach (FriendArmyParameter army in param.Armies)
                {
                    if (!this.m_ArmyLevels.ContainsKey(army.ArmyType))
                    {
                        this.m_ArmyLevels.Add(army.ArmyType, army.ArmyLevel);
                    }

                    ArmyType       type           = army.ArmyType;
                    ArmyConfigData armyConfigData = ConfigInterface.Instance.ArmyConfigHelper.GetArmyData(army.ArmyType, army.ArmyLevel);
                    this.m_AlreadyArmyCapacity += armyConfigData.CapcityCost;
                    if (!this.m_ArmyObjects.ContainsKey(type))
                    {
                        this.m_ArmyObjects.Add(type, new Dictionary <int, FriendArmyParameter>());
                    }
                    ArmyIdentity armyID = new ArmyIdentity(type, this.m_ArmyObjects[type].Count);
                    data.AvailableArmy.Add(armyID);
                    this.m_ArmyObjects[type].Add(armyID.armyNO, army);
                }
            }
            data.AvailableItem = new List <ItemIdentity>();
            if (param.Items != null)
            {
                foreach (FriendItemParameter item in param.Items)
                {
                    ItemType type = item.ItemType;
                    if (!this.m_ItemObjects.ContainsKey(type))
                    {
                        this.m_ItemObjects.Add(type, new Dictionary <int, FriendItemParameter>());
                    }
                    ItemIdentity itemID = new ItemIdentity(type, this.m_ItemObjects[type].Count);
                    data.AvailableItem.Add(itemID);
                    this.m_ItemObjects[type].Add(itemID.itemNO, item);
                }
            }

            this.m_TotalCampCapacity += configData.ArmyCapacity;
        }

        Dictionary <ResourceType, Dictionary <BuildingIdentity, int> > result = this.m_ResourceManager.CalculateStorage
                                                                                    (userData.CurrentStoreGold, userData.CurrentStoreFood, userData.CurrentStoreOil);

        foreach (KeyValuePair <ResourceType, Dictionary <BuildingIdentity, int> > resource in result)
        {
            foreach (KeyValuePair <BuildingIdentity, int> r in resource.Value)
            {
                switch (resource.Key)
                {
                case ResourceType.Gold:
                {
                    datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreGold = r.Value;
                }
                break;

                case ResourceType.Food:
                {
                    datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreFood = r.Value;
                }
                break;

                case ResourceType.Oil:
                {
                    datas[r.Key.buildingType][r.Key.buildingNO].CurrentStoreOil = r.Value;
                }
                break;
                }
            }
        }
    }
示例#14
0
 // Use this for initialization
 void Start()
 {
     this.m_ConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(this.m_Type, 0);
 }
示例#15
0
    public void ConstructBuilding(FindRivalResponseParameter response)
    {
        foreach (BattleRemovableObjectParameter removableObject in response.Objects)
        {
            this.ConstructRemovableObject(removableObject);
        }

        foreach (BattleDefenseObjectParameter defenseObject in response.DefenseObjects)
        {
            this.ConstructDefenseObject(defenseObject);
        }

        if (response.Buffs != null)
        {
            BuildingBuffSystem.Instance.ClearBuff();
            BuildingBuffSystem.Instance.InitialBuff(response.Buffs);
        }

        bool isReplay = Application.loadedLevelName == ClientStringConstants.BATTLE_REPLAY_LEVEL_NAME;
        Dictionary <BuildingType, int> NOGenerater = new Dictionary <BuildingType, int>();

        if (isReplay)
        {
            for (int i = 0; i < (int)BuildingType.Length; i++)
            {
                NOGenerater.Add((BuildingType)i, 0);
            }
        }
        Age  age          = Age.Prehistoric;
        bool isInitialAge = false;
        List <BuildingSurfaceBehavior> notInitialSurfaces = new List <BuildingSurfaceBehavior>();

        foreach (BattleBuildingParameter building in response.Buildings)
        {
            BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(building.BuildingType, building.Level);
            string             prefabName = string.Format("{0}{1}{2}", ClientStringConstants.BATTLE_SCENE_RESOURCE_PREFAB_PREFIX_NAME,
                                                          ClientStringConstants.BUILDING_OBJECT_PREFAB_PREFIX_NAME, configData.BuildingPrefabName);

            GameObject buildingPrefab = Resources.Load(prefabName) as GameObject;
            GameObject buildingObject = GameObject.Instantiate(buildingPrefab) as GameObject;

            buildingObject.transform.position = PositionConvertor.GetWorldPositionFromBuildingTileIndex
                                                    (new TilePosition(building.PositionColumn, building.PositionRow));
            buildingObject.transform.parent = this.m_ParentNode;

            BuildingPropertyBehavior property = buildingObject.GetComponent <BuildingPropertyBehavior>();
            property.BuildingType = building.BuildingType;

            if (building.BuildingType == BuildingType.CityHall)
            {
                this.m_CurrentRivalCityHallLevel = building.Level;
                age          = CommonUtilities.CommonUtilities.GetAgeFromCityHallLevel(building.Level);
                isInitialAge = true;
            }

            if (isReplay)
            {
                property.BuildingNO = NOGenerater[building.BuildingType];
                NOGenerater[building.BuildingType]++;
            }
            else
            {
                property.BuildingNO = building.BuildingNO;
            }
            property.BuildingCategory = (BuildingCategory)configData.Category;
            property.Level            = building.Level;

            property.BuildingPosition     = new TilePosition(building.PositionColumn, building.PositionRow);
            property.BuildingObstacleList = new List <TilePosition>();
            property.ActorObstacleList    = new List <TilePosition>();
            foreach (TilePoint buildingObstacle in configData.BuildingObstacleList)
            {
                property.BuildingObstacleList.Add(buildingObstacle.ConvertToTilePosition());
            }
            foreach (TilePoint actorObstacle in configData.ActorObstacleList)
            {
                property.ActorObstacleList.Add(actorObstacle.ConvertToTilePosition());
            }

            //propert
            property.PlunderRate  = configData.PlunderRate;
            property.GoldCapacity = configData.StoreGoldCapacity;
            property.FoodCapacity = configData.StoreFoodCapacity;
            property.OilCapacity  = configData.StoreOilCapacity;

            property.Buffs = BuildingBuffSystem.Instance.GetBuffs(property.BuildingCategory);

            if (building.CurrentGold.HasValue || building.CurrentFood.HasValue || building.CurrentOil.HasValue)
            {
                property.Gold = building.CurrentGold.HasValue ? building.CurrentGold.Value : 0;
                property.Food = building.CurrentFood.HasValue ? building.CurrentFood.Value : 0;
                property.Oil  = building.CurrentOil.HasValue ? building.CurrentOil.Value : 0;

                property.Gold         = Mathf.RoundToInt(property.Gold * property.PlunderRate);
                property.Food         = Mathf.RoundToInt(property.Food * property.PlunderRate);
                property.Oil          = Mathf.RoundToInt(property.Oil * property.PlunderRate);
                property.OriginalGold = property.Gold;
                property.OriginalFood = property.Food;
                property.OriginalOil  = property.Oil;

                this.m_SceneHelper.AddProduceResourceBuilding(property);
            }
            else
            {
                if ((configData.CanStoreGold && !configData.CanProduceGold && building.Level != 0) ||
                    (configData.CanStoreFood && !configData.CanProduceFood && building.Level != 0) ||
                    (configData.CanStoreOil && !configData.CanProduceOil && building.Level != 0))
                {
                    this.m_SceneHelper.AddResourceBuilding(buildingObject,
                                                           new CapacityConfigData()
                    {
                        GoldCapacity = configData.StoreGoldCapacity,
                        FoodCapacity = configData.StoreFoodCapacity, OilCapacity = configData.StoreOilCapacity
                    });
                }
            }

            BuildingHPBehavior hp = buildingObject.GetComponent <BuildingHPBehavior>();
            hp.TotalHP       = Mathf.Max(1, configData.MaxHP + property.BuffHPEffect);
            hp.SceneHelper   = this.m_SceneHelper;
            hp.ArmorCategory = configData.ArmorCategory;

            if (building.BuilderLevel.HasValue)
            {
                BattleObstacleUpgradingInfo info = new BattleObstacleUpgradingInfo()
                {
                    AttachedBuilderLevel = building.BuilderLevel.Value, ObstacleProperty = property
                };
                this.m_SceneHelper.AddUpgradingObstacle(info);
            }
            if (building.IsUpgrading)
            {
                this.ConstructFacility(buildingObject, property);
            }

            BuildingSurfaceBehavior surface = buildingObject.GetComponent <BuildingSurfaceBehavior>();
            if (surface != null)
            {
                if (isInitialAge)
                {
                    surface.SetSurface(age, building.BuildingType);
                }
                else
                {
                    notInitialSurfaces.Add(surface);
                }
            }

            BuildingAI buildingAI = buildingObject.GetComponent <BuildingAI>();
            if (configData.CanAttack && !building.IsUpgrading)
            {
                buildingAI.enabled = false;
                AttackBehavior attackBehavior = null;
                if (configData.ApMinScope > 0)
                {
                    attackBehavior = buildingObject.AddComponent <RingAttackBehavior>();
                    ((RingAttackBehavior)attackBehavior).BlindScope = configData.ApMinScope;
                }
                else
                {
                    attackBehavior = buildingObject.AddComponent <AttackBehavior>();
                }
                int cd = Mathf.FloorToInt(configData.AttackCD * ClientConfigConstants.Instance.TicksPerSecond);
                attackBehavior.AttackCD       = Mathf.Max(1, cd - property.BuffAttackSpeedEffect);
                attackBehavior.AttackScope    = configData.ApMaxScope;
                attackBehavior.AttackValue    = Mathf.Max(1, configData.AttackValue + property.BuffAttackValueEffect);
                attackBehavior.BulletFlySpeed = configData.AttackMiddleSpeed;
                attackBehavior.AttackType     = (AttackType)configData.AttackType;
                attackBehavior.AttackCategory = configData.AttackCategory;
                attackBehavior.TargetType     = (TargetType)configData.TargetType;
                attackBehavior.DamageScope    = configData.DamageScope;
                attackBehavior.PushTicks      = configData.DamagePushTicks;
                attackBehavior.PushVelocity   = configData.DamagePushVelocity;
                attackBehavior.BulletParent   = this.m_BulletParent;

                buildingAI.AttackBehavior = attackBehavior;
                BuildingIdleState idleState = new BuildingIdleState(buildingAI, true);
                buildingAI.ChangeState(idleState);
                buildingAI.SceneHelper = BattleSceneHelper.Instance;
            }
            else
            {
                buildingAI.DetachSelf();
            }

            this.m_SceneHelper.ConstructBuilding(buildingObject);
        }

        foreach (BuildingSurfaceBehavior surface in notInitialSurfaces)
        {
            surface.SetSurface(age, surface.GetComponent <BuildingPropertyBehavior>().BuildingType);
        }

        this.m_SceneHelper.DistributeResource(response.TotalGold, response.TotalFood, response.TotalOil);


        foreach (BattleAchievementBuildingParameter achievementBuilding in response.AchievementBuildings)
        {
            this.ConstructAchievementBuilding(achievementBuilding, age);
        }
    }
示例#16
0
    public static FindRivalResponseParameter ConvertJSONToParameter(Hashtable map)
    {
        FindRivalResponseParameter result = new FindRivalResponseParameter();

        result.Objects              = new List <BattleRemovableObjectParameter>();
        result.Buildings            = new List <BattleBuildingParameter>();
        result.AchievementBuildings = new List <BattleAchievementBuildingParameter>();
        result.DefenseObjects       = new List <BattleDefenseObjectParameter>();
        result.RivalHonour          = 10000;
        result.RivalID              = -100;
        result.RivalLevel           = -100;
        result.RivalName            = "电脑";
        result.TotalFood            = 0;
        result.TotalGold            = 0;
        result.TotalOil             = 0;

        if (map.ContainsKey(EditorConfigInterface.Instance.MapBuildingKey))
        {
            var buildings = (ArrayList)map[EditorConfigInterface.Instance.MapBuildingKey];
            foreach (var b in buildings)
            {
                Hashtable building            = (Hashtable)b;
                BattleBuildingParameter param = new BattleBuildingParameter();

                param.BuildingNO     = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingNoKey]);
                param.BuildingType   = (BuildingType)(Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingTypeKey]));
                param.IsUpgrading    = false;
                param.Level          = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingLevelKey]);
                param.PositionColumn = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingColumnKey]);
                param.PositionRow    = Convert.ToInt32(building[EditorConfigInterface.Instance.MapBuildingRowKey]);

                BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(param.BuildingType, param.Level);
                if (configData.StoreGoldCapacity > 0)
                {
                    if (configData.CanProduceGold)
                    {
                        param.CurrentGold = configData.StoreGoldCapacity;
                    }
                    else
                    {
                        result.TotalGold += configData.StoreGoldCapacity;
                    }
                }
                if (configData.StoreFoodCapacity > 0)
                {
                    if (configData.CanProduceFood)
                    {
                        param.CurrentFood = configData.StoreFoodCapacity;
                    }
                    else
                    {
                        result.TotalFood += configData.StoreFoodCapacity;
                    }
                }
                if (configData.StoreOilCapacity > 0)
                {
                    if (configData.CanProduceOil)
                    {
                        param.CurrentOil = configData.StoreOilCapacity;
                    }
                    else
                    {
                        result.TotalOil += configData.StoreOilCapacity;
                    }
                }
                result.Buildings.Add(param);
            }
        }

        if (map.ContainsKey(EditorConfigInterface.Instance.MapRemovableObjectKey))
        {
            var objects = (ArrayList)map[EditorConfigInterface.Instance.MapRemovableObjectKey];
            foreach (var o in objects)
            {
                Hashtable removableObject            = (Hashtable)o;
                BattleRemovableObjectParameter param = new BattleRemovableObjectParameter();

                param.ObjectType     = (RemovableObjectType)(Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapRemovableObjectTypeKey]));
                param.PositionRow    = Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapBuildingRowKey]);
                param.PositionColumn = Convert.ToInt32(removableObject[EditorConfigInterface.Instance.MapBuildingColumnKey]);

                result.Objects.Add(param);
            }
        }

        if (map.ContainsKey(EditorConfigInterface.Instance.MapAchievementBuildingKey))
        {
            var achievementBuildings = (ArrayList)map[EditorConfigInterface.Instance.MapAchievementBuildingKey];
            int buildingNo           = 0;
            foreach (var a in achievementBuildings)
            {
                Hashtable achievementBuilding            = (Hashtable)a;
                BattleAchievementBuildingParameter param = new BattleAchievementBuildingParameter();

                param.AchievementBuildingNo   = ++buildingNo;
                param.AchievementBuildingType = (AchievementBuildingType)(Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingTypeKey]));
                param.IsDropProps             = false;
                param.PositionRow             = Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingRowKey]);
                param.PositionColumn          = Convert.ToInt32(achievementBuilding[EditorConfigInterface.Instance.MapAchievementBuildingColumnKey]);

                result.AchievementBuildings.Add(param);
            }
        }

        if (map.ContainsKey(EditorConfigInterface.Instance.MapDefenseObjectKey))
        {
            var  defenseObjects = (ArrayList)map[EditorConfigInterface.Instance.MapDefenseObjectKey];
            long objectID       = 0;
            foreach (var d in defenseObjects)
            {
                Hashtable defenseObject            = (Hashtable)d;
                BattleDefenseObjectParameter param = new BattleDefenseObjectParameter();

                param.DefenseObjectID = objectID++;
                param.PropsType       = (PropsType)(Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectTypeKey]));
                param.PositionRow     = Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectRowKey]);
                param.PositionColumn  = Convert.ToInt32(defenseObject[EditorConfigInterface.Instance.MapDefenseObjectColumnKey]);

                result.DefenseObjects.Add(param);
            }
        }

        return(result);
    }
    private BuildingData GenerateBuildingData(BuildingParameter param, List <ArmyData> armies, List <ItemData> items, Dictionary <MercenaryIdentity, MercenaryData> mercenaries,
                                              List <ObjectUpgrade <ArmyType> > armyUpgrades, List <ObjectUpgrade <ItemType> > itemUpgrades, UserData userData)
    {
        BuildingData       result     = new BuildingData();
        BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData
                                            (param.BuildingTypeID, param.Level);

        result.ConfigData = configData;

        BuildingIdentity id = new BuildingIdentity();

        id.buildingNO     = param.BuildingNO;
        id.buildingType   = param.BuildingTypeID;
        result.BuildingID = id;

        result.BuildingPosition         = new TilePosition(param.PositionColumn, param.PositionRow);
        result.Level                    = param.Level;
        result.UpgradeRemainingWorkload = param.RemainWorkload;

        if (param.LastCollectGoldTick.HasValue)
        {
            result.LastCollectedGoldTick = param.LastCollectGoldTick.Value;
        }
        if (param.CollectedGold.HasValue)
        {
            result.CollectedGold = param.CollectedGold.Value;
        }
        if (param.LastCollectFoodTick.HasValue)
        {
            result.LastCollectedFoodTick = param.LastCollectFoodTick.Value;
        }
        if (param.CollectedFood.HasValue)
        {
            result.CollectedFood = param.CollectedFood.Value;
        }
        if (param.LastCollectOilTick.HasValue)
        {
            result.LastCollectedOilTick = param.LastCollectOilTick.Value;
        }
        if (param.CollectedOil.HasValue)
        {
            result.CollectedOil = param.CollectedOil.Value;
        }

        if (param.ArmyProducts != null)
        {
            result.ProduceArmy = new List <KeyValuePair <ArmyType, List <ArmyIdentity> > >();
            ArmyType?previousType = null;
            foreach (ArmyProductParameter product in param.ArmyProducts)
            {
                if (previousType.HasValue && previousType.Value == product.ArmyType)
                {
                    result.ProduceArmy[result.ProduceArmy.Count - 1].Value.Add(new ArmyIdentity(product.ArmyType, product.ArmyNO));
                }
                else
                {
                    List <ArmyIdentity> newList = new List <ArmyIdentity>()
                    {
                        new ArmyIdentity(product.ArmyType, product.ArmyNO)
                    };
                    result.ProduceArmy.Add(new KeyValuePair <ArmyType, List <ArmyIdentity> >(product.ArmyType, newList));
                }
                previousType = product.ArmyType;
                armies.Add(this.GenerateArmyData(product, userData));
            }
        }

        if (param.Armies != null)
        {
            result.AvailableArmy = new List <ArmyIdentity>();
            foreach (ArmyParameter army in param.Armies)
            {
                result.AvailableArmy.Add(new ArmyIdentity(army.ArmyType, army.ArmyNO));
                armies.Add(this.GenerateArmyData(army, userData, id));
            }
        }
        if (param.ArmyUpgrade != null)
        {
            result.ArmyUpgrade = param.ArmyUpgrade.ArmyType;
            ObjectUpgrade <ArmyType> upgrade = new ObjectUpgrade <ArmyType>(param.ArmyUpgrade.ArmyType, param.ArmyUpgrade.RemainingWorkload);
            armyUpgrades.Add(upgrade);
        }


        if (param.ItemProducts != null)
        {
            result.ProduceItem = new List <KeyValuePair <ItemType, List <ItemIdentity> > >();

            ItemType?previousType = null;
            foreach (ItemProductParameter product in param.ItemProducts)
            {
                if (previousType.HasValue && previousType.Value == product.ItemType)
                {
                    result.ProduceItem[result.ProduceItem.Count - 1].Value.Add(new ItemIdentity(product.ItemType, product.ItemNO));
                }
                else
                {
                    List <ItemIdentity> newList = new List <ItemIdentity>()
                    {
                        new ItemIdentity(product.ItemType, product.ItemNO)
                    };
                    result.ProduceItem.Add(new KeyValuePair <ItemType, List <ItemIdentity> >(product.ItemType, newList));
                }
                previousType = product.ItemType;
                items.Add(this.GenerateItemData(product, userData));
            }
        }


        if (param.Items != null)
        {
            result.AvailableItem = new List <ItemIdentity>();
            foreach (ItemParameter item in param.Items)
            {
                result.AvailableItem.Add(new ItemIdentity(item.ItemType, item.ItemNO));
                items.Add(this.GenerateItemData(item, userData));
            }
        }

        if (param.ItemUpgrade != null)
        {
            result.ItemUpgrade = param.ItemUpgrade.ItemType;
            ObjectUpgrade <ItemType> upgrade = new ObjectUpgrade <ItemType>(param.ItemUpgrade.ItemType, param.ItemUpgrade.RemainingWorkload);
            itemUpgrades.Add(upgrade);
        }

        if (param.Mercenaries != null)
        {
            result.AvailableMercenary = new List <MercenaryIdentity>();
            foreach (MercenaryParameter mercenary in param.Mercenaries)
            {
                result.AvailableMercenary.Add(new MercenaryIdentity(mercenary.MercenaryType, mercenary.MercenaryNO));
                mercenaries.Add(new MercenaryIdentity(mercenary.MercenaryType, mercenary.MercenaryNO), this.GenerateMercenaryData(mercenary, id));
            }
        }

        if (param.MercenaryProducts != null)
        {
            Dictionary <MercenaryType, MercenaryProductData> dict = new Dictionary <MercenaryType, MercenaryProductData>();
            foreach (MercenaryProductParameter mercenaryProduct in param.MercenaryProducts)
            {
                MercenaryProductData data = new MercenaryProductData();
                data.ReadyNumber   = mercenaryProduct.Number;
                data.RemainingTime = mercenaryProduct.RemainingSecond;
                data.ConfigData    = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(mercenaryProduct.MercenaryType);
                dict.Add(mercenaryProduct.MercenaryType, data);
            }
            result.ProduceMercenary = new MercenaryProductCollectionLogicObject(dict);
        }

        if (param.ResourceAccelerate != null)
        {
            result.RemainResourceAccelerateTime = param.ResourceAccelerate.RemainingTime;
        }

        if (param.ArmyAccelerate != null)
        {
            result.RemainArmyAccelerateTime = param.ArmyAccelerate.RemainingTime;
        }

        if (param.ItemAccelerate != null)
        {
            result.RemainItemAccelerateTime = param.ItemAccelerate.RemainingTime;
        }

        return(result);
    }
示例#18
0
 public void DestroyBuilding(TilePosition position, BuildingConfigData configData)
 {
     this.PopulateMapData(position, configData.BuildingObstacleList, null);
 }