Exemplo n.º 1
0
        /// <summary>
        /// Score the Garden based on the linearity of the Rocks in it.
        /// If Rocks are determined to be linear (or close to linear), the number returned will
        /// be less than 1, allowing the evaluator to reduce the score of the Garden. If no Rocks
        /// are linear, then this method will return a value
        /// </summary>
        /// <param name="garden"></param>
        /// <returns></returns>
        private double scoreLinearity(Garden garden)
        {
            double            score            = 1;
            int               triangle         = 3;
            List <double>     scores           = new List <double>();
            List <Resident>   allRocksInGarden = getAllResidents(garden, Rock.rockString);
            List <Resident[]> AllRockTriangles = new List <Resident[]>();
            List <int[]>      pickThree        = new List <int[]>();

            Resident[] tempResidents = new Resident[triangle], tempResidentsCopy = new Resident[triangle];

            combinations(ref pickThree, 0, 0, triangle, allRocksInGarden.Count, new int[triangle]);
            foreach (int[] combo in pickThree)
            {
                for (int i = 0; i < triangle; i++)
                {
                    tempResidents[i] = allRocksInGarden[combo[i]];
                }
                tempResidents.CopyTo(tempResidentsCopy, 0);
                AllRockTriangles.Add(tempResidentsCopy);
            }
            foreach (Resident[] triangleArrrangement in AllRockTriangles)
            {
                scores.Add(Math.Pow(triangleLinearity(triangleArrrangement), 1 / linearityRootWeight));
            }
            if (scores.Count > 0)
            {
                return(scores.Average());
            }
            return(score);
        }
Exemplo n.º 2
0
        public Garden makeChild(int length, int width, List <Resident> rocks, int movementMax)
        {
            Garden child        = new Garden(length, width);
            Random gen          = new Random();
            Point  tempLocation = new Point();

            foreach (Resident rock in rocks)
            {
                tempLocation    = rock.origin;
                tempLocation.X += gen.Next(-1 * movementMax, movementMax);
                tempLocation.Y += gen.Next(-1 * movementMax, movementMax);
                tempLocation.X  = (tempLocation.X + width) % width;
                tempLocation.Y  = (tempLocation.Y + length) % length;

                child.addResident(new Rock(rock.length, rock.width), tempLocation, false);
            }
            child.fillWithGravel();
            if (child.getAllOfType(Rock.rockString).Count != rocks.Count)
            {
                child = makeChild(length, width, rocks, movementMax);
            }

            Console.WriteLine(child);

            return(child);
        }
Exemplo n.º 3
0
        public List <Garden> makeChildren(Garden parent, int movementMax, int numberOfChildren)
        {
            List <Resident> allRocksInParent          = parent.getAllOfType(Rock.rockString);
            List <Garden>   childrenOfTheParentGarden = new List <Garden>();

            for (int childNumber = 0; childNumber < numberOfChildren; childNumber++)
            {
                childrenOfTheParentGarden.Add(makeChild(parent.length, parent.width, allRocksInParent, movementMax));
            }
            return(childrenOfTheParentGarden);
        }
Exemplo n.º 4
0
        public Garden geneticSelection(Garden baseGarden, int steps, int movementMax, int numberOfChildren)
        {
            GardenEvaluator ge        = new GardenEvaluator();
            List <Garden>   ancestors = new List <Garden>();

            ancestors.Add(baseGarden);
            for (int i = 0; i < steps; i++)
            {
                ancestors = nextStep(ancestors, numberOfChildren, movementMax - (i * movementMax / steps), ge);
            }
            return(ancestors[0]);
        }
Exemplo n.º 5
0
        private double distanceScore(Garden toScore)
        {
            Resident[][]  allRocks = NChooseK(toScore.getAllOfType(Rock.rockString), 2);
            Resident[]    combo;
            List <double> allDistances = new List <double>();
            double        maxDistance  = Math.Sqrt(Math.Pow(toScore.width, 2) + Math.Pow(toScore.length, 2));

            for (int i = 0; i < allRocks.Length; i++)
            {
                combo = allRocks[i];
                allDistances.Add(distance(combo[0].origin, combo[1].origin) / maxDistance);
            }
            return(allDistances.Average());
        }
Exemplo n.º 6
0
        //the search type probably should be an integer since thos comparisons are faster than equals.
        //future refactor.
        /// <summary>
        /// Gets all the residents in the Garden of a certain type denoted by the string type.
        /// </summary>
        /// <param name="garden">The Garden to be searched.</param>
        /// <param name="type">The string of the object being searched.</param>
        /// <returns>A List of the Residents that match the type passed.</returns>
        private List <Resident> getAllResidents(Garden garden, string type)
        {
            List <Resident> allResidents      = garden.residentsList;
            List <Resident> specificResidents = new List <Resident>();

            foreach (Resident resident in allResidents)
            {
                if (resident.ToString().Equals(type))
                {
                    specificResidents.Add(resident);
                }
            }
            return(specificResidents);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Score the Garden passed based on a variety of methods.
        /// </summary>
        /// <param name="toScore">The Garden to score.</param>
        /// <returns>The score of a Garden, the higher the better.</returns>
        public double scoreGarden(Garden toScore)
        {
            //should pull this method into this class
            double        symmetry             = toScore.symmetric(jigger, symmetryWeight);
            double        balance              = balanceOfGarden(toScore);
            double        nonLinearity         = scoreLinearity(toScore);
            double        distanceBetweenAll   = distanceScore(toScore);
            double        locationScoreAverage = locationScore(toScore);
            List <double> scores = new List <double>();

            scores.Add(symmetry);
            scores.Add(balance);
            scores.Add(nonLinearity);
            scores.Add(distanceBetweenAll);
            scores.Add(locationScoreAverage);
            return(scores.Average());
        }
Exemplo n.º 8
0
        /// <summary>
        /// Find how much any half the Garden dominates the other half.
        /// Finds the standard deviation of nRocks from each half.
        /// We seek to avoid one half having 50 rocks while the other has 0
        /// </summary>
        /// <param name="toScore"></param>
        /// <returns></returns>
        private double balanceOfGarden(Garden toScore)
        {
            Neighborhood[] halves = toScore.allHalves();
            List <double>  nRocksPerHalf = new List <double>();
            double         sumOfVariance = 0, average;

            foreach (Neighborhood half in halves)
            {
                nRocksPerHalf.Add(half.numberOfRocks());
            }
            average = nRocksPerHalf.Average();
            foreach (double nRocks in nRocksPerHalf)
            {
                sumOfVariance += Math.Pow(nRocks - average, 2);
            }
            return(Math.Sqrt(sumOfVariance / (nRocksPerHalf.Count - 1)) / maxStDev(average, halves.Length) * balanceWeight);
        }
Exemplo n.º 9
0
        private double locationScore(Garden toScore)
        {
            List <Resident> allRocks       = toScore.getAllOfType(Rock.rockString);
            List <double>   locationScores = new List <double>();

            foreach (Resident rock in allRocks)
            {
                if (toScore.atomAt(rock.origin).rockBorderHeuristic < 0.2)
                {
                    double x = toScore.atomAt(rock.origin).rockBorderHeuristic;
                }
                else
                {
                    double x = toScore.atomAt(rock.origin).rockBorderHeuristic;
                }
                locationScores.Add(toScore.atomAt(rock.origin).rockBorderHeuristic);
            }
            return(locationScores.Average());
        }
Exemplo n.º 10
0
        public Tester(int length, int width)
        {
            GardenEvaluator ge = new GardenEvaluator();

            this.width  = width;
            this.length = length;
            testGarden  = new Garden(length, width);
            fillWithGravel();
            addResident(new Rock(2, 2), new Point(10, 12), false);
            addResident(new Rock(2, 2), new Point(1, 12), false);
            addResident(new Rock(2, 2), new Point(16, 12), false);
            fillWithGravel();
            //addResident(new Rock(10, 10), new Point(3, 4), true);
            fillWithGravel();
            //should be the only rock that is in the garden
            //removeResident(new Point(3, 5));
            fillWithGravel();
            List <Point> starts = new List <Point>();
            List <Point> ends   = new List <Point>();

            starts.Add(new Point(0, 0));
            starts.Add(new Point(0, 1));
            ends.Add(new Point(4, 4));
            ends.Add(new Point(4, 5));
            addRiver(starts, ends);
            double score = ge.scoreGarden(testGarden);

            Console.WriteLine(ge.scoreGarden(testGarden));
            List <int[]> combos = new List <int[]>();

            GardenEvaluator.combinations(ref combos, 0, 0, 3, 5, new int[3]);
            Garden best = geneticSelection(testGarden, 20, 3, 20);

            Console.WriteLine(ge.scoreGarden(best));
            Console.WriteLine(best.ToString());
            best.addStreamAStar(new Point(12, 2), new Point(2, 19));
            //Console.ReadLine();
        }