<file_sep>﻿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 JasChess {
    public partial class Pensando : Form {
        DateTime inicio;

        public Pensando() {
            InitializeComponent();
            this.inicio = System.DateTime.Now;
        }
        int estado = 0;
        private void timer1_Tick(object sender, EventArgs e) {

            if(estado == 0) {
                Opacity -= 0.07;
            }
            else {
                Opacity += 0.07;
            }
            estado = Opacity == 0 || Opacity == 1 ? 1 - estado : estado;
        }

        //public int tempo = 0;
        private void timer2_Tick(object sender, EventArgs e) {
            Busca.x = DateTime.Now.Subtract(inicio).TotalSeconds;
        }
    }
}
<file_sep># JasChess
 Xadrez didático desenvolvido durante projeto de Iniciação Científica
<file_sep>﻿using System;
using System.Drawing;
using System.Windows.Forms;
using static JasChess.Jogo;
using static JasChess.Pecas;
using static JasChess.Tabuleiro;

namespace JasChess {
    public partial class GUI : Form {

        public GUI() {
            InitializeComponent();

        }

        private void pictureBox_MouseEnter(object sender, EventArgs e) {
            PictureBox c = sender as PictureBox;
            c.Image = Properties.Resources.selecao;
            c.Cursor = c.BackgroundImage != null || c.BackColor == proxV ? Cursors.Hand : Cursors.Arrow;
            int ind;
            for(ind = 0; ind < 64; ind++)
                if(casa[ind] == (PictureBox)sender) {
                    if(casa[ind].BackgroundImage != null)
                        tsFoco.Text = Nome(ind);
                    break;
                }

        }

        private void pictureBox_MouseLeave(object sender, EventArgs e) {
            PictureBox c = sender as PictureBox;
            c.Image = null;
            tsFoco.Text = null;
        }

        private void tsJNH_Click(object sender, EventArgs e) {
            NovoJogo(false);
            tsVez.Text = "Vez das: Brancas";
        }
        private void tsNJH_Click(object sender, EventArgs e) {
            NovoJogo(true);
            tsVez.Text = "Vez das: Brancas";
        }

        private void tsSobre_Click(object sender, EventArgs e) {
            new Sobre().ShowDialog();
        }

        public static Color atual = Color.Gold;
        public static Color proxV = Color.PaleGreen;
        public static Color proxO = Color.IndianRed;
        public static Color antO = Color.LightSkyBlue;
        public static Color antD = Color.PowderBlue;

        public static int lino;
        public static int colo;
        public static int lind;
        public static int cold;
        public static bool flag = false, temSom = true;

        private void tocarSonsToolStripMenuItem_Click(object sender, EventArgs e) {
            tocarSonsToolStripMenuItem.Checked = !tocarSonsToolStripMenuItem.Checked;
            temSom = tocarSonsToolStripMenuItem.Checked;
        }

        private void GUI_Load(object sender, EventArgs e) {

        }

        private void pictureBox_Click(object sender, EventArgs e) {

            int ind;
            int lin = -1;
            int col = -1;

            for(ind = 0; ind < 64; ind++) {
                if(casa[ind] == (PictureBox)sender) {
                    lin = lind = ind / 8 + 2;
                    col = cold = ind % 8 + 2;
                    break;
                }
            }

            if(!TemCoisa(lin, col) && !flag)
                ResetCor();
            else if(flag && (casa[ind].BackColor == proxO || casa[ind].BackColor == proxV)) {
                Jogar();
                tsVez.Text = "Vez das: " + new string[] { "Brancas", "Pretas" }[jogador];
            }
            else if(TemCoisa(lin, col) && Cor(lin, col) == jogador) {
                ResetCor();
                casa[ind].BackColor = atual;
                lino = ind / 8 + 2;
                colo = ind % 8 + 2;
                flag = true;

                MostrarPosicoes(lin, col);
               
            }
            else ResetCor();
        }

     
    }
    }
<file_sep>﻿using System.Drawing;
using static JasChess.Properties.Resources;
using static JasChess.Tabuleiro;

namespace JasChess {

    public class Pecas {

        public const int PEAO_BRANCO = 10;
        public const int BISPO_BRANCO = 20;
        public const int CAVALO_BRANCO = 30;
        public const int TORRE_BRANCA = 40;
        public const int DAMA_BRANCA = 50;
        public const int REI_BRANCO = 60;

        public const int PEAO_PRETO = 11;
        public const int BISPO_PRETO = 21;
        public const int CAVALO_PRETO = 31;
        public const int TORRE_PRETA = 41;
        public const int DAMA_PRETA = 51;
        public const int REI_PRETO = 61;

        public const int PEAO = 1;
        public const int BISPO = 2;
        public const int CAVALO = 3;
        public const int TORRE = 4;
        public const int DAMA = 5;
        public const int REI = 6;

        public const int BRANCA = 0;
        public const int PRETA = 1;

        public static int[] rei = new int[2];

        public static Image[,] peca = { { _10, _20, _30, _40, _50, _60 }, { _11, _21, _31, _41, _51, _61 } };

        public static int[,] ATAQUES_PEAO = new int[68, 6];
        public static int[,] ATAQUES_BISPO = new int[92, 28];
        public static int[,] ATAQUES_CAVALO = new int[92, 8];
        public static int[,] ATAQUES_TORRE = new int[92, 28];


        public static int Cor(int peca) {
            return peca % 10;
        }
        public static int Cor(int lin, int col) {
            return tabuleiro[lin, col] % 10;
        }

        public static int Tipo(int lin, int col) {
            return tabuleiro[lin, col] / 10;
        }
        public static int Tipo(int peca) {
            return peca / 10;
        }

        public static int Quantidade() {
            int q = 0;
            for(int i = 2; i < 9; i++) 
                for(int j = 2; j < 9; j++) 
                    if(TemCoisa(i, j)) q++;

            return q;
        }
        public static int Quantidade(int cor) {
            int q = 0;
            for(int i = 2; i < 9; i++)
                for(int j = 2; j < 9; j++)
                    if(TemCoisa(i, j) && Cor(i,j) == cor) q++;

            return q;
        }

        public static bool TemPar(int peca) {
            bool achou = false;
            for(int i = 2; i < 10; i++) 
                for(int j = 2; j < 10; j++) 
                    if(tabuleiro[i,j] == peca) 
                        if(achou) return true; 
                        else achou = true;

            return false;
        }

        public static string Nome(int pos) {
            pos = (pos / 8+2) * 12 + (pos % 8+2);
            string[] tipo = { "Peão", "Bispo", "Cavalo", "Torre", "Rainha", "Rei" };
            string[] cor = { "branco", "preto", "branca", "preta"};

            if(TemCoisa(pos / 12, pos % 12) && ÉValida(pos / 12, pos % 12)) {
                int a = Tipo(pos / 12, pos % 12) - 1;
                int b = a == TORRE-1 || a == DAMA -1? Cor(pos / 12, pos % 12) + 2 : Cor(pos / 12, pos % 12);
                return tipo[a] + " " + cor[b];
            } else
                return null;
        }

        public static void Promover(int jog) {
            int lin = 7 * jog + 2;
            for(int col = 2; col < 10; col++) {
                if(Tipo(lin, col) == PEAO) {
                    if(!Jogo.humano && Cor(lin,col) == PRETA) {
                        tabuleiro[lin, col] = DAMA_PRETA;
                        casa[(lin - 2) * 8 + col - 2].BackgroundImage = peca[PRETA, DAMA - 1];
                    } else {
                        Promocao p = new Promocao();
                        p.ShowDialog();
                        tabuleiro[lin, col] = (p.nova + 1) * 10 + jog;
                        casa[(lin - 2) * 8 + col - 2].BackgroundImage = peca[jog, p.nova];
                        
                    }
                    if(GUI.temSom) Jogo.sons[1].Play();
                }
            }
        }

        public static void AtribuirValores() {
            int lin, col;
            int[] bispo = { -1, 1 };
            int[,] cavalo = { { -1, 1 }, { 2, -2 } };
            int[] torreA = { -1, 0, 1, 0 };
            int[] torreB = { 0, 1, 0, -1 };

            for(int cont = 0, x = 26, y = 0; cont < 92; cont++, x++, y = 0) {
                // CAVALO
                for(int i = 0; i <= 1; i++)
                    for(int j = 0; j <= 1; j++)
                        for(int k = 0; k <= 1; k++) {
                            lin = cavalo[i, j] + x / 12;
                            col = cavalo[1 - i, k] + x % 12;
                            ATAQUES_CAVALO[cont, y++] = lin * 12 + col;
                        }

                y = 0;
                // TORRE
                for(int i = 1; i < 8; i++)
                    for(int j = 0; j < 4; j++, y++) {
                        lin = (i * torreA[j]) + x / 12;
                        col = (i * torreB[j]) + x % 12;
                        if((lin * 12 + col > -1) && (lin * 12 + col < 144))
                            ATAQUES_TORRE[cont, y] = lin * 12 + col;
                    }

                y = 0;
                // BISPO
                for(int k = 1; k < 8; k++)
                    for(int i = 0; i <= 1; i++)
                        for(int j = 0; j <= 1; j++, y++) {
                            lin = (k * bispo[i]) + x / 12;
                            col = (k * bispo[j]) + x % 12;
                            if((lin * 12 + col > -1) && (lin * 12 + col < 144))
                                ATAQUES_BISPO[cont, y] = lin * 12 + col;
                        }
            }

            // PEÃO
            for(int cont = 0, x = 38, y = 0; cont < 68; cont++, x++, y = 0)
                for(int i = -1; i < 2; i += 2)
                    for(int j = -1; j < 2; j++, y++) {
                        lin = i + x / 12;
                        col = j + x % 12;
                        ATAQUES_PEAO[cont, y] = lin * 12 + col;
                    }

        }

    }
}<file_sep>﻿using System.Media;
using System.Windows.Forms;
using static JasChess.GUI;
using static JasChess.Movimentos;
using static JasChess.Pecas;
using static JasChess.Tabuleiro;
using static JasChess.Busca;
using static JasChess.Properties.Resources;

namespace JasChess {
    class Jogo {
        public const int XEQUE = -1;
        public const int XEQUE_MATE = 0;
        public const int REI_AFOGADO = 1;
        public const int EMPATE = 2;

        private static string[] sentenca = { "Xeque-mate", "Rei afogado", "Empate" };
        private static string[] resultado = { "vitória das brancas", "vitória das pretas", "não houve vencedor" };
        public static SoundPlayer[] sons = { new SoundPlayer(move),  new SoundPlayer(promocao),
                                             new SoundPlayer(xeque), new SoundPlayer(empate),
                                             new SoundPlayer(uder),  new SoundPlayer(uvi)};

        private static int situacao = 3;
        private static int vencedor = -1;
        public static int jogador = 0;

        public static bool humano = true;


        public static void NovoJogo(bool human) {
            IniciarTabuleiro();
            jogador = 0;
            humano = human;
            gui.tsTempo.Visible = !humano;
            if(temSom) sons[1].Play();
            MessageBox.Show("Tudo pronto! As brancas começam.", "JasChess", MessageBoxButtons.OK, MessageBoxIcon.None);
        }

        public static void Jogar() {
            FacaMovimento(lino, colo, lind, cold, true);
            Promover(jogador);


            lino = colo = -1;
            flag = false;
            jogador = 1 - jogador;
            if(FimJogo(ref jogador, ref situacao, ref vencedor)) 
                Finaliza();
            else {
                if(situacao == XEQUE) {
                    int a = (rei[jogador] / 12 - 2) * 8;
                    int b = a + (rei[jogador] % 12) - 2;
                    casa[b].BackColor = proxO;
                    if(temSom) sons[2].Play();
                    MessageBox.Show("Xeque!", "JasChess", MessageBoxButtons.OK, MessageBoxIcon.None);
                }

                if(jogador == PRETA && !humano) {
                    ComputadorJoga();

                    lino = colo = -1;
                    flag = false;
                    jogador = 1 - jogador;
                    if(FimJogo(ref jogador, ref situacao, ref vencedor))
                        Finaliza();
                    else {
                        if(situacao == XEQUE) {
                            int a = (rei[jogador] / 12 - 2) * 8;
                            int b = a + (rei[jogador] % 12) - 2;
                            casa[b].BackColor = proxO;
                            if(temSom) sons[2].Play();
                            MessageBox.Show("Xeque!", "JasChess", MessageBoxButtons.OK, MessageBoxIcon.None);
                        }
                    }
                }
            }
        }

        public static void MostrarPosicoes(int lin, int col) {
            switch(Tipo(lin, col)) {
                case PEAO:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverPeao(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
                case BISPO:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverBispo(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
                case CAVALO:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverCavalo(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
                case TORRE:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverTorre(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
                case DAMA:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverDama(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
                case REI:
                    for(int i = 0; i < 64; i++) {
                        int nil = i / 8 + 2;
                        int loc = i % 8 + 2;
                        if(MoverRei(lin * 12 + col, nil * 12 + loc, jogador)) {
                            casa[i].BackColor = TemCoisa(nil, loc) ? proxO : proxV;
                        }
                    }
                    break;
            }
        }

        
        public static bool FimJogo(ref int jog, ref int sit, ref int venc) {
            if(Xeque(jog)) {
                if(!ExisteMovimentosValidos(jog)) {
                    sit = XEQUE_MATE;
                    venc = 1 - jog;
                    return true;
                } else {
                    sit = XEQUE;
                    return false;
                }
            } else if(!ExisteMovimentosValidos(jog)) {
                sit = REI_AFOGADO;
                venc = 2;
                return true;
            } else if(Quantidade() == 2) {
                sit = venc = EMPATE;
                return true;
            }

            sit = 3;
            return false;
        }

        static void Finaliza() {

            if(temSom)
                switch(situacao) {
                    case XEQUE_MATE:
                        int a = (rei[jogador] / 12 - 2) * 8;
                        int b = a + (rei[jogador] % 12) - 2;
                        casa[b].BackColor = proxO;
                        sons[5 - vencedor].Play();
                        break;
                    case REI_AFOGADO:
                    case EMPATE:
                        sons[3].Play();
                        break;
                }

            string msg = string.Format("{0}, {1}.", sentenca[situacao], resultado[vencedor]);
            MessageBox.Show(msg, "\nFim de Jogo.", MessageBoxButtons.OK, MessageBoxIcon.None);

            DialogResult d = MessageBox.Show("Iniciar nova partida?", "JasChess", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
            if(d == DialogResult.Yes)
                NovoJogo(humano);
            else 
                for(int i = 0; i < 64; casa[i++].Enabled = false) ;
        }
    }
}<file_sep>﻿using static JasChess.Pecas;
using static JasChess.Tabuleiro;

namespace JasChess {
    class Movimentos {

        public static void FacaMovimento(int lin_o, int col_o, int lin_d, int col_d, bool real) {

            if(Tipo(lin_o, col_o) == REI)
                rei[Jogo.jogador] = lin_d * 12 + col_d;

            tabuleiro[lin_d, col_d] = tabuleiro[lin_o, col_o];
            tabuleiro[lin_o, col_o] = CASA_VAZIA;
            
            if(real) {
                ResetCor();
                casa[(lin_o - 2) * 8 + col_o - 2].BackColor = GUI.antO;
                casa[(lin_d - 2) * 8 + col_d - 2].BackColor = GUI.antD;

                casa[(lin_d - 2) * 8 + col_d - 2].BackgroundImage = casa[(lin_o - 2) * 8 + col_o - 2].BackgroundImage;
                casa[(lin_o - 2) * 8 + col_o - 2].BackgroundImage = null;

                if(GUI.temSom) Jogo.sons[0].Play();

            }
        }


        public static bool PeaoAtaca(int pos_o, int pos_d, int jogador) {
            // VERIFICA SE O PEÃO DE jogador SE MOVE DE pos_o PARA pos_d

            // *j <- -1, PARA O JOGADOR 0}
            // *j <-  1, PARA O JOGADOR 1}

            for(int i = 0, j = (2 * jogador - 1); i < 6; i++)
                if(pos_d == ATAQUES_PEAO[pos_o - 38, i])
                    return (pos_o / 12 + j == pos_d / 12);

            return false;
        }
        public static bool BispoAtaca(int pos_o, int pos_d, int max) {
            int casa;
            max = 4 * max - 1;

            // VERIFICA SE O "BISPO" SE MOVE DE pos_o PARA pos_d
            for(int i = 0; i <= max; i++) {
                if(pos_d == ATAQUES_BISPO[pos_o - 26, i]) {
                    // VERIFICA SE HÁ ALGUMA PEÇA NO CAMINHO OU SE CHEGOU NO FIM DO TABULEIRO
                    for(int j = i % 4; j < i; j += 4) {
                        casa = ATAQUES_BISPO[pos_o - 26, j];
                        if(TemCoisa(casa / 12, casa % 12))
                            return false;
                    }
                    return true;
                }
            }
            return false;
        }
        public static bool CavaloAtaca(int pos_o, int pos_d) {
            for(int i = 0; i < 8; i++)
                if(pos_d == ATAQUES_CAVALO[pos_o - 26, i])
                    return true;

            return false;
        }
        public static bool TorreAtaca(int pos_o, int pos_d, int max) {
            int casa;
            max = 4 * max;

            // VERIFICA SE A "TORRE" SE MOVE DE pos_o PARA pos_d
            for(int i = 0; i < max; i++) {
                if(pos_d == ATAQUES_TORRE[pos_o - 26, i]) {
                    // VERIFICA SE HÁ ALGUMA PEÇA NO CAMINHO OU SE CHEGOU NO FIM DO TABULEIRO
                    for(int j = i % 4; j < i; j += 4) {
                        casa = ATAQUES_TORRE[pos_o - 26, j];
                        if(TemCoisa(casa / 12, casa % 12))
                            return false;
                    }
                    return true;
                }
            }

            return false;
        }


        public static bool Xeque(int jogador) {
            // VERIFICA SE O REI DE jogador ESTÁ EM XEQUE

            int x, y, oponente = 1 - jogador;

            // ATAQUE POR CAVALO
            for(int i = 0; i < 8; i++) {
                x = ATAQUES_CAVALO[rei[jogador] - 26, i] / 12;
                y = ATAQUES_CAVALO[rei[jogador] - 26, i] % 12;

                if(Tipo(x, y) == CAVALO && Cor(x, y) == oponente)
                        return true;
            }

            // ATAQUE POR TORRE, REI OU RAINHA (EM LINHA RETA)
            for(int i = 0; i < 4; i++) {
                for(int j = i; j < 28; j += 4) {
                    x = (ATAQUES_TORRE[rei[jogador] - 26, j] / 12);
                    y = (ATAQUES_TORRE[rei[jogador] - 26, j] % 12);
                    if(i == j && tabuleiro[x, y] == 60 + oponente)
                        return true;

                    switch(Tipo(x, y)) {
                        case TORRE:
                        case DAMA:
                            if(TorreAtaca((x * 12 + y), rei[jogador], 7) && Cor(x, y) == oponente)
                                    return true;
                            break;
                    }
                }
            }

            // ATAQUE POR BISPO, REI OU RAINHA (EM DIAGONAL)
            for(int i = 0; i < 4; i++)
                for(int j = i; j < 28; j += 4) {
                    x = (ATAQUES_BISPO[rei[jogador] - 26, j] / 12);
                    y = (ATAQUES_BISPO[rei[jogador] - 26, j] % 12);
                    if(i == j && tabuleiro[x, y] == 60 + oponente)
                        return true;

                    switch(Tipo(x, y)) {
                        case BISPO:
                        case DAMA:
                            if(BispoAtaca((x * 12 + y), rei[jogador], 7) && Cor(x, y) == oponente)
                                    return true;
                            break;
                    }
                }

            // ATAQUE POR PEÃO
            for(int i = -1; i < 2; i += 2) {
                x = (rei[jogador] / 12) + (2 * jogador - 1);
                y = (rei[jogador] % 12) + i;
                if(tabuleiro[x, y] == 10 + oponente)
                    return true;

            }

            return false;
        }
        public static bool ExisteMovimentosValidos(int jogador) {
            // VERIFICA SE O jogador PODE FAZER ALGUM L<NAME>

            int origem, destino;

            for(int lin = 2; lin < 10; lin++)
                for(int col = 2; col < 10; col++)
                    if(TemCoisa(lin, col) && (Cor(lin, col) == jogador)) {
                        origem = lin * 12 + col;

                        switch(Tipo(lin, col)) { 
                            case PEAO:
                                for(int i = 0; i < 3; i++) {
                                    destino = ATAQUES_PEAO[origem - 38, 3 * jogador + i];
                                    if(MoverPeao(origem, destino, jogador)) 
                                        return true;
                                }
                                if((lin == 2 && Cor(lin, col) == PRETA) || (lin == 9 && Cor(lin, col) == BRANCA)) {
                                    destino = lin * 12 + col + (24 * (2 * jogador - 1));
                                    if(MoverPeao(origem, destino, jogador))
                                        return true;
                                }
                                break;

                            case CAVALO:
                                for(int i = 0; i < 8; i++) {
                                    destino = ATAQUES_CAVALO[origem - 26, i];
                                    if(MoverCavalo(origem, destino, jogador))
                                        return true;
                                }
                                break;

                            case BISPO:
                            case DAMA:
                                for(int i = 0; i < 28; i++) {
                                    destino = ATAQUES_BISPO[origem - 26, i];
                                    if(MoverBispo(origem, destino, jogador))
                                        return true;
                                }
                                if(Tipo(lin, col) == DAMA) goto case TORRE;
                                break;

                            case TORRE:
                                for(int i = 0; i < 28; i++) {
                                    destino = ATAQUES_TORRE[origem - 26, i];
                                    if(MoverTorre(origem, destino, jogador))
                                        return true;
                                }
                                break;

                            case REI:
                                for(int i = -1; i < 2; i++) {
                                    for(int j = -1; j < 2; j++) {
                                        destino = (lin + i) * 12 + col + j;
                                        if(ÉValida(lin + i, col + j))
                                            if(MoverRei(origem, destino, jogador))
                                                return true;
                                    }
                                }
                                break;
                        }
                    }

            return false;
        }
        public static bool Ilegal(int pos_o, int pos_d, int jogador) {
            // EXECUTA O MOVIMENTO, VERIFICA SE O REI ESTARÁ EM XEQUE, DESFAZ A JOGADA
            // RETORNA VERDADEIRO SE O REI FICARÁ EM XEQUE
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            int aux = tabuleiro[lin_d, col_d];
            FacaMovimento(lin_o, col_o, lin_d, col_d, false);
            bool ret = Xeque(jogador);
            tabuleiro[lin_o, col_o] = tabuleiro[lin_d, col_d];
            tabuleiro[lin_d, col_d] = aux;

            return ret;
        }


        public static bool MoverPeao(int pos_o, int pos_d, int jogador) {

            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;
            bool valido = !Ilegal(pos_o, pos_d, jogador) && (ÉValida(lin_d, col_d));


            if(Tipo(lin_o, col_o) == PEAO)
                // VERIFICA SE ESTÁ NA PRIMEIRA FILA
                if((lin_o == (5 * (1 - jogador) + 3)) && (col_o == col_d)) {
                    int i = (2 * jogador - 1);
                    // UMA OU DUAS CASAS À FRENTE
                    for(int j = 1; j < 3; j++)
                        if((lin_o + i * j) == lin_d && j == 1)
                            return !TemCoisa(lin_d, col_d) && valido;
                        else if((lin_o + i * j) == lin_d && j == 2)
                            return !TemCoisa(lin_d, col_d) && valido && !TemCoisa(lin_d - i, col_d);
                } else {
                    if(PeaoAtaca(pos_o, pos_d, jogador))
                        if(col_o == col_d)
                            // MOVIMENTO SIMPLES(PARA FRENTE)
                            return (!TemCoisa(lin_d, col_d)) && valido;
                        else
                            // MOVIMENTO DE CAPTURA (NA DIAGONAL)
                            return ((Cor(lin_d, col_d) != jogador) && TemCoisa(lin_d, col_d)) && valido;
                }

            return false;
        }
        public static bool MoverBispo(int pos_o, int pos_d, int jogador) {
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            // VERIFICA SE É BISPO OU RAINHA
            if((Tipo(lin_o, col_o) == BISPO) || (Tipo(lin_o, col_o) == DAMA)) {
                // VALIDAÇÃO DO MOVIMENTO
                if(BispoAtaca(pos_o, pos_d, 7))
                    if((tabuleiro[lin_d, col_d] == CASA_VAZIA) || ((Cor(lin_d, col_d) != jogador) && (tabuleiro[lin_d, col_d] != CASA_NULA)))
                        return !Ilegal(pos_o, pos_d, jogador);
            }

            return false;
        }
        public static bool MoverCavalo(int pos_o, int pos_d, int jogador) {
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            // VERIFICA SE É CAVALO
            if(Tipo(lin_o, col_o) == CAVALO) {
                // VALIDAÇÃO DO MOVIMENTO
                if(CavaloAtaca(pos_o, pos_d))
                    if((tabuleiro[lin_d, col_d] == CASA_VAZIA) || ((Cor(lin_d, col_d) != jogador) && (tabuleiro[lin_d, col_d] != CASA_NULA)))
                        return !Ilegal(pos_o, pos_d, jogador);
            }

            return false;
        }
        public static bool MoverTorre(int pos_o, int pos_d, int jogador) {
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            // VERIFICA SE É TORRE OU RAINHA
            if((Tipo(lin_o, col_o) == TORRE) || (Tipo(lin_o, col_o) == DAMA)) {
                // VALIDAÇÃO DO MOVIMENTO
                if(TorreAtaca(pos_o, pos_d, 7))
                    if((tabuleiro[lin_d, col_d] == CASA_VAZIA) || ((Cor(lin_d, col_d) != jogador) && (tabuleiro[lin_d, col_d] != CASA_NULA)))
                        return !Ilegal(pos_o, pos_d, jogador);
            }

            return false;
        }
        public static bool MoverDama(int pos_o, int pos_d, int jogador) {
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            // VERIFICA SE É RAINHA
            if(Tipo(lin_o, col_o) == DAMA)
                if(((lin_o == lin_d) && (col_o != col_d)) || ((lin_o != lin_d) && (col_o == col_d)))
                    // MOVIMENTO EM LINHA RETA
                    return MoverTorre(pos_o, pos_d, jogador);
                else
                    //MOVIMENTO EM DIAGONAL
                    return MoverBispo(pos_o, pos_d, jogador);

            return false;
        }
        public static bool MoverRei(int pos_o, int pos_d, int jogador) {
            int lin_o = pos_o / 12;
            int col_o = pos_o % 12;

            int lin_d = pos_d / 12;
            int col_d = pos_d % 12;

            if(!ÉValida(lin_d, col_d)) return false;
            bool valido = false;

            // VERIFICA SE É REI
            if(Tipo(lin_o, col_o) == REI)
                // PODE SE MOVIMENTAR
                if(((lin_o == lin_d) && (col_o != col_d)) || ((lin_o != lin_d) && (col_o == col_d)))
                    // - EM LINHA RETA?
                    valido = TorreAtaca(pos_o, pos_d, 1);
                else
                    // - EM DIAGONAL?
                    valido = BispoAtaca(pos_o, pos_d, 1);


            if(valido) {
                // VERIFICA SE O REI FICARÁ EM XEQUE
                rei[jogador] = pos_d;
                valido = !Ilegal(pos_o, pos_d, jogador);
                valido &= !TemCoisa(lin_d, col_d) || ((Cor(lin_d, col_d) != jogador) && (ÉValida(lin_d, col_d)));
                rei[jogador] = pos_o;
                return valido;
            }

            return false;
        }
    }
}<file_sep>﻿using System.Resources;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("JasChess")]
[assembly: AssemblyDescription("JasChess é um jogo de xadrez didático desenvolvido durante um trabalho de Iniciação Científica, com a lógica de movimentação baseada em pré-indicações para onde uma peça poderia se mover a partir de tal posição. A Inteligência Artificial presente está baseada na Busca em Profundidade, integrando os algoritmos Minimax e Poda Alfa-Beta com implementação na linguagem Microsoft Visual C#, sendo desenvolvida na versão 4.5.2 do Microsoft .NET Framework. {0}{0}Seus algoritmos foram inteiramente escritos por Josué Fonseca, sob a orientação do Me. <NAME>, com ajuda intelectual de <NAME> e do Dr. <NAME>. A interface gráfica foi programada pelo autor, sendo as peças desenhadas por <NAME>.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("IFSP - Campus Cubatão")]
[assembly: AssemblyProduct("JasChess")]
[assembly: AssemblyCopyright("© 2018 Josué Fonseca")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("ea557216-784e-444b-8e60-7d2f34072d91")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("2.1.1.0")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: NeutralResourcesLanguage("pt-BR")]

<file_sep>﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static JasChess.Pecas;
using static JasChess.Movimentos;
using static JasChess.Tabuleiro;

namespace JasChess {
    class Heuristica {
        public static int Avaliacao() {
            int pontuacao = 0;

            for(int lin = 2; lin < 10; lin++)
                for(int col = 2; col < 10; col++)
                    if(TemCoisa(lin, col))
                        pontuacao += ValorDe(tabuleiro[lin, col], lin);


            return pontuacao;
        }

        private static int ValorDe(int peca, int lin) {
            int valor = 0;
            switch(Tipo(peca)) {
                case PEAO:
                    valor = ((Cor(peca) == PRETA && lin >= 5) || (Cor(peca) == BRANCA && lin <= 6)) ? 125 : 100;
                    valor = ((Cor(peca) == PRETA && lin == 9) || (Cor(peca) == BRANCA && lin == 2)) ? 500 : valor;
                    valor += int.Parse(Math.Pow(2, (Cor(peca) == PRETA ? lin - 2 : 9 - lin)).ToString());
                    break;
                case BISPO:
                case CAVALO:
                    valor = TemPar(peca) ? 325 : 300;
                    break;
                case TORRE:
                    valor = TemPar(peca) ? 425 : 400;
                    break;
                case DAMA:
                    valor = TemPar(peca) ? 900 : 500;
                    break;
                case REI:
                    valor = Xeque(Cor(peca)) ? -2000 : 0;
                    break;
            }

            return Cor(peca) == BRANCA ? -valor : valor;
        }
    }
}<file_sep>﻿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 JasChess {
    public partial class Promocao : Form {
        public Promocao() {
            InitializeComponent();
        }

        private int _nova;

        public int nova {
            get { return _nova; }
            set { _nova = value; }
        }

        private void btn_Click(object sender, EventArgs e) {
            Button b = sender as Button;
            nova = b.TabIndex;
            this.Close();
        }
    }
}<file_sep>[LocalizedFileNames]
tada.wav=@%windir%\system32\mmres.dll,-710
<file_sep>﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static JasChess.Program;
using static JasChess.Pecas;

namespace JasChess {
    class Tabuleiro {
        public const int CASA_VAZIA = 0;
        public const int CASA_NULA = -1;

        public static GUI gui = new GUI();

        public static int[,] tabuleiro = new int[12, 12];
        public static PictureBox[] casa = new PictureBox[64];

        public static bool TemCoisa(int lin, int col) {
            return tabuleiro[lin, col] != CASA_VAZIA;
        }
        public static bool ÉValida(int lin, int col) {
            return tabuleiro[lin, col] != CASA_NULA;
        }


        public static void IniciarTabuleiro() {
           
            int i = 0;

            foreach(Control c in gui.Controls) {
                if(c is PictureBox) {
                   casa[i] = c as PictureBox;
                   casa[i].Enabled = true;
                   casa[i++].BackgroundImage = null;
                }
            }
            ResetCor();

            // MOLDURA
            for(int lin = 0; lin < 2; lin++)
                for(int col = 0; col < 12; col++)
                    tabuleiro[lin, col] = CASA_NULA;
            //--------

            // PEÇAS PRETAS (COMPUTADOR)
            {
                tabuleiro[2, 0] = CASA_NULA;
                tabuleiro[2, 1] = CASA_NULA;
                tabuleiro[2, 2] = TORRE_PRETA;      casa[0].BackgroundImage = peca[PRETA, TORRE - 1];
                tabuleiro[2, 3] = CAVALO_PRETO;     casa[1].BackgroundImage = peca[PRETA, CAVALO - 1];
                tabuleiro[2, 4] = BISPO_PRETO;      casa[2].BackgroundImage = peca[PRETA, BISPO - 1];
                tabuleiro[2, 5] = DAMA_PRETA;       casa[3].BackgroundImage = peca[PRETA, DAMA - 1];
                tabuleiro[2, 6] = REI_PRETO;        casa[4].BackgroundImage = peca[PRETA, REI - 1];
                tabuleiro[2, 7] = BISPO_PRETO;      casa[5].BackgroundImage = peca[PRETA, BISPO - 1];
                tabuleiro[2, 8] = CAVALO_PRETO;     casa[6].BackgroundImage = peca[PRETA, CAVALO - 1];
                tabuleiro[2, 9] = TORRE_PRETA;      casa[7].BackgroundImage = peca[PRETA, TORRE - 1];
                tabuleiro[2, 10] = CASA_NULA;
                tabuleiro[2, 11] = CASA_NULA;

                tabuleiro[3, 0] = CASA_NULA;
                tabuleiro[3, 1] = CASA_NULA;
                for(int col = 2; col < 10; tabuleiro[3, col] = PEAO_PRETO, casa[col + 6].BackgroundImage = peca[PRETA, PEAO - 1], col++) ;
                tabuleiro[3, 10] = CASA_NULA;
                tabuleiro[3, 11] = CASA_NULA;

                rei[1] = 30;
            }
            //--------

            // MEIO DO TABULEIRO
            for(int lin = 4; lin < 8; lin++) {
                for(int col = 0; col < 2; tabuleiro[lin, col] = CASA_NULA, col++) ;
                for(int col = 2; col < 10; tabuleiro[lin, col] = CASA_VAZIA, col++) ;
                for(int col = 10; col < 12; tabuleiro[lin, col] = CASA_NULA, col++) ; 
            }
            //--------

            // <NAME> (<NAME>)
            {
                tabuleiro[8, 0] = CASA_NULA;
                tabuleiro[8, 1] = CASA_NULA;
                for(int col = 2; col < 10; tabuleiro[8, col] = PEAO_BRANCO, casa[col + 46].BackgroundImage = peca[BRANCA, PEAO - 1], col++) ;
                tabuleiro[8, 10] = CASA_NULA;
                tabuleiro[8, 11] = CASA_NULA;

                tabuleiro[9, 0] = CASA_NULA;
                tabuleiro[9, 1] = CASA_NULA;
                tabuleiro[9, 2] = TORRE_BRANCA;     casa[56].BackgroundImage = peca[BRANCA, TORRE - 1];
                tabuleiro[9, 3] = CAVALO_BRANCO;    casa[57].BackgroundImage = peca[BRANCA, CAVALO - 1];
                tabuleiro[9, 4] = BISPO_BRANCO;     casa[58].BackgroundImage = peca[BRANCA, BISPO - 1];
                tabuleiro[9, 5] = DAMA_BRANCA;      casa[59].BackgroundImage = peca[BRANCA, DAMA - 1];
                tabuleiro[9, 6] = REI_BRANCO;       casa[60].BackgroundImage = peca[BRANCA, REI - 1];
                tabuleiro[9, 7] = BISPO_BRANCO;     casa[61].BackgroundImage = peca[BRANCA, BISPO - 1];
                tabuleiro[9, 8] = CAVALO_BRANCO;    casa[62].BackgroundImage = peca[BRANCA, CAVALO - 1];
                tabuleiro[9, 9] = TORRE_BRANCA;     casa[63].BackgroundImage = peca[BRANCA, TORRE - 1];
                tabuleiro[9, 10] = CASA_NULA; 
                tabuleiro[9, 11] = CASA_NULA; 
                rei[0] = 114;
            }
            
            // MOLDURA
            for(int lin = 10; lin < 12; lin++)
                for(int col = 0; col < 12; col++)
                    tabuleiro[lin, col] = CASA_NULA;
            //--------
        }

        public static void ResetCor() {
            for(int i = 0; i < 64; i++) 
                casa[i].BackColor = (i % 8 % 2 == 1) && (i / 8 % 2 == 0) ||
                                    (i % 8 % 2 == 0) && (i / 8 % 2 == 1)  ?
                                    System.Drawing.Color.SaddleBrown : System.Drawing.Color.SandyBrown;
            
        }
    }
}