Jump to content

chamar função dentro de outra função e não corresponde em C


mirador_22
 Share

Recommended Posts

Ola a todos, estou com uma duvida em chamar funções apartir de outras funções e não corresponde nada,

já vi todas as partes e não consigo decifrar o erro e alguma ideia, eu agradecia.

ps: só foi postado alguma parte de codigo que tenho duvidas

#define MAX_NUM_JOGADOR	   3//numero maximo de jogadores
#define MAX_NUM_BOLA	   2//numero maximo de bolas para jogo

typedef struct BOLA BOLA; // tipo de dados estruturado BOLA que irá ser declarado
typedef struct JOGADOR JOGADOR; // tipo de dados estruturado JOGADOR que irá ser declarado
typedef struct CAMPO CAMPO; // tipo de dados estruturado CAMPO que irá ser declarado

struct BOLA {//cada bola
int num_bola; // contem um numero de bola
}; // Declaração da estrutura que define a bola

struct JOGADOR {//cada jogador
int num_jogador; // contem um numero de jogador
BOLA bola[MAX_NUM_BOLA]; // existem várias bolas entre uma a duas bolas
}; // Declaração da estrutura que define o jogador

struct CAMPO {//O campo
JOGADOR jogadores[MAX_NUM_JOGADOR]; // contem no maximo 5 jogadores
BOLA bolas[MAX_NUM_BOLA]; // possui no maximo 3 bolas para cada jogo
}; // Declaração da estrutura que define o campo

JOGADOR novo_jogador; /*novo jogador*/
BOLA nova_bola; /*nova bola*/
CAMPO campo;

BOLA *ptr_bola; /*apontador para  nova bola*/
JOGADOR *ptr_jogador; /*apontador para  novo jogador*/
CAMPO *ptr_campo; /*apontador para  campo*/

void criar_jogador(void);
void criar_bola(void);
void bola_para_jogador(void);
void dar_bola_ao_jogador(int, int);
void chutar_bola_para_baliza(int, int);

// funçao para criar jogador e adicionar ao campo
void criar_jogador(void) {
int i; //identificador para incrementar criação de jogador
/* criar jogador*/
for (i = 0; i < MAX_NUM_JOGADOR; i++) {
	*ptr_jogador = novo_jogador;
	novo_jogador.num_jogador++; //incrementa o numero de jogador
	campo.jogadores[i] = *ptr_jogador; //adicionar o jogador no campo
	*ptr_campo = campo;
	printf("Criando jogador %02d...\n\n", ptr_campo->jogadores[i].num_jogador + 1);
}
}

/* função criar bola*/
void criar_bola(void) {
int k; //identificador para incrementar criação de bola

for (k = 0; k < MAX_NUM_BOLA; k++) {
	*ptr_bola = nova_bola;
	nova_bola.num_bola++; //incrementa o numero da bola
	campo.bolas[k] = *ptr_bola; //adicionar a bola no campo
	*ptr_campo = campo;
	printf("Criar bola %02d...\n\n", ptr_campo->bolas[k].num_bola + 1);
}
}

/*função para dar bola ao jogador escolhido aleatoriamente*/
void dar_bola_ao_jogador(int num_bola, int num_jogador){

*ptr_bola = nova_bola;
*ptr_jogador = novo_jogador;
*ptr_campo = campo;
*ptr_estatistica = estatisticas;

	//se o jogador no campo que recebe a bola for igual ao jogador escolhido
	if (num_jogador == ptr_campo->jogadores[num_jogador].num_jogador) {//Duvida
		//a bola recebida é a mesma que está no campo
		ptr_campo->jogadores[num_jogador].t_posse_bola = time(NULL); //tempo de posse bola
		ptr_campo->jogadores[num_jogador].bola[num_bola].num_bola = ptr_campo->bolas[num_bola].num_bola;
		printf("\tA bola %02d foi para jogador %02d na baliza %02d...\n\n",
				ptr_campo->bolas[num_bola].num_bola + 1,
				ptr_campo->jogadores[num_jogador].num_jogador + 1,
				ptr_campo->jogadores[num_jogador].baliza.num_baliza + 1);
		sleep(1);
		printf("\tO jogador %02d na baliza %02d tem a bola %02d...\n\n",
				ptr_campo->jogadores[num_jogador].num_jogador + 1,
				ptr_campo->jogadores[num_jogador].baliza.num_baliza + 1,
				ptr_campo->jogadores[num_jogador].bola[num_bola].num_bola + 1);

	}

}

/*função para jogador X chutar bola para baliza de outro jogador*/
void chutar_bola_para_baliza(int num_bola, int chuta_bola) {

int trajetoria_bola;
int recebe_bola_chutada;
 srand(time(NULL));

*ptr_bola = nova_bola;
*ptr_jogador = novo_jogador;
*ptr_campo = campo;

while (1) {//para teste

	//Duvida -> o jogador não chuta para sua baliza
	recebe_bola_chutada = rand() % MAX_NUM_JOGADOR + 1;

	//jogador X tem a bola e chuta para Jogador Y -> Duvida
	if (ptr_campo->jogadores[recebe_bola_chutada].num_jogador != ptr_campo->jogadores[chuta_bola].num_jogador) {

		ptr_campo->jogadores[recebe_bola_chutada].bola[num_bola] = ptr_campo->jogadores[chuta_bola].bola[num_bola];
		ptr_campo->jogadores[chuta_bola].estatistica.qt_remates++;

		printf("\tO jogador %02d chutou a bola %02d para baliza %02d do jogador %02d...\n\n",
				ptr_campo->jogadores[chuta_bola].num_jogador + 1,
				ptr_campo->jogadores[chuta_bola].bola[num_bola].num_bola + 1,
				ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
				ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1);

		sleep(1);
		printf("\tO jogador %02d na baliza %02d tem a bola %02d...\n\n",
				ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
				ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
				ptr_campo->jogadores[recebe_bola_chutada].bola[num_bola].num_bola + 1);
	}
}
}

e a minha duvida é nesta parte em chamar as funções

void dar_bola_ao_jogador(int num_bola, int num_jogador);
e função void chutar_bola_para_baliza(int num_bola, int chuta_bola);

/* função dar bola ao jogador - aleatorio*/
void bola_para_jogador(void) {

int m, n, p, q;
int recebe_bola;
srand(time(NULL));

*ptr_bola = nova_bola;
*ptr_jogador = novo_jogador;
*ptr_campo = campo;

printf("\n\n");
printf("\t\t+====================================+\n");
printf("\t\t|			INICIAR JOGO			|\n");
printf("\t\t+====================================+\n\n");

for (m = 0, p = 0; m < MAX_NUM_BOLA; m++) {
	recebe_bola = rand() % MAX_NUM_JOGADOR;
	for (q = 0; q < MAX_NUM_JOGADOR; q++) {
		if (recebe_bola == ptr_campo->jogadores[q].num_jogador) {
			dar_bola_ao_jogador(m, ptr_campo->jogadores[q].num_jogador);
		}
	}
	p++;
}
if (p == qt_bola) {
	chutar_bola_para_baliza(m, ptr_campo->jogadores[recebe_bola].num_jogador);

	printf("\n\n");
	printf("\t\t+====================================+\n");
	printf("\t\t|		   JOGO TERMINOU			|\n");
	printf("\t\t+====================================+\n\n");
}
}

eis a imagem da simulação...

vDGay4L.jpg?1

Edited by mirador_22
Link to comment
Share on other sites

o objetivo é mais ou menos assim

nStg4dp.jpg?1

de acordo com o este codigo em baixo..., mas o problema consiste em chamar as funções

void dar_bola_ao_jogador(int num_bola, int num_jogador);

e função void chutar_bola_para_baliza(int num_bola, int chuta_bola);

/* função dar bola ao jogador - aleatorio*/
void bola_para_jogador(void) {
int m;
int recebe_bola;
srand(time(NULL));

*ptr_bola = nova_bola;
*ptr_jogador = novo_jogador;
*ptr_campo = campo;
*ptr_estatistica = estatisticas;

printf("\n\n");
printf("\t\t+====================================+\n");
printf("\t\t|			INICIAR JOGO			|\n");
printf("\t\t+====================================+\n\n");

for (m = 0; m < qt_bola; m++) {
	printf("Bola %02d\n", m + 1);
	recebe_bola = rand() % qt_jogador + 1;
	printf("Jogador %02d recebe bola %02d\n", recebe_bola, m + 1);
}
printf("\n\n");
printf("\t\t+====================================+\n");
printf("\t\t|		   JOGO TERMINOU			|\n");
printf("\t\t+====================================+\n\n");
}
Edited by mirador_22
Link to comment
Share on other sites

Pronto já consegui resolver embora ainda existe alguns erros mas é normal, o que eu fiz foi juntar os dois metodos em apenas um metodo que faz toda as duas operaçõe, aqui vai o codigo

/* função comecar o jogo */
void comecar_jogo(void) {

int m, p;
int recebe_bola;
int recebe_bola_chutada;
int trajetoria_bola;
srand(time(NULL));

*ptr_bola = nova_bola;
*ptr_jogador = novo_jogador;
*ptr_campo = campo;

printf("\n\n");
printf("\t\t+====================================+\n");
printf("\t\t|			INICIAR JOGO			|\n");
printf("\t\t+====================================+\n\n");
for (m = 0, p = 0; m < qt_bola; m++) {
	recebe_bola = rand() % qt_jogador + 1;
	printf("Jogador %02d recebe bola %02d...\n", recebe_bola, m + 1);
	//se o jogador no campo que recebe a bola for igual ao jogador escolhido
	if (recebe_bola == ptr_campo->jogadores[recebe_bola].num_jogador) {//Duvida
		//a bola recebida é a mesma que está no campo
		ptr_campo->jogadores[recebe_bola].t_posse_bola = time(NULL); //tempo de posse bola
		ptr_campo->jogadores[recebe_bola].bola[m].num_bola = ptr_campo->bolas[m].num_bola;
		printf("\tA bola %02d foi para jogador %02d na baliza %02d...\n",
				ptr_campo->bolas[m].num_bola + 1,
				ptr_campo->jogadores[recebe_bola].num_jogador,
				ptr_campo->jogadores[recebe_bola].baliza.num_baliza + 1);
		sleep(1);
		printf("O jogador %02d na baliza %02d tem a bola %02d...\n\n",
				ptr_campo->jogadores[recebe_bola].num_jogador,
				ptr_campo->jogadores[recebe_bola].baliza.num_baliza + 1,
				ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1);
		sleep(1);
	}
	p++;
}
if (p == qt_bola) {
	while (1) {//para teste
		//Duvida -> o jogador não chuta para sua baliza
		recebe_bola_chutada = rand() % qt_jogador + 1;
		//jogador X tem a bola e chuta para Jogador Y -> Duvida
		if (ptr_campo->jogadores[recebe_bola_chutada].num_jogador != ptr_campo->jogadores[recebe_bola].num_jogador) {
			ptr_campo->jogadores[recebe_bola_chutada].bola[m] = ptr_campo->jogadores[recebe_bola].bola[m];
			ptr_campo->jogadores[recebe_bola].estatistica.qt_remates++;
			printf("O jogador %02d chutou a bola %02d para baliza %02d do jogador %02d...\n",
					ptr_campo->jogadores[recebe_bola].num_jogador + 1,
					ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
					ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
					ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1);
			sleep(1);
			//Duvida -> o jogador não chuta para sua baliza
			trajetoria_bola = 1 + rand() % 5;
			ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria = obter_trajetoria_da_bola(trajetoria_bola); //meio da baliza
			if (trajetoria_bola == 5) {//para fora
				printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s...\n",
						ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
						ptr_campo->jogadores[recebe_bola].num_jogador + 1,
						ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
						ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
						ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
			} else {
				printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s da baliza...\n",
						ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
						ptr_campo->jogadores[recebe_bola].num_jogador + 1,
						ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
						ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
						ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
			}
			sleep(1);
			printf("O jogador %02d na baliza %02d tem a bola %02d...\n\n",
					ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
					ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
					ptr_campo->jogadores[recebe_bola_chutada].bola[m].num_bola + 1);
		}
	}
}
}

aqui o printscreen da simulação

nota: o projeto é em C usando tecnicas de sincronização, mas não achei necessario colocar os semaforos

bFxdauN.jpg?1

ps: alguma sugestão, orientação ou ajuda para imprimir os valores corretos

eu agradecia

Edited by mirador_22
Link to comment
Share on other sites

se é um trabalho de concorrência, não achas estranho que não exista nada a sincronizar ?

sim por acaso, é um trabalho de concorrencia e achei desnecessario ter que colocar os semaforos

e memorias partilhadas, esse foi um exemplo mais pratico sem uso de semaforos e se é isso que estása dizer

entao vai o codigo abaixo com os semaforos

/**********************************************
**	 Declaração dos Semaforos			 **
**********************************************/
semaphore mutex_jogador; /*mutex*/
semaphore full_jogador; /*cheio*/
semaphore empty_jogador; /*vazio*/
semaphore mutex_estatistica; /*estatistica*/
semaphore time_mutex;
semaphore print_mutex;
semaphore mutex_baliza; /*mutex*/
semaphore full_baliza; /*cheio*/
semaphore empty_baliza; /*vazio*/
semaphore mutex_bola; /*mutex*/
semaphore full_bola; /*cheio*/

/************************************************
**   Função para inicializar os Semaforos	 ** 
************************************************/
void inicializar_semaforos(void) {

   mutex_jogador = init_sem(1); /*mutex*/
   full_jogador = init_sem(0); /*cheio*/
   empty_jogador = init_sem(qt_jogador); /*vazio*/

   mutex_estatistica = init_sem(1); /*estatistica*/
   time_mutex = init_sem(1);
   print_mutex = init_sem(1);

   mutex_baliza = init_sem(1); /*mutex*/
   full_baliza = init_sem(0); /*cheio*/
   empty_baliza = init_sem(qt_jogador); /*vazio*/

   mutex_bola = init_sem(1); /*mutex*/
   full_bola = init_sem(0); /*cheio*/
   empty_bola = init_sem(qt_bola); /*vazio*/
}
/* função comecar o jogo */
void comecar_jogo(void) {

   int m, p;
   int recebe_bola;
   int recebe_bola_chutada;
   int trajetoria_bola;
   srand(time(NULL));

   *ptr_bola = nova_bola;
   *ptr_jogador = novo_jogador;
   *ptr_campo = campo;

   printf("\n\n");
   printf("\t\t+====================================+\n");
   printf("\t\t|		    INICIAR JOGO		    |\n");
   printf("\t\t+====================================+\n\n");
   for (m = 0, p = 0; m < qt_bola; m++) {
    recebe_bola = rand() % qt_jogador + 1;
    printf("Jogador %02d recebe bola %02d...\n", recebe_bola, m + 1);
    P(mutex_jogador);
    P(mutex_bola);
    //se o jogador no campo que recebe a bola for igual ao jogador escolhido
    if (recebe_bola == ptr_campo->jogadores[recebe_bola].num_jogador) {//Duvida
	    //a bola recebida é a mesma que está no campo
	    ptr_campo->jogadores[recebe_bola].t_posse_bola = time(NULL); //tempo de posse bola
	    ptr_campo->jogadores[recebe_bola].bola[m].num_bola = ptr_campo->bolas[m].num_bola;
	    P(print_mutex);
	    printf("\tA bola %02d foi para jogador %02d na baliza %02d...\n",
			    ptr_campo->bolas[m].num_bola + 1,
			    ptr_campo->jogadores[recebe_bola].num_jogador,
			    ptr_campo->jogadores[recebe_bola].baliza.num_baliza + 1);
	    sleep(1);
	    printf("O jogador %02d na baliza %02d tem a bola %02d...\n\n",
			    ptr_campo->jogadores[recebe_bola].num_jogador,
			    ptr_campo->jogadores[recebe_bola].baliza.num_baliza + 1,
			    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1);
	    V(print_mutex);
	    sleep(1);
    }
    p++;
    V(mutex_bola);
    V(mutex_jogador);
   }
   if (p == qt_bola) {
    while (1) {//para teste
	    //Duvida -> o jogador não chuta para sua baliza
	    recebe_bola_chutada = rand() % qt_jogador + 1;
	    //jogador X tem a bola e chuta para Jogador Y -> Duvida
	    if (ptr_campo->jogadores[recebe_bola_chutada].num_jogador != ptr_campo->jogadores[recebe_bola].num_jogador) {
		    P(mutex_jogador);
		    P(mutex_bola);
		    ptr_campo->jogadores[recebe_bola_chutada].bola[m] = ptr_campo->jogadores[recebe_bola].bola[m];
		    ptr_campo->jogadores[recebe_bola].estatistica.qt_remates++;
		    P(print_mutex);
		    printf("O jogador %02d chutou a bola %02d para baliza %02d do jogador %02d...\n",
				    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
				    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
				    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
				    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1);
		    sleep(1);
		    //Duvida -> o jogador não chuta para sua baliza
		    trajetoria_bola = 1 + rand() % 5;
		    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria = obter_trajetoria_da_bola(trajetoria_bola); //meio da baliza
		    if (trajetoria_bola == 5) {//para fora
			    printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s...\n",
					    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
					    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
					    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
					    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
					    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
		    } else {
			    printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s da baliza...\n",
					    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
					    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
					    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
					    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
					    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
		    }
		    sleep(1);
		    printf("O jogador %02d na baliza %02d tem a bola %02d...\n\n",
				    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
				    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
				    ptr_campo->jogadores[recebe_bola_chutada].bola[m].num_bola + 1);
		    V(print_mutex);
		    sleep(2);
		    V(mutex_bola);
		    V(mutex_jogador);
	    }
    }
    printf("\n\n");
    printf("\t\t+====================================+\n");
    printf("\t\t|		   JOGO TERMINOU		    |\n");
    printf("\t\t+====================================+\n\n");
   }
}
Edited by mirador_22
Link to comment
Share on other sites

novamente, continuo a não ver nada a ser sincronizado ... onde andam os threads ?

é assim, normalmente threads usamos em Java e C# e será utilizado no outro projeto mais a frente

neste projeto, usamos a função fork() para criar os processos, tal como esta referenciado na função

simulação em vez de usar #include <pthread.h> /* pthread functions and data structures */

/************************************************
**	Função que executa a simulação		  **
************************************************/
void simulacao(int *qt_jogador, int *qt_bola) {

int estado_filhos; /*estado dos processos filhos*/
pid_t child_pid[MAX_CHILD], wait_pid; /*processo pai*/
int i; //identificador para incrementar criação de processos filhos

mostrar_configuracao(qt_jogador, qt_bola); /*mostra as configurações atuais*/
sleep(1); /*aguarda 1 segundo*/

printf("\n\t Inicializar a memoria partilhada...\n");
incializar_memoria_partilhada(); /*inicializar a memória partilhada*/
sleep(1); /*aguarda 1 segundo*/
printf("\t Ok!\n\n");

sleep(1); /*aguarda 1 segundo*/
printf("\t Inicializar os semáforos...\n");
inicializar_semaforos(); /*inicializar os semaforos*/
sleep(1); /*aguarda 1 segundo*/
printf("\t Ok!\n\n");

sleep(1); /*aguarda 1 segundo*/
printf("\n\n\n\t\t---------- INICIANDO SIMULAÇÃO ----------\n\n"); /*inicia a simulação*/
sleep(1); /*aguarda 1 segundo*/
for (i = 0; i < MAX_CHILD; i++) {
	child_pid[i] = fork(); /*criação dos processos filhos*/
	switch (child_pid[i]) {
		case -1: /*falha no fork??*/
			printf("\n O Fork falhou!!! \n");
			exit(0);
			break;
		case 0: //processo filho
			alarm(tempo_jogo); /*alarme para matar o processo filho*/
			for (; {/*ciclo infinito para correr o código dos filhos*/
				switch (i) {
					case 0:
						iniciar_jogo();
						break;
					default:
						printf("\n\t\t Erro na criação de processo!!\n\n");
						exit(1);
						break;
				}
			}
			exit(1);
			break;
		default:
			if (i == (MAX_CHILD - 1)) {
				for (int j = 0; j < MAX_CHILD; ++j) {
					wait_pid = wait(&estado_filhos);
					if (wait_pid == -1) {
						printf("\n Falha no WAIT \n");
						errno = 0;
					};
				};
			}
	}
}
puts("\n\t\t---------- TERMINANDO DA SIMULAÇÃO ----------\n\n"); /*termina a simulação*/
//mostrar_estatisticas(); /*mostra a estatistica*/
sleep(2); /*aguarda 2 segundos*/
printf("\n\t Limpando Semaforos...\n"); /*prepara para limpar os semaforos*/
limpar_semaforos(); /*limpa os semaforos*/
sleep(2); /*aguarda 2 segundos*/
printf("\t Ok!\n\n"); /**/
sleep(1); /*aguarda 1 segundo*/
printf("\t Limpando memoria partilhada...\n"); /*prepara para limpar as memorias partilhadas*/
limpar_memoria_partilhada(); /*limpa as memorias partilhadas*/
sleep(2); /*aguarda 2 segundos*/
printf("\t Ok!\n\n"); /**/
sleep(1); /*aguarda 1 segundo*/
printf("\t Regressando ao Menu Utilizador...\n\n"); /*prepara para voltar ao menu de utilizador*/
sleep(1); /*aguarda 1 segundo*/
menu_utilizador(qt_jogador, qt_bola); /*mostra o menu de utilizador*/
}
Edited by mirador_22
Link to comment
Share on other sites

pelo que vejo nesse código, o que estás a fazer é criar MAX_CHILD simulações em simultâneo, o que desconfio que não é exactamente o pretendido pelo problema

a função void simulacao(void), faz parte do esqueleto do projeto que foi fornecido pelo prof. na qual utilizamos a função fork() para criar os processos filhos atraves processo pai, no meu tive que usar dois apontadores para capturarem os valores de jogador e bola, para que possa ser mostrado nas configurações tal como está referenciao aqui

void simulacao(int *qt_jogador, int *qt_bola) {

    int estado_filhos; /*estado dos processos filhos*/
    pid_t child_pid[MAX_CHILD], wait_pid; /*processo pai*/
    int i; //identificador para incrementar criação de processos filhos

    mostrar_configuracao(qt_jogador, qt_bola); /*mostra as configurações atuais*/
    sleep(1); /*aguarda 1 segundo*/
...}

o meu problema é apartir daqui que em verificar os jogadores que tem a bola e devem chutar para outro jogador mas não para sua propria baliza

if (p == qt_bola) {
	    while (1) {//para teste
			    //Duvida -> o jogador não chuta para sua baliza
			    recebe_bola_chutada = rand() % qt_jogador + 1;
			    //jogador X tem a bola e chuta para Jogador Y -> Duvida
			    if (ptr_campo->jogadores[recebe_bola_chutada].num_jogador != ptr_campo->jogadores[recebe_bola].num_jogador) {
					    P(mutex_jogador);
					    P(mutex_bola);
					    ptr_campo->jogadores[recebe_bola_chutada].bola[m] = ptr_campo->jogadores[recebe_bola].bola[m];
					    ptr_campo->jogadores[recebe_bola].estatistica.qt_remates++;
					    P(print_mutex);
					    printf("O jogador %02d chutou a bola %02d para baliza %02d do jogador %02d...\n",
									    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
									    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
									    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
									    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1);
					    sleep(1);
					    //Duvida -> o jogador não chuta para sua baliza
					    trajetoria_bola = 1 + rand() % 5;
					    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria = obter_trajetoria_da_bola(trajetoria_bola); //meio da baliza
					    if (trajetoria_bola == 5) {//para fora
							    printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s...\n",
											    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
											    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
											    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
											    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
											    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
					    } else {
							    printf("\tA bola %02d chutada pelo jogador %02d para baliza %02d do jogador %02d foi %s da baliza...\n",
											    ptr_campo->jogadores[recebe_bola].bola[m].num_bola + 1,
											    ptr_campo->jogadores[recebe_bola].num_jogador + 1,
											    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
											    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
											    ptr_campo->jogadores[recebe_bola].bola[m].tipo_trajetoria);
					    }
					    sleep(1);
					    printf("O jogador %02d na baliza %02d tem a bola %02d...\n\n",
									    ptr_campo->jogadores[recebe_bola_chutada].num_jogador + 1,
									    ptr_campo->jogadores[recebe_bola_chutada].baliza.num_baliza + 1,
									    ptr_campo->jogadores[recebe_bola_chutada].bola[m].num_bola + 1);
					    V(print_mutex);
					    sleep(2);
					    V(mutex_bola);
					    V(mutex_jogador);
			    }
	    }
Link to comment
Share on other sites

este foi o esqueleto do projeto que serviu com o exemplo de um projeto estruturado e ainda falta o outro ficheiro sema.h que contém a estrutura e operaçoes dos semaforos que vais usar para fazer deadlock no processo

ps: a estrutura organizada e alguns dos codigos foram modificados por mim
Edited by mirador_22
Link to comment
Share on other sites

HappyHippyHippo

não dises nada relevante à minha questão ... continuas a ter MAX_CHILD simulações em vez de ter uma única simulação em que cada processo é uma entidade a correr em simultâneo/paralelo.

IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.