1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Jogo em C++

Discussão em 'Programação' iniciada por Spiderman, 3 de Março de 2008. (Respostas: 23; Visualizações: 9932)

  1. Spiderman

    Spiderman I folded Myself

    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:

    [​IMG]

    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 ;)
     
  2. hYpe

    hYpe [email protected] Member

    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
     
  3. balute

    balute Power Member

    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):
    Código:
    //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
     
  4. The_True_Eue

    The_True_Eue Power Member

    Basicamente é um flood fill. Tens é que introduzir um caso especial para quando se chegar a uma das casas "do outro lado" dizer que sim, ganhou.
     
  5. IComeFromBehind

    IComeFromBehind Power Member

    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.
     
  6. faeuk

    faeuk Power Member

    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?
     
  7. Spiderman

    Spiderman I folded Myself

    Ya, FEUP Rula... :007:

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

    :x2:
     
  8. OubeLa

    OubeLa Power Member

    Que outros projectos vocês têm para além desse? Se calhar existiriam opções mais favoráveis.
     
    Última edição: 19 de Março de 2008
  9. OubeLa

    OubeLa Power Member

    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

    Código:
    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 ;)
     
    Última edição: 2 de Abril de 2008
  10. Spiderman

    Spiderman I folded Myself

    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??
     
  11. Spiderman

    Spiderman I folded Myself

  12. balute

    balute Power Member

    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:

    [​IMG]

    Já agora, vou re-escrever o algoritmo
    Código:
    //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))
    }
     
    Última edição: 12 de Abril de 2008
  13. Spiderman

    Spiderman I folded Myself

    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:

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

    balute Power Member

    A imagem é de 13x13, também contei com as bordas. :P
     
  15. Spiderman

    Spiderman I folded Myself

    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:
     
  16. balute

    balute Power Member

    Sim, é suposto ser usado dessa forma.
    Ou ficam a branco, ou eliminam-se. As peças dos cantos não servem para nada, como já deves ter reparado. :P
     
  17. Spiderman

    Spiderman I folded Myself

    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:
     
  18. 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

    Contactem-me por pm ou por aqui se houver alguma dúvida...
     
  19. 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! ^.^
     

Partilhar esta Página