Beispiel #1
0
Datei: Aad.cs Projekt: resc/Risk
        public void Attack(TurnManager turnManager)
        {
            for (var i = 1; i < 250; i++)
            {
                var possibleAttacks = GetAllPossibleAttacks(turnManager);

                foreach (var possibleAttack in possibleAttacks)
                {
                    possibleAttack.SuccesRate = GetSuccessRate(possibleAttack);
                }

                var myAttack = possibleAttacks.OrderBy(pa => pa.SuccesRate).Last();

                var riskRate = 900;

                if (IsLastEnemyInContinent(turnManager, myAttack.Victim))
                {
                    riskRate = 400;
                }

                if (myAttack.SuccesRate < riskRate)
                {
                    return;
                }

                turnManager.Attack(myAttack.MyCountry, myAttack.Victim, myAttack.NumberOfTroops);
            }
        }
Beispiel #2
0
        public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
        {
            if (attackRolls.Count(x => x > 3) > 1)
                return 1;

            return 2;
        }
Beispiel #3
0
        public void Attack(TurnManager turnManager)
        {
            var country = GetRandomOwnedCountryThatCanAttack(turnManager);
            var countryToAttack = GetRandomAdjacentCountryToAttack(turnManager, country);

            turnManager.Attack(country, countryToAttack, country.NumberOfTroops - 1);
        }
Beispiel #4
0
Datei: Pros.cs Projekt: resc/Risk
        public void Attack(TurnManager turnManager)
        {
            //var country = GetRandomOwnedCountryThatCanAttack();
            //var countryToAttack = GetRandomAdjacentCountryToAttack(country);

            var repeat = 0;
            var timeout = 0;

            do
            {
                var tempList = turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this);
                foreach (var country in tempList)
                {
                    var adjacentCountryList = country.AdjacentCountries.Where(p => p.Owner != this);

                    foreach (var countryToAttack in adjacentCountryList)
                    {
                        if (countryToAttack.NumberOfTroops < country.NumberOfTroops && country.NumberOfTroops > 3)
                        {
                            turnManager.Attack(country, countryToAttack,
                                                                      country.NumberOfTroops - 1);
                            repeat++;
                        }
                    }
                }

                timeout++;
            } while (repeat < 2 && timeout < 200);
        }
Beispiel #5
0
Datei: Aad.cs Projekt: resc/Risk
 public void Deploy(TurnManager turnManager, int numberOfTroops)
 {
     while (numberOfTroops > 0)
     {
         turnManager.DeployTroops(GetMostImportantCountry(turnManager), 1);
         numberOfTroops--;
     }
 }
Beispiel #6
0
 public void Deploy(TurnManager turnManager, int numberOfTroops)
 {
     while (numberOfTroops > 0)
     {
         turnManager.DeployTroops(GetRandomOwnedCountry(turnManager), 1);
         numberOfTroops--;
     }
 }
Beispiel #7
0
 private Country GetRandomOwnedCountryThatCanAttack(TurnManager turnManager)
 {
     var ownedCountries =turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this).Where(c => c.NumberOfTroops > 1 &&
                                                                                        c.AdjacentCountries.Any(
                                                                                            ac =>
                                                                                            ac.Owner != c.Owner))
                                         .ToList();
     return ownedCountries[r.Next(0, ownedCountries.Count - 1)];
 }
Beispiel #8
0
        public void Deploy(TurnManager turnManager, int numberOfTroops)
        {
            gameInformation = turnManager.GetGameInfo();

            //exclude all isolated countries (all countries with only enemy neighbours)
            var countriesToAimAt =
                gameInformation.GetAllCountriesOwnedByPlayer(this)
                               .Where(x => gameInformation.GetAdjacentCountriesWithSameOwner(x).Any())
                               .ToArray();

            //Determine defensiveRate.
            //While there are countries with low defensiveRate (number of own troops / number of surrounding troups), make those stronger.
            var countriesWithEnemyNeighbours =
                countriesToAimAt.Where(x => gameInformation.GetAdjacentCountriesWithDifferentOwner(x).Count > 0)
                                .ToArray();
            var defensiveRates =
                GetDefensiveRates(countriesWithEnemyNeighbours).OrderBy(x => x.Value);

            while (defensiveRates.First().Value < DEFENSIVE_THRESHOLD_FOR_DEPLOYMENT && numberOfTroops > 0)
            {
                turnManager.DeployTroops(defensiveRates.First().Key, 1);
                defensiveRates = GetDefensiveRates(countriesWithEnemyNeighbours).OrderByDescending(x => x.Value);
                numberOfTroops--;
            }

            //Get the continent with the biggest presence.
            //Determine what country has the highest defensiveRate (number of own troops / number of surrounding troups), make those even stronger.
            //Make sure this ratio is not too big.
            var biggestContinent = GetBiggestOwnedContinentWithRemainingEnemyCountries();

            var allOwnCountriesInBiggestContinent =
                countriesToAimAt.Where(x => x.Continent == biggestContinent.Key).ToArray();
            var countriesWithRates =
                GetDefensiveRates(allOwnCountriesInBiggestContinent)
                    .Where(x => x.Key.NumberOfTroops < MAX_TROOPS_FOR_DEPLOYMENT)
                    .OrderByDescending(x => x.Value);

            while (countriesWithRates.Any() && numberOfTroops > 0)
            {
                turnManager.DeployTroops(countriesWithRates.First().Key, 1);
                countriesWithRates =
                    GetDefensiveRates(allOwnCountriesInBiggestContinent)
                        .Where(x => x.Key.NumberOfTroops < MAX_TROOPS_FOR_DEPLOYMENT)
                        .OrderByDescending(x => x.Value);
                numberOfTroops--;
            }

            while (numberOfTroops > 0)
            {
                turnManager.DeployTroops(GetRandomOwnedCountry(turnManager), 1);
                numberOfTroops--;
            }
        }
Beispiel #9
0
        public void Attack(TurnManager turnManager)
        {
            gameInformation = turnManager.GetGameInfo();

            var countryToAttackWith = GetCountryToAttackWith();
            while (countryToAttackWith != null)
            {
                turnManager.Attack(countryToAttackWith.Item1, countryToAttackWith.Item2,
                                                          countryToAttackWith.Item1.NumberOfTroops - 1);
                countryToAttackWith = GetCountryToAttackWith();
            }
        }
Beispiel #10
0
Datei: Pros.cs Projekt: resc/Risk
        public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
        {
            if (attackRolls.Count == 3)
            {
                var dangerlevel = 0;

                if (attackRolls[0] >= 5)
                {
                    dangerlevel++;
                }

                if (attackRolls[1] >= 5)
                {
                    dangerlevel++;
                }

                if (attackRolls[2] >= 5)
                {
                    dangerlevel++;
                }

                if (dangerlevel >= 2)
                {
                    return 1;
                }

                return 2;
            }
            else
            {
                var dangerlevel = 0;

                if (attackRolls[0] >= 5)
                {
                    dangerlevel++;
                }

                // bug here, there can be only 1 attack roll
                // Remco: added check for attack roll count
                if (attackRolls.Count>1 && attackRolls[1] >= 5)
                {
                    dangerlevel++;
                }

                if (dangerlevel >= 2)
                {
                    return 1;
                }

                return 2;
            }
        }
Beispiel #11
0
 /// <summary>
 ///     Adds attack info to the analysis, but only if there is a chance for success
 /// </summary>
 private void AddAttack(TurnManager turnManager, RiskAnalysis analysis, Country friendly, Country enemy)
 {
     var minDefenders = 2;
     if (friendly.NumberOfTroops > minDefenders+1 && friendly.NumberOfTroops > enemy.NumberOfTroops )
     {
         analysis.Attacks.Add(new Attack(turnManager)
             {
                 FromCountry = friendly,
                 ToCountry = enemy,
                 Troops = friendly.NumberOfTroops - minDefenders,
             });
     }
 }
Beispiel #12
0
        public void Attack(TurnManager turnManager)
        {
            var losses = 0;

            while (losses <= 3)
            {
                var analysis = riskAnalyzer.Analyze(turnManager);
                if (analysis.Attacks.Count == 0)
                    return;

                analysis.ExecuteAttacks();
                losses += analysis.Attacks.Count(x => x.Succeeded == false);
            }
        }
Beispiel #13
0
Datei: Aad.cs Projekt: resc/Risk
        public void Move(TurnManager turnManager)
        {
            for (var i = 0; i < 250; i++)
            {
                var info = turnManager.GetGameInfo();
                foreach (var country in info.GetAllCountriesOwnedByPlayer(this))
                {
                    var surroundingFriendlyCountries =
                        country.AdjacentCountries.ToList().Where(c => c.Owner == this).Count();

                    if (surroundingFriendlyCountries == country.AdjacentCountries.Count)
                    {
                        while (country.NumberOfTroops > 1)
                        {
                            MoveTroopsToSurroundingCountries(turnManager, country);
                        }
                    }
                }
            }
        }
Beispiel #14
0
        /// <summary>
        ///     Performs analysis of the game state.
        ///     It does a full analysis for every phase of a turn.
        ///     This wastes some computational resources, but hopefully leads to a better outcome.
        /// </summary>
        public RiskAnalysis Analyze(TurnManager turnManager)
        {
            var analysis = new RiskAnalysis();
            // the ordering of the analysis steps is important
            // each step depends on the results of the previous steps.

            // first, check the state of the board.
            DoContinentAnalysis(turnManager, analysis);
            // next, find which countries we want.
            DoAttackAnalysis(turnManager, analysis);
            // then check if we need to move troops
            DoMoveAnalysis(turnManager, analysis);
            // then place reinforcements on the board.
            DoDeployAnalysis(turnManager, analysis);

            // gather important countries.
            DoImportantCountryAnalysis(turnManager, analysis);

            return analysis;
        }
Beispiel #15
0
 private Country GetRandomOwnedCountry(TurnManager turnManager)
 {
     var ownedCountries = turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this);
     return ownedCountries[r.Next(0, ownedCountries.Count - 1)];
 }
Beispiel #16
0
 public void Move(TurnManager turnManager)
 {
     turnManager.MoveTroops(GetRandomOwnedCountryThatCanAttack(turnManager),
                                                   GetRandomOwnedCountryThatCanAttack(turnManager), 1);
 }
Beispiel #17
0
 private Country GetRandomAdjacentCountryToAttack(TurnManager turnManager, Country country)
 {
     var adjacentCountries =
         turnManager.GetGameInfo().GetAdjacentCountriesWithDifferentOwner(country);
     return adjacentCountries[r.Next(0, adjacentCountries.Count - 1)];
 }
Beispiel #18
0
 public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
 {
     return 2;
 }
Beispiel #19
0
Datei: Aad.cs Projekt: resc/Risk
        private bool IsLastEnemyInContinent(TurnManager turnManager, Country country)
        {
            var victimContinent = country.Continent;

            var info = turnManager.GetGameInfo();

            var myCountriesInContinent =
                info.GetAllCountriesOwnedByPlayer(this).Count(c => c.Continent == country.Continent);
            var allCountriesInContinent = info.GetAllCountries().Count(c => c.Continent == country.Continent);

            return (allCountriesInContinent - myCountriesInContinent) == 1;
        }
Beispiel #20
0
 public void Move(TurnManager turnManager)
 {
     var analysis = riskAnalyzer.Analyze(turnManager);
     analysis.ExecuteMoves();
 }
Beispiel #21
0
Datei: Aad.cs Projekt: resc/Risk
 private void MoveTroopsToSurroundingCountries(TurnManager turnManager, Country country)
 {
     turnManager.MoveTroops(country, GetMostImportantSurroundingCountry(turnManager, country), 1);
 }
Beispiel #22
0
 public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
 {
     var analysis = riskAnalyzer.Analyze(turnManager);
     return analysis.GetDefenceRolls(attackRolls, countryToDefend);
 }
Beispiel #23
0
 public void Deploy(TurnManager turnManager, int numberOfTroops)
 {
     var analysis = riskAnalyzer.Analyze(turnManager);
     analysis.ExecuteDeployments(numberOfTroops);
 }
Beispiel #24
0
        public void Move(TurnManager turnManager)
        {
            var countriesToAimAt =
                gameInformation.GetAllCountriesOwnedByPlayer(this)
                               .Where(x => gameInformation.GetAdjacentCountriesWithSameOwner(x).Any())
                               .ToArray();

            if (countriesToAimAt.Any())
            {
                //Determine defensiveRate.
                //While there are countries with low defensiveRate (number of own troops / number of surrounding troups), make those stronger.
                var countriesWithEnemyNeighbours =
                    countriesToAimAt.Where(x => gameInformation.GetAdjacentCountriesWithDifferentOwner(x).Count > 0)
                                    .ToArray();
                var defensiveRates =
                    GetDefensiveRates(countriesWithEnemyNeighbours).OrderBy(x => x.Value);

                var moveCounter = 0;

                while (defensiveRates.Any(x => x.Value < DEFENSIVE_THRESHOLD_FOR_DEPLOYMENT) && moveCounter++ < 250)
                {
                    var first = defensiveRates.First();

                    var adjacentCountriesWithSameOwner =
                        gameInformation.GetAdjacentCountriesWithSameOwner(first.Key)
                                       .Where(
                                           x =>
                                           defensiveRates.Single(y => y.Key == x).Value >
                                           DEFENSIVE_THRESHOLD_FOR_DEPLOYMENT)
                                       .ToArray();
                    if (adjacentCountriesWithSameOwner.Any())
                    {
                        turnManager.MoveTroops(first.Key, adjacentCountriesWithSameOwner.First(),
                                                                      adjacentCountriesWithSameOwner.First()
                                                                                                    .NumberOfTroops - 1);
                    }

                    defensiveRates = GetDefensiveRates(countriesWithEnemyNeighbours).OrderBy(x => x.Value);
                }
            }
        }
Beispiel #25
0
Datei: Aad.cs Projekt: resc/Risk
        private double AverageTroopsPerCountry(TurnManager turnManager)
        {
            var info = turnManager.GetGameInfo();
            var totalCountries = 0.0;
            var totalTroops = 0.0;
            info.GetAllCountriesOwnedByPlayer(this).ToList().ForEach(
                (Country c) =>
                {
                    totalCountries += 1;
                    totalTroops += c.NumberOfTroops;
                });

            return totalTroops / totalCountries;
        }
Beispiel #26
0
Datei: Move.cs Projekt: resc/Risk
 public Move(TurnManager turnManager)
 {
     this.turnManager = turnManager;
 }
Beispiel #27
0
 public Deployment(TurnManager turnManager)
 {
     this.turnManager = turnManager;
 }
Beispiel #28
0
 public Attack(TurnManager turnManager)
 {
     this.turnManager = turnManager;
 }
Beispiel #29
0
Datei: Pros.cs Projekt: resc/Risk
        /*

         DONT LOOK AT OUR CODE PLS

         */
        public void Deploy(TurnManager turnManager, int numberOfTroops)
        {
            if (numberOfTroops == 2)
            {
                var tempList = turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this);
                var Australia = tempList.Where(p => p.Continent == EContinent.Australia).ToList();
                var SouthAmerica = tempList.Where(p => p.Continent == EContinent.SouthAmerica).ToList();
                var Africa = tempList.Where(p => p.Continent == EContinent.Africa).ToList();
                var NorthAmerica = tempList.Where(p => p.Continent == EContinent.NorthAmerica).ToList();
                var Europe = tempList.Where(p => p.Continent == EContinent.Europe).ToList();
                var Asia = tempList.Where(p => p.Continent == EContinent.Asia).ToList();
                var AustraliaCount = Australia.Count;
                if (Australia.Count >= 2)
                {
                    if (AustraliaCount == 4)
                    {
                        var AustraliaBottleNeck =
                            tempList.Where(p => p.Continent == EContinent.Australia && p.Number == 4).Single();
                        var i = AustraliaBottleNeck.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (AustraliaBottleNeck.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(AustraliaBottleNeck, 1);
                            numberOfTroops--;
                        }
                    }
                    else
                    {
                        var Random = new Random();
                        var AustraliaBottleNeck =
                            tempList.Where(p => p.Continent == EContinent.Australia);
                        if (AustraliaBottleNeck != null)
                        {
                            var index = Random.Next(Australia.Count);
                            var country = Australia[index];
                            var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                            while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                            {
                                turnManager.DeployTroops(country, 1);
                                numberOfTroops--;
                            }
                        }
                    }
                }
                if (SouthAmerica.Count >= 2)
                {
                    var Random = new Random();
                    var SouthAmericaBottleNeck =
                        tempList.Where(p => p.Continent == EContinent.SouthAmerica);
                    if (SouthAmericaBottleNeck != null)
                    {
                        var index = Random.Next(SouthAmerica.Count);
                        var country = SouthAmerica[index];
                        var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(country, 1);
                            numberOfTroops--;
                        }
                    }
                }

                if (Africa.Count >= 4)
                {
                    var Random = new Random();
                    var AfricaBottleNeck = tempList.Where(p => p.Continent == EContinent.Africa);
                    if (AfricaBottleNeck != null)
                    {
                        var index = Random.Next(Africa.Count);
                        var country = Africa[index];
                        var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(country, 1);
                            numberOfTroops--;
                        }
                    }
                }
                if (NorthAmerica.Count >= 5)
                {
                    var Random = new Random();
                    var AfricaBottleNeck = tempList.Where(p => p.Continent == EContinent.NorthAmerica);
                    if (AfricaBottleNeck != null)
                    {
                        var index = Random.Next(NorthAmerica.Count);
                        var country = NorthAmerica[index];
                        var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(country, 1);
                            numberOfTroops--;
                        }
                    }
                }
                if (Europe.Count >= 7)
                {
                    var Random = new Random();
                    var AfricaBottleNeck = tempList.Where(p => p.Continent == EContinent.Europe);
                    if (AfricaBottleNeck != null)
                    {
                        var index = Random.Next(Europe.Count);
                        var country = Europe[index];
                        var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(country, 1);
                            numberOfTroops--;
                        }
                    }
                }

                if (Asia.Count >= 8)
                {
                    var Random = new Random();
                    var AfricaBottleNeck = tempList.Where(p => p.Continent == EContinent.Asia);
                    if (AfricaBottleNeck != null)
                    {
                        var index = Random.Next(Asia.Count);
                        var country = Asia[index];
                        var i = country.AdjacentCountries.Where(p => p.Owner != this).ToList();
                        while (country.NumberOfTroops < 10 && numberOfTroops > 0 && i.Count > 0)
                        {
                            turnManager.DeployTroops(country, 1);
                            numberOfTroops--;
                        }
                    }
                }

                while (numberOfTroops > 0)
                {
                    var target = GetRandomOwnedCountry(turnManager);

                    var i = target.AdjacentCountries.Where(p => p.Owner != this).ToList();
                    if (i.Count > 0)
                    {
                        if (target.NumberOfTroops < 7)
                        {
                            var z = 0;
                            while (numberOfTroops > 0)
                            {
                                turnManager.DeployTroops(GetRandomOwnedCountry(turnManager), 1);
                                z++;
                                numberOfTroops--;
                                if (z > 30)
                                {
                                    break;
                                }
                            }
                        }

                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }

                while (numberOfTroops > 0)
                {
                    turnManager.DeployTroops(GetRandomOwnedCountry(turnManager), 1);

                    numberOfTroops--;
                }
            }
            else
            {
                var myCountries = turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this);
                var potential = new List<Country>();
                foreach (var country in myCountries)
                {
                    if (country.AdjacentCountries.Where(p => p.Owner != this).ToList().Count > 0)
                    {
                        potential.Add(country);
                    }
                }
                var tempList = potential.OrderBy(p => p.NumberOfTroops).ToList();
                foreach (var countryy in tempList)
                {
                    while (countryy.NumberOfTroops < 10 && numberOfTroops > 0)
                    {
                        turnManager.DeployTroops(countryy, 1);
                        numberOfTroops--;
                    }
                }
                if (numberOfTroops > 0)
                {
                    foreach (var countryy in tempList)
                    {
                        while (numberOfTroops > 0)
                        {
                            turnManager.DeployTroops(countryy, 1);
                            numberOfTroops--;
                        }
                    }
                }
            }
        }
Beispiel #30
0
Datei: Pros.cs Projekt: resc/Risk
        public void Move(TurnManager turnManager)
        {
            var movesLeft = 7;

            var tempList = turnManager.GetGameInfo().GetAllCountriesOwnedByPlayer(this);

            foreach (var country in tempList)
            {
                if (country.NumberOfTroops > 1)
                {
                    var hasHostile = false;
                    var checkForHostileCountries =
                        country.AdjacentCountries.Where(p => p.Owner != this).ToList();

                    if (checkForHostileCountries.Count > 0)
                    {
                        hasHostile = true;
                    }

                    if (hasHostile == false)
                    {
                        var adjacentCountryListOwned =
                            country.AdjacentCountries.Where(p => p.Owner == this).ToList();

                        foreach (var countryToMove in adjacentCountryListOwned)
                        {
                            var adjacentCountryListEnemey =
                                countryToMove.AdjacentCountries.Where(p => p.Owner != this).ToList();
                            var hasHostile2 = false;
                            if (adjacentCountryListEnemey.Count > 0)
                            {
                                hasHostile2 = true;
                            }

                            if (hasHostile2)
                            {
                                if (country.NumberOfTroops - 1 > 0 && movesLeft > 0)
                                {
                                    if (movesLeft > (country.NumberOfTroops - 1))
                                    {
                                        turnManager.MoveTroops(country, countryToMove,
                                                                                      country.NumberOfTroops - 1);
                                        movesLeft = movesLeft - (country.NumberOfTroops - 1);
                                    }
                                    else
                                    {
                                        turnManager.MoveTroops(country, countryToMove, movesLeft);
                                        movesLeft = 0;
                                    }
                                }
                            }
                            else
                            {
                                var adjacentCountryListOwned2 =
                                    countryToMove.AdjacentCountries.Where(p => p.Owner == this).ToList();

                                foreach (var countryToMove2 in adjacentCountryListOwned2)
                                {
                                    var adjacentCountryListEnemey2 =
                                        countryToMove2.AdjacentCountries.Where(p => p.Owner != this).ToList();
                                    var hasHostile3 = false;
                                    if (adjacentCountryListEnemey2.Count > 0)
                                    {
                                        hasHostile3 = true;
                                    }

                                    if (hasHostile3)
                                    {
                                        if (country.NumberOfTroops - 1 > 0 && movesLeft > 0)
                                        {
                                            if (movesLeft > (country.NumberOfTroops - 1))
                                            {
                                                turnManager.MoveTroops(country, countryToMove,
                                                                                              country.NumberOfTroops - 1);
                                                movesLeft = movesLeft - (country.NumberOfTroops - 1);
                                            }
                                            else
                                            {
                                                turnManager.MoveTroops(country, countryToMove,
                                                                                              movesLeft);
                                                movesLeft = 0;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        //hmm
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }