Esempio n. 1
0
        public Form1()
        {
            GhostGrid = new int[8];
            GhostX    = width - 1;
            GhostY    = height - 1;
            PacX      = 0;
            PacY      = 0;

            grid   = new int[width, height];
            picArr = new PictureBox[width, height];
            ran    = new Random();

            move    = new int[200];
            picture = new int[move.Length, 8];

            timer = new Timer
            {
                Interval = time_interval
            };
            timer.Tick   += new EventHandler(TimerTick);
            timer.Enabled = false;

            ghostArray = new NN_Ghost[2];
            pacArray   = new NN_Pacman[2];
            for (int x = 0; x < ghostArray.Length; x++)
            {
                ghostArray[x] = new NN_Ghost();
            }
            for (int x = 0; x < pacArray.Length; x++)
            {
                pacArray[x] = new NN_Pacman(width, height);
            }

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    grid[x, y] = value_food;
                }
            }

            GenWall();
            grid[GhostX, GhostY] = value_ghost;
            grid[0, 0]           = value_pacman;
            if (render)
            {
                PaintBoard();
            }
            InitializeComponent();

            PacX = 0;
            PacY = 0;
        }
Esempio n. 2
0
        private void BreedPac()
        {
            int counter1 = 0;

            NN_Pacman[] newGen = new NN_Pacman[pacArray.Length];
            NN_Pacman   child  = new NN_Pacman(width, height);

            int[] genNew = new int[pacArray.Length];

            for (int x = 0; x < genNew.Length; x++)
            {
                for (int y = 0; y < genNew.Length; y++)
                {
                    if (pacArray[counter1].GetScore() < pacArray[y].GetScore())
                    {
                        counter1 = y;
                    }
                }
                genNew[x] = counter1;
                pacArray[counter1].AddScore(point_kill);
            }

            newGen[0] = pacArray[genNew[0]];
            newGen[1] = pacArray[genNew[1]];
            newGen[0].AddScore(-newGen[0].GetScore());
            newGen[1].AddScore(-newGen[1].GetScore());

            int[] raffle = new int[(genNew.Length + 1) * genNew.Length / 2];
            for (int x = 1; x <= genNew.Length; x++)
            {
                for (int y = 0; y < x; y++)
                {
                    raffle[y] = (x - 1);
                }
            }

            int counter2 = 0;

            double[] parent1;
            double[] parent2;

            for (int x = 2; x < newGen.Length; x++)
            {
                counter1 = (int)(ran.NextDouble() * (pacArray.Length + 1) / 2 * pacArray.Length);
                counter2 = (int)(ran.NextDouble() * (pacArray.Length + 1) / 2 * pacArray.Length);
                parent1  = pacArray[raffle[counter1]].DNA();
                parent2  = pacArray[raffle[counter2]].DNA();

                for (int y = 0; y < parent1.Length; y++)
                {
                    parent1[x] = (parent1[x] + parent2[x]) / 2;
                    if (ran.NextDouble() < 1.1)
                    {
                        parent1[x] += (ran.NextDouble() - 0.5) / 100;
                    }
                }

                child.Child(parent1);
                newGen[x] = child;
            }

            for (int x = 0; x < pacArray.Length; x++)
            {
                pacArray[x] = newGen[x];
            }
        }