contador no programa usando funções

[lphilipf 0]

Sou aluno do curso de Sistemas de Informação e meu professor pediu para fazer um jogo simples, o batalha naval, só que tem um problema eu não consigo fazer o contador do programa funcionar.

 

O programa utiliza matrizes 3 x 3, e várias funções que foram determinadas pelo meu professor. O jogo é entre dois jogadores, o programa solicita os nomes dos jogadores e cada um posiciona 3 navios no tabuleiro. Depois que os dois jogadores posicionam os navios, os dois começam a atacar um ao outro, depois disso o jogador1 ataca o jogador2 se no tabuleiro do jogador2 tiver um navio o programa marca como explosão se não marca como agua.

 

Quando um dos dois jogadores conseguir acertar os 3 navios do seu adversário o jogo acaba e fala qual dos dois é o vencedor, e é nessa parte que eu não estou conseguindo fazer.

 

Abaixo está o codigo:

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void creditos(void);

void limpa(void);

void limpa_tabuleiro(unsigned char[][]);

void exibe_tabuleiro(unsigned char[][]);

void posiciona_navio(unsigned char[][], unsigned char);

unsigned char tiro(unsigned char[][], int);

void exibe_tabuleiros(unsigned char[], unsigned char[][], unsigned char[], unsigned char[][]);

int main(int argc, char *argv[])
{
   int i = 0, contp1 = 0, contp2 = 0;
   unsigned char p1tab[3][3], p2tab[3][3], player1[16], player2[16];

   creditos();

   printf("Digite o nome do primeiro jogador (max. 15 letras): ");
   gets(player1);

   limpa();

   printf("\n%s, posicione seus navios.\n", player1);

   limpa_tabuleiro(p1tab);
   exibe_tabuleiro(p1tab);
   posiciona_navio(p1tab, 127);

   system("PAUSE");
   limpa();

   printf("\nDigite o nome do segundo jogador (max. 15 letras): ");
   gets(player2);

   limpa();

   printf("\n%s, posicione seus navios.\n", player2);

   limpa_tabuleiro(p2tab);
   exibe_tabuleiro(p2tab);
   posiciona_navio(p2tab, 127);

   system("PAUSE");
   limpa();

   do{
         exibe_tabuleiros(player1, p1tab, player2, p2tab);
         printf("%s! Sua vez de atirar!\n\n", player1);
         printf("Digite as coordenadas do seu tiro %d: ", i + 1);
         tiro(p2tab, contp1);
         limpa();

         exibe_tabuleiros(player1, p1tab, player2, p2tab);
         printf("%s! Sua vez de atirar!\n\n", player2);
         printf("Digite as coordenadas do seu tiro %d: ", i + 1);
         tiro(p1tab, contp2);
         limpa();

   } while((contp1 == 3) || (contp2 == 3));

   if (contp1 == 3)
   {
              printf("Voce foi o vencedor %s!\n", player1);
   }

   if (contp2 == 3)
   {
              printf("Voce foi o vencedor %s!\n", player2);
   }

   system("PAUSE");
   return 0;
}

void creditos(void)
{
    printf("\n");
    printf(" ##   #  ###  #  #   # #  #   #  #  #  # #  #  #\n");
    printf(" # # # #  #  # # #   # # # #  ## # # # # # # # #\n");
    printf(" ##  ###  #  ### #   ### ###  # ## ### # # ### #\n");
    printf(" # # # #  #  # # #   # # # #  #  # # # # # # # #\n");
    printf(" ##  # #  #  # # ### # # # #  #  # # #  #  # # ###\n");
    printf("\n");
    printf("                      Copyright 2011 - Luiz Felipe\n\n\n\n");
}

void limpa(void)
{
    system("cls");
}

void limpa_tabuleiro(unsigned char _tab[3][3])
{
    int i, j;

    for(i = 0; i < 3; i++)
    {
           for(j = 0; j < 3; j++)
           {
                   _tab[i][j] = 0;
           }
   }
}

void exibe_tabuleiro(unsigned char _tab[3][3])
{
    printf("\n    A   B   C\n\n");
    printf(" 1  %c %c %c %c %c", _tab[0][0], 186, _tab[0][1], 186, _tab[0][2]);
    printf("\t\t%c -> Navio\n", 127);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 2  %c %c %c %c %c\n", _tab[1][0], 186, _tab[1][1], 186, _tab[1][2]);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 3  %c %c %c %c %c\n\n", _tab[2][0], 186, _tab[2][1], 186, _tab[2][2]);

}

void posiciona_navio(unsigned char _tab[3][3], unsigned char _marcador)
{
    int k, l, c;
    unsigned char jogada[2];

    for(k = 0; k < 3; k++)
    {
          printf("Digite as coordenadas para o navio %d [A1]:\n", k + 1);
          gets(jogada);

          if((jogada[0] == 'A') || (jogada[0] == 'a'))
          {
                       c = 0;
          }

          if((jogada[0] == 'B') || (jogada[0] == 'b'))
          {
                       c = 1;
          }

          if((jogada[0] == 'C') || (jogada[0] == 'c'))
          {
                       c = 2;
          }

          if(jogada[1] == '1')
          {
                       l = 0;
          }

          if(jogada[1] == '2')
          {
                       l = 1;
          }

          if(jogada[1] == '3')
          {
                       l = 2;
          }

          _tab[l][c] = _marcador;

          limpa();
          exibe_tabuleiro(_tab);
    }
}

unsigned char tiro(unsigned char _tab[3][3], int cont)
{
        int l, c;
        unsigned char jogada[2];

        gets(jogada);

        if((jogada[0] == 'A') || (jogada[0] == 'a'))
        {
                      c = 0;
        }

        if((jogada[0] == 'B') || (jogada[0] == 'b'))
        {
                      c = 1;
        }

        if((jogada[0] == 'C') || (jogada[0] == 'c'))
        {
                      c = 2;
        }

        if(jogada[1] == '1')
        {
                      l = 0;
        }

        if(jogada[1] == '2')
        {
                      l = 1;
        }

        if(jogada[1] == '3')
        {
                      l = 2;
        }

        if(_tab[l][c] == 127)
        {
                      return _tab[l][c] = 15;
                      cont = cont + 1;
                      return cont;
        }

        if(_tab[l][c] == 0)
        {
                      return _tab[l][c] = 254;
        }
}

void exibe_tabuleiros(unsigned char _j1[16], unsigned char _tabj1[3][3], unsigned char _j2[16], unsigned char _tabj2[3][3])
{
    int i, j;
    unsigned char _tabj1limpo[3][3], _tabj2limpo[3][3];

    for(i = 0; i < 3; i++)
    {
          for(j = 0; j < 3; j++)
          {
                if(_tabj1[i][j] == 0)
                {
                                _tabj1limpo[i][j] = 0;
                }

                if(_tabj2[i][j] == 0)
                {
                                _tabj2limpo[i][j] = 0;
                }

                if(_tabj1[i][j] == 127)
                {
                                _tabj1limpo[i][j] = 0;
                }

                if(_tabj2[i][j] == 127)
                {
                                _tabj2limpo[i][j] = 0;
                }

                if(_tabj1[i][j] == 254)
                {
                                _tabj1limpo[i][j] = 254;
                }

                if(_tabj2[i][j] == 254)
                {
                                _tabj2limpo[i][j] = 254;
                }

                if(_tabj1[i][j] == 15)
                {
                                _tabj1limpo[i][j] = 15;
                }

                if(_tabj2[i][j] == 15)
                {
                                _tabj2limpo[i][j] = 15;
                }
          }
    }


    printf(" %c %s\n", 16, _j1);
    printf("\n    A   B   C\n\n");
    printf(" 1  %c %c %c %c %c", _tabj1limpo[0][0], 186, _tabj1limpo[0][1], 186, _tabj1limpo[0][2]);
    printf("\t\t%c -> Agua\n", 254);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 2  %c %c %c %c %c", _tabj1limpo[1][0], 186, _tabj1limpo[1][1], 186, _tabj1limpo[1][2]);
    printf("\t\t%c -> Explosao\n", 15);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 3  %c %c %c %c %c\n\n\n", _tabj1limpo[2][0], 186, _tabj1limpo[2][1], 186, _tabj1limpo[2][2]);

    printf(" %c %s\n", 16, _j2);
    printf("\n    A   B   C\n\n");
    printf(" 1  %c %c %c %c %c\n", _tabj2limpo[0][0], 186, _tabj2limpo[0][1], 186, _tabj2limpo[0][2]);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 2  %c %c %c %c %c\n", _tabj2limpo[1][0], 186, _tabj2limpo[1][1], 186, _tabj2limpo[1][2]);
    printf("   %c%c%c%c%c%c%c%c%c%c%c\n", 205, 205, 205, 206, 205, 205, 205, 206, 205, 205, 205);
    printf(" 3  %c %c %c %c %c\n\n", _tabj2limpo[2][0], 186, _tabj2limpo[2][1], 186, _tabj2limpo[2][2]);
}

[quitZAUMMM 18]

você consegue controlar quantos tiros a pessoa acertou?

 

[]s

[guidjos 65]

Seu programa não compila. A implementação não consegue adivinhar o tamanho de vetores que são elementos de vetores. Em declarações de funções, parâmetros com tipos de vetor determinam que serão usados objetos com o tipo do valor destes tipos de vetores; ou seja, com tipo de ponteiro para [ tipo dos elementos do vetor ]. Por isto, só é possível que a implementação fique ignorante ao tamanho do vetor em si, e não o tamanho dos vetores que o compõem.

 

Este erro está nas seguintes declarações, e em todas as definições que as utilizem:

 

void limpa_tabuleiro(unsigned char[][]);

void exibe_tabuleiro(unsigned char[][]);

void posiciona_navio(unsigned char[][], unsigned char);

unsigned char tiro(unsigned char[][], int);

void exibe_tabuleiros(unsigned char[], unsigned char[][], unsigned char[], unsigned char[][]);

 

Detalhando melhor:

 

void foo(int p[]);

 

A declaração acima dita que será recebido o valor de um vetor de int:

 

void foo(int p[]) {
// ...
}

// ...

int a[] = { 1, 2, 3 }; // a é um vetor de 3 ints, ou (int[3])
foo(a);                // o VALOR de a é passado

 

O valor de a é um ponteiro para seu primeiro elemento. Em foo(a);, o lvalue 'a' é equivalente a '&a[0]' e tem tipo (int *).

 

No caso de vetores de vetores:

 

void bar(int p[][5]);

 

Agora temos a declaração de uma função 'bar' que manipula vetores de vetores de 5 ints. Não é preciso saber quantos elementos este vetor tem, porque, como no caso anterior, só receberemos um ponteiro para seu primeiro elemento (o valor do vetor):

 

void bar(int p[][5])
{
// ...
}


// abaixo, o tipo de b é 'vetor de 2 vetores de 5 ints',
// ou (int[2][5]).

int b[][5] = {
{ 1, 2, 3, 4, 5 },
{ 6, 7, 8, 9, 10 }
};

bar(b);

 

Acima, a chamada 'bar(b)' toma o valor de b, que, como no caso anterior, é sinônimo para '&b[0]'. O tipo do valor de b é, de forma análoga, 'ponteiro para vetor de 5 ints', ou (int (*)[5]). Assim, as duas declarações são equivalentes:

 

void funcao(int (*)p[5]);
void funcao(int p[][5]);