//funcao de avaliacao que considera a quantidade de pecas e o lugar onde estao
//cada peca tem um valor associado peao, peao perto de virar dama e dama
//cada posicao do tabuleiro tem um valor associado
public static int evalMaterial(Estado estado)
{
int i, j, peca, valorPeca, valorPos, sum1 = 0, sum2 = 0;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
peca = estado.tabuleiro[i, j];
valorPos = valoracao[i, j];
if (Tipos.isDama(peca))
{
valorPeca = 10;
}
else if (((i == 1) && Tipos.isJogador1(peca)) || ((i == 6) && Tipos.isJogador2(peca)))
{
valorPeca = 7;
}
else
{
valorPeca = 5;
}
if (Tipos.isJogador1(peca))
{
sum1 += valorPeca * valorPos;
}
else if (Tipos.isJogador2(peca))
{
sum2 += valorPeca * valorPos;
}
}
}
if (estado.jogadorAtual == 1)
{
return(sum1 - sum2);
}
else
{
return(sum2 - sum1);
}
}
public static Estado result(Estado antigo, Jogada acao)
{
Estado novo = new Estado(antigo.tabuleiro, antigo.jogadorAtual, antigo.ultimaJogada, antigo.contaJogadas);
novo.jogadorAtual = novo.jogadorAtual == 1 ? 2 : 1;
novo.ultimaJogada = acao;
int size = acao.movimentos.Count;
int pecaSendoMovimentada = antigo.tabuleiro[acao.posInicial[0], acao.posInicial[1]];
novo.tabuleiro[acao.ultimoMovimento()[0], acao.ultimoMovimento()[1]] = novo.tabuleiro[acao.posInicial[0], acao.posInicial[1]];
novo.tabuleiro[acao.posInicial[0], acao.posInicial[1]] = Tipos.vazio;
foreach (int[] peca in acao.pecasComidas)
{
novo.tabuleiro[peca[0], peca[1]] = Tipos.vazio;
}
// if (acao.virouDama)
// {
// int jogadorAtual = Tipos.pegaJogador(novo.tabuleiro[acao.ultimoMovimento()[0], acao.ultimoMovimento()[1]]);
// novo.tabuleiro[acao.ultimoMovimento()[0], acao.ultimoMovimento()[1]] = Tipos.getPecaJogadorX(Tipos.dama, jogadorAtual);
// }
if (acao.pecasComidas.Count == 0 && Tipos.isDama(pecaSendoMovimentada))
{
novo.jogadasCondicaoEmpate++;
}
else
{
novo.jogadasCondicaoEmpate = 0;
}
novo.contaJogadas++;
return(novo);
}
public int verificaVitoriaEmpate(Estado estado)
{
// 0: não está em vitória nem em empate
// 1: vitória do jogador 1
// 2: vitória do jogador 2
// 3: empate
int resultado = 0;
int qtdPecasJogador1, qtdPecasjogador2, qtdDamasJogador1, qtdDamasJogador2, qtdPecasNormaisJogador1, qtdPecasNormaisJogador2;
qtdPecasJogador1 = qtdPecasjogador2 = qtdDamasJogador1 = qtdDamasJogador2 = qtdPecasNormaisJogador1 = qtdPecasNormaisJogador2 = 0;
foreach (int peca in estado.tabuleiro)
{
if (Tipos.isJogador1(peca))
{
if (Tipos.isDama(peca))
{
qtdDamasJogador1++;
}
qtdPecasJogador1++;
}
else if (Tipos.isJogador2(peca))
{
if (Tipos.isDama(peca))
{
qtdDamasJogador2++;
}
qtdPecasjogador2++;
}
}
if (qtdPecasJogador1 == 0)
{
mudaTexto("JOGADOR 2 GANHOU!!");
return(2); //jogador 1 sem peças, vitoria do jogador 2
}
else if (qtdPecasjogador2 == 0)
{
mudaTexto("JOGADOR 1 GANHOU!!");
return(1);//jogador 2 sem peças, vitoria do jogador 1
}
qtdPecasNormaisJogador1 = qtdPecasJogador1 - qtdDamasJogador1;
qtdPecasNormaisJogador2 = qtdPecasjogador2 - qtdDamasJogador2;
int qtdPecasNormais = qtdPecasNormaisJogador1 + qtdPecasNormaisJogador2;
// 2 damas contra 2 damas;
// 2 damas contra uma;
// 2 damas contra uma dama e uma pedra;
// uma dama contra uma dama e uma dama contra uma dama e uma pedra, são declarados empatados após 5 lances de cada jogador.
if (estado.jogadasCondicaoEmpate >= 20 ||
((qtdDamasJogador1 == 2 && qtdDamasJogador2 == 2) && qtdPecasNormais == 0) ||
((qtdDamasJogador1 == 2 && qtdDamasJogador2 == 1) && qtdPecasNormais == 0) ||
((qtdDamasJogador1 == 1 && qtdDamasJogador2 == 2) && qtdPecasNormais == 0) ||
((qtdDamasJogador1 == 2 && qtdDamasJogador2 == 1) && qtdPecasNormaisJogador2 == 1) ||
((qtdDamasJogador1 == 1 && qtdDamasJogador2 == 2) && qtdPecasNormaisJogador1 == 1) ||
((qtdDamasJogador1 == 1 && qtdDamasJogador2 == 1 && qtdPecasNormais == 0) && estado.jogadasCondicaoEmpate >= 5) ||
((qtdDamasJogador1 == 1 && qtdDamasJogador2 == 1 && qtdPecasNormais == 1) && estado.jogadasCondicaoEmpate >= 5))
{
mudaTexto("EMPATE!!");
return(3);
}
Debug.Log("Qtd Pecas Jogador 1: " + qtdPecasJogador1 + " Qtd Pecas Jogador 2: " + qtdPecasjogador2);
return(resultado);
}
private void processaClique()
{
if (this.jogo != 0)
{
return;
}
if (Input.GetMouseButtonUp(0) && !clickFlag)
{
clickFlag = true;
if (!GameController.instance.getTurnoJogador())
{
return; //turno IA
}
GameObject objeto_resposta = checaClique();
if (objeto_resposta != null)
{
if (isPeca(objeto_resposta))
{
seleciona_pedra(objeto_resposta);
mostraHighlight(objeto_resposta);
}
else if (isPosicao(objeto_resposta) && this.pedraSelecionada)
{
Jogada jogadaASerExecutada = null;
Peca pecaSelecionada = pedraSelecionada.GetComponent <Peca>();
List <int[]> posicoesPecasJogadorAtual = GameController.instance.posicoes_jogador_atual();
// otimizar para chamar a máquina de regras uma vez apenas quando mudar o turno, pegando todos os movimentos possiveis do jogador atual
List <List <Jogada> > jogadas = MaquinaDeRegras.PossiveisMovimentosUmJogador(
GameController.instance.estadoAtual.tabuleiro,
posicoesPecasJogadorAtual);
foreach (List <Jogada> lista in jogadas)
{
// verifica se lista sendo avaliada neste momento é a lista de jogadas da peça que eu quero movimentar agora
if (lista[0].posInicial[0] == pecaSelecionada.posicao.lin &&
lista[0].posInicial[1] == pecaSelecionada.posicao.col)
{
// se for a lista de jogadas da peça que eu quero mover tenho que achar a Jogada que tem como ultimo movimento
// a posicao que quero mover a peca
int linFinalAtual, colFinalAtual, linFinalDestino, colFinalDestino;
foreach (Jogada jogada in lista) // as jogadas para encontrar qual é a jogada que quero fazer
{
linFinalAtual = jogada.ultimoMovimento()[0];
colFinalAtual = jogada.ultimoMovimento()[1];
Posicao posicaoDestino = objeto_resposta.GetComponent <Posicao>();
linFinalDestino = posicaoDestino.lin;
colFinalDestino = posicaoDestino.col;
if (linFinalAtual == linFinalDestino && colFinalAtual == colFinalDestino)
// Encontrando a jogada procurada temos que a jogada que queríamos fazer é válida, portando mudamos a variavel jogadaASerExecutada
{
jogadaASerExecutada = jogada;
if (jogadaASerExecutada.pecasComidas.Count == 0 && Tipos.isDama(pecaSelecionada.tipo))
{
GameController.instance.estadoAtual.jogadasCondicaoEmpate++;
}
else
{
GameController.instance.estadoAtual.jogadasCondicaoEmpate = 0;
}
}
}
}
}
if (jogadaASerExecutada != null) //se a jogada for valida posso movimentar, alterar matriz, passar turno e descelecionar e atualizar o estadoAtual
{
// executar movimento visual
if (jogadaASerExecutada.pecasComidas.Count == 0)
{
movimenta(this.pedraSelecionada, objeto_resposta);
}
else
{
comePecasGraphical(this.pedraSelecionada, jogadaASerExecutada);
}
if (jogadaASerExecutada.virouDama)
{
if (GameController.instance.estadoAtual.getJogadorAtual() == 1)
{
pedraSelecionada.GetComponent <SpriteRenderer>().sprite = damaPreta;
}
else
{
pedraSelecionada.GetComponent <SpriteRenderer>().sprite = damaVermelha;
}
}
descelecionarPedraAtual();
GameController.instance.estadoAtual.tabuleiro = alteraMatriz(GameController.instance.estadoAtual.tabuleiro, jogadaASerExecutada);
GameController.instance.estadoAtual.ultimaJogada = jogadaASerExecutada; // VERIFICAR
GameController.instance.passarTurno();
}
else
{
marcaXVermelhoNoTransform(objeto_resposta.transform);
}
}
}
else
{
descelecionarPedraAtual();
}
clickFlag = false;
}
}
