Exemple #1
0
        public static bool IsResourceField(BuildingEnum building)
        {
            int buildingInt = (int)building;

            // If id between 1 and 4, it's resource field
            return(buildingInt < 5 && buildingInt > 0);
        }
 public void ShowLogo(BuildingEnum val)
 {
     foreach (BuildingLogo logo in LogoBuildings)
     {
         logo.Logo.gameObject.SetActive(logo.Type == val);
     }
 }
Exemple #3
0
        private static Building GetLowestProduction(List <Building> buildings, Village vill)
        {
            //get distinct field types
            var          distinct   = buildings.Select(x => x.Type).Distinct().ToList();
            long         lowestProd = long.MaxValue;
            BuildingEnum toUpgrade  = BuildingEnum.Cropland;

            foreach (var distinctType in distinct)
            {
                if (distinctType == BuildingEnum.Woodcutter && vill.Res.Production.Wood < lowestProd)
                {
                    lowestProd = vill.Res.Production.Wood; toUpgrade = BuildingEnum.Woodcutter;
                }
                if (distinctType == BuildingEnum.ClayPit && vill.Res.Production.Clay < lowestProd)
                {
                    lowestProd = vill.Res.Production.Clay; toUpgrade = BuildingEnum.ClayPit;
                }
                if (distinctType == BuildingEnum.IronMine && vill.Res.Production.Iron < lowestProd)
                {
                    lowestProd = vill.Res.Production.Iron; toUpgrade = BuildingEnum.IronMine;
                }
                if (distinctType == BuildingEnum.Cropland && vill.Res.Production.Crop < lowestProd)
                {
                    lowestProd = vill.Res.Production.Crop; toUpgrade = BuildingEnum.Cropland;
                }
            }
            return(FindLowestLevelBuilding(buildings.Where(x => x.Type == toUpgrade).ToList()));
        }
    public Purchase Get(BuildingEnum buildingType)
    {
        switch (buildingType)
        {
        case BuildingEnum.MainBuilding:
            return(Get(PurchasesEnum.MainBuilding));

        case BuildingEnum.Library:
            return(Get(PurchasesEnum.Library));

        case BuildingEnum.Barracks:
            return(Get(PurchasesEnum.Barracks));

        case BuildingEnum.Infirmary:
            return(Get(PurchasesEnum.Infirmary));

        case BuildingEnum.House:
            return(Get(PurchasesEnum.House));

        case BuildingEnum.Mill:
            return(Get(PurchasesEnum.Mill));

        case BuildingEnum.Sawmill:
            return(Get(PurchasesEnum.Sawmill));

        case BuildingEnum.Bank:
            return(Get(PurchasesEnum.Bank));

        default:
            return(null);
        }
    }
        public static BuildingCategoryEnum GetBuildingsCategory(BuildingEnum building)
        {
            switch (building)
            {
            case BuildingEnum.GrainMill:
            case BuildingEnum.Sawmill:
            case BuildingEnum.Brickyard:
            case BuildingEnum.IronFoundry:
            case BuildingEnum.Bakery:
                return(BuildingCategoryEnum.Resources);

            case BuildingEnum.RallyPoint:
            case BuildingEnum.EarthWall:
            case BuildingEnum.CityWall:
            case BuildingEnum.MakeshiftWall:
            case BuildingEnum.StoneWall:
            case BuildingEnum.Palisade:
            case BuildingEnum.Barracks:
            case BuildingEnum.HerosMansion:
            case BuildingEnum.Academy:
            case BuildingEnum.Smithy:
            case BuildingEnum.Stable:
            case BuildingEnum.GreatBarracks:
            case BuildingEnum.GreatStable:
            case BuildingEnum.Workshop:
            case BuildingEnum.TournamentSquare:
                return(BuildingCategoryEnum.Military);

            default:
                return(BuildingCategoryEnum.Infrastructure);
            }
        }
Exemple #6
0
        public static DateTime GetTrainingTimeForBuilding(BuildingEnum building, Village vill)
        {
            var def = DateTime.Now;

            switch (building)
            {
            case BuildingEnum.Barracks:
                return(vill.Troops.CurrentlyTraining.Barracks?.LastOrDefault()?.FinishTraining ?? def);

            case BuildingEnum.Stable:
                return(vill.Troops.CurrentlyTraining.Stable?.LastOrDefault()?.FinishTraining ?? def);

            case BuildingEnum.GreatBarracks:
                return(vill.Troops.CurrentlyTraining.GB?.LastOrDefault()?.FinishTraining ?? def);

            case BuildingEnum.GreatStable:
                return(vill.Troops.CurrentlyTraining.GS?.LastOrDefault()?.FinishTraining ?? def);

            case BuildingEnum.Workshop:
                return(vill.Troops.CurrentlyTraining.Workshop?.LastOrDefault()?.FinishTraining ?? def);

            default:
                return(def);
            }
        }
Exemple #7
0
        /// <summary>
        /// Upgrades specified building for exactly one level. Will upgrade the lowest level building.
        /// </summary>
        /// <param name="acc">Account</param>
        /// <param name="vill">Village</param>
        /// <param name="building">Building to be upgraded by one</param>
        /// <param name="bottom">Whether to insert the building task on the bottom of the build list</param>
        /// <returns>Whether the method executed successfully</returns>
        internal static bool UpgradeBuildingForOneLvl(Account acc, Village vill, BuildingEnum building, bool bottom = true)
        {
            // We already have a build task
            if (!bottom && vill.Build.Tasks.FirstOrDefault()?.Building == building)
            {
                return(true);
            }
            if (bottom && vill.Build.Tasks.LastOrDefault()?.Building == building)
            {
                return(true);
            }

            var upgrade = vill.Build
                          .Buildings
                          .OrderBy(x => x.Level)
                          .FirstOrDefault(x => x.Type == building);

            // We don't have this building in the village yet
            if (upgrade == null)
            {
                return(AddBuildingTask(acc, vill, new BuildingTask()
                {
                    TaskType = BuildingType.General,
                    Building = building,
                    Level = 1,
                }, bottom));
            }

            var currentLvl = (int)upgrade.Level;

            RemoveFinishedCB(vill);
            currentLvl += vill.Build.CurrentlyBuilding.Count(x => x.Building == building);

            if (BuildingsData.MaxBuildingLevel(acc, building) == currentLvl)
            {
                // Building is on max level, construct new building if possible
                if (!BuildingsData.CanHaveMultipleBuildings(building))
                {
                    return(false);
                }

                return(AddBuildingTask(acc, vill, new BuildingTask()
                {
                    TaskType = BuildingType.General,
                    Building = building,
                    Level = 1,
                }, bottom));
            }
            else // Upgrade the defined building
            {
                return(AddBuildingTask(acc, vill, new BuildingTask()
                {
                    TaskType = BuildingType.General,
                    Building = building,
                    Level = currentLvl + 1,
                    BuildingId = upgrade.Id
                }, bottom));
            }
        }
Exemple #8
0
 private bool BonusHelper(Village vill, BuildingEnum field, BuildingEnum bonus, int fieldLvl) // vill does not have bonus building on 5, create or upgrade it
 {
     //res field is high enoguh, bonus building is not on 5, there is still space left to build, there isn't already a bonus building buildtask
     return(!vill.Build.Buildings.Any(x => x.Type == bonus && x.Level >= 5) &&
            vill.Build.Buildings.Any(x => x.Type == field && x.Level >= fieldLvl) &&
            vill.Build.Buildings.Any(x => x.Type == BuildingEnum.Site) &&
            !vill.Build.Tasks.Any(x => x.Building == bonus));
 }
        public GameObject GetPrefab(BuildingEnum id)
        {
            BuildingConfig config = BuildingConfigs.FirstOrDefault(x => x.Id == id);

            if (config == null)
            {
                throw new NullReferenceException($"No Building config for id: {nameof(id)}");
            }

            return(config.Prefab);
        }
Exemple #10
0
        public BaseBuilding Build(BuildingEnum type)
        {
            if (Content != null)
            {
                return(null);
            }

            Content  = Instantiate(BuildingFactory.GetPrefab(type), transform);
            Building = Content.GetComponent <BaseBuilding>();
            return(Building);
        }
Exemple #11
0
        public static async Task <bool> EnterBuilding(Account acc, Village vill, BuildingEnum buildingEnum, string query = "", bool dorf = true)
        {
            var building = vill.Build.Buildings.FirstOrDefault(x => x.Type == buildingEnum);

            if (building == null)
            {
                acc.Wb.Log($"Tried to enter {buildingEnum} but couldn't find it in village {vill.Name}!");
                return(false);
            }
            return(await EnterBuilding(acc, vill, building, query, dorf));
        }
        private void CreateBuilding(Slot slot, BuildingEnum type)
        {
            BaseBuilding building = slot.Build(type);

            if (building == null)
            {
                return;
            }
            Vector3 original = building.Model.transform.position;

            building.Model.transform.position -= Vector3.up * 5;
            building.Model.DOMove(original, 0.4f).SetDelay(0.1f);
        }
Exemple #13
0
        /// <summary>
        /// Helper method for checking whether the bot should add the bonus building to the build list
        /// </summary>
        private bool BonusHelper(Village vill, BuildingEnum field, BuildingEnum bonus, int fieldLvl)
        {
            // If the bonus building is currently being upgraded to level 5, don't try to re-add it
            if (vill.Build.CurrentlyBuilding.Any(x => x.Building == bonus && x.Level == 5))
            {
                return(false);
            }

            // Bonus building is not on 5, res field is high enough, there is still space left to build, there isn't already a bonus building buildtask
            return(!vill.Build.Buildings.Any(x => x.Type == bonus && 5 <= x.Level) &&
                   vill.Build.Buildings.Any(x => x.Type == field && fieldLvl <= x.Level) &&
                   vill.Build.Buildings.Any(x => x.Type == BuildingEnum.Site) &&
                   !vill.Build.Tasks.Any(x => x.Building == bonus));
        }
Exemple #14
0
        /// <summary>
        /// Adds all building prerequisites for this building if they do not exist yet.
        /// After this you should call RemoveDuplicates().
        /// </summary>
        /// <param name="acc"></param>
        /// <param name="vill"></param>
        /// <param name="building"></param>
        /// <returns>Whether we have all prerequisite buildings</returns>
        public static bool AddBuildingPrerequisites(Account acc, Village vill, BuildingEnum building, bool bottom = true)
        {
            RemoveFinishedCB(vill);

            (var tribe, var prereqs) = BuildingsData.GetBuildingPrerequisites(building);
            if (acc.AccInfo.Tribe != tribe && tribe != TribeEnum.Any)
            {
                return(false);
            }
            if (prereqs.Count == 0)
            {
                return(true);
            }
            var ret = true;

            foreach (var prereq in prereqs)
            {
                var prereqBuilding = vill.Build.Buildings.Where(x => x.Type == prereq.Building);

                // Prerequired building already exists and is on on/above/being upgraded on desired level
                if (prereqBuilding.Any(x =>
                                       prereq.Level <= x.Level + (x.UnderConstruction ? 1 : 0))
                    )
                {
                    continue;
                }

                if (bottom && vill.Build.Tasks.Any(x => prereq.Building == x.Building &&
                                                   prereq.Level <= x.Level))
                {
                    continue;
                }

                // If there is no required building, build it's prerequisites first
                if (!prereqBuilding.Any())
                {
                    AddBuildingPrerequisites(acc, vill, prereq.Building);
                }

                AddBuildingTask(acc, vill, new BuildingTask()
                {
                    Building = prereq.Building,
                    Level    = prereq.Level,
                    TaskType = BuildingType.General
                }, bottom);
                ret = false;
            }
            return(ret);
        }
Exemple #15
0
        /// <summary>
        /// Enters a specific building.
        /// </summary>
        /// <param name="acc">Account</param>
        /// <param name="vill">Village</param>
        /// <param name="buildingEnum">Building to enter</param>
        /// <returns>Whether it was successful</returns>
        public static async Task <bool> EnterBuilding(Account acc, Village vill, BuildingEnum buildingEnum, string query = "")
        {
            var building = vill.Build
                           .Buildings
                           .FirstOrDefault(x => x.Type == buildingEnum);

            if (building == null)
            {
                acc.Wb.Log($"Tried to enter {buildingEnum} but couldn't find it in village {vill.Name}!");
                return(false);
            }

            await acc.Wb.Navigate($"{acc.AccInfo.ServerUrl}/build.php?id={building.Id}{query}");

            return(true);
        }
 private static void BuildingAddOrUpdate(Account acc, BuildingEnum building, string localizedName)
 {
     localizedName = WebUtility.HtmlDecode(localizedName.ToLower()).Trim();
     if (acc.Settings.Localization == null)
     {
         acc.Settings.Localization = new Dictionary <string, BuildingEnum>();
     }
     if (acc.Settings.Localization.ContainsKey(localizedName))
     {
         acc.Settings.Localization[localizedName] = building;
     }
     else
     {
         acc.Settings.Localization.Add(localizedName, building);
     }
 }
Exemple #17
0
    public TemporaryBuilding CreateTemporaryMainBuilding(NetworkInstanceId playerId, BuildingEnum buildingType)
    {
        TemporaryBuilding building;

        switch (buildingType)
        {
        case BuildingEnum.MainBuilding:
            building = Instantiate(mainBuildingPrefab);
            break;

        case BuildingEnum.Library:
            building = Instantiate(libraryPrefab);
            break;

        case BuildingEnum.Barracks:
            building = Instantiate(barracksPrefab);
            break;

        case BuildingEnum.Infirmary:
            building = Instantiate(infirmaryPrefab);
            break;

        case BuildingEnum.House:
            building = Instantiate(housePrefab);
            break;

        case BuildingEnum.Mill:
            building = Instantiate(millPrefab);
            break;

        case BuildingEnum.Sawmill:
            building = Instantiate(sawmillPrefab);
            break;

        case BuildingEnum.Bank:
            building = Instantiate(bankPrefab);
            break;

        default:
            building = null;
            break;
        }
        building.playerNetId = playerId;
        return(building);
    }
Exemple #18
0
        private static Building GetLowestRes(Account acc, Village vill, List <Building> buildings)
        {
            //get distinct field types
            var          distinct  = buildings.Select(x => x.Type).Distinct().ToList();
            long         lowestRes = long.MaxValue;
            BuildingEnum toUpgrade = BuildingEnum.Cropland;

            var heroRes = vill.Settings.UseHeroRes ?
                          HeroHelper.GetHeroResources(acc) :
                          new long[] { 0, 0, 0, 0 };

            var resSum = ResourcesHelper.SumArr(vill.Res.Stored.Resources.ToArray(), heroRes);

            foreach (var distinctType in distinct)
            {
                if (distinctType == BuildingEnum.Woodcutter &&
                    resSum[0] < lowestRes)
                {
                    lowestRes = resSum[0];
                    toUpgrade = BuildingEnum.Woodcutter;
                }
                else if (distinctType == BuildingEnum.ClayPit &&
                         resSum[1] < lowestRes)
                {
                    lowestRes = resSum[1];
                    toUpgrade = BuildingEnum.ClayPit;
                }
                else if (distinctType == BuildingEnum.IronMine &&
                         resSum[2] < lowestRes)
                {
                    lowestRes = resSum[2];
                    toUpgrade = BuildingEnum.IronMine;
                }
                else if (distinctType == BuildingEnum.Cropland &&
                         resSum[3] < lowestRes)
                {
                    lowestRes = resSum[3];
                    toUpgrade = BuildingEnum.Cropland;
                }
            }
            return(FindLowestLevelBuilding(buildings.Where(x => x.Type == toUpgrade).ToList()));
        }
Exemple #19
0
        public static bool BuildingRequirementsAreMet(BuildingEnum building, Village vill, TribeEnum tribe) //check if user can construct this building
        {
            bool exists = (vill.Build.Buildings.FirstOrDefault(x => x.Type == building) != null);           //there is already a building of this type in the vill

            if (exists)
            {
                //check cranny/warehouse/grannary/trapper/GG/GW
                switch (building)
                {
                case BuildingEnum.Warehouse: return(BuildingIsOnLevel(BuildingEnum.Warehouse, 20, vill));

                case BuildingEnum.Granary: return(BuildingIsOnLevel(BuildingEnum.Granary, 20, vill));

                case BuildingEnum.GreatWarehouse: return(BuildingIsOnLevel(BuildingEnum.GreatWarehouse, 20, vill));

                case BuildingEnum.GreatGranary: return(BuildingIsOnLevel(BuildingEnum.GreatGranary, 20, vill));

                case BuildingEnum.Trapper: return(BuildingIsOnLevel(BuildingEnum.Trapper, 20, vill));

                case BuildingEnum.Cranny: return(BuildingIsOnLevel(BuildingEnum.Cranny, 10, vill));

                default: return(false);
                }
            }

            //check for prerequisites for this building
            (var ReqTribe, var Prerequisites) = BuildingsData.GetBuildingPrerequisites(building);
            if (ReqTribe != TribeEnum.Any && ReqTribe != tribe)
            {
                return(false);
            }
            //if we either already have this building OR is on our build task list, requirements are met.
            foreach (var prerequisite in Prerequisites)
            {
                if (!vill.Build.Buildings.Any(x => x.Level >= prerequisite.Level && x.Type == prerequisite.Building) &&
                    !vill.Build.Tasks.Any(x => x.Level >= prerequisite.Level && x.Building == prerequisite.Building))
                {
                    return(false);
                }
            }
            return(true);
        }
Exemple #20
0
        public static bool IsWall(BuildingEnum building)
        {
            switch (building)
            {
            // Teutons
            case BuildingEnum.EarthWall:
            // Romans
            case BuildingEnum.CityWall:
            // Gauls
            case BuildingEnum.Palisade:
            // Egyptians
            case BuildingEnum.StoneWall:
            // Huns
            case BuildingEnum.MakeshiftWall:
                return(true);

            default:
                return(false);
            }
        }
Exemple #21
0
    //factory pattern
    public void CreateBuilding(BuildingEnum buildingType, Vector3 position)
    {
        switch (buildingType)
        {
        case BuildingEnum.RedBuilding:
            allBuildings.Add(new RedBuilding(position));
            break;

        case BuildingEnum.BlueBuildinng:
            allBuildings.Add(new BlueBuilding(position));
            break;

        case BuildingEnum.GreenBuilding:
            allBuildings.Add(new GreenBuilding(position));
            break;

        case BuildingEnum.YellowBuilding:
            allBuildings.Add(new YellowBuilding(position));
            break;
        }
    }
        /// <summary>
        /// Gets the highest level a building can be on
        /// </summary>
        /// <param name="building">Building</param>
        /// <returns>Max level</returns>
        public static int MaxBuildingLevel(Account acc, BuildingEnum building)
        {
            switch (building)
            {
            case BuildingEnum.Brewery:
                switch (acc.AccInfo.ServerVersion)
                {
                case ServerVersionEnum.T4_4: return(10);

                default: return(20);
                }

            case BuildingEnum.Bakery:
            case BuildingEnum.Brickyard:
            case BuildingEnum.IronFoundry:
            case BuildingEnum.GrainMill:
            case BuildingEnum.Sawmill:
                return(5);

            case BuildingEnum.Cranny: return(10);

            default: return(20);
            }
        }
Exemple #23
0
        /// <summary>
        /// Upgrades storage of the village
        /// </summary>
        /// <param name="acc">Account</param>
        /// <param name="vill">Village</param>
        /// <param name="building">Storage building</param>
        private static void UpgradeStorage(Account acc, Village vill, BuildingEnum building)
        {
            var task = new BuildingTask()
            {
                Building = building,
                TaskType = Classificator.BuildingType.General
            };

            var current = vill.Build.Buildings.FirstOrDefault(x =>
                                                              x.Type == building &&
                                                              (x.Level != 20 || (x.Level != 19 && x.UnderConstruction))
                                                              );

            if (current == null)
            {
                task.ConstructNew = true;
                task.Level        = 1;
            }
            else
            {
                task.Level = current.Level + 1;
            }
            BuildingHelper.AddBuildingTask(acc, vill, task, false);
        }
    public bool BuildBuilding(BuildingEnum type)
    {
        var purchase = playerState.playerPurchases.Get(type);

        return(purchase.IsActive(null) && purchase.Do(null));
    }
Exemple #25
0
        public override async Task <TaskRes> Execute(Account acc)
        {
            building = TroopsHelper.GetTroopBuilding(Troop, Great);

            // Switch hero helmet. If hero will be switched, this TrainTroops task
            // will be executed right after the hero helmet switch
            if (HeroHelper.SwitchHelmet(acc, this.Vill, building, this))
            {
                return(TaskRes.Executed);
            }

            await base.Execute(acc);

            if (!await VillageHelper.EnterBuilding(acc, Vill, building))
            {
                return(TaskRes.Executed);
            }

            if (this.UpdateOnly || this.Troop == TroopsEnum.None)
            {
                return(TaskRes.Executed);
            }

            (TimeSpan dur, Resources cost) = TroopsParser.GetTrainCost(acc.Wb.Html, this.Troop);

            var troopNode = acc.Wb.Html.DocumentNode.Descendants("img").FirstOrDefault(x => x.HasClass("u" + (int)Troop));

            if (troopNode == null)
            {
                acc.Wb.Log($"Bot tried to train {Troop} in {Vill.Name}, but couldn't find it in {building}! Are you sure you have {Troop} researched?");
                return(TaskRes.Executed);
            }
            while (!troopNode.HasClass("details"))
            {
                troopNode = troopNode.ParentNode;
            }
            var inputName = troopNode.Descendants("input").FirstOrDefault().GetAttributeValue("name", "");

            long maxNum = 0;

            switch (acc.AccInfo.ServerVersion)
            {
            case ServerVersionEnum.T4_4:
                maxNum = Parser.RemoveNonNumeric(
                    troopNode.ChildNodes
                    .FirstOrDefault(x => x.Name == "a")?.InnerText ?? "0"
                    );
                break;

            case ServerVersionEnum.T4_5:
                maxNum = Parser.RemoveNonNumeric(
                    troopNode.ChildNodes
                    .First(x => x.HasClass("cta"))
                    .ChildNodes
                    .First(x => x.Name == "a")
                    .InnerText);
                break;
            }

            if (!HighSpeedServer)
            {
                var trainNum = TroopsHelper.TroopsToFill(acc, Vill, this.Troop, this.Great);

                // Don't train too many troops, just fill up the training building
                if (maxNum > trainNum)
                {
                    maxNum = trainNum;
                }
            }

            if (maxNum < 0)
            {
                // We have already enough troops in training.
                return(TaskRes.Executed);
            }

            acc.Wb.Driver.ExecuteScript($"document.getElementsByName('{inputName}')[0].value='{maxNum}'");

            await Task.Delay(100);

            await DriverHelper.ExecuteScript(acc, "document.getElementsByName('s1')[0].click()");

            UpdateCurrentlyTraining(acc.Wb.Html, acc);

            if (!HighSpeedServer)
            {
                RepeatTrainingCycle(acc.Wb.Html, acc);
            }

            return(TaskRes.Executed);
        }
        public override async Task <TaskRes> Execute(HtmlDocument htmlDoc, ChromeDriver wb, Files.Models.AccModels.Account acc)
        {
            building = TroopsHelper.GetTroopBuilding(Troop, Great);

            var buildId = vill.Build.Buildings.FirstOrDefault(x => x.Type == building);

            if (buildId == null)
            {
                //update dorf, no buildingId found?
                TaskExecutor.AddTask(acc, new UpdateDorf2()
                {
                    ExecuteAt = DateTime.Now, vill = vill
                });
                Console.WriteLine($"There is no {building} in this village!");
                return(TaskRes.Executed);
            }
            await acc.Wb.Navigate($"{acc.AccInfo.ServerUrl}/build.php?id={buildId.Id}");

            //after finishing task, update currently training
            this.PostTaskCheck.Add(UpdateCurrentlyTraining);
            if (!HighSpeedServer)
            {
                this.PostTaskCheck.Add(RepeatTrainingCycle);
            }
            if (this.UpdateOnly || this.Troop == TroopsEnum.None)
            {
                return(TaskRes.Executed);
            }

            (TimeSpan dur, Resources cost) = TroopsParser.GetTrainCost(htmlDoc, this.Troop);

            var troopNode = htmlDoc.DocumentNode.Descendants("img").FirstOrDefault(x => x.HasClass("u" + (int)Troop));

            while (!troopNode.HasClass("details"))
            {
                troopNode = troopNode.ParentNode;
            }
            var inputName = troopNode.Descendants("input").FirstOrDefault().GetAttributeValue("name", "");

            var maxNum = Parser.RemoveNonNumeric(troopNode.ChildNodes.FirstOrDefault(x => x.Name == "a").InnerText);

            if (!HighSpeedServer)
            {
                var trainNum = TroopsHelper.TroopsToFill(acc, vill, this.Troop, this.Great);

                // Don't train too many troops, just fill up the training building
                if (maxNum > trainNum)
                {
                    maxNum = trainNum;
                }
            }

            if (maxNum < 0)
            {
                // We have already enough troops in training.
                return(TaskRes.Executed);
            }

            wb.ExecuteScript($"document.getElementsByName('{inputName}')[0].value='{maxNum}'");
            await Task.Delay(100);

            wb.ExecuteScript("document.getElementsByName('s1')[0].click()"); //Train button
            return(TaskRes.Executed);
        }
Exemple #27
0
    private void CmdCreateTempBuilding(BuildingEnum buildingType)
    {
        var tempBuilding = factory.CreateTemporaryMainBuilding(netId, buildingType);

        NetworkServer.SpawnWithClientAuthority(tempBuilding.gameObject, gameObject);
    }
Exemple #28
0
 /// <summary>
 /// Creates the temporary building of given type.
 /// </summary>
 /// <param name="buildingType">type of the building</param>
 public void CreateTempBuilding(BuildingEnum buildingType) => CmdCreateTempBuilding(buildingType);
Exemple #29
0
 public void CmdCreateBuilding(NetworkInstanceId tempBuildingID, BuildingEnum buildingType)
 {
     GameState.Instance.RpcCreateBuilding(tempBuildingID, buildingType);
 }
Exemple #30
0
 private static bool BuildingIsOnLevel(BuildingEnum building, int lvl, Village vill)
 {
     //if there already is a building on specific level or there is a task for this building
     // TODO: change FristOrDefault to Any
     return(vill.Build.Buildings.FirstOrDefault(x => x.Level == lvl && x.Type == building) != null || vill.Build.Tasks.FirstOrDefault(x => x.Level == lvl && x.Building == building) != null);
 }