Boas

Tenho um trabalho para fazer em C++ que consiste em fazer um jogo de Tabuleiro(matriz) de 1 vs 1. Verificar se o jogador joga segundo as regras, e dizer quando um dos jogadores ganhou.

Até agora o que me mais agradou foi este:

http://img155.imageshack.us/img155/2420/hexgameoverra6.png

O objectivo do jogo é fazer um caminho de um lado ao outro do tabuleiro, da cor correspondente. Neste caso o vermelho ganhou.

Eu gostava é que alguem me expicasse como é que eu posso verificar que um jogador ganhou. Como faço para ver se está uma sucessão de peças de um lado ao outro do tabuleiro. É facil, ou mais vale mudar de jogo??

Também tenho outros jogos à escolhe, como 4 em linha, damas, xadrez, etc...

Apenas escolhi este para ser um bocado diferente do normal....

Cumps ;)

Olá!

Isso de ver se um jogador ganhou vai depender da maneira como pegares no exercício.

Já tens alguma coisa pensada para guardar a informação do tabuleiro?

Cumps

Parece-me uma ideia interessante :)

Quanto à verificação de uma sucessão de peças, basta pensares num algoritmo decente.
Se fosse eu, começava com qualquer coisa assim (nota que isto nem sequer tá escrito em C++, é só para descrever o algoritmo):
//seja M uma matriz (n+1)*(n+1) = tabuleiro do jogo
//seja 0=célula branca; 1=célula azul; 2=célula vermelha
int M[n,n]
int celulasTentadas[n,n]

bool VerificarSucessao(int corCelula)
{
celulasTentadas.Clear() //nem sei se isto existe, o objectivo é pôr tudo a 0 neste array
if corCelula = 1
return ProcurarSucessao(0, 1, 1) //supondo que a célula (0,1) é azul
else
return ProcurarSucessao(1, 0, 2) //supondo que a célula (1,0) é vermelha
endif
}

bool ProcurarSucessao(int i, int j, int corCelula)
{
if celulasTentadas[i, j] = 1 or M[i,j] != corCelula
return false
else if (i = n and corCelula = 1) or (j = n and corCelula = 2)
return true
else
celulasTentadas[i, j] = 1
endif
return ( ProcurarSucessao(i-1,j-1,corCelula) or ProcurarSucessao(i-1,j,corCelula)
or ProcurarSucessao(i,j-1,corCelula) or ProcurarSucessao(i,j+1,corCelula)
or ProcurarSucessao(i+1,j,corCelula) or ProcurarSucessao(i+1,j+1,corCelula) )
}Deve ter uns erros, mas espero que percebas e que seja útil :P

Basicamente é um flood fill (http://en.wikipedia.org/wiki/Flood_fill). Tens é que introduzir um caso especial para quando se chegar a uma das casas "do outro lado" dizer que sim, ganhou.

Spiderman deves estar na Feup no curso de elctrotecnica e computadores.È que eu tambem tenho que fazer um jogo em c++ durante este semestre.lol.Eu escolhi o reversi.

Em vez de andar sempre a fazer um flood fill podias ter um campo em cada peça aceca da extremidade a que esta está ligada.

Quando duas peças adjacentes estiverem ligadas a extremidades diferentes acaba o jogo.

Spiderman e el mono já somos 3. FEUP electro ftw:victory:
Eu fiquei com as damas.
E tinha encontrado um site porreiro com montes de códigos fonte, em c++.
Claro que não é pegar naquilo e já está mas sempre dá um boa ajuda. O meu profe é o rossetti e até nos disse para ver uns já feitos e o código.
Já algum de vocês falou com o monitor que vos calhou?

Ya, FEUP Rula... :016:

Calhou-me mesmo este jogo. É começar a fazer, e deixar esta parte mais dificil para o fim....

:x2:

Que outros projectos vocês têm para além desse? Se calhar existiriam opções mais favoráveis.

Alguém já tem alguma coisa feita no jogo ' Damas '?

Alguém me pode dar umas luzes? :|

Quanto aos jogos, eram os seguintes:



Xadrez (http://en.wikipedia.org/wiki/Chess)
Damas (http://en.wikipedia.org/wiki/Checkers)
Otelo (Reversi) (http://en.wikipedia.org/wiki/Reversi)
4 em Linha (Connect four) (http://en.wikipedia.org/wiki/Connect_4)
Ataxx (http://en.wikipedia.org/wiki/Ataxx)
Quarto (da Gigamic) (http://en.wikipedia.org/wiki/Quarto_%28board_game%29)
Quixo (da Gigamic)
Quits (da Gigamic)
Fanorana (http://www.msoworld.com/mindzine/news/classic/fanorona.html)
Alquerque (http://en.wikipedia.org/wiki/Alquerque)
Tablut (http://en.wikipedia.org/wiki/Tablut)
Amazons (http://en.wikipedia.org/wiki/Game_of_the_Amazons)
Lines of Action (http://en.wikipedia.org/wiki/Lines_of_action)
Jungle Game (Jogo da Selva) (http://en.wikipedia.org/wiki/Jungle_%28board_game%29)
Seega (http://www.di.fc.ul.pt/%7Ejpn/gv/seega.htm)
Mancala (Bantumi) (http://en.wikipedia.org/wiki/Bantumi)
Damas Chinesas (2 Jogadores) (http://en.wikipedia.org/wiki/Chinese_checkers)
Halma (2 Jogadores) (http://en.wikipedia.org/wiki/Halma)
Abalone (http://en.wikipedia.org/wiki/Abalone_%28board_game%29)
Hex (http://en.wikipedia.org/wiki/Hex_%28board_game%29)

Para o jogo das damas podes fazer uma matriz (array bidimensional). Depois crias uma função para verificar se determinado movimento é valido, e quando estiveres no jogo em si, ao tentares fazer um determinado movimento chamas essa função para verificar se é valido. Crias também uma função para remover peças (no caso de a peça ser "comida"), crias outra função para teres damas. Bem, neste caso o mais facil será teres um membro private que diga se determinada peça é ou não uma dama, estilo isto

bool dama;Se for true, é dama, se for false não é dama.

EDIT: para a função de verificação de uma jogada valida ou invalida, podes sempre pensar assim: a função pode receber como argumento se é ou não uma dama. Recebe também o local para onde vai ser movida (indice no array...). No caso de não ser uma dama, as jogadas não permitidas serão: andar para trás, ou andar directamente para a frente, ou seja, para uma casa da mesma coluna. Apenas pode avançar na diagonal. Isto num array bidimensional significa que só pode andar para uma posição [linha_actual+1][coluna_actual+1] ou [linha_actual+1] [coluna_actual-1], isto dependo do sentido para onde estas a jogar claro.

Acho que é um projecto interessante e não muito complicado ;)

Bem, fiquei mesmo com este jogo. Hex

Já está tudo feito, e so falta a implementação do codigo para verificar o vencedor.
Tivemos que partir de um codigo-base que nos foi dado, que na realidade era o "jogo do galo"

O Ш¡zard·σf·Шαr tentou ajudar, mas acho que ele não percebeu como funciona o jogo.

O jogador pode por as suas peças onde bem entender, desde que a casa do tabuleiro esteja livre. Pode começar no meio do tabuleiro, no canto, etc...

Eu estava a pensar fazer um codigo que partisse da peça que o jogador jogou na altura.

O The_True_Eue falou naquela tecnica do flood fill. Parece interessante. Não sei é se dá/consigo aplicar neste caso.

Alguma sugestão??

any help??

O jogador pode por as suas peças onde bem entender, desde que a casa do tabuleiro esteja livre. Pode começar no meio do tabuleiro, no canto, etc...
Também considerei isso...

O que fiz foi tratar o tabuleiro como uma tabela deste tipo, iniciando a procura numa das peças assinaladas a verde:

http://img147.imageshack.us/img147/5661/hexgameoverra64il0.png

Já agora, vou re-escrever o algoritmo
//seja M uma matriz (n+1)*(n+1) = tabuleiro do jogo
//0=célula branca; 1=célula azul; 2=célula vermelha
int n = 12;
int M[n+1,n+1];
int celulasTestadas[n+1,n+1];

bool VerificarSucessao(int corCelula)
{
int i, j;

//inicializar o array das células testadas
for (i = 0, i <= n, i++)
for (j = 0, j <= n, j++)
celulasTestadas[i, j] = 0;

if (corCelula == 1)
return ProcurarSucessao(0, 1, 1); //supondo que a célula (0,1) é azul, tal como aparece na imagem acima
else
return ProcurarSucessao(1, 0, 2); //supondo que a célula (1,0) é vermelha, tal como aparece na imagem acima
}

bool ProcurarSucessao(int i, int j, int corCelula)
{
if (i < 0 || i > n || j < 0 || j > n)
return false;
if (celulasTestadas[i, j] == 1 || M[i,j] != corCelula) //se for uma célula de cor diferente ou vazia, ou se já tiver sido testada, devolve false
return false;
if (i == n && corCelula == 1) || (j == n && corCelula == 2) //se já chegou à outra borda do tabuleiro, devolve true
return true;

celulasTestadas[i, j] = 1

//executa recursivamente a mesma função para todas as "ligações" possíveis da peça actual
return (
ProcurarSucessao(i-1, j, corCelula) ||
ProcurarSucessao(i, j-1, corCelula) ||
ProcurarSucessao(i, j+1, corCelula) ||
ProcurarSucessao(i+1, j, corCelula) ||
ProcurarSucessao(i-1, j+1, corCelula) ||
ProcurarSucessao(i+1, j-1, corCelula))
}

Já agora, vou re-escrever o algoritmo



Obrigado pela ajuda. Eu ia por isso da imagem tranformada num quadrado. É que so me apercebi depois de fazer isso, que não se podia analizar uma das diagonais.

Só uma coisa:


//seja M uma matriz (n+1)*(n+1) = tabuleiro do jogo
//0=célula branca; 1=célula azul; 2=célula vermelha
int n = 12;
int M[n+1,n+1];


Isto dá uma matriz de 13x13. A que está na imagem é de 11x11. Não quererias dizer apenas 12x12 ?? (n+1)x(n+1)

Isto dá uma matriz de 13x13. A que está na imagem é de 11x11. Não quererias dizer apenas 12x12 ?? (n+1)x(n+1)
A imagem é de 13x13, também contei com as bordas. :P

só duas coisas:

bool VerificarSucessao(int corCelula)

esta corCelula, suponho que seja a cor da celula do jogador que jogou no momento. É isso, certo?

E outra coisa. Numa fase inicial, ao ter um tabuleiro de M[n+2][n+2], vou ter de preencher as peças a volta com vermelho e azul em cada lateral. E as peças dos cantos?
Segundo me parece, e até pelo modo como o codigo detecta o vencedor, acho que têm de ficar a branco.

Obrigado pela ajuda Ш¡zard·σf·Шαr :beerchug:

só duas coisas:

bool VerificarSucessao(int corCelula)

esta corCelula, suponho que seja a cor da celula do jogador que jogou no momento. É isso, certo?
Sim, é suposto ser usado dessa forma.
E outra coisa. Numa fase inicial, ao ter um tabuleiro de M[n+2][n+2], vou ter de preencher as peças a volta com vermelho e azul em cada lateral. E as peças dos cantos?
Segundo me parece, e até pelo modo como o codigo detecta o vencedor, acho que têm de ficar a branco.
Ou ficam a branco, ou eliminam-se. As peças dos cantos não servem para nada, como já deves ter reparado. :P

Era so para dar um Obrigado a todos, em especial ao Ш¡zard·σf·Шαr, pela ajuda que me deram.

Isto já está a funcionar. Sem problemas.

:x2:

Boas... já que o spiderman veio abrir o assunto... venho cá por o meu problema...

Ora bem, tenho o mesmo projecto mas o meu jogo é o Abalone...
Engatei na parte final das regras... não vejo nenhuma solução para movimentar bem as peças, para empurrar as peças do adversario e para "atirar" estas para fora do tabuleiro...

A alguem interessado a gastar um tempito a tentar ajudar-me ficaria grato...
Deixo aki um link para poderem sacar o k já tenho feito até este ponto do ProjectoAbalone (http://www.box.net/shared/hjaco6fkss)

Contactem-me por pm ou por aqui se houver alguma dúvida...

Ok... problema resolvido e projecto entregue...
Se bem que há algumas arestas que gostaria de limar... o programar cobre quase todas as regras (só nao cobre uma)
Se alguem estiver interessado no código contacte-me! ^.^

Não sei se ainda precisas de ajuda, mas esse jogo chama-se: "Avallon" e o problema pode ser facilmente resolvido se for definido um bom esquema de objectos e se recorrer a backtracking :)

Tens razão, o nome original é "Avallon" o jogo foi criado por, se nao me engano, 2 franceses, agora o nome adoptado internacionalmente e para marketing foi o ingles Abalone (http://en.wikipedia.org/wiki/Abalone_%28board_game%29) é também comercializado sobre este nome em portugal! =P eu tinha o jogo... foi uma das razoes k o escolhi para programar lol...
Mas bem, o problema já foi resolvido... de uma forma um bom bocado estupida e com algoritmos de força bruta... mas agradeço a resposta! ^.^

Não sei se ainda precisas de ajuda, mas esse jogo chama-se: "Avallon" e o problema pode ser facilmente resolvido se for definido um bom esquema de objectos e se recorrer a backtracking :)

Julgo que eles ainda não têm conhecimentos para usar algoritmos desse tipo, pelo menos só falei nisso em cadeiras do segundo ano (MIEIC). Mas de qualquer forma, e vendo assim por alto, era uma boa forma de resolver isso.

Só uma pequena curiosidade.

Esse jogo que tu escolhes-te (o Hex) é jogado online por pessoas de quase todo o mundo e por incrivel que pareça, existe um torneio nacional dos jogos da matemática em que o Hex é um deles. Para o vencedor de cada um desses jogos, o prémio é um computador portátil.

Cumps

P.S - Desculpem o off-topic