C Matriz dinâmica usando malloc

Pietra Ester · 26 de dezembro de 2021

Olá! estou desenvolvendo um jogo em c, um jogo da memória, já postei no fórum um tópico com o mesmo programa e consegui solucionar o problema. Agora estou na reta final do meu programa e apresento o seguinte problema: depois que esconde o tabuleiro, o usuário faz sua jogada na matriz dinâmica de char com o malloc, mas a jogada não mostra no tabuleiro, não vira as cartas, apenas verifica as condições do IF e não mostra as cartas jogadas pelo usuário no tabuleiro escondido.

São 3 níveis de dificuldade que criei, estou testando o jogo no nível fácil por enquanto. Como posso desvirar as cartas selecionadas pelo usuário?

#include <stdio.h>  //biblioteca padrão
#include <stdlib.h> //biblioteca da alocação dinâmica
#include <locale.h> //biblioteca de idiomas
#include <time.h>   //biblioteca de aleatória
#include <string.h> //biblioteca para strings
#include <windows.h>//biblioteca do sleep
#define F_LIN 4     //biblioteca de qntd de linhas nivel fácil
#define F_COL 4     //biblioteca de qntd de colunas nivel fácil

//PROTÓTIPOS DE FUNÇÕES
void linha();
char fácil();

//variavel global
int lin, col, lin2, col2, pts=0;
char nome[50][50];

//FUNÇÃO QUE GERA LINHA
void linha(){
	printf("-------------------------------------------------\n");
}

//FUNÇÃO QUE GERA TABULEIRO DE NÍVEL FÁCIL
char fácil(){
	char **tabuleiro, cartas[F_LIN * F_COL / 2] = {'a', 'b', 'c', 'd', 'e', 'f','g','h'};//'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'};
	int i, j, c=0, cont=0;
    srand(time(NULL));
    		
// aloca um vetor de F_LIN ponteiros para as linhas
tabuleiro = (char **) malloc (F_LIN * sizeof (char*)) ;

// aloca cada uma das linhas (vetores de F_COL char)
for (i=0; i < F_LIN; i++)
   tabuleiro[i] = (char *) malloc (F_COL * sizeof (char)) ;

//preenche com caracteres aleatórios
for (i=0; i<F_LIN; i++){
	for (j=0; j<F_COL;j++)
         tabuleiro [i][j]='*';
    }
            
	while (c<F_LIN*F_COL/2) {
	     i = rand() % F_LIN;
		 j = rand() % F_COL;
		 if (tabuleiro[i][j] == '*') {
		 	tabuleiro [i][j] = cartas[c];
		 	cont= cont + 1;
		    }	else { continue; }
		 if (cont==2) {
		 	c=c+1;
		 	cont=0;
		 }
	}
			
//âncora para nova jogada	
jogada:
system("cls");

//status do jogo
	linha();
	printf("> NÍVEL  : Fácil\n");
	printf("> JOGADOR: %s\n", nome[i]);
	printf("> PONTOS : %d pts\n", pts);
	linha();
					
//imprime a matriz
printf("     "); 
for(i=0; i<4; i++){
 printf("%d   ", i);	
} 
printf("\n");
for (i=0; i < F_LIN; i++){
	printf(" %d | ", i);
	for (j=0; j < F_COL; j++){
//esconde o tabuleiro
		if(pts < 800) printf("  | ");
		else{
   	 printf("%c | ", tabuleiro[i][j]);}
     }
     printf("\n");
}	
linha();

//lógica do jogo
while (pts < 800){
			
			printf("\n> Digite a linha e coluna respectivamente: ");
			scanf("%d %d", &lin, &col);
			printf("> Digite a linha e coluna respectivamente: ");
			scanf("%d %d", &lin2, &col2);
			 
			if (lin <0 || lin > 4 || col < 0 || col > 4){
			linha();
			printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n");
			system("pause");
			goto jogada;
			}
			else if (lin2 <0 || lin2 > 4 || col2 < 0 || col2 > 4){
			linha();
			printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n");
			system("pause");
			goto jogada;
		    }
		    
		    else if(lin == lin2 && col == col2){
		    linha();
			printf("\t\t JOGADA INVÁLIDA!\n\t\t*Lugar ocupado!\n\n");
			Sleep(2000);
			goto jogada;	
			}
			
			else if(tabuleiro[lin][col] == tabuleiro[lin2][col2]){
				printf("\n\t\t BOOAAA!\n \t\t*Ganhou +100 pts!\n\n");
				Sleep(2000);
				pts = pts + 100;
				goto jogada;
			}
			
			else if (tabuleiro[lin][col] != tabuleiro[lin2][col2]){
				printf("\n\t\tERROU!!!\n\n");
				Sleep(2000);
				goto jogada;
			}
			
		}
		if(pts == 800){
				printf("\n ***PARABÉNS %s você alcançou os 800 pontos!*\n ***Sua memória é muito boa!!!* 8)\n", nome[i]);
				printf("\t\t  _1_ \n");
				printf("\t\t  |o| \n\n");
				system("pause");
				system("cls");
				exit(0);
			}
   
// libera a memória da matriz
for (i=0; i < F_LIN; i++){
	free (tabuleiro[i]) ;
} 
free (tabuleiro) ;
}

//FUNÇÃO PRINCIPAL
int main(){
	//variáveis
	int difi, opcao, i;
	//limpar o buffer do teclado
	fflush(stdin);
	//idioma em português
	setlocale(LC_ALL, "Portuguese");
	//cor do sistema
	system("color 1e");
		
do{
    //menu
	linha();
	printf("    ****** BEM VINDO AO JOGO DA MEMÓRIA ******\n");
	linha();
	printf("\n\t\t[1] JOGAR\n");
	printf("\t\t[2] TUTORIAL\n");
	printf("\t\t[3] SAIR\n\n");
	printf("\t\tOpção: ");
	scanf("%d", &opcao);
	linha();
	
	
switch (opcao){
	case 1:
		
		//lê o nome do jogador
		system("cls");
		linha();
		printf("> NOME DO JOGADOR > ");
		fflush(stdin);
		gets(nome[i]);
		linha();
		system("Pause");
		system("cls");
		
	do{
		//jogador escolhe o nível da dificuldade
		printf("> %s, escolha o nível de dificuldade: \n\n", nome[i]);	
		printf("\t\t[1] Fácil\n");
		printf("\t\t[2] Médio\n");
		printf("\t\t[3] Difícil\n\n");
		printf("\t\tOpção: ");
		scanf("%d", &difi);
		linha();
	
	//menu de opções de níveis de dificuldade
	switch (difi){
		case 1:
			system("cls");
			printf("> NÍVEL  : Médio\n");
			printf("> JOGADOR: %s\n", nome[i]);
			printf("> PONTOS : %d\n", pts);
			//imprime o tabuleiro
			fácil();
			linha();
		break;
		
		case 2:
			system("cls");
			printf("> NÍVEL  : Médio\n");
			printf("> JOGADOR: %s\n", nome[i]);
			printf("> PONTOS : %d\n", pts);
			linha();
			//medio();
			linha();
			
		break;
		
		case 3:
			system("cls");
			printf("> NÍVEL  : Difícil\n");
			printf("> JOGADOR: %s\n", nome[i]);
			printf("> PONTOS : %d\n", pts);
			linha();
	        //difícil();
			linha();
				
		break;
		
		default:
			system("cls");
			printf("> Opção inválida!\n");
			linha();
	}
	
	}while(difi > 1 || difi < 3);

	break; 
	
	case 2:
		system("cls");
		printf(" > TUTORIAL:\n");
		linha();
		printf(" # O objetivo do jogo é achar um par de cada carta.\n # Alcançar 800 pontos no nível fácil.\n # Alcançar 3200 pontos no nível médio. \n # Alcançar 5000 pontos no nível difícil.\n\n # Boa sorte! :)\n\n");
	    system("Pause");
	    system("cls");
	  break;
	  
	case 3:
		system("cls");
		printf("> SAINDO DO PROGRAMA...\n");
		exit(0);
		
	default:
		system("cls");
		printf("> Opção inválida!\n");
	}
	
}while(opcao > 1 || opcao < 3);

return 0;
}

Ansi C · 26 de dezembro de 2021

Use dois tabuleiros. Você tem o tabuleiro com as combinações certas, falta o tabuleiro de combinações já acertadas. Desvirar significa exibir o que tem nas coordenadas escolhidas, acrescentar ao tabuleiro das escolhas acertadas, quando certas. e sempre exibir esse tabuleiro no final.

Concorda?

Lucca Rodrigues · 26 de dezembro de 2021

@Pietra Ester Não use acentuação para dar nome a variáveis, funções ou qualquer coisa do tipo. Pode funcionar na sua máquina, mas veja, na minha não funcionou.

Perceba também que você colocou a declaração das funções fácil() e linha() seguida da definição, e a main() está no final do arquivo. Sempre coloque a main() como primeira.

12 horas atrás, Pietra Ester disse:

//FUNÇÃO QUE GERA LINHA
void linha(){
	printf("-------------------------------------------------\n");
}

Nesse trecho você criou uma função que não recebe e nem retorna nada para chamar a printf(), em geral é desnecessário.

12 horas atrás, Pietra Ester disse:

#define F_LIN 4     //biblioteca de qntd de linhas nivel fácil
#define F_COL 4     //biblioteca de qntd de colunas nivel fácil

F_LIN e F_COL são constantes simbólicas. #define associa esses identificadores à constante 4.

Não se trata de uma biblioteca ou algo do tipo.

13 horas atrás, Pietra Ester disse:

	printf("> NÍVEL  : Fácil\n");
	printf("> JOGADOR: %s\n", nome[i]);
	printf("> PONTOS : %d pts\n", pts);

Você não precisa chamar a printf() 3 vezes, só uma chamada já basta:

printf("> NÍVEL  : Fácil\n"
       "> JOGADOR: %s\n"
       "> PONTOS : %d pts\n",
       nome[i], pts);

13 horas atrás, Pietra Ester disse:
goto jogada;

Você não precisa necessariamente de goto nesse caso. Se precisa repetir algo como iniciar uma nova jogada, você poderia criar um loop.

13 horas atrás, Pietra Ester disse:
char fácil()

fácil() deveria retornar char, mas ao final da função não há return.

13 horas atrás, Pietra Ester disse:
//limpar o buffer do teclado
	fflush(stdin);

Não funciona bem assim, e você não precisa disso em nenhuma ocasião para o stream de entrada. Inclusive essa função só tem comportamento definido para fluxos de saída.

13 horas atrás, Pietra Ester disse:

//variavel global
int lin, col, lin2, col2, pts=0;
char nome[50][50];

Muitas variáveis globais, e não parece necessário.

Você tem 2 funções além da main(), que tal passar algo como argumento na chamada delas caso precise? Declare-as na main().

13 horas atrás, Pietra Ester disse:
gets(nome[i]);

gets() é obsoleta, você pode usar scanf(), fgets() ou alguma outra função:

scanf(" %49[^\n]", nome[i]);

Inclusive você não inicializou o índice i:

13 horas atrás, Pietra Ester disse:
int difi, opcao, i;

Acredito que não está incrementando o valor de i também, para armazenar os demais nomes.

13 horas atrás, Pietra Ester disse:

	switch (difi){
		case 1:
			system("cls");
			printf("> NÍVEL  : Médio\n");
			printf("> JOGADOR: %s\n", nome[i]);
			printf("> PONTOS : %d\n", pts);
			//imprime o tabuleiro
			fácil();
			linha();
		break;

Acredito que no primeiro caso, a dificuldade seria fácil.
E veja, você está imprimindo essas estatísticas tanto na main() quanto na função fácil(). Resultado:

Ele não imprime o nome do jogador na função fácil() porque você usou o índice i em um loop, então o valor dele muda.

13 horas atrás, Pietra Ester disse:

a jogada não mostra no tabuleiro, não vira as cartas, apenas verifica as condições do IF e não mostra as cartas jogadas pelo usuário no tabuleiro escondido

Acredito que basta atualizar a tela para mostrar as cartas escolhidas. Você pode seguir a ideia de @mauro_b

Enfim, Só alterei certas coisas no código segundo o que fui anotando acima:

#define F_LIN 4     //constante de quantidade de linhas nivel fácil
#define F_COL 4     //constante de quantidade de colunas nivel fácil

#include <stdio.h>  //biblioteca padrão
#include <stdlib.h> //biblioteca da alocação dinâmica
#include <locale.h> //biblioteca de idiomas
#include <time.h>   //biblioteca de aleatória
#include <string.h> //biblioteca para strings
#include <windows.h>//biblioteca do sleep

//PROTÓTIPOS DE FUNÇÕES
void fácil(); // Mudei o retorno para void para testar

//variavel global
int lin, col, lin2, col2, pts=0;
char nome[50][50];

//FUNÇÃO PRINCIPAL
int main()
{
    //variaveis
    int difi, opcao, i = -1;
    //idioma em português
    setlocale(LC_ALL, "Portuguese");
    //cor do sistema
    system("color 1e");

    do{
        //menu
        printf("-------------------------------------------------\n");
        printf("    ****** BEM VINDO AO JOGO DA MEMÓRIA ******\n");
        printf("-------------------------------------------------\n");
        printf("\n\t\t[1] JOGAR\n");
        printf("\t\t[2] TUTORIAL\n");
        printf("\t\t[3] SAIR\n\n");
        printf("\t\tOpção: ");
        scanf(" %d", &opcao);
        printf("-------------------------------------------------\n");


        switch (opcao)
        {
            case 1:
                //lê o nome do jogador
                system("cls");
                printf("-------------------------------------------------\n");
                printf("> NOME DO JOGADOR > ");
                i++; // Caso sejam 50 jogadores no máximo, faça uma condição que verifica isso com base no valor de i
                scanf(" %49[^\n]", nome[i]);
                printf("-------------------------------------------------\n");
                system("Pause");
                system("cls");

                do {
                    //jogador escolhe o nível da dificuldade
                    printf("> %s, escolha o nível de dificuldade: \n\n", nome[i]);
                    printf("\t\t[1] fácil\n");
                    printf("\t\t[2] Médio\n");
                    printf("\t\t[3] Difícil\n\n");
                    printf("\t\tOpção: ");
                    scanf(" %d", &difi);
                    printf("-------------------------------------------------\n");

                    //menu de opções de níveis de dificuldade
                    switch (difi)
                    {
                        case 1:
                            system("cls");
                            printf("> NÍVEL  : Fácil\n");
                            printf("> JOGADOR: %s\n", nome[i]);
                            printf("> PONTOS : %d\n", pts);
                            //imprime o tabuleiro
                            fácil();
                            printf("-------------------------------------------------\n");
                        break;

                        case 2:
                            system("cls");
                            printf("> NÍVEL  : Médio\n");
                            printf("> JOGADOR: %s\n", nome[i]);
                            printf("> PONTOS : %d\n", pts);
                            printf("-------------------------------------------------\n");
                            //medio();
                            printf("-------------------------------------------------\n");
                        break;

                        case 3:
                            system("cls");
                            printf("> NÍVEL  : Difícil\n");
                            printf("> JOGADOR: %s\n", nome[i]);
                            printf("> PONTOS : %d\n", pts);
                            printf("-------------------------------------------------\n");
                            //difícil();
                            printf("-------------------------------------------------\n");
                        break;

                        default:
                            system("cls");
                            printf("> Opção invalida!\n");
                            printf("-------------------------------------------------\n");
                    }
                } while(difi > 1 || difi < 3);
            break;

            case 2:
                system("cls");
                printf(" > TUTORIAL:\n");
                printf("-------------------------------------------------\n");
                printf(" # O objetivo do jogo é achar um par de cada carta.\n # Alcançar 800 pontos no nível fácil.\n # Alcançar 3200 pontos no nível médio. \n # Alcançar 5000 pontos no nível difícil.\n\n # Boa sorte! :)\n\n");
                system("Pause");
                system("cls");
            break;

            case 3:
                system("cls");
                printf("> SAINDO DO PROGRAMA...\n");
                exit(0);

            default:
                system("cls");
                printf("> Opção invalida!\n");
        }
    } while(opcao > 1 || opcao < 3);

    return 0;
}

//FUNÇÃO QUE GERA TABULEIRO DE NÍVEL FÁCIL
void fácil()
{
    char** tabuleiro;
    char cartas[F_LIN * F_COL / 2] = {'a', 'b', 'c', 'd', 'e', 'f','g','h'};//'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'};
    int i, j, c=0, cont=0, k = 0; // Use k para imprimir o nome do jogador
    srand(time(NULL));

    // aloca um vetor de F_LIN ponteiros para as linhas
    tabuleiro = (char**) malloc (F_LIN * sizeof (char*)) ;

    // aloca cada uma das linhas (vetores de F_COL char)
    for (i=0; i < F_LIN; i++)
    {
        tabuleiro[i] = (char*) malloc (F_COL * sizeof (char)) ;
    }

    //preenche com caracteres aleatórios
    for (i=0; i<F_LIN; i++)
    {
        for (j=0; j<F_COL;j++)
        {
            tabuleiro [i][j]='*';
        }
    }

    while (c<F_LIN*F_COL/2)
    {
        i = rand() % F_LIN;
        j = rand() % F_COL;
        if (tabuleiro[i][j] == '*')
        {
            tabuleiro [i][j] = cartas[c];
            cont= cont + 1;
        }
        else
        {
            continue;
        }
        if (cont==2)
        {
            c=c+1;
            cont=0;
        }
    }

    //âncora para nova jogada
    jogada:
    system("cls");

    //status do jogo
    printf("-------------------------------------------------\n");
    printf("> NÍVEL  : Fácil\n"
           "> JOGADOR: %s\n"
           "> PONTOS : %d pts\n",
           nome[k], pts);
    printf("-------------------------------------------------\n");

    //imprime a matriz
    printf("     ");
    for(i=0; i<4; i++)
    {
        printf("%d   ", i);
    }
    printf("\n");
    for (i=0; i < F_LIN; i++)
    {
        printf(" %d | ", i);
        for (j=0; j < F_COL; j++)
        {
            //esconde o tabuleiro
            if(pts < 800)
            {
                printf("  | ");
            }
            else
            {
                printf("%c | ", tabuleiro[i][j]);
            }
        }
        printf("\n");
    }
    printf("-------------------------------------------------\n");

    //lógica do jogo
    while (pts < 800)
    {
        printf("\n> Digite a linha e coluna respectivamente: ");
        scanf(" %d %d", &lin, &col);
        printf("> Digite a linha e coluna respectivamente: ");
        scanf(" %d %d", &lin2, &col2);

        if (lin <0 || lin > 4 || col < 0 || col > 4)
        {
            printf("-------------------------------------------------\n");
            printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n");
            system("pause");
            goto jogada;
        }
        else if (lin2 <0 || lin2 > 4 || col2 < 0 || col2 > 4)
        {
            printf("-------------------------------------------------\n");
            printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n");
            system("pause");
            goto jogada;
        }
        else if(lin == lin2 && col == col2)
        {
            printf("-------------------------------------------------\n");
            printf("\t\t JOGADA INVÁLIDA!\n\t\t*Lugar ocupado!\n\n");
            Sleep(2000);
            goto jogada;
        }
        else if(tabuleiro[lin][col] == tabuleiro[lin2][col2])
        {
            printf("\n\t\t BOOAAA!\n \t\t*Ganhou +100 pts!\n\n");
            Sleep(2000);
            pts = pts + 100;
            goto jogada;
        }
        else if (tabuleiro[lin][col] != tabuleiro[lin2][col2])
        {
            printf("\n\t\tERROU!!!\n\n");
            Sleep(2000);
            goto jogada;
        }

    }
    if(pts == 800)
    {
        printf("\n ***PARABÉNS %s você alcançou os 800 pontos!*\n ***Sua memória é muito boa!!!* 8)\n", nome[i]);
        printf("\t\t  _1_ \n");
        printf("\t\t  |o| \n\n");
        system("pause");
        system("cls");
        exit(0);
    }

    // libera a memória da matriz
    for (i=0; i < F_LIN; i++)
    {
        free(tabuleiro[i]);
    }
    free(tabuleiro);

    return; //??
}

devair1010 · 26 de dezembro de 2021

@Pietra Ester ele não mostra as cartas por que você colocou uma condição para isso , nesse trecho de seu código

printf("\n");
for (i = 0; i < F_LIN; i++) 
{
    printf(" %d | ", i);
    for (j = 0; j < F_COL; j++) 
    {
        // esconde o tabuleiro 
        // se os pontos forem menor de 800
        if (pts < 800) 
            printf("  | ");                   // aqui não mostra
        else                                  // mas se forem maiores de 800 
        {
            printf("%c | ", tabuleiro[i][j]); // aqui mostra
        }
}
printf("\n");
}
linha();

e então Qual sua ideia das regras desse jogo ? por exemplo .:

vai mostrar o Tabuleiro com todas as cartas e esperar por um tempo e depois esconder o Tabuleiro , e aí o usuário vai tentar lembrar onde estão as cartas ?

Pietra Ester · 26 de dezembro de 2021

@mauro_b obgda pela ajuda! é isso mesmo.

@Lucca Rodrigues obgda pela ajuda!, falava o incremento mesmo por isso o nome do jogador sumia depois que atualiza a tela.

@devair1010 exatamente, não tem uma condição para mostrar as jogadas, e vou criar outro tabuleiro igual o @mauro_b mencionou.

@Lucca Rodrigues obdga por corrigir!!!

arfneto · 27 de dezembro de 2021

Em 25/12/2021 às 23:04, Pietra Ester disse:

	char **tabuleiro, cartas[F_LIN * F_COL / 2] = {'a', 'b', 'c', 'd', 'e', 'f','g','h'};//'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'};

Seu programa tem muitos erros. Talvez deva postar o programa como está agora se ainda precisa de ajuda.

E não está bom. Tem muitos dos problemas comuns e deve ser consequência do modo como ensinam e escrevem sobre isso hoje em dia. Vai ter um trabalho do inferno para progredir assim:

porque pouco do que escreve poderá usar no programa seguinte.
Está muito difícil de ler e testar.
Está frágil e complicado demais

Sobre o código acima:

evite declarar mais que uma variável por linha. Não ajuda ninguém, pelo contrário. Inicialize todas as variáveis. Prefira

	char**    tabuleiro = NULL;
	char      cartas[]  = { 'a','b','c',d','e','f','g','h' };

Entenda que tabuleiro sendo char** quase sempre vai precisar de outra variável para dizer quantas colunas tem o tabuleiro então é muito mais simples e esperto já colocar essa variável junto com o tabuleiro na mesma estrutura, já que ela é básica para todo o programa. Assim fica tudo muito mais simples.

Compare:

typedef struct
{
    int    lin;
    int    col;  // o tamanho do tabuleiro
    char** tab;

}   Tabuleiro;

Assim cada tabuleiro se auto-descreve, e tem as dimensões DENTRO. Isso se chama encapsulamento e é básico para uma vida tranquila programando em qualquer linguagem.

Evite, em especial quando está aprendendo, declarar coisas como

	char    **t;

Em C você declara uma variável como sendo de um tipo. A variável aqui é t. E o tipo é char**. Essa é a realidade. Então aprende a ler e escrever e entender assim:

	char**                                                     t;

porque t é do tipo char**. E isso quer dizer que

*t é char*, um ponteiro para char.
**t é um char

Isso é C. O operador * pega o valor do que tem no endereço. O operador & traz o endereço.

Sobre o programa

Escreva uma função de mostra o tabuleiro. algo como
```
	int tab_mostra( Tabuleiro* t, int tempo);
```

E programa para deixar o tabuleiro na tela se o tempo for zero, ou manter na tela o valor passado em tempo. Para isso são as funções. Imagine a diferença disso em seu programa:

pode chamar a função, a MESMA função, para vários tabuleiros e vários tempos.
quando o cara estiver pensando pode usar o tempo = 0 e deixar na tela
depois que ele jogar pode passar um tempo bem pequeno ou grande para ele ver as peças antes de desvirar as escolhidas

Use funções, mas com parâmetros. E retorne coisas, ao menos um status.

// PROTÓTIPOS DE FUNÇÕES
void linha();
char fácil();

// variavel global
int  lin, col, lin2, col2, pts = 0;
char nome[50][50];

// FUNÇÃO QUE GERA LINHA
void linha()
{
    printf("-------------------------------------------------\n");
}

Evite esses comentários óbvios. É sabido que são protótipos.
NUNCA use void x(). Passe argumentos pelas razões que eu expliquei. E se não entendeu pergunte. É um forum.
Nunca use acentos em comentários. muito menos em nomes de variáveis. Não use acentos. Nada acrescenta. Quando o programa estiver ok e se for realmente necessário aí pense nisso.
qual o propósito de uma função de uma linha que mostra uma linha?

Pietra Ester · 29 de dezembro de 2021

@arfneto então moço, obgda pelo seu feedback construtivo, meu professor na faculdade esta me ensinando a programar assim, ele ensinou a criar parametros e retornar coisas, mas ainda não prendi a colocar parametros e também não são obrigatórios meu professor disse. Bom, a parte que estou é ainda na mesma, ainda estou pensando como posso fazer para esconder o tabuleiro inicialmente e mostrar as coordenadas jogadas.

5 minutos atrás, Pietra Ester disse:

@arfneto então moço, obgda pelo seu feedback construtivo, meu professor na faculdade esta me ensinando a programar assim, ele ensinou a criar parametros e retornar coisas, mas ainda não prendi a colocar parametros e também não são obrigatórios meu professor disse. Bom, a parte que estou é ainda na mesma, ainda estou pensando como posso fazer para esconder o tabuleiro inicialmente e mostrar as coordenadas jogadas.

Esta assim por enquanto, eu não coloco acento no nome das funções, é o editor do forum que coloca automaticamente:

#define F_LIN 4     //constante de quantidade de linhas nivel fácil
#define F_COL 4     //constante de quantidade de colunas nivel fácil

//bibliotecas
#include <stdio.h>  //biblioteca padrão
#include <stdlib.h> //biblioteca da alocação dinâmica
#include <locale.h> //biblioteca de idiomas
#include <time.h>   //biblioteca de aleatória
#include <string.h> //biblioteca para strings
#include <windows.h>//biblioteca do sleep

//PROTÓTIPOS DE FUNÇÕES
char fácil(); 
void cabecalho();

//variavel global
int lin, col, lin2, col2, k=0, pts=0, acertos=0, jogadas=0;
char nome[50][50];

//FUNÇÃO PRINCIPAL
int main()
{
    //variaveis
    int difi, opcao, i = -1;
    //idioma em português
    setlocale(LC_ALL, "Portuguese");
    //cor do sistema
    //system("color 1e");

    do{
        //menu
        cabecalho();
        printf("\t\t\t\t\t\t[1] JOGAR\n");
        printf("\t\t\t\t\t\t[2] TUTORIAL\n");
        printf("\t\t\t\t\t\t[3] CRÉDITOS\n");
        printf("\t\t\t\t\t\t[4] SAIR\n\n");
        printf("\t\t\t\t\t\tOpção: ");
        scanf(" %d", &opcao);
        printf("-------------------------------------------------\n");


        switch (opcao)
        {
            case 1:
                //lê o nome do jogador
                system("cls");
                cabecalho();
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t> NOME DO JOGADOR > ");
                i++; // Caso sejam 50 jogadores no máximo, faça uma condição que verifica isso com base no valor de i
                scanf(" %49[^\n]", nome[i]);
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t");
                system("Pause");
                system("cls");

                do {
                	cabecalho();
                    //jogador escolhe o nível da dificuldade
                    printf("\t\t\t\t> %s, escolha o nível de dificuldade: \n\n", nome[i]);
                    printf("\t\t\t\t\t\t[1] fácil\n");
                    printf("\t\t\t\t\t\t[2] Médio\n");
                    printf("\t\t\t\t\t\t[3] Difícil\n\n");
                    printf("\t\t\t\t\t\tOpção: ");
                    scanf(" %d", &difi);

                    //menu de opções de níveis de dificuldade
                    switch (difi)
                    {
                        case 1:
                            system("cls");
                            //imprime o tabuleiro
                            fácil();
                            printf("-------------------------------------------------\n");
                        break;

                        case 2:
                            system("cls");
                            printf("-------------------------------------------------\n");
                            //medio();
                            printf("-------------------------------------------------\n");
                        break;

                        case 3:
                            system("cls");
                            printf("-------------------------------------------------\n");
                            //difícil();
                            printf("-------------------------------------------------\n");
                        break;

                        default:
                            system("cls");
                            cabecalho();
                            printf("\t\t\t\t-------------------------------------------------\n");
                            printf("\t\t\t\t> Opção inválida!\n");
                            printf("\t\t\t\t-------------------------------------------------\n");
                            Sleep(2000);
			                system("cls");
                    }
                } while(difi > 1 || difi < 3);
            break;

            case 2:
                system("cls");
                cabecalho();
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t > TUTORIAL:\n");
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t # O objetivo do jogo é achar um par de cada carta.\n\t\t\t\t # Alcançar 800 pontos no nível fácil.\n\t\t\t\t # Alcançar 3200 pontos no nível médio. \n\t\t\t\t # Alcançar 5000 pontos no nível difícil.\n\n\t\t\t\t # Boa sorte! :)\n\n");
                printf("\t\t\t\t-------------------------------------------------\n");
				printf("\t\t\t\t");
				system("Pause");
                system("cls");
            break;
            
            case 3:
                system("cls");
                cabecalho();
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t > CRÉDITOS:\n");
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\tAutor: Pietra Ester\n"
 						"\t\t\t\tEngenharia de Software \n\n"
						"\t\t\t\tEsse código foi escrito por Pietra, compilado e\n\t\t\t\ttestado sobre o Windows 11 Home Single Language,\n\t\t\t\tsistema operacional de 64 bits.\n\n" 
						"\t\t\t\tIDE: Dev-C++ 5.11\n");
                printf("\t\t\t\t-------------------------------------------------\n");
				printf("\t\t\t\t");
				system("Pause");
                system("cls");
            break;

            case 4:
                system("cls");
                printf("> SAINDO DO PROGRAMA...\n");
                exit(0);

            default:
                system("cls");
                cabecalho();
                printf("\t\t\t\t-------------------------------------------------\n");
                printf("\t\t\t\t> Opção inválida!\n");
                printf("\t\t\t\t-------------------------------------------------\n");
                Sleep(2000);
                system("cls");
        }
    } while(opcao > 1 || opcao < 4);

    return 0;
}

//funcão de cabeçalho
void cabecalho(){
	    printf("\t\t\t\t/////////////////////////////////////////////////\n");
        printf("\t\t\t\t///////// BEM VINDO AO JOGO DA MEMÓRIA //////////\n");
        printf("\t\t\t\t/////////////////////////////////////////////////\n\n");
}

//FUNÇÃO QUE GERA TABULEIRO DE NÍVEL FÁCIL
char fácil()
{
    char** tabuleiro;
    char cartas[F_LIN * F_COL / 2] = {'a', 'b', 'c', 'd', 'e', 'f','g','h'};//'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'};
    int i, j, c=0, cont=0;
    srand(time(NULL));

    // aloca um vetor de F_LIN ponteiros para as linhas
    tabuleiro = (char**) malloc (F_LIN * sizeof (char*)) ;

    // aloca cada uma das linhas (vetores de F_COL char)
    for (i=0; i < F_LIN; i++)
    {
        tabuleiro[i] = (char*) malloc (F_COL * sizeof (char)) ;
    }

    //preenche com caracteres aleatórios
    for (i=0; i<F_LIN; i++)
    {
        for (j=0; j<F_COL;j++)
        {
            tabuleiro [i][j]='*';
        }
    }

    while (c<F_LIN*F_COL/2)
    {
        i = rand() % F_LIN;
        j = rand() % F_COL;
        if (tabuleiro[i][j] == '*')
        {
            tabuleiro [i][j] = cartas[c];
            cont= cont + 1;
        }
        else
        {
            continue;
        }
        if (cont==2)
        {
            c=c+1;
            cont=0;
        }
    }

    //âncora para nova jogada
    jogada:
    system("cls");
    jogadas++;
    
    //status do jogo
    cabecalho();
    printf("\t\t\t\t-------------------------------------------------\n");
    printf("\t\t\t\t> JOGADOR : %s\n"
		   "\t\t\t\t> NÍVEL   : Fácil\n"
           "\t\t\t\t> PONTOS  : %d pts\n"
           "\t\t\t\t> ACERTOS : %d\n"
		   "\t\t\t\t> JOGADAS : %d\n",
           nome[k], pts, acertos, jogadas);
    printf("\t\t\t\t-------------------------------------------------\n");

    //imprime a matriz
    printf("\t\t\t\t\t          ");
    for(i=0; i<4; i++)
    {
        printf("%d   ", i);
    }
    printf("\n");
    for (i=0; i < F_LIN; i++)
    {
    	printf("\t\t\t\t\t     ");
        printf(" %d | ", i);
        for (j=0; j < F_COL; j++)
        {
            printf("%c | ", tabuleiro[i][j]);
        }
        printf("\n");
    }
    printf("\t\t\t\t-------------------------------------------------\n");

    //lógica do jogo
    while(pts < 800)
	{
        printf("\n\t\t\t\t> Digite a linha e coluna respectivamente: ");
        scanf(" %d %d", &lin, &col);    	
			
        printf("\t\t\t\t> Digite a linha e coluna respectivamente: ");
        scanf(" %d %d", &lin2, &col2);
		    
        if (lin <0 || lin > 3 || col < 0 || col > 3)
        {
            printf("\t\t\t\t-------------------------------------------------\n\n");
            printf("\t\t\t\tJOGADA INVÁLIDA! Digite números de 0 a 3!\n\n");
            printf("\t\t\t\t");
            system("pause");
            goto jogada;
        }
        else if (lin2 <0 || lin2 > 3 || col2 < 0 || col2 > 3)
        {
            printf("\t\t\t\t-------------------------------------------------\n\n");
            printf("\t\t\t\tJOGADA INVÁLIDA! Digite números de 0 a 3!\n\n");
            printf("\t\t\t\t");
            system("pause");
            goto jogada;
        }
        else if(lin == lin2 && col == col2)
        {
            printf("\t\t\t\t-------------------------------------------------\n\n");
            printf("\t\t\t\t\tJOGADA INVÁLIDA! Lugar ocupado!\n\n");
            Sleep(2000);
            goto jogada;
        }
        
        else if(tabuleiro[lin][col] == tabuleiro[lin2][col2])
        {
            printf("\n\t\t\t\t\tBOOAAA! Você ganhou +100 pts!\n\n");
            Sleep(2000);
            pts = pts + 100;
            acertos ++;
            goto jogada;
        }
        else if (tabuleiro[lin][col] != tabuleiro[lin2][col2])
        {
            printf("\n\t\t\t\t\t\t    ERROU!!!\n\n");
            Sleep(2000);
            goto jogada;
        }

    }
    
    if(pts == 800)
    {
    	jogadas--;
    	acertos--;
        printf("\n\t\t\t\t***PARABÉNS %s!\n\t\t\t\t*Você alcançou os 800 pontos com %d jogadas!*\n\t\t\t\t***Sua memória é muito boa!!!* 8)\n", nome[k], jogadas);
        printf("\t\t\t\t\t\t   _1_ \n");
        printf("\t\t\t\t\t\t   |o| \n\n");
        printf("\t\t\t\t");
        system("pause");
        system("cls");
        exit(0);
    }

    // libera a memória da matriz
    for (i=0; i < F_LIN; i++)
    {
        free(tabuleiro[i]);
    }
    free(tabuleiro); 
}

arfneto · 29 de dezembro de 2021

4 horas atrás, Pietra Ester disse:

meu professor na faculdade esta me ensinando a programar assim

não programe assim, pelas razões que te expliquei. Nem precisa trocar de professor. Apenas compare e julgue.

Exemplos

Seu programa roda dentro de um loop:

    // lógica do jogo
    while (pts < 800)
    {
         //...
    }

Acho mesmo que não precisa desse tipo de comentário...

No entanto veja o que tem ao final do loop:

if(pts == 800)
    {
    	jogadas--;
    	acertos--;
        printf("\n\t\t\t\t***PARABÉNS %s!\n\t\t\t\t*
               Você alcançou os 800 pontos \
        com %d jogadas!*\n\t\t\t\t***Sua memória \
        é muito boa!!!* 8)\n", nome[k], jogadas);
        printf("\t\t\t\t\t\t   _1_ \n");
        printf("\t\t\t\t\t\t   |o| \n\n");
        printf("\t\t\t\t");
        system("pause");
        system("cls");
        exit(0);
    }

    // libera a memória da matriz
    for (i=0; i < F_LIN; i++)
    {
        free(tabuleiro[i]);
    }
    free(tabuleiro); 
};	// while()...

800 não é menor que 800... Isso quer dizer que esse código do if está no lugar errado. Já programou a saida para quanto pts não for menor que 800.

Isso deveria estar depois do while.

E importa? Sim, importa: durante todo o jogo vai testar isso duas vezes. E ainda tem um buraco negro para quando e se pts for MAIOR que 800 já que não vai encerrar o programa pelo if mas vai sair do loop e cair no vazio...

Se cada loop no while equivale a um jogo porque não tem uma função para isso?

E se ela retornasse os pontos obtidos no jogo? Não seria bem conveniente?

Acha mesmo que esses comentários adicionam algo ao programa?

E os acentos?

Não use acentos nos nomes das variáveis.

// variavel global
int  lin, col, lin2, col2, k = 0, pts = 0, acertos = 0, jogadas = 0;
char nome[50][50];

Não use isso. É proibido em toda parte, escolas e empresas.

E muito menos globais com um nominho ingênuo como k, lin...

// FUNÇÃO QUE GERA TABULEIRO DE NÍVEL FÁCIL
char fácil()

Notou que a[esar do comentário a função fácil() não só gera o tabuleiro como tem o loop do jogo? Não escreva assim.

Não seria mais simples ter uma função

Tabuleiro**    gera( nivel );

onde você passa 0 para fácil e 1 a 9 para outros níveis e ela devolve o tabuleiro?

E ter uma outra

Tabuleiro**    apaga( Tabuleiro** a_apagar );

em que você passa o endereço do tabuleiro e ela libera a memória e retorna NULL?

E ter uma outra

    int jogo(Tabuleiro** t, int pontos);

Em que você passa os pontos que o cara já tem e o endereço do tabuleiro e ela retorna os pontos ao final de um jogo?

Seria.

    char   cartas[F_LIN * F_COL / 2] = {
        'a', 'b', 'c', 'd', 'e',
        'f', 'g', 'h'};  //'i','j','k','l','m','n','o','p'\
,'q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'};

É a mesma coisa que

    char   cartas[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};

E isso

Não seria a solução para seu problema???

EXEMPLO

isso

    // status do jogo
    cabecalho();
    printf(
        "\t\t\t\t-------------------------------------------------\n");
    printf(
        "\t\t\t\t> JOGADOR : %s\n"
        "\t\t\t\t> NÍVEL   : Fácil\n"
        "\t\t\t\t> PONTOS  : %d pts\n"
        "\t\t\t\t> ACERTOS : %d\n"
        "\t\t\t\t> JOGADAS : %d\n",
        nome[k], pts, acertos, jogadas);
    printf(
        "\t\t\t\t-------------------------------------------------\n");

é a mesma coisa que isso

    // status do jogo
    cabecalho();
    printf("\
\t\t\t\t-----------------------"
" --------------------------\n\
\t\t\t\t> JOGADOR : %s\n\
\t\t\t\t> NÍVEL   : Fácil\n\
\t\t\t\t> PONTOS  : %d pts\n\
\t\t\t\t> ACERTOS : %d\n\
\t\t\t\t> JOGADAS : %d\n\
\t\t\t\t-----------------------"
"--------------------------\n",
        nome[k], pts, acertos, jogadas);