예제 #1
0
        private void FillBuildingListByType(List <SmartEntity> list, BuildingType type)
        {
            switch (type)
            {
            case BuildingType.Any:
            {
                NodeList <BuildingNode> nodeList = this.entityController.GetNodeList <BuildingNode>();
                for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
                {
                    list.Add((SmartEntity)buildingNode.Entity);
                }
                return;
            }

            case BuildingType.HQ:
                for (HQNode hQNode = this.HQNodeList.Head; hQNode != null; hQNode = hQNode.Next)
                {
                    list.Add((SmartEntity)hQNode.Entity);
                }
                return;

            case BuildingType.Barracks:
                for (BarracksNode barracksNode = this.BarracksNodeList.Head; barracksNode != null; barracksNode = barracksNode.Next)
                {
                    list.Add((SmartEntity)barracksNode.Entity);
                }
                return;

            case BuildingType.Factory:
                for (FactoryNode factoryNode = this.FactoryNodeList.Head; factoryNode != null; factoryNode = factoryNode.Next)
                {
                    list.Add((SmartEntity)factoryNode.Entity);
                }
                return;

            case BuildingType.FleetCommand:
                for (FleetCommandNode fleetCommandNode = this.FleetCommandNodeList.Head; fleetCommandNode != null; fleetCommandNode = fleetCommandNode.Next)
                {
                    list.Add((SmartEntity)fleetCommandNode.Entity);
                }
                return;

            case BuildingType.HeroMobilizer:
                for (TacticalCommandNode tacticalCommandNode = this.TacticalCommandNodeList.Head; tacticalCommandNode != null; tacticalCommandNode = tacticalCommandNode.Next)
                {
                    list.Add((SmartEntity)tacticalCommandNode.Entity);
                }
                return;

            case BuildingType.ChampionPlatform:
                for (ChampionPlatformNode championPlatformNode = this.ChampionPlatformNodeList.Head; championPlatformNode != null; championPlatformNode = championPlatformNode.Next)
                {
                    list.Add((SmartEntity)championPlatformNode.Entity);
                }
                return;

            case BuildingType.Housing:
                for (HousingNode housingNode = this.HousingNodeList.Head; housingNode != null; housingNode = housingNode.Next)
                {
                    list.Add((SmartEntity)housingNode.Entity);
                }
                return;

            case BuildingType.Squad:
                for (SquadBuildingNode squadBuildingNode = this.SquadBuildingNodeList.Head; squadBuildingNode != null; squadBuildingNode = squadBuildingNode.Next)
                {
                    list.Add((SmartEntity)squadBuildingNode.Entity);
                }
                return;

            case BuildingType.Starport:
                for (StarportNode starportNode = this.StarportNodeList.Head; starportNode != null; starportNode = starportNode.Next)
                {
                    list.Add((SmartEntity)starportNode.Entity);
                }
                return;

            case BuildingType.DroidHut:
                for (DroidHutNode droidHutNode = this.DroidHutNodeList.Head; droidHutNode != null; droidHutNode = droidHutNode.Next)
                {
                    list.Add((SmartEntity)droidHutNode.Entity);
                }
                return;

            case BuildingType.Wall:
                for (WallNode wallNode = this.WallNodeList.Head; wallNode != null; wallNode = wallNode.Next)
                {
                    list.Add((SmartEntity)wallNode.Entity);
                }
                return;

            case BuildingType.Turret:
                for (TurretBuildingNode turretBuildingNode = this.TurretBuildingNodeList.Head; turretBuildingNode != null; turretBuildingNode = turretBuildingNode.Next)
                {
                    list.Add((SmartEntity)turretBuildingNode.Entity);
                }
                return;

            case BuildingType.TroopResearch:
                for (OffenseLabNode offenseLabNode = this.OffenseLabNodeList.Head; offenseLabNode != null; offenseLabNode = offenseLabNode.Next)
                {
                    list.Add((SmartEntity)offenseLabNode.Entity);
                }
                return;

            case BuildingType.DefenseResearch:
                for (DefenseLabNode defenseLabNode = this.DefenseLabNodeList.Head; defenseLabNode != null; defenseLabNode = defenseLabNode.Next)
                {
                    list.Add((SmartEntity)defenseLabNode.Entity);
                }
                return;

            case BuildingType.Resource:
                for (GeneratorNode generatorNode = this.GeneratorNodeList.Head; generatorNode != null; generatorNode = generatorNode.Next)
                {
                    list.Add((SmartEntity)generatorNode.Entity);
                }
                return;

            case BuildingType.Storage:
                for (StorageNode storageNode = this.StorageNodeList.Head; storageNode != null; storageNode = storageNode.Next)
                {
                    list.Add((SmartEntity)storageNode.Entity);
                }
                return;

            case BuildingType.ShieldGenerator:
                for (ShieldGeneratorNode shieldGeneratorNode = this.ShieldGeneratorNodeList.Head; shieldGeneratorNode != null; shieldGeneratorNode = shieldGeneratorNode.Next)
                {
                    list.Add((SmartEntity)shieldGeneratorNode.Entity);
                }
                return;

            case BuildingType.Clearable:
                for (ClearableNode clearableNode = this.ClearableNodeList.Head; clearableNode != null; clearableNode = clearableNode.Next)
                {
                    list.Add((SmartEntity)clearableNode.Entity);
                }
                return;

            case BuildingType.Trap:
                for (TrapNode trapNode = this.TrapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
                {
                    list.Add((SmartEntity)trapNode.Entity);
                }
                return;

            case BuildingType.Cantina:
                for (CantinaNode cantinaNode = this.CantinaNodeList.Head; cantinaNode != null; cantinaNode = cantinaNode.Next)
                {
                    list.Add((SmartEntity)cantinaNode.Entity);
                }
                return;

            case BuildingType.NavigationCenter:
                for (NavigationCenterNode navigationCenterNode = this.NavigationCenterNodeList.Head; navigationCenterNode != null; navigationCenterNode = navigationCenterNode.Next)
                {
                    list.Add((SmartEntity)navigationCenterNode.Entity);
                }
                return;

            case BuildingType.ScoutTower:
                for (ScoutTowerNode scoutTowerNode = this.ScoutTowerNodeList.Head; scoutTowerNode != null; scoutTowerNode = scoutTowerNode.Next)
                {
                    list.Add((SmartEntity)scoutTowerNode.Entity);
                }
                return;

            case BuildingType.Armory:
                for (ArmoryNode armoryNode = this.ArmoryNodeList.Head; armoryNode != null; armoryNode = armoryNode.Next)
                {
                    list.Add((SmartEntity)armoryNode.Entity);
                }
                return;
            }
            Service.Logger.Warn("Unknown building type " + type);
        }
예제 #2
0
        public bool HasConstructedBuilding(BuildingTypeVO reqBuilding)
        {
            int lvl = reqBuilding.Lvl;

            switch (reqBuilding.Type)
            {
            case BuildingType.HQ:
                for (HQNode hQNode = this.HQNodeList.Head; hQNode != null; hQNode = hQNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)hQNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Barracks:
                for (BarracksNode barracksNode = this.BarracksNodeList.Head; barracksNode != null; barracksNode = barracksNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)barracksNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Factory:
                for (FactoryNode factoryNode = this.FactoryNodeList.Head; factoryNode != null; factoryNode = factoryNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)factoryNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.FleetCommand:
                for (FleetCommandNode fleetCommandNode = this.FleetCommandNodeList.Head; fleetCommandNode != null; fleetCommandNode = fleetCommandNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)fleetCommandNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.HeroMobilizer:
                for (TacticalCommandNode tacticalCommandNode = this.TacticalCommandNodeList.Head; tacticalCommandNode != null; tacticalCommandNode = tacticalCommandNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)tacticalCommandNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.ChampionPlatform:
                for (ChampionPlatformNode championPlatformNode = this.ChampionPlatformNodeList.Head; championPlatformNode != null; championPlatformNode = championPlatformNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)championPlatformNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Housing:
                for (HousingNode housingNode = this.HousingNodeList.Head; housingNode != null; housingNode = housingNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)housingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Squad:
                for (SquadBuildingNode squadBuildingNode = this.SquadBuildingNodeList.Head; squadBuildingNode != null; squadBuildingNode = squadBuildingNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)squadBuildingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Starport:
                for (StarportNode starportNode = this.StarportNodeList.Head; starportNode != null; starportNode = starportNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)starportNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.DroidHut:
                for (DroidHutNode droidHutNode = this.DroidHutNodeList.Head; droidHutNode != null; droidHutNode = droidHutNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)droidHutNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Wall:
                for (WallNode wallNode = this.WallNodeList.Head; wallNode != null; wallNode = wallNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)wallNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Turret:
                for (TurretBuildingNode turretBuildingNode = this.TurretBuildingNodeList.Head; turretBuildingNode != null; turretBuildingNode = turretBuildingNode.Next)
                {
                    if (turretBuildingNode.BuildingComp.BuildingType.UpgradeGroup == reqBuilding.UpgradeGroup && GameUtils.GetBuildingEffectiveLevel((SmartEntity)turretBuildingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.TroopResearch:
                for (OffenseLabNode offenseLabNode = this.OffenseLabNodeList.Head; offenseLabNode != null; offenseLabNode = offenseLabNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)offenseLabNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.DefenseResearch:
                for (DefenseLabNode defenseLabNode = this.DefenseLabNodeList.Head; defenseLabNode != null; defenseLabNode = defenseLabNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)defenseLabNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Resource:
                for (GeneratorNode generatorNode = this.GeneratorNodeList.Head; generatorNode != null; generatorNode = generatorNode.Next)
                {
                    if (generatorNode.BuildingComp.BuildingType.Currency == reqBuilding.Currency && GameUtils.GetBuildingEffectiveLevel((SmartEntity)generatorNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Storage:
                for (StorageNode storageNode = this.StorageNodeList.Head; storageNode != null; storageNode = storageNode.Next)
                {
                    if (storageNode.BuildingComp.BuildingType.Currency == reqBuilding.Currency && GameUtils.GetBuildingEffectiveLevel((SmartEntity)storageNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Trap:
                for (TrapNode trapNode = this.TrapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)trapNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Cantina:
                for (CantinaNode cantinaNode = this.CantinaNodeList.Head; cantinaNode != null; cantinaNode = cantinaNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)cantinaNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.NavigationCenter:
                for (NavigationCenterNode navigationCenterNode = this.NavigationCenterNodeList.Head; navigationCenterNode != null; navigationCenterNode = navigationCenterNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)navigationCenterNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.ScoutTower:
                for (ScoutTowerNode scoutTowerNode = this.ScoutTowerNodeList.Head; scoutTowerNode != null; scoutTowerNode = scoutTowerNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)scoutTowerNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Armory:
                for (ArmoryNode armoryNode = this.ArmoryNodeList.Head; armoryNode != null; armoryNode = armoryNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)armoryNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);
            }
            Service.Logger.Warn("Unknown reqBuilding type for level: " + reqBuilding.Uid);
            return(false);
        }
예제 #3
0
        public int GetBuildingPurchasedQuantity(BuildingTypeVO building)
        {
            switch (building.Type)
            {
            case BuildingType.Invalid:
                Service.Logger.Warn("Invalid building type for count: " + building.Uid);
                return(0);

            case BuildingType.HQ:
                return(this.HQNodeList.CalculateCount());

            case BuildingType.Barracks:
                return(this.BarracksNodeList.CalculateCount());

            case BuildingType.Factory:
                return(this.FactoryNodeList.CalculateCount());

            case BuildingType.FleetCommand:
                return(this.FleetCommandNodeList.CalculateCount());

            case BuildingType.HeroMobilizer:
                return(this.TacticalCommandNodeList.CalculateCount());

            case BuildingType.ChampionPlatform:
            {
                int num = 0;
                for (ChampionPlatformNode championPlatformNode = this.ChampionPlatformNodeList.Head; championPlatformNode != null; championPlatformNode = championPlatformNode.Next)
                {
                    if (championPlatformNode.BuildingComp.BuildingType.UpgradeGroup == building.UpgradeGroup)
                    {
                        num++;
                    }
                }
                return(num);
            }

            case BuildingType.Housing:
                return(this.HousingNodeList.CalculateCount());

            case BuildingType.Squad:
                return(this.SquadBuildingNodeList.CalculateCount());

            case BuildingType.Starport:
                return(this.StarportNodeList.CalculateCount());

            case BuildingType.DroidHut:
                return(this.DroidHutNodeList.CalculateCount());

            case BuildingType.Wall:
                return(this.WallNodeList.CalculateCount());

            case BuildingType.Turret:
            {
                int num2 = 0;
                for (TurretBuildingNode turretBuildingNode = this.TurretBuildingNodeList.Head; turretBuildingNode != null; turretBuildingNode = turretBuildingNode.Next)
                {
                    if (turretBuildingNode.BuildingComp.BuildingType.UpgradeGroup == building.UpgradeGroup)
                    {
                        num2++;
                    }
                }
                return(num2);
            }

            case BuildingType.TroopResearch:
                return(this.OffenseLabNodeList.CalculateCount());

            case BuildingType.DefenseResearch:
                return(this.DefenseLabNodeList.CalculateCount());

            case BuildingType.Resource:
            {
                int num3 = 0;
                for (GeneratorNode generatorNode = this.GeneratorNodeList.Head; generatorNode != null; generatorNode = generatorNode.Next)
                {
                    if (generatorNode.BuildingComp.BuildingType.Currency == building.Currency)
                    {
                        num3++;
                    }
                }
                return(num3);
            }

            case BuildingType.Storage:
            {
                int num4 = 0;
                for (StorageNode storageNode = this.StorageNodeList.Head; storageNode != null; storageNode = storageNode.Next)
                {
                    if (storageNode.BuildingComp.BuildingType.Currency == building.Currency)
                    {
                        num4++;
                    }
                }
                return(num4);
            }

            case BuildingType.ShieldGenerator:
            {
                int num5 = 0;
                NodeList <BuildingNode> nodeList = this.entityController.GetNodeList <BuildingNode>();
                for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
                {
                    if (buildingNode.BuildingComp.BuildingType.Type == BuildingType.ShieldGenerator)
                    {
                        num5++;
                    }
                }
                return(num5);
            }

            case BuildingType.Rubble:
                return(0);

            case BuildingType.Trap:
            {
                int num6 = 0;
                for (TrapBuildingNode trapBuildingNode = this.TrapBuildingNodeList.Head; trapBuildingNode != null; trapBuildingNode = trapBuildingNode.Next)
                {
                    if (trapBuildingNode.BuildingComp.BuildingType.UpgradeGroup == building.UpgradeGroup)
                    {
                        num6++;
                    }
                }
                return(num6);
            }

            case BuildingType.Cantina:
                return(this.CantinaNodeList.CalculateCount());

            case BuildingType.NavigationCenter:
                return(this.NavigationCenterNodeList.CalculateCount());

            case BuildingType.ScoutTower:
                return(this.ScoutTowerNodeList.CalculateCount());

            case BuildingType.Armory:
                return(this.ArmoryNodeList.CalculateCount());
            }
            Service.Logger.Warn("Unknown building type for count: " + building.Uid);
            return(0);
        }