Esempio n. 1
0
int ehMesmoNaipe( CAR_tppCarta carta1, CAR_tppCarta carta2 )
{
   char naipe1 = '?' ;
   char naipe2 = '!' ; 

   CAR_ObterNaipe(carta1, &naipe1);
   CAR_ObterNaipe(carta2, &naipe2);

   if( naipe1 == naipe2 ) 
   {
      return 1;
   }
   return 0;
}
Esempio n. 2
0
   PIL_tpCondRet PIL_PopCarta( PIL_tppPilha pPilha , CAR_tppCarta * pCarta )
   {
	    int valor ;
		char naipe ;
		PIL_tpCondRet condRet = PIL_VerCarta( pPilha , pCarta , 0 ) ;
        
        *pCarta = NULL ;
        
		if ( condRet != PIL_CondRetOK )
		{
			return condRet ;
		}

		CAR_ObterNaipe( *pCarta, &naipe );
		CAR_ObterValor( *pCarta, &valor );

		LIS_ExcluirElemento( pPilha->pListaCartas ); 

		/*LIS_ExcluirElemento irá destruir a carta junto do nó.
			 É necessário que ela seja criada novamente*/
		CAR_CriarCarta( pCarta ) ;
		CAR_PreencheCarta( *pCarta , naipe, valor ) ;

		return PIL_CondRetOK ; 	

   }/* Fim função: PIL Pop Carta */
/***************************************************************************
*
*  Função: PIL  &Adicionar Carta
*  ****/
PIL_tpCondRet PIL_AdicionarCarta (PIL_tpPilha pPilha, CAR_tpCarta carta) {


	LIS_tpCondRet retorno;
	CAR_tpCarta copiaCarta;
	CAR_tpValor	copiaValor;
	CAR_tpNaipe	copiaNaipe;
	CAR_tpEstado copiaEstado;
	CAR_tpCondRet condRetCarta;
	int tornarInvisivel = 0;

	if (pPilha == NULL)
		return PIL_CondRetPilhaNaoExiste;

	if (carta == NULL)
		return PIL_CondRetCartaNaoExiste;


	condRetCarta = CAR_ObterEstado(carta,&copiaEstado);
		
	if (condRetCarta != CAR_CondRetOK)
		return PIL_CondRetCartaNaoExiste;
		
	if (copiaEstado == CAR_EstadoInvisivel){
			CAR_TornarVisivel(carta);
			tornarInvisivel = 1;
		}

	condRetCarta = CAR_ObterValor(carta,&copiaValor);
		
	if (condRetCarta != CAR_CondRetOK)
		return PIL_CondRetCartaNaoExiste;
		
	condRetCarta = CAR_ObterNaipe(carta,&copiaNaipe);
		
	if (condRetCarta != CAR_CondRetOK)
		return PIL_CondRetCartaNaoExiste;
		
	condRetCarta = CAR_CriarCarta(&copiaCarta,copiaValor,copiaNaipe);

	if(condRetCarta == CAR_CondRetFaltouMemoria)
		return PIL_CondRetFaltouMemoria;

	if (tornarInvisivel)
		CAR_TornarInvisivel(copiaCarta);

	
	retorno = LIS_InserirElementoAntes( pPilha->cabeca ,copiaCarta);

	if (retorno == LIS_CondRetFaltouMemoria)
		return PIL_CondRetFaltouMemoria;


	return PIL_CondRetOK;

}
/***************************************************************************
*
*  Função: PIL  &Imprimir Pilha Cartas
*  ****/
PIL_tpCondRet PIL_ImprimirPilhaCartas (PIL_tpPilha pPilha) {
	
	CAR_tpCondRet condRetCarta = CAR_CondRetOK;
	LIS_tpCondRet condRetLista;
	int qtd = 0;

	if (pPilha == NULL)
		return PIL_CondRetPilhaNaoExiste;

	printf("\n > ");
	
	PIL_QuantidadeCartas(pPilha,&qtd);
	if (qtd == 0 ) {	
		printf("\n");
		return PIL_CondRetPilhaVazia;
	}

	IrFinalLista(pPilha->cabeca);
	while (qtd) {
	
		CAR_tpCarta carta;
		CAR_tpValor valor;
		CAR_tpNaipe naipe;
		PIL_tpCondRet condRetPilha;

		condRetPilha = PIL_VerCarta(pPilha,&carta);
		if (condRetPilha == PIL_CondRetPilhaVazia)
			return condRetPilha;
	
		
		condRetCarta = CAR_ObterValor(carta,&valor);
		CAR_ObterNaipe(carta,&naipe);

	
		if(condRetCarta == CAR_CondRetCartaInvisivel)
			printf("# ");
		else
			printf(" %s%s ",PegarStringValor(valor),PegarStringNaipe(naipe));

			condRetLista = LIS_AvancarElementoCorrente( pPilha->cabeca , -1 );
	qtd--;
	}
	printf("\n");
	return PIL_CondRetOK;
}	/* Fim função: PIL  &Imprimir Pilha Cartas */
/***************************************************************************
*
*  Função: PIL  &Remover Carta
*  ****/
PIL_tpCondRet PIL_RemoverCarta( PIL_tpPilha pPilha , CAR_tpCarta * pCarta ) {

	LIS_tpCondRet condRetLis;
	CAR_tpCarta carta;

	if (pPilha == NULL)
		return PIL_CondRetPilhaNaoExiste;

	condRetLis = LIS_ObterValor( pPilha->cabeca , (void**)&carta);

	if (condRetLis != LIS_CondRetOK)
		return PIL_CondRetPilhaVazia; 
	else {
		CAR_tpCarta cartaCriada;
		CAR_tpValor valor;
		CAR_tpNaipe naipe;
		CAR_tpEstado estado;
		CAR_tpCondRet condRetCar;

		//nao precisa testar cond de ret porque já foi garantido que carta existe
		CAR_ObterValor(carta,&valor);
		
		CAR_ObterNaipe(carta,&naipe);
	
		CAR_ObterEstado(carta,&estado);

		condRetCar = CAR_CriarCarta( &cartaCriada,valor,naipe);

		if (estado == CAR_EstadoInvisivel)
			CAR_TornarInvisivel(cartaCriada);

		if (condRetCar == CAR_CondRetFaltouMemoria)
			return PIL_CondRetFaltouMemoria;
		else {
			 LIS_ExcluirElemento( pPilha->cabeca );
			 *pCarta = cartaCriada;
			//aqui há garantia que a lista nao esta vazia pois ja se obteve o valor anteriormente
			return PIL_CondRetOK;
		}

	}
}
Esempio n. 6
0
   FRC_tpCondRet FRC_MoverCarta( LIS_tppLista pMesa , char * origem , 
                    int CodOrigem , char * destino , int CodDestino  )
   {
      CAR_tppCarta pAuxCar = NULL;

      int naipeParaPos[ 4 ] = { 0 , 1 , 2 , 3 } ;
         /* Determina em qual coluna de ordenadas a carta deve ser inserida */

      #ifdef _DEBUG
         if( pMesa == NULL || origem == NULL || destino == NULL
            || CodOrigem < 0 || CodOrigem > 9 || CodDestino < 0
            || CodDestino > 9 )
         {
            return FRC_CondRetErroParm ;
         }
      #endif

      IrInicioLista( pMesa ) ;
      
      /* Obtem-se a carta que deseja-se mover */
         if( strcmp( origem , "vis" ) == 0 )
         {
            LIS_AvancarElementoCorrente( pMesa , 4 + CodOrigem ) ;
            pAuxCar = VIS_ObterCartaPosicao( (VIS_tppVisivel) LIS_ObterValor(pMesa) , 0 ) ;
         }

         else if( strcmp( origem , "ext" ) == 0 )
         {
            LIS_AvancarElementoCorrente( pMesa , 4 ) ;
            pAuxCar = EXT_ObterCartaPosicao( (EXT_tppExtras) LIS_ObterValor(pMesa) ,
                                     CodOrigem ) ;
         } /* if */

      /* Nenhuma carta obtida indica que a lista estava vazia */
         if( pAuxCar == NULL )
            return FRC_CondRetListaVazia ;
      
      /* Tenta-se inserir a carta na coluna de destino */
         IrInicioLista( pMesa ) ;
         if( strcmp( destino , "ord" ) == 0 )
         {
            LIS_AvancarElementoCorrente( pMesa , 
               naipeParaPos[ CAR_ObterNaipe( pAuxCar ) ] ) ;
            if( ORD_InserirCarta( ( ORD_tppOrdenada ) LIS_ObterValor( pMesa ) , 
                  pAuxCar) != ORD_CondRetOK )
            {
               return FRC_CondRetInsInvalida ;
            } /* if */
         } 
         else if( strcmp( destino , "vis" ) == 0 )
         {
            LIS_AvancarElementoCorrente(pMesa, 4 + CodDestino);
            if( VIS_InserirCarta( ( VIS_tppVisivel ) LIS_ObterValor( pMesa ) , 
                  pAuxCar , VIS_ModoComOrdem ) != VIS_CondRetOK )
            {
               return FRC_CondRetInsInvalida ;
            } /* if */
         }
         else if( strcmp( destino , "ext" ) == 0 ){
            LIS_AvancarElementoCorrente( pMesa , 4 ) ;
            if( EXT_InserirCartaPosicao( ( EXT_tppExtras ) LIS_ObterValor(pMesa) ,
                     pAuxCar , CodDestino ) != EXT_CondRetOK )
            {
               return FRC_CondRetInsInvalida ;
            } /* if */
         } /* if */


      /* Caso tenha sido possível inserir a carta, remove da origem */
         IrInicioLista( pMesa ) ;
         if( strcmp( origem , "vis" ) == 0 )
         {
            LIS_AvancarElementoCorrente(pMesa, 4 + CodOrigem ) ;
            if( VIS_RemoverCarta( ( VIS_tppVisivel ) LIS_ObterValor( pMesa ) ) != VIS_CondRetOK )
            {
               return FRC_CondRetRemInvalida;
            } /* if */
         } /* if */

         else if( strcmp( origem , "ext" ) == 0 ){
            LIS_AvancarElementoCorrente(pMesa, 4);
            if(EXT_RemoverCartaPosicao(( EXT_tppExtras ) LIS_ObterValor( pMesa ) , 
                  CodOrigem ) != EXT_CondRetOK )
            {
               return FRC_CondRetRemInvalida;
            } /* if */
         } /* if */
      
      return FRC_CondRetOK;


   }