public void CriarPosicaoValida(Point point)
{
if (PosicaoDentroDoTabuleiro(point))
{
PecaDama vPeca = new PecaDama();
vPeca.Tipo = TipoPeca.PosicaoValida;
vPeca.Jogador = Jogador.GM;
vPeca.Pos = point;
PecasTabuleiro.Add(vPeca);
ListaLugaresValidos.Add(vPeca);
}
}
public void ExibirPossibilidadeMovimento(PecaDama peca)
{
List<PecaDama> pecasCandidatasEliminacao = PecasCandidatasEliminacao(peca);
//movimento de eliminacao
if (pecasCandidatasEliminacao.Any())
{
ExibirMovimentoAtaque(peca, pecasCandidatasEliminacao);
}
else//movimento normal
{
ExibirMovimento(peca);
}
}
public void retorna_pecas_vizinhas_inimigas_a_partir_da_peca ()
{
this.CriarTabuleiroFake();
PecaDama pecaTeste = new PecaDama { Pos = new Point(6, 6), Tipo = TipoPeca.Peao, Jogador = Jogador.Agil };
RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);
List<PecaDama> pecasInimigas = regraPeao.RetornaPecasVizinhasInimigas(pecaTeste);
List<PecaDama> pecasInimigasCandidatas = regraPeao.RetornaPecasComPossibilidadeEliminacao(pecaTeste, pecasInimigas);
regraPeao.ExibirMovimentoAtaque(pecaTeste, pecasInimigasCandidatas);
}
public void ExibirMovimentoAtaque(PecaDama peca, List<PecaDama> pecasCandidatasEliminacao)
{
foreach (var pecaInimigaCandidata in pecasCandidatasEliminacao)
{
//nordeste
if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
{
CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X + 2, peca.Pos.Y + 2));
}
//sudeste
if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
{
CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X + 2, peca.Pos.Y - 2));
}
//noroeste
if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
{
CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X - 2, peca.Pos.Y + 2));
}
//sudoeste
if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
{
CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X - 2, peca.Pos.Y - 2));
}
}
}
private void MovimentarPecaIA(PecaDama peca)
{
_pecaSelecionada.Pos = peca.Pos;
}
private void MovimentarPeca(PecaDama peca)
{
_pecaSelecionada.Pos = peca.Pos;
_gridPecaSelecionada.Background = null;
}
private bool TurnoCorreto(PecaDama peca)
{
if (peca.Jogador == Jogador.GM)
{
return true;
}
if (_turnoTeste.ObterTurno() != peca.Jogador)
{
return false;
}
return true;
}
public PecaDama VirarDama(PecaDama peca)
{
peca.Tipo = TipoPeca.Dama;
//var rotateAnimation = new DoubleAnimation(0, 360, TimeSpan.FromSeconds(1));
//var rt = (RotateTransform)TabuleiroDama.RenderTransform;
//rt.CenterX = 0.5;
//rt.CenterY = 0.5;
//rt.BeginAnimation(RotateTransform.AngleProperty, rotateAnimation);
return peca;
}
private void CriarPossibilidadeMovimento(PecaDama peca, Grid grid)
{
RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);
RegraDama regraDama = new RegraDama(_pecasTabuleiro, _listaLugaresValidos);
switch (peca.Tipo)
{
case TipoPeca.Peao:
regraPeao.ExibirPossibilidadeMovimento(peca);
break;
case TipoPeca.Dama:
regraDama.ExibirPossibilidadeMovimento(peca);
break;
}
}
private void PecaClickIA(PecaDama peca)
{
if (!TurnoCorreto(peca))
return;
if (EstaMovimentando(peca))
{
bool atacou = false;
if (EstaAtacando(peca))
{
RemoverPecaInimiga(peca.PecaAEliminar);
atacou = true;
}
MovimentarPecaIA(peca);
LimparLugaresValidos();
//verificando se ainda tem possibilidade de ataque
if (atacou)
{
List<PecaDama> pecasCandidatasEliminacao = ObterPecasCandidatasEliminacao(_pecaSelecionada);
if (pecasCandidatasEliminacao.Count > 0)
{
PecaClickIA(_pecaSelecionada);
return;
}
NumeroJogadasRestantes.Content = 20;
}
else
{
NumeroJogadasRestantes.Content = Convert.ToInt32(NumeroJogadasRestantes.Content) - 1;
}
//-----------------------------
RetirarDoTabuleiroPecasMortas();
VerificarTransformacaoDama(_pecaSelecionada);
TerminarJogadaTurnoAtual();
SomarNumeroDeJogadas();
ContarTempoJogada();
VerificarFimDePartida();
}
else
{
if (!PecaAtacanteEJogoEmAtaque(peca))
{
return;
}
SelecionarPeca(peca);
LimparPinturaAreaSelecinada();
//PintarAreaSelecinada(grid);
LimparLugaresValidos();
CriarPossibilidadeMovimento(_pecaSelecionada, null);
}
}
private void ExibirMovimentoParaFrente(PecaDama peca)
{
double xValido;
double yValido;
if (peca.Jogador == Jogador.Agil)
{
yValido = peca.Pos.Y + 1;
}
else
{
yValido = peca.Pos.Y - 1;
}
xValido = peca.Pos.X - 1;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
xValido = peca.Pos.X + 1;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
}
public List<PecaDama> PecasCandidatasEliminacao(PecaDama peca)
{
List<PecaDama> pecasVizinhasInimigas = RetornaPecasVizinhasInimigas(peca);
List<PecaDama> pecasCandidatasEliminacao = RetornaPecasComPossibilidadeEliminacao(peca, pecasVizinhasInimigas);
return pecasCandidatasEliminacao;
}
public List<PecaDama> RetornaPecasComPossibilidadeEliminacao(PecaDama peca, List<PecaDama> pecasVizinhasInimigas)
{
List<PecaDama> pecasInimigasCandidatas = new List<PecaDama>();
if (pecasVizinhasInimigas.Count == 0)
return pecasInimigasCandidatas;
IEnumerable<PecaDama> pecas;
foreach (var pecaInimigaCandidata in pecasVizinhasInimigas)
{
//nordeste
if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 2 && x.Pos.Y == peca.Pos.Y + 2).ToList();
if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X + 2, peca.Pos.Y + 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
if (!pecaInimigaCandidata.IsDead)
pecasInimigasCandidatas.Add(pecaInimigaCandidata);
}
//sudeste
if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 2 && x.Pos.Y == peca.Pos.Y - 2).ToList();
if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X + 2, peca.Pos.Y - 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
if (!pecaInimigaCandidata.IsDead)
pecasInimigasCandidatas.Add(pecaInimigaCandidata);
}
//noroeste
if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 2 && x.Pos.Y == peca.Pos.Y + 2).ToList();
if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X - 2, peca.Pos.Y + 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
if (!pecaInimigaCandidata.IsDead)
pecasInimigasCandidatas.Add(pecaInimigaCandidata);
}
//sudoeste
if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
&& peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 2 && x.Pos.Y == peca.Pos.Y - 2).ToList();
if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X - 2, peca.Pos.Y - 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
if (!pecaInimigaCandidata.IsDead)
pecasInimigasCandidatas.Add(pecaInimigaCandidata);
}
}
return pecasInimigasCandidatas;
}
public List<PecaDama> RetornaPecasVizinhasInimigas(PecaDama peca)
{
List<PecaDama> pecasVizinhasInimigas = new List<PecaDama>();
IEnumerable<PecaDama> pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 1 && x.Pos.Y == peca.Pos.Y + 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
pecasVizinhasInimigas.Add(pecas.First());
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 1 && x.Pos.Y == peca.Pos.Y - 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
pecasVizinhasInimigas.Add(pecas.First());
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 1 && x.Pos.Y == peca.Pos.Y + 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
pecasVizinhasInimigas.Add(pecas.First());
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 1 && x.Pos.Y == peca.Pos.Y - 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
pecasVizinhasInimigas.Add(pecas.First());
return pecasVizinhasInimigas;
}
private void ExibirMovimento(PecaDama peca)
{
double xValido;
double yValido;
//nordeste
for (int i = 1; i < 8; i++)
{
xValido = peca.Pos.X + i;
yValido = peca.Pos.Y + i;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
else
{
break;
}
}
//noroeste
for (int i = 1; i < 8; i++)
{
xValido = peca.Pos.X - i;
yValido = peca.Pos.Y + i;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
else
{
break;
}
}
//sudeste
for (int i = 1; i < 8; i++)
{
xValido = peca.Pos.X + i;
yValido = peca.Pos.Y - i;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
else
{
break;
}
}
//sudoeste
for (int i = 1; i < 8; i++)
{
xValido = peca.Pos.X - i;
yValido = peca.Pos.Y - i;
if (!TemPeca(peca, xValido, yValido))
{
CriarPosicaoValida(new Point(xValido, yValido));
}
else
{
break;
}
}
}
private void SelecionarPeca(PecaDama peca)
{
_pecaSelecionada = peca;
}
public bool EstaMovimentando(PecaDama peca)
{
if (peca.Tipo == TipoPeca.PosicaoValida)
{
return true;
}
return false;
}
private List<PecaDama> ObterPecasCandidatasEliminacao(PecaDama peca)
{
List<PecaDama> pecas = new List<PecaDama>();
RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);
RegraDama regraDama = new RegraDama(_pecasTabuleiro, _listaLugaresValidos);
switch (peca.Tipo)
{
case TipoPeca.Peao:
pecas = regraPeao.PecasCandidatasEliminacao(peca);
break;
case TipoPeca.Dama:
pecas = regraDama.PecasCandidatasEliminacao(peca);
break;
}
return pecas;
}
private PecaDama VerificarTransformacaoDama(PecaDama pecaSelecionada)
{
if (pecaSelecionada.Jogador == Jogador.Classico && pecaSelecionada.Pos.Y.Equals(0) && pecaSelecionada.Tipo != TipoPeca.Dama)
{
pecaSelecionada = VirarDama(pecaSelecionada);
}
if (pecaSelecionada.Jogador == Jogador.Agil && pecaSelecionada.Pos.Y.Equals(7) && pecaSelecionada.Tipo != TipoPeca.Dama)
{
pecaSelecionada = VirarDama(pecaSelecionada);
}
return pecaSelecionada;
}
private bool PecaAtacanteEJogoEmAtaque(PecaDama peca)
{
List<PecaDama> pecasEmAtaque = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos).PecasEmAtaque(peca.Jogador);
if (pecasEmAtaque.Count > 0 && !pecasEmAtaque.Exists(x => x == peca))
{
return false;
}
return true;
}
private void RemoverPecaInimiga(PecaDama pecaAEliminar)
{
pecaAEliminar.IsDead = true;
}
private bool EstaAtacando(PecaDama peca)
{
if (peca.PecaAEliminar != null)
{
return true;
}
return false;
}
protected bool TemPeca(PecaDama peca, double posicaoXaValidar, double posicaoYaValidar)
{
bool temPeca =
PecasTabuleiro.Any(item => item.Pos.Equals(new Point(posicaoXaValidar, posicaoYaValidar)));
return temPeca;
}
private List<PecaDama> RetornaPecasVizinhasInimigas(PecaDama peca)
{
List<PecaDama> pecasVizinhasInimigas = new List<PecaDama>();
IEnumerable<PecaDama> pecas;
//nordeste
for (int i = 1; i < 8; i++)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + i && x.Pos.Y == peca.Pos.Y + i
&& x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
{
pecasVizinhasInimigas.Add(pecas.First());
break;
}
}
//noroeste
for (int i = 1; i < 8; i++)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - i && x.Pos.Y == peca.Pos.Y + i
&& x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
{
pecasVizinhasInimigas.Add(pecas.First());
break;
}
}
//sudeste
for (int i = 1; i < 8; i++)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + i
&& x.Pos.Y == peca.Pos.Y - i && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
{
pecasVizinhasInimigas.Add(pecas.First());
break;
}
}
//sudoeste
for (int i = 1; i < 8; i++)
{
pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - i && x.Pos.Y == peca.Pos.Y - i
&& x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
if (pecas.Any())
{
pecasVizinhasInimigas.Add(pecas.First());
break;
}
}
return pecasVizinhasInimigas;
}