MazeBot (29/04/2017)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MazeBot
{
    public partial class frmMazeBot : Form
    {
        public int size = 8;

        public Point[] Neighbor = new Point[4];
        public int neighborCont = 0;

        public PictureBox[,] LED = new PictureBox[30, 30];
        public bool[,] bloco = new bool[30, 30];
        public int i, j;

        public Point walker;
        public int moveX, moveY;

        public Point[] Path = new Point[225];
        public int pathCont;

        public Random rnd = new Random();
        public int borda;

        public Point blocoInicial;
        public Point blocoFinal;
        public int blocoExtremidade;

        public Point[] Aberta = new Point[225];
        public Point[] Fechada = new Point[225];
        public int fechadaCont;
        public Point Atual;
        public int[] Vizinho = new int[4];

        public Point Obstaculo;

        public string direcao = "up";

        public string movimento;
        public int k = 0;/////////////////////

        public frmMazeBot()
        {
            InitializeComponent();

            for (j = 0; j < 30; j++)
            {
                for (i = 0; i < 30; i++)
                {
                    LED[i, j] = new PictureBox();
                    Controls.Add(LED[i, j]);
                }
            }

            AtualizarSize();

            for (neighborCont = 0; neighborCont < 4; neighborCont++)
            {
                Neighbor[neighborCont] = new Point(size, size);
            }

        }

        private void btnGerarLabirinto_Click(object sender, EventArgs e)
        {
        ResetarLabirinto:

            ZerarLEDs();
            txtMovimentos.Text = "";
            k = 0;

            blocoInicial = new Point(0, size - 1);

            LED[blocoInicial.X, blocoInicial.Y].BackColor = Color.Blue;
            bloco[blocoInicial.X, blocoInicial.Y] = true;

            while (true)
            {
                blocoExtremidade = rnd.Next(0, size);
                borda = rnd.Next(2);

                switch (borda)
                {
                    case 0://SUPERIOR
                        blocoFinal = new Point(blocoExtremidade, 0);
                        break;
                    case 1://DIREITA
                        blocoFinal = new Point(size - 1, blocoExtremidade);
                        break;
                }

                LED[blocoFinal.X, blocoFinal.Y].BackColor = Color.Blue;
                bloco[blocoFinal.X, blocoFinal.Y] = true;

                int NumDeExtremidades = 0;

                for (j = 0; j < size; j++)
                    for (i = 0; i < size; i++)
                        if (bloco[i, j])
                            NumDeExtremidades++;//CONTA EXTREMIDADES (PONTO INICIAL E FINAL)

                if (NumDeExtremidades == 2)
                    break;//SAI DO WHILE CASO JA TENHA PONTO INICIAL E FINAL
            }

            walker = blocoInicial;//walker --> ponto que se desloca para determinar caminho

            Path[pathCont] = walker;
            pathCont++;

            try
            {
                //Teste();
                Maze(3);
                //MauriciosWay();
                //A_Estrela();

                ListarCaminho();

                for (j = 0; j < size - 1; j++)
                {
                    for (i = 0; i < size - 1; i++)
                    {
                        if (bloco[i, j] &&
                            bloco[i + 1, j] &&
                            bloco[i, j + 1] &&
                            bloco[i + 1, j + 1])
                        {
                            goto ResetarLabirinto;
                        }

                        if (i < size - 3 && j < size - 3)
                        {
                            if (bloco[i + 1, j] &&
                                bloco[i, j + 1] &&
                                bloco[i + 1, j + 1] &&
                                bloco[i + 2, j + 1] &&
                                bloco[i + 1, j + 2])
                            {
                                goto ResetarLabirinto;
                            }
                        }

                    }
                }

                for (j = 0; j < size; j++)
                {
                    for (i = 0; i < size; i++)
                    {
                        if (!bloco[i, j])
                        {
                            int obs = rnd.Next(2);

                            if (obs != 0)
                            {
                                LED[i, j].BackColor = Color.DimGray;
                            }
                        }
                        else if (blocoInicial != new Point(i, j) && blocoInicial != new Point(i, j) && blocoFinal != new Point(i, j) && blocoFinal != new Point(i, j))
                        {
                            if (chkShowPath.Checked)
                            {
                                LED[i, j].BackColor = Color.Red;
                            }
                            else
                            {
                                LED[i, j].BackColor = Color.LightGray;
                            }
                        }
                    }
                }

                LED[blocoFinal.X, blocoFinal.Y].BackColor = Color.Blue;

                Atual = new Point(0, size - 1);
                lblBot.Left = LED[Atual.X, Atual.Y].Left + (LED[Atual.X, Atual.Y].Width - lblBot.Width) / 2;
                lblBot.Top = LED[Atual.X, Atual.Y].Top + (LED[Atual.X, Atual.Y].Height - lblBot.Height) / 2;

                lblBot.BringToFront();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error: " + ex.Message, "Erro");
            }

        }

        public void ZerarLEDs()
        {
            for (j = 0; j < size; j++)
            {
                for (i = 0; i < size; i++)
                {
                    LED[i, j].BackColor = Color.LightGray;//COR DEFAULT DOS LEDS
                    bloco[i, j] = false;
                    pathCont = 0;
                }
            }

            neighborCont = 0;
            fechadaCont = 0;
            listBox1.Items.Clear();
        }

        public void ListarCaminho()
        {
            listBox2.Items.Clear();

            for (pathCont = 0; pathCont < 64; pathCont++)
            {
                listBox2.Items.Add("(" + Path[pathCont].X + ", " + Path[pathCont].Y + ")");

                if (Path[pathCont] == blocoFinal)
                {
                    break;
                }
            }
        }

        public void Teste()
        {
            moveX = blocoFinal.X - blocoInicial.X;
            moveY = blocoFinal.Y - blocoInicial.Y;

            TracarCaminho(moveX, moveY);
        }

        public void Maze(int nivel)
        {
            for (int n = 0; n < nivel; n++)
            {
                if (n + 1 == nivel)
                {
                    moveX = blocoFinal.X - walker.X;
                    listBox1.Items.Add("moveX: " + moveX);
                    moveY = blocoFinal.Y - walker.Y;
                    listBox1.Items.Add("moveY: " + moveY);
                    TracarCaminho(moveX, moveY);
                    break;
                }

            RANDOM_X:
                moveX = rnd.Next(1 - walker.X, size - 1 - walker.X);
                if (moveX == 0 || walker.X + moveX == blocoFinal.X)
                    goto RANDOM_X;
                listBox1.Items.Add("random: " + moveX);

            RANDOM_Y:
                moveY = rnd.Next(1 - walker.Y, size - 1 - walker.Y);
                if (moveY == 0 || walker.Y + moveY == blocoFinal.Y)
                    goto RANDOM_Y;
                listBox1.Items.Add("random: " + moveY);
                TracarCaminho(moveX, moveY);
            }
        }

        public void MauriciosWay()
        {
            for (int k = 0; k < 5; k++)
            {
                idVizinhos();

                if (Neighbor[1] == new Point(size, size) && Neighbor[2] == new Point(size, size) && Neighbor[3] == new Point(size, size))
                    walker = Neighbor[0];
                else if (Neighbor[2] == new Point(size, size) && Neighbor[3] == new Point(size, size))
                    walker = Neighbor[rnd.Next(2)];
                else if (Neighbor[3] == new Point(size, size))
                    walker = Neighbor[rnd.Next(3)];
                else
                    walker = Neighbor[rnd.Next(4)];

                //walker = Neighbor[rnd.Next(4)];
                Path[pathCont] = walker;
                LED[walker.X, walker.Y].BackColor = Color.Red;
                bloco[walker.X, walker.Y] = true;

                for (neighborCont = 0; neighborCont < 4; neighborCont++)
                {
                    Neighbor[neighborCont] = new Point(size, size);
                }
            }


            moveX = blocoFinal.X - walker.X;
            listBox1.Items.Add("moveX: " + moveX);
            moveY = blocoFinal.Y - walker.Y;
            listBox1.Items.Add("moveY: " + moveY);
            TracarCaminho(moveX, moveY);

        }

        public void A_Estrela()
        {

            Atual = walker;

            while (Atual != blocoFinal)
            {
                LED[Atual.X, Atual.Y].BackColor = Color.Red;

                for (int k = 0; k < 4; k++)
                    Vizinho[k] = 100;

                if (Atual.Y - 1 >= 0)
                {
                    for (int k = 0; k < 64; k++)
                        if (Fechada[k] == new Point(Atual.X, Atual.Y - 1))
                            break;
                    Vizinho[0] = Math.Abs((Atual.X) - blocoFinal.X) + Math.Abs((Atual.Y - 1) - blocoFinal.Y);
                }

                if (Atual.X + 1 <= size - 1)
                {
                    for (int k = 0; k < 64; k++)
                        if (Fechada[k] == new Point(Atual.X + 1, Atual.Y))
                            break;
                    Vizinho[1] = Math.Abs((Atual.X + 1) - blocoFinal.X) + Math.Abs((Atual.Y) - blocoFinal.Y);
                }

                if (Atual.Y + 1 <= size - 1)
                {
                    for (int k = 0; k < 64; k++)
                        if (Fechada[k] == new Point(Atual.X, Atual.Y + 1))
                            break;
                    Vizinho[2] = Math.Abs((Atual.X) - blocoFinal.X) + Math.Abs((Atual.Y + 1) - blocoFinal.Y);
                }

                if (Atual.X - 1 >= 0)
                {
                    for (int k = 0; k < 64; k++)
                        if (Fechada[k] == new Point(Atual.X - 1, Atual.Y))
                            break;
                    Vizinho[3] = Math.Abs((Atual.X - 1) - blocoFinal.X) + Math.Abs((Atual.Y) - blocoFinal.Y);
                }


                int Near = Math.Min(Math.Min(Vizinho[0], Vizinho[1]), Math.Min(Vizinho[2], Vizinho[3]));

                Fechada[fechadaCont] = Atual;
                fechadaCont++;

                if (Near == Vizinho[0])
                    Atual = new Point(Atual.X, Atual.Y - 1);
                else if (Near == Vizinho[1])
                    Atual = new Point(Atual.X + 1, Atual.Y);
                else if (Near == Vizinho[2])
                    Atual = new Point(Atual.X, Atual.Y + 1);
                else if (Near == Vizinho[3])
                    Atual = new Point(Atual.X - 1, Atual.Y);
            }

        }

        public void TracarCaminho(int moveX, int moveY)
        {
            if (moveX > 0)//CASO MOVIMENTO SEJA PARA A DIREITA
            {
                for (int k = 0; k < moveX; k++)//ANDA N CASAS NO EIXO X
                {
                    walker.X++;
                    LED[walker.X, walker.Y].BackColor = Color.Red;
                    bloco[walker.X, walker.Y] = true;
                    Path[pathCont] = walker;
                    pathCont++;
                }
            }
            else if (moveX < 0)//CASO MOVIMENTO SEJA PARA A ESQUERDA
            {
                for (int k = 0; k > moveX; k--)//ANDA N CASAS NO EIXO X
                {
                    walker.X--;
                    LED[walker.X, walker.Y].BackColor = Color.Red;
                    bloco[walker.X, walker.Y] = true;
                    Path[pathCont] = walker;
                    pathCont++;
                }
            }

            if (moveY > 0)//CASO MOVIMENTO SEJA PARA BAIXO
            {
                for (int k = 0; k < moveY; k++)//ANDA N CASAS NO EIXO Y
                {
                    walker.Y++;
                    LED[walker.X, walker.Y].BackColor = Color.Red;
                    bloco[walker.X, walker.Y] = true;
                    Path[pathCont] = walker;
                    pathCont++;
                }
            }
            else if (moveY < 0)//CASO MOVIMENTO SEJA PARA CIMA
            {
                for (int k = 0; k > moveY; k--)//ANDA N CASAS NO EIXO Y
                {
                    walker.Y--;
                    LED[walker.X, walker.Y].BackColor = Color.Red;
                    bloco[walker.X, walker.Y] = true;
                    Path[pathCont] = walker;
                    pathCont++;
                }
            }
        }

        public void idVizinhos()
        {
            neighborCont = 0;

            if (walker.X + 1 <= size - 1)
            {
                if (!bloco[walker.X + 1, walker.Y])
                {
                    Neighbor[neighborCont] = new Point(walker.X + 1, walker.Y);
                    neighborCont++;
                }
            }

            if (walker.X - 1 >= 0)
            {
                if (!bloco[walker.X - 1, walker.Y])
                {
                    Neighbor[neighborCont] = new Point(walker.X - 1, walker.Y);
                    neighborCont++;
                }
            }

            if (walker.Y + 1 <= size - 1)
            {
                if (!bloco[walker.X, walker.Y + 1])
                {
                    Neighbor[neighborCont] = new Point(walker.X, walker.Y + 1);
                    neighborCont++;
                }
            }

            if (walker.Y - 1 >= 0)
            {
                if (!bloco[walker.X, walker.Y - 1])
                {
                    Neighbor[neighborCont] = new Point(walker.X, walker.Y - 1);
                    neighborCont++;
                }
            }

            neighborCont = 0;
        }

        private void numChangeSize_ValueChanged(object sender, EventArgs e)
        {
            for (j = 0; j < size; j++)
            {
                for (i = 0; i < size; i++)
                {
                    LED[i, j].BackColor = Color.White;
                }
            }
            size = (int)numChangeSize.Value;
            AtualizarSize();
        }

        public void AtualizarSize()
        {
            for (j = 0; j < size; j++)
            {
                for (i = 0; i < size; i++)
                {
                    LED[i, j].Width = (int)((560 - size + 1) / size);
                    LED[i, j].Height = (int)((560 - size + 1) / size);
                    LED[i, j].Left = (int)(30 + i * ((560 - size + 1) / size + 1));
                    LED[i, j].Top = (int)(50 + j * ((560 - size + 1) / size + 1));

                    LED[i, j].BackColor = Color.LightGray;//COR DEFAULT DOS LEDS

                    bloco[i, j] = false;
                }
            }
        }

        private void chkShowPath_CheckedChanged(object sender, EventArgs e)
        {
            for (j = 0; j < size; j++)
            {
                for (i = 0; i < size; i++)
                {
                    if (bloco[i, j] && blocoInicial != new Point(i, j) && blocoInicial != new Point(i, j) && blocoFinal != new Point(i, j) && blocoFinal != new Point(i, j))
                    {
                        if (chkShowPath.Checked)
                        {
                            LED[i, j].BackColor = Color.Red;
                        }
                        else
                        {
                            LED[i, j].BackColor = Color.LightGray;
                        }
                    }
                }
            }
        }

        private void frmMazeBot_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.W)
            {
                switch (direcao)
                {
                    case "left":
                        Spin(90);
                        break;
                    case "down":
                        Spin(180);
                        break;
                    case "right":
                        Spin(-90);
                        break;
                }
                GoForward();
            }

            if (e.KeyCode == Keys.A)
            {
                switch (direcao)
                {
                    case "down":
                        Spin(90);
                        break;
                    case "right":
                        Spin(180);
                        break;
                    case "up":
                        Spin(-90);
                        break;
                }
                GoForward();
            }

            if (e.KeyCode == Keys.D)
            {
                switch (direcao)
                {
                    case "up":
                        Spin(90);
                        break;
                    case "left":
                        Spin(180);
                        break;
                    case "down":
                        Spin(-90);
                        break;
                }
                GoForward();
            }

            if (e.KeyCode == Keys.S)
            {
                switch (direcao)
                {
                    case "right":
                        Spin(90);
                        break;
                    case "up":
                        Spin(180);
                        break;
                    case "left":
                        Spin(-90);
                        break;
                }
                GoForward();
            }

        }
        public void GoForward()
        {
            switch (direcao)
            {
                case "up":
                    Atual.Y--;
                    break;
                case "down":
                    Atual.Y++;
                    break;
                case "left":
                    Atual.X--;
                    break;
                case "right":
                    Atual.X++;
                    break;
            }

            try
            {
                lblBot.Left = LED[Atual.X, Atual.Y].Left + (LED[Atual.X, Atual.Y].Width - lblBot.Width) / 2;
                lblBot.Top = LED[Atual.X, Atual.Y].Top + (LED[Atual.X, Atual.Y].Height - lblBot.Height) / 2;
            }
            catch (Exception)
            {

            }

            if (LED[Atual.X, Atual.Y].BackColor == Color.DimGray)
            {
                GameOverTetris();
            }
            else if (Atual == blocoFinal)
            {
                YouWin();
            }
        }

        public void Spin(int graus)
        {
            if ((direcao == "up" && graus == -90) ||
                (direcao == "right" && graus == 180) ||
                (direcao == "down" && graus == 90))//left
            {
                lblBot.Text = "<";
                direcao = "left";
            }
            else if ((direcao == "up" && graus == 90) ||
                (direcao == "left" && graus == 180) ||
                (direcao == "down" && graus == -90))//right
            {
                lblBot.Text = ">";
                direcao = "right";
            }
            else if ((direcao == "right" && graus == -90) ||
                (direcao == "down" && graus == 180) ||
                (direcao == "left" && graus == 90))//up
            {
                lblBot.Text = "^";
                direcao = "up";
            }
            else if ((direcao == "left" && graus == -90) ||
                (direcao == "up" && graus == 180) ||
                (direcao == "right" && graus == 90))//down
            {
                lblBot.Text = "v";
                direcao = "down";
            }
        }

        public void GameOverTetris()
        {
            Tocar("LA", 100);
            Tocar("FA", 100);
            Tocar("SOL", 100);
            Tocar("RE#", 100);
            Tocar("FA", 100);
            Tocar("RE", 100);
            Tocar("MI", 100);
            Tocar("DO#", 100);
            Tocar("RE#", 100);

            for (int j = size - 1; j >= 0; j--)
            {
                for (int i = 0; i < size; i++)
                {
                    int cor = rnd.Next(size - 1);
                    switch (cor)
                    {
                        case 0:
                            LED[i, j].BackColor = Color.Blue;
                            break;
                        case 1:
                            LED[i, j].BackColor = Color.Green;
                            break;
                        case 2:
                            LED[i, j].BackColor = Color.Red;
                            break;
                        case 3:
                            LED[i, j].BackColor = Color.Orange;
                            break;
                        case 4:
                            LED[i, j].BackColor = Color.Yellow;
                            break;
                        case 5:
                            LED[i, j].BackColor = Color.Purple;
                            break;
                        case 6:
                            LED[i, j].BackColor = Color.LightBlue;
                            break;
                    }
                }
            }
        }

        public void YouWin()
        {
            Tocar("RE#", 100);
            Tocar("SOL#", 100);
            Tocar("DO2", 100);
            Tocar("SOL#", 100);
            Tocar("DO2", 100);
            Tocar("RE#2", 100);
        }

        public void Tocar(string nota, int tempo)
        {
            switch (nota)
            {
                case "DO":
                    Console.Beep(1046, tempo);
                    break;
                case "DO#":
                    Console.Beep(1108, tempo);
                    break;
                case "RE":
                    Console.Beep(1174, tempo);
                    break;
                case "RE#":
                    Console.Beep(1244, tempo);
                    break;
                case "MI":
                    Console.Beep(1318, tempo);
                    break;
                case "FA":
                    Console.Beep(1396, tempo);
                    break;
                case "FA#":
                    Console.Beep(1479, tempo);
                    break;
                case "SOL":
                    Console.Beep(1567, tempo);
                    break;
                case "SOL#":
                    Console.Beep(1661, tempo);
                    break;
                case "LA":
                    Console.Beep(1760, tempo);
                    break;
                case "LA#":
                    Console.Beep(1864, tempo);
                    break;
                case "SI":
                    Console.Beep(1975, tempo);
                    break;
                case "DO2":
                    Console.Beep(2093, tempo);
                    break;
                case "DO#2":
                    Console.Beep(2217, tempo);
                    break;
                case "RE2":
                    Console.Beep(2349, tempo);
                    break;
                case "RE#2":
                    Console.Beep(2489, tempo);
                    break;
            }
        }

        private void btnGo_Click(object sender, EventArgs e)
        {
            movimento = txtMovimentos.Text.ToUpper();
            timer1.Start();

        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            switch (movimento[k])
            {
                case 'U':
                    switch (direcao)
                    {
                        case "left":
                            Spin(90);
                            break;
                        case "down":
                            Spin(180);
                            break;
                        case "right":
                            Spin(-90);
                            break;
                    }
                    GoForward();
                    break;
                case 'J':
                    switch (direcao)
                    {
                        case "right":
                            Spin(90);
                            break;
                        case "up":
                            Spin(180);
                            break;
                        case "left":
                            Spin(-90);
                            break;
                    }
                    GoForward();
                    break;
                case 'H':
                    switch (direcao)
                    {
                        case "down":
                            Spin(90);
                            break;
                        case "right":
                            Spin(180);
                            break;
                        case "up":
                            Spin(-90);
                            break;
                    }
                    GoForward();
                    break;
                case 'K':
                    switch (direcao)
                    {
                        case "up":
                            Spin(90);
                            break;
                        case "left":
                            Spin(180);
                            break;
                        case "down":
                            Spin(-90);
                            break;
                    }
                    GoForward();
                    break;
            }

            k++;

            if (Atual == blocoFinal)
            {
                timer1.Stop();
            }
        }
    }
}