public override int Execute(LogicLevel level)
        {
            LogicArrayList <LogicGameObject> gameObjects = level.GetGameObjectManagerAt(0).GetGameObjects(LogicGameObjectType.BUILDING);

            for (int i = 0; i < gameObjects.Size(); i++)
            {
                LogicBuilding building = (LogicBuilding)gameObjects[i];

                if (building.GetData() == LogicDataTables.GetAllianceCastleData())
                {
                    LogicWarResourceStorageComponent warResourceStorageComponent = building.GetWarResourceStorageComponent();

                    if (warResourceStorageComponent.IsNotEmpty())
                    {
                        warResourceStorageComponent.CollectResources();
                    }
                }
            }

            return(0);
        }
        public static int GetTotalCharacterMaxHousing(int townHallLevel, bool includeAllianceCastle)
        {
            LogicTownhallLevelData townhallLevelData = LogicDataTables.GetTownHallLevel(townHallLevel);
            LogicDataTable         table             = LogicDataTables.GetTable(LogicDataType.BUILDING);

            int housingSpace = 0;

            for (int i = 0; i < table.GetItemCount(); i++)
            {
                LogicBuildingData buildingData = (LogicBuildingData)table.GetItemAt(i);

                if (includeAllianceCastle || buildingData != LogicDataTables.GetAllianceCastleData())
                {
                    int unlockedBuildingCount = townhallLevelData.GetUnlockedBuildingCount(buildingData);

                    if (unlockedBuildingCount > 0 && !buildingData.IsForgesSpells())
                    {
                        housingSpace += unlockedBuildingCount * buildingData.GetUnitStorageCapacity(buildingData.GetMaxUpgradeLevelForTownHallLevel(townHallLevel));
                    }
                }
            }

            return(housingSpace);
        }
示例#3
0
        public override void RecalculateAvailableLoot()
        {
            LogicAvatar    homeOwnerAvatar = this.m_parent.GetLevel().GetHomeOwnerAvatar();
            LogicDataTable resourceTable   = LogicDataTables.GetTable(LogicDataType.RESOURCE);

            for (int i = 0; i < this.m_resourceCount.Size(); i++)
            {
                LogicResourceData data = (LogicResourceData)resourceTable.GetItemAt(i);

                if (this.m_parent.GetData() == LogicDataTables.GetAllianceCastleData())
                {
                    LogicResourceData refData = data.GetWarResourceReferenceData();

                    int resourceCount = this.m_resourceCount[i];

                    if (refData != null)
                    {
                        int warLootPercentage     = LogicDataTables.GetGlobals().GetWarLootPercentage();
                        int lootableResourceCount = 0;

                        if ((this.m_parent.GetLevel().GetMatchType() | 4) != 7 && !this.m_parent.GetLevel().IsArrangedWar())
                        {
                            lootableResourceCount = (int)((long)resourceCount * warLootPercentage / 100);
                        }

                        int storageLootCap   = LogicDataTables.GetTownHallLevel(homeOwnerAvatar.GetTownHallLevel()).GetStorageLootCap(data);
                        int maxResourceCount = LogicMath.Min(homeOwnerAvatar.GetResourceCount(data), homeOwnerAvatar.GetResourceCap(data));

                        if (maxResourceCount > storageLootCap && maxResourceCount > 0)
                        {
                            int clampedValue;

                            if (storageLootCap < 1000000)
                            {
                                if (storageLootCap < 100000)
                                {
                                    if (storageLootCap < 10000)
                                    {
                                        clampedValue = storageLootCap < 1000
                                            ? (resourceCount * storageLootCap + (maxResourceCount >> 1)) / maxResourceCount
                                            : 10 * ((resourceCount * (storageLootCap / 10) + (maxResourceCount >> 1)) / maxResourceCount);
                                    }
                                    else
                                    {
                                        clampedValue = 100 * ((resourceCount * (storageLootCap / 100) + (maxResourceCount >> 1)) / maxResourceCount);
                                    }
                                }
                                else
                                {
                                    clampedValue = 1000 * ((resourceCount * (storageLootCap / 1000) + (maxResourceCount >> 1)) / maxResourceCount);
                                }
                            }
                            else
                            {
                                clampedValue = 40000 * ((resourceCount * (storageLootCap / 40000) + (maxResourceCount >> 1)) / maxResourceCount);
                            }

                            if (lootableResourceCount > clampedValue)
                            {
                                lootableResourceCount = clampedValue;
                            }
                        }

                        if (lootableResourceCount > resourceCount)
                        {
                            lootableResourceCount = resourceCount;
                        }

                        this.m_stealableResourceCount[i] = lootableResourceCount;
                    }
                }
            }
        }