SEQJ_tpCondRet SEQJ_PushCartaSequencia( SEQJ_tppSeqJ pSeqJ, CAR_tppCarta pCarta )
{
CAR_tppCarta cartaAux;
if (pSeqJ == NULL)
{
return SEQJ_CondRetSequenciaVazia;
}
// se tiverem cartas na seq, verificar se pode colocar
if( totalCartasNaSeq( pSeqJ ) != 0 )
{
PIL_VerCarta( pSeqJ->pPilha, &cartaAux, 0 );
if ( !ehSequenciaValor( cartaAux, pCarta ))
{
return SEQJ_CondRetCartasForaDaSequencia;
}
}
//senao apenas dar push
PIL_PushCarta( pSeqJ->pPilha, pCarta);
pSeqJ->numCartasViradas++;
return SEQJ_CondRetOK;
}
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 &Tornar Carta Invisivel
* ****/
PIL_tpCondRet PIL_TornarCartaInvisivel( PIL_tpPilha pPilha){
CAR_tpCarta carta;
PIL_tpCondRet condRet;
condRet = PIL_VerCarta( pPilha ,&carta);
if( condRet == PIL_CondRetOK )
CAR_TornarInvisivel(carta);
return condRet;
}
int totalCartasNaSeq( SEQJ_tppSeqJ pSeqJ )
{
CAR_tppCarta cartaAux ;
int numCartasSeq = 0 ;
while( PIL_VerCarta( pSeqJ->pPilha, &cartaAux, numCartasSeq ) == PIL_CondRetOK )
{
numCartasSeq++;
}
return numCartasSeq ;
}
/***************************************************************************
*
* 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 */
SEQJ_tpCondRet SEQJ_VerificaSeqCompleta( SEQJ_tppSeqJ pSeqJ )
{
int i ;
int seqComecou ;
int valor ;
CAR_tppCarta cartaAux;
CAR_tppCarta cartaAnterior;
seqComecou = 0;
valor = 0;
if (pSeqJ == NULL)
{
return SEQJ_CondRetSequenciaVazia;
}
for (i = 0 ; i < 13 ; i++)
{
PIL_VerCarta( pSeqJ->pPilha, &cartaAux, i );
CAR_ObterValor(cartaAux, &valor);
if( valor != i+1 )
{
return SEQJ_CondRetCartasForaDaSequencia;
}
if( seqComecou )
{
if( !ehSequenciaValor(cartaAux, cartaAnterior) || !ehMesmoNaipe(cartaAux, cartaAnterior))
{
return SEQJ_CondRetCartasForaDaSequencia;
}
}
cartaAnterior = cartaAux;
if( !seqComecou ) seqComecou = 1;
}
return SEQJ_CondRetOK;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
PIL_tpCondRet CondRetObtido = PIL_CondRetOK ;
PIL_tpCondRet CondRetEsperada = PIL_CondRetFaltouMemoria ;
/* inicializa para qualquer coisa */
char NaipeEsperado = '?' ;
char NaipeObtido = '!' ;
char NaipeDado = '\0' ;
int ValorEsperado = -1 ;
int ValorObtido = -2 ;
int ValorDado = 0 ;
int PosicaoPilha = -1 ;
int NumPilha = -1 ;
int NumLidos = -1 ;
CAR_tppCarta CartaObtida ;
CAR_tppCarta CartaDada ;
TST_tpCondRet Ret ;
/* Testar PIL Criar Pilha de Cartas */
if ( strcmp( ComandoTeste , CRIAR_PIL_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" , &NumPilha ,
&CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_CriarPilhaVazia( &vPilhas[NumPilha] ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar pilha." );
} /* fim ativa: Testar PIL Criar Pilha de cartas*/
/* Testar PIL Push Carta na pilha */
else if ( strcmp( ComandoTeste , PUSH_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "icii" ,
&NumPilha, &NaipeDado , &ValorDado, &CondRetEsperada ) ;
if ( NumLidos != 4 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CAR_CriarCarta( &CartaDada ) ;
CAR_PreencheCarta( CartaDada, NaipeDado , ValorDado );
CondRetObtido = PIL_PushCarta( vPilhas[NumPilha] , CartaDada ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao operar 'push' na pilha" );
} /* fim ativa: Testar PIL Push Carta na pilha */
/* Testar PIL Pop Carta da Pilha */
else if ( strcmp( ComandoTeste , POP_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&NumPilha , &CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_PopCarta( vPilhas[NumPilha] , &CartaObtida ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao operar 'pop' na pilha") ;
} /* Testar PIL Ver Carta da Pilha */
else if ( strcmp( ComandoTeste , VER_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&NumPilha , &PosicaoPilha , &CondRetEsperada ) ;
if ( NumLidos != 3 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_VerCarta( vPilhas[NumPilha] , &CartaObtida , PosicaoPilha ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao ver carta da pilha") ;
} /* Testar PIL Ver Carta da Pilha */
/* Testar PIL Destruir pilha de cartas */
else if ( strcmp( ComandoTeste , DESTROI_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" , &NumPilha ,
&CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_DestruirPilha( vPilhas[NumPilha] ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado destruir pilha." );
} /* fim ativa: Testar PIL Destruir Pilha de Cartas */
/* Testar PIL Destruir Pilha */
return TST_CondRetNaoConhec ;
} /* Fim função: TPIL Efetuar operações de teste específicas para pilha de cartas */
