void consumidor(Shared *shm) {
  int j, n;
  while(1) {
    /* Se o produtor nao vai mais produzir, o proprio consumidor tem que liberar o seu semaforo */
    if(shm->termina) {
      sem_post(&shm->c_sem);
      /* Se a pilha ficar vazia e o produtor nao vai mais produzir, terminou a tarefa */
      if(pilhaVazia(&shm->pilha)) break;
    }

    /* Aguarda ate semaforo ficar verde */
    sem_wait(&shm->c_sem);
    
    /* Cada consumidor vai consumir entre 0 e 9 vezes por ciclo */
    n = randomNumber(0, 9);
    printf("[PID: %d] Consumir: %d vezes\n", getpid(), n);

    /* Consome N vezes por ciclo */
    for(j = 0; j < n; j++) {
      if(!pilhaVazia(&shm->pilha)) {
        printf("[PID: %d] Consumindo: %d\n", getpid(), topoPilha(&shm->pilha));
        desempilha(&shm->pilha);
      } else {
        printf("[PID: %d] Pilha esvaziou! Lote teve %d unidades\n", getpid(), j);
        break;
      }
    }

    /* Libera produtor */
    sem_post(&shm->p_sem);
  }
}
Exemple #2
0
/*****************************************************************************
 * Movimenta uma carta de [A-H] para [A-H]
 *****************************************************************************/
void movimentaNormalParaNormal(Pilha* pilhasNormais[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador){
  Carta cartaColunaOrigem = topoPilha(pilhasNormais[indiceColunaOrigem]);
  unsigned short int corCartaColunaOrigem = checaCorNaipe(cartaColunaOrigem.naipe);

  Carta cartaColunaDestino = topoPilha(pilhasNormais[indiceColunaDestino]);
  unsigned short int corCartaColunaDestino = checaCorNaipe(cartaColunaDestino.naipe);

  if(corCartaColunaDestino != corCartaColunaOrigem){
    if(cartaColunaOrigem.numero == cartaColunaDestino.numero-1 || pilhasNormais[indiceColunaDestino]->qntd == 0){
      inserePilha(pilhasNormais[indiceColunaDestino], cartaColunaOrigem);
      removePilha(pilhasNormais[indiceColunaOrigem]);
      (*jogadaJogador)++;
    } else {
      strcpy(mensagemErro, "Voce so pode agrupar cartas em ordem decrescente.");
    }
  } else {
    strcpy(mensagemErro, "Voce so pode agrupar cartas cujos naipes tenham cores diferentes.");
  }
}
Exemple #3
0
/*****************************************************************************
 * Movimenta uma carta de [A-H] para [W-Z]
 *****************************************************************************/
void movimentaNormalParaSuperiorEsquerda(Carta cartasSuperiorEsquerda[], Pilha* pilhasNormais[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador){
  if(cartasSuperiorEsquerda[indiceColunaDestino].numero == 0){
    Carta cartaColunaOrigem = topoPilha(pilhasNormais[indiceColunaOrigem]);
    cartasSuperiorEsquerda[indiceColunaDestino] = cartaColunaOrigem;
    removePilha(pilhasNormais[indiceColunaOrigem]);
    (*jogadaJogador)++;
  } else {
    strcpy(mensagemErro, "As colunas [W-Z] so podem ter uma carta por vez.");
  }
}
Exemple #4
0
/*****************************************************************************
 * Movimenta uma carta de [A-H] para [0-3]
 *****************************************************************************/
void movimentaNormalParaSuperiorDireita(Pilha* pilhasNormais[], Pilha* pilhasSuperiorDireita[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador, unsigned short int *colunasFormadas){
  Carta cartaColunaOrigem = topoPilha(pilhasNormais[indiceColunaOrigem]);
  Carta cartaColunaDestino = topoPilha(pilhasSuperiorDireita[indiceColunaDestino]);

  if(cartaColunaOrigem.naipe == cartaColunaDestino.naipe || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0){

    if(cartaColunaOrigem.numero == cartaColunaDestino.numero+1 || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0 && cartaColunaOrigem.numero == 1){
      (*jogadaJogador)++;
      inserePilha(pilhasSuperiorDireita[indiceColunaDestino], cartaColunaOrigem);
      removePilha(pilhasNormais[indiceColunaOrigem]);

      if(cartaColunaOrigem.numero == MAIOR_VALOR_CARTA){
        colunasFormadas++;
      }

    } else {
      strcpy(mensagemErro, "Nas colunas [0-3], voce so pode agrupar cartas em ordem crescente.");
    }
  } else {
    strcpy(mensagemErro, "Nas colunas [0-3], as cartas precisam ser sempre do mesmo naipe.");
  }
}
Exemple #5
0
/*****************************************************************************
 * Imprime cartas do canto superior direito ([0-3])
 *****************************************************************************/
void imprimeSuperiorDireita(Pilha* pilhasSuperiorDireita[]){
  unsigned short int coluna;
  for(coluna = 0; coluna < MAX_PILHAS_SUPERIOR_DIREITA; coluna++){
    if(pilhasSuperiorDireita[coluna]->qntd == 0){
      printf("|      |  ");
    } else {
      Carta carta = topoPilha(pilhasSuperiorDireita[coluna]);
      char numero[3];
      pegaSimboloCartaPeloNumero(carta.numero, numero);
      printf("| %s %c |  ", numero, carta.naipe);
    }
  }

  printf("\n\n");
  printf("\t   [#W]      [#X]      [#Y]      [#Z]      [#0]      [#1]      [#2]      [#3]   \n");
  printf("\n\n\n");
}
Exemple #6
0
/*****************************************************************************
 * Movimenta uma carta de [W-Z] para [0-3]
 *****************************************************************************/
void movimentaSuperiorEsquerdaParaSuperiorDireita(Carta cartasSuperiorEsquerda[], Pilha* pilhasSuperiorDireita[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador, unsigned short int *colunasFormadas){
  Carta cartaColunaOrigem = cartasSuperiorEsquerda[indiceColunaOrigem];
  Carta cartaColunaDestino = topoPilha(pilhasSuperiorDireita[indiceColunaDestino]);

  if(cartaColunaOrigem.naipe == cartaColunaDestino.naipe || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0){
    if(cartaColunaOrigem.numero == cartaColunaDestino.numero+1 || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0 && cartaColunaOrigem.numero == 1){
      inserePilha(pilhasSuperiorDireita[indiceColunaDestino], cartaColunaOrigem);
      inicializaCartaComValorPadrao(&(cartasSuperiorEsquerda[indiceColunaOrigem]));
      (*jogadaJogador)++;

      // Se a carta a ser inserida eh a ultima (13), entao a coluna esta formada
      if(cartaColunaOrigem.numero == MAIOR_VALOR_CARTA){
        colunasFormadas++;
      }

    } else {
      strcpy(mensagemErro, "Nas colunas [0-3], voce so pode agrupar cartas em ordem crescente.");
    }
  } else {
    strcpy(mensagemErro, "Nas colunas [0-3], as cartas precisam ser sempre do mesmo naipe.");
  }
}