int ehSequenciaValor( CAR_tppCarta carta1, CAR_tppCarta carta2 )
{
int valor1 = 0 ;
int valor2 = 0 ;
CAR_ObterValor(carta1, &valor1);
CAR_ObterValor(carta2, &valor2);
if( valor1 -1 == valor2 )
{
return 1; // carta1 é sequencia e maior do que carta2
}
return 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;
}
}
}
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;
}
