projecto jogo do bloqueio

[luismsantana]

boa noite pessoal,

vou criar este tópico para ir colocando todas as duvidas que me forem aparecendo durante a resolução deste projecto, só para nao estar sempre a criar novos tópicos ... (se os responsáveis pelo site o permitirem) ...

aqui vai ...

eu tenho um vector que tem guardado o tabuleiro com as peças ... a cada jogada esse tabuleiro é alterado e o tabuleiro actualizado é guardado num novo nó de uma lista ligada ... nao podem haver repetições de jogadas sendo que se o houver o jogo termina e é empate ... pois bem, está-me a dar empate logo da primeira vez que o programa vai realizar a comparação, depois de eu já ter alterado o vector ...

aqui vão as funções que influenciam esta parte ...

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct jgd jog, *jogad;
typedef struct jogadores{
char nome1[10];
char nome2[10];
}jogador;
struct jgd{
int *tab;
jogad prox;
};
typedef struct
{
int n_jogadas;
int * valores;
int n_linhas;
int n_colunas;
} Matrix;
jogad jogar(jogad p,Matrix dim,jogador jog, Matrix *matrix)
{
   int op,jogd,pedra,empate,pedra_vezes=0;

   do{
       for(jogd=1;jogd<=2;jogd++)
       {
           if(jogd==1)
               printf("Vez do Jogador %s\n\n",jog.nome1);
           else
               printf("Vez do Jogador %s\n\n",jog.nome2);

           empate=verifica_empate(p,dim,matrix);
           if(empate==1){
               printf("o jogo terminou empatado! uma jogada foi repetida!\n");
               return NULL;
           }

           if(empate==2){
               printf("o jogo terminou empatado! foi atingido o numero maximo de jogadas!\n");
               return NULL;
           }


           printf("\n\n\n%d\n",matrix->n_colunas);
           printf("%d\n",matrix->n_linhas);
           printf("%d\n\n\n",matrix->n_jogadas);
           printf("\n\nTABULEIRO:\n\n");
           mostra_tabuleiro(matrix);
           printf("\n\n");
           printf("o que pretende fazer?\n");
           printf("1- colocar pedra\n");
           printf("2- retirar pedra\n");
           printf("3- mover peca\n");
           printf("4- inserir linha ou coluna\n");
           printf("5- voltar atras\n");
           printf("\nopcao:");
           scanf("%d",&op);

               switch(op)
               {
               case 1: pedra=verifica_pedras(matrix);
                       if(pedra==1)
                           p=coloca_pedra(p,dim,matrix);
                       else{
                           printf("Nao pode colocar mais pedras!\n");
                           break;
                       }; break;
               case 2: retirar_peca(); break;
               case 3: p=mover_peca(p,matrix,jogd); break;
               case 4: mostra_lista(p,dim); break;
               case 5:return 0;
               }
       }
   }while(1);

   return p;
}

int verifica_empate(jogad p,Matrix d,Matrix *m)
{
   int igual=0,contador_jogadas=0;
   jogad anterior=NULL;

   if(p!=NULL){
       /*while(p->prox!=NULL)
       {
           if(memcmp(p->tab,m,sizeof(int)*m->n_colunas*m->n_linhas)==0)
               return 1;
           else{
               p=p->prox;
               contador_jogadas++;
           }
       }*/
       anterior=p;
       while(p->prox!=NULL)
       {
           if(memcmp(anterior->tab,m,sizeof(int)*m->n_colunas*m->n_linhas)==0)
               return 1;
           else{
               anterior=p;
               p=p->prox;
               contador_jogadas++;
           }

       }
   if(contador_jogadas==d.n_jogadas)
       return 2;
   }
}

espero que me possam ajudar 😄

Edited August 30, 2012 at 09:35 AM by anolsi
Adição do geshi

[HappyHippyHippo]

podes me dizer o que retorna a função "verifica_empate" quando não existe uma jogada repetida ?

e o que retorna se a variável "p" tiver o valor NULL ?

[luismsantana]

pelos vistos nada xD

tenho de fazer retornar todos os casos?

[HappyHippyHippo]

se não me consegues responder a estas perguntas como achas que o programa sabe o que fazer ?

[luismsantana]

estamos sempre a aprender ... fiquei a saber, ok? 🙂

obrigado, ja está a funcionar 🙂

[HappyHippyHippo]

mas achas que o código está bem ? dá o resultado correto, mas a quantidade de código que não faz nada é mas do metade das linhas ...

// nota que alterei o protótipo da função para ser mais claro
// e só requisitar os valores necessários
int verifica_empate(jogad jogadas, Matrix * jogada, int max_jogadas)
 int count = 0;

 // ciclo de verificação das jogadas anteriores
 while (!jogadas)
 {
   // verificacao da jogada de numero "count" com a jogada realizada
   if(memcmp(jogadas->tab, jogada, sizeof(int) * jogada->n_colunas * jogada->n_linhas) == 0)
     return 1;

   // incrementados do ciclo
   jogada = jogada->prox;
   count++;
 }

 // verificar se o numero maximo de jogadas foi atingido
 if (count == max_jogadas)
   return 2;

 return 0;
}

[luismsantana]

mas repara, a parte que está comentada está incrementada assim como tu fizeste agora (à excepção dos returns) ... a parte que nao está comentada eu fiz só para ver se estava errado por causa da condição do while, mas já percebi que era pq nao estava a retornar os valores como deve ser 🙂

obrigado pela ajuda e preocupação em explicar como ficaria melhor implementado o meu código .. vou ja apagar a parte do "anterior=p ... " 🙂

[luismsantana]

boa tarde, mais uma vez 🙂

agora estou com outro problema ... eu tenho um vector e quero incrementar em uma unidade a celula escolhida ... mas nao está a dar ...

o código:

void altera_vector_pedras(Matrix *v)
{
   int i;

   for(i=0;i<v->n_colunas*v->n_linhas;i++)
   {
       if(v->valores[i]>0)
           v->valores[i]++;
   }
}

o v->valores++ nao deveria fazê-lo?

ps- o vector ja tem valores inicializados a 0 e a 1 ... se o valor da celula for maior que zero, incrementa uma unidade ...

abraço

[HappyHippyHippo]

o que te leva a dizer que o valor não é incrementado ??

[luismsantana]

ao imprimir o vector verifico que nao é incrementado ...

[HappyHippyHippo]

e o código da chamada das duas funções ?

[luismsantana]

e o código da chamada das duas funções ?

void vector_pedras(Matrix *v, Matrix d, Matrix *g)
{
   int i;

   for(i=0;i<d.n_colunas*d.n_linhas;i++)
   {
       g->valores[i]=0;

       if(v->valores[i]==9)
           g->valores[i]=1;
   }
}

int n_iteracoes_pedras(Matrix *v,int x, int y)
{
   int i;

   if(v->valores[y]==x+1)
       return 1;
   else
       return 0;
}

jogad jogar(jogad p,Matrix dim,jogador jog, Matrix *matrix)
{
   int op,i,jogd,pedra,empate,pedra_vezes=0,n_pedras_p=0;
   Matrix *aux=NULL;

   aux=(Matrix*) malloc(sizeof(Matrix)*dim.n_colunas*dim.n_linhas);

   aux->valores=(int*) malloc(sizeof(int*)*dim.n_colunas*dim.n_linhas);

   n_pedras_p=(dim.n_linhas*dim.n_colunas)*0.10;

   do{
       for(jogd=1;jogd<=2;jogd++)
       {
           if(jogd==1)
               printf("Vez do Jogador %s\n\n",jog.nome1);
           else
               printf("Vez do Jogador %s\n\n",jog.nome2);

           empate=verifica_empate(p,matrix, dim.n_jogadas);

           if(empate==1){
               printf("o jogo terminou empatado!\n");
               return NULL;
           }
           else{
               altera_vector_pedras(aux);

               for(i=0;i<dim.n_colunas*dim.n_linhas;i++)
                   printf("%d ",aux->valores[i]);
               printf("\n\n");

               printf("\n\nTABULEIRO:\n\n");
               mostra_tabuleiro(matrix);
               printf("\n\n");
               printf("o que pretende fazer?\n");
               printf("1- colocar pedra\n");
               printf("2- retirar pedra\n");
               printf("3- mover peca\n");
               printf("4- inserir linha ou coluna\n");
               printf("5- voltar atras\n");
               printf("\nopcao:");
               scanf("%d",&op);

               switch(op)
               {
               case 1: pedra=verifica_pedras(matrix);
                       if(pedra==1){
                           p=coloca_pedra(p,dim,matrix);
                           printf("e aqui\n");
                           vector_pedras(matrix,dim,aux);
                       }
                       else{
                           printf("Nao pode colocar mais pedras!\n");
                           break;
                       }; break;
               case 2: p=retirar_pedra(p,aux,matrix,n_pedras_p); break;
               case 3: p=mover_peca(p,matrix,jogd); break;
               case 4: mostra_lista(p,dim); break;
               case 5:return 0;
               }
           }
       }
   }while(1);

   return p;
}

[HappyHippyHippo]

typedef struct
{
int n_jogadas;
int * valores;
int n_linhas;
int n_colunas;
} Matrix;
...
aux=(Matrix*) malloc(sizeof(Matrix)*dim.n_colunas*dim.n_linhas);
aux->valores=(int*) malloc(sizeof(int*)*dim.n_colunas*dim.n_linhas);

não te estás a esquecer de inicializar nada ??

[luismsantana]

não te estás a esquecer de inicializar nada ??

é estritamente obrigatório inicializar todos os campos da estrutura se eu so vou usar um campo? (pergunta ignorante, eu sei ... mas é o resultado de pouca experiencia) ... é que tenho usado assim e tem resultado na mesma ..

[HappyHippyHippo]

obrigatório não é. mas vamos ver o que está a acontecer :

vamos supor que a variável aux será alocada pelo malloc sendo depois efectuado novo malloc para alocar memória para o campo valores (este é o código que tens), ficando desta forma

aux->n_jogadas == 0; // vamos supor que fica com o valor 0 (isto porque não inicializaste)
aux->valores;
aux->n_linhas == 0; // vamos supor que fica com o valor 0 (isto porque não inicializaste)
aux->n_colunas == 0; // vamos supor que fica com o valor 0 (isto porque não inicializaste)

agora, é este o ponteiro que passas para a função "altera_vector_pedras"

vou escrever o código desta função alterando com os valores assumidos

void altera_vector_pedras(Matrix * v)
 int i;

//for(i = 0; i < v->n_colunas * v->n_linhas; i++)
 for(i = 0; i < 0            * 0          ; i++) // ora 0*0 = 0 ...
 {
   if(v->valores[i]>0)
     v->valores[i]++;
 }
}

e isto porque tens tido sorte, porque se supores (porque não efetuaste a inicialização) que os valores eram outros quaisquer, poderias ter isto:

void altera_vector_pedras(Matrix * v)
 int i;

//for(i = 0; i < v->n_colunas * v->n_linhas; i++)
 for(i = 0; i < 242682348    * 2934623408 ; i++)
   // não só terias um problema que o resultado não cabe num inteiro
   // como chegavas um ponto e estava a manipular fora da memória alocada e terias uma
   // exceção a dizer que andavas a mexer em memória não permitida
 {
   if(v->valores[i]>0)
     v->valores[i]++;
 }
}

[luismsantana]

obrigado 🙂 mas conseguiste perceber porque aquilo nao está a funcionar? nao é por causa dos outros campos porque eu nao os estou a utilizar ... 🙂

esquece, estou a utilizar sim ... vou alterar 🙂

[HappyHippyHippo]

... estou a conter-me que nem imaginas ...

então eu acabei de te explicar (com código) que estás e vens dizer que não ?!?!?

[luismsantana]

eu ja disse que tens razão ... nao é preciso irritações ...

ja está a dar, obrigado 🙂

[luismsantana]

boa tarde novamente ...

está-me a dar problema a criar um novo nó para a lista ligada ... não percebo porquê :s para pedir espaço para o p->tab com menos de 20 celulas dá mas para mais nao -.-

typedef struct jgd jog, *jogad;

struct jgd{
int *tab;
jogad prox;
};

jogad nova_jogada(jogad p, Matrix *a)
{
int i;

//printf("%d %d\n",a->n_linhas, a->n_colunas);

p->tab=(int*) malloc(sizeof(int)*a->n_colunas*a->n_linhas); // está a crashar aqui!


memcpy(p->tab,a->valores,sizeof(int)*a->n_colunas*a->n_linhas);

  // for(i=0;i<a->n_colunas*a->n_linhas;i++)
//	printf("%d ",p->tab[i]);
  // printf("\n\n");

p->prox=NULL;

return p;
}

jogad adiciona_l_c(jogad p, Matrix *mat, Matrix d)
{

char *buffer;
int linha1, linha2;
jogad novo=(jogad) malloc(sizeof(jog)),aux;

buffer=(char*)malloc(sizeof(char)*7);

printf("quer introduzir uma linha ou uma coluna?\n");
fflush(stdin);
scanf("%s",buffer);

printf("%s\n",buffer);
if(strcmp(buffer,"linha")==0 || strcmp(buffer,"Linha")==0){
	adiciona_linha(mat,d);			   // entra aqui e faz tudo o que é suposto
}
/*if(strcmp(buffer,"coluna")==1 || strcmp(buffer,"Coluna")==1)
	adiciona_coluna(mat,d);*/

printf("...\n");
novo=nova_jogada(novo,mat);

aux=p;
while(aux->prox!=NULL)
	aux=aux->prox;
aux->prox=novo;

return p;
}

convem dizer que o vector "mat" sofreu um realloc e provavelmente é daí que advem o problema ...

typedef struct
{
       int n_jogadas;
    int * valores;
    int n_linhas;
    int n_colunas;
} Matrix;

void adiciona_linha_inicio(Matrix *m, Matrix dim)
{
   int i, j, *aux;

   aux=(int*)malloc(sizeof(int)*dim.n_linhas*dim.n_colunas);

   memcpy(aux,m->valores,sizeof(int)*dim.n_linhas*dim.n_colunas);

   m->n_linhas=dim.n_linhas+1;
   m->n_colunas=dim.n_colunas;

   m->valores=(int*)realloc(m->valores,sizeof(m->n_linhas*m->n_colunas));

   for(i=0;i<dim.n_linhas*dim.n_colunas;i++)
       printf("%d ",aux[i]);
   printf("\n\n");

   printf("preenche o novo vector com zeros so na primeira linha!\n");
   for(i=0;i<m->n_colunas;i++)
           m->valores[i]=0;


   printf("mostra a primeira coluna a zero e o restante vector\n");
   for(i=0;i<m->n_linhas*m->n_colunas;i++)
       printf("%d ",m->valores[i]);
   printf("\n\n");

   printf("copia os valores de aux para a segunda linha e restante do novo vetor\n");
   for(i=m->n_colunas,j=0;i<m->n_colunas*m->n_linhas, j<dim.n_colunas*dim.n_linhas;i++,j++)
           m->valores[i]=aux[j];


   printf("mostra o vector ja pronto\n");

   for(i=0;i<m->n_linhas*m->n_colunas;i++)
       printf("%d ",m->valores[i]);
   printf("\n\n");

   //liberta o vector pedido para auxiliar a acao
   //free(aux);
   printf("ola1\n");
}

Edited September 1, 2012 at 04:42 PM by luismsantana

[luismsantana]

está resolvido o problema ..