TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxLista = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
TST_tpCondRet CondRet ;
char StringDado[ DIM_VALOR ] ;
char * pDado ;
int ValEsp = -1 ;
int i ;
int numElem = -1 ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de lista */
if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_LISTA ; i++ )
{
vtListas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
vtListas[ inxLista ] =
LIS_CriarLista( DestruirValor ) ;
return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] ,
"Erro em ponteiro de nova lista." ) ;
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_EsvaziarLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_DestruirLista( vtListas[ inxLista ] ) ;
vtListas[ inxLista ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( pDado , StringDado ) ;
CondRet = LIS_InserirElementoAntes( vtListas[ inxLista ] , pDado ) ;
if ( CondRet != LIS_CondRetOK )
{
free( pDado ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento apos */
else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( pDado , StringDado ) ;
CondRet = LIS_InserirElementoApos( vtListas[ inxLista ] , pDado ) ;
if ( CondRet != LIS_CondRetOK )
{
free( pDado ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir apos." ) ;
} /* fim ativa: Testar inserir elemento apos */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxLista , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_ExcluirElemento( vtListas[ inxLista ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALOR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , pDado ,
"Valor não deveria existir." ) ;
} /* if */
if ( pDado == NULL )
{
return TST_CompararPonteiroNulo( 1 , pDado ,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , pDado ,
"Valor do elemento errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar ir para o elemento inicial */
else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
LIS_IrInicioLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
LIS_IrFinalLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" , &inxLista , &numElem ,
&CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) ,
"Condicao de retorno errada ao avancar" ) ;
} /* fim ativa: LIS &Avançar elemento */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS &Testar lista */
GRA_tpCondRet GRA_ExcluirAresta(char pVertOrig , char pVertDest , GRA_tppGrafo pGrafo)
{
tpVerticeGrafo * pVertO;
tpVerticeGrafo * pVertD;
tpArestaGrafo * pAres;
pVertO = GRA_BuscarVertice(pGrafo, pVertOrig);
if(pVertO == NULL){
return GRA_CondRetNaoAchou ;
} /* if */
pVertD = GRA_BuscarVertice(pGrafo, pVertDest);
if(pVertD == NULL){
return GRA_CondRetNaoAchou ;
} /* if */
pGrafo->pCorrente = pVertO;
ListaRetCaminho = LIS_IrInicioLista(pVertO->pVerSuc);
while(ListaRetCaminho==LIS_CondRetOK || ListaRetCaminho==LIS_CondRetFimLista){
LIS_ObterValor (pVertO->pVerSuc , (void**)&pAres);
if(pAres->pVerticeDest->pIdVertice == pVertDest){
GRA_excluirValorListaAresta(pAres);
LIS_ExcluirElemento(pVertO->pVerSuc);
break;
} /* if */
if(ListaRetCaminho == LIS_CondRetFimLista){
break;
} /* if */
ListaRetCaminho = LIS_AvancarElementoCorrente(pVertO->pVerSuc, 1);
} /* while */
pGrafo->pCorrente = pVertD;
ListaRetCaminho = LIS_IrInicioLista(pVertD->pVerAnt);
while(ListaRetCaminho==LIS_CondRetOK || ListaRetCaminho==LIS_CondRetFimLista){
LIS_ObterValor (pVertD->pVerAnt , (void**)&pVertO);
if(pVertO->pIdVertice == pVertOrig){
LIS_ExcluirElemento(pVertD->pVerAnt);
break;
} /* if */
if(ListaRetCaminho == LIS_CondRetFimLista){
break;
} /* if */
ListaRetCaminho = LIS_AvancarElementoCorrente(pVertD->pVerAnt, 1);
} /* while */
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_BuscarCaminho( GRA_tppGrafo pGrafo , int idVerticeOrigem, int idVerticeDestino, LIS_tppLista * pLista ) {
tpVertice * v = NULL;
tpVertice * u = NULL;
tpVertice * origem1 = NULL;
tpVertice * origem2 = NULL;
int lenV = 0;
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
LIS_tppLista retorno = NULL;
int t;
int len = 0;
int achou = 0;
int ok = 0;
int i,j,in;
int lenD;
int alt = 0;
int* visitados = NULL; // Vetor de vertices visitados
int* vizinhos = NULL;
int* idAux = NULL;
Dist** dists = NULL;
Dist* dist = NULL; //aux;
Dist* currDist = NULL;
lenD = 1;
v = get_by_id(pGrafo, idVerticeOrigem);
u = get_by_id(pGrafo, idVerticeDestino);
if(v == NULL || u == NULL) {
return GRA_CondRetNaoEhVertice;
}
origem1 = ObterOrigem(pGrafo, v);
origem2 = ObterOrigem(pGrafo, u);
if (origem1 != origem2) {
return GRA_CondRetNaoEhConexo;
}//Else: É conexo, devia retornar Ok.
for (;;) {
dists = (Dist**)calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1, sizeof(Dist*));
if (dists == NULL) {break;}
dists[0] = newDist(idVerticeOrigem, 0);
retorno = LIS_CriarLista(free);
if (retorno == NULL) { break; }
else if (v == u) {
if( LIS_InserirElementoApos(retorno, newInt(idVerticeOrigem)) == LIS_CondRetOK) {
*pLista = retorno;
return GRA_CondRetOK;
} else {
break;
}
}
visitados = (int*) calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1,sizeof(int));
if (visitados == NULL) { break; }
Q = LIS_CriarLista(free);
if (Q == NULL) { break; }
visitados[0] = idVerticeOrigem;
lenV = 1;
if (LIS_InserirElementoApos(Q, newInt(idVerticeOrigem)) != LIS_CondRetOK) { break;} //enque
ok = 1;
break;
}
if (!ok) {
free(dists);
LIS_DestruirLista(retorno);
free(visitados);
LIS_DestruirLista(Q);
return GRA_CondRetFaltouMemoria;
}
while (LIS_NumeroDeElementos(Q) > 0) {
//dequeue
LIS_IrInicioLista(Q);
t = getInt(LIS_ObterValor(Q));
LIS_ExcluirElemento(Q);
//Iterar sobre vizinhos
GRA_ObterVizinhos(pGrafo, t, &arestas);
vizinhos = converteListaParaVetorDeInteiros(arestas, &len);
LIS_DestruirLista(arestas);
arestas = NULL;
currDist = getDist(dists, t);
if(!currDist) {
return GRA_CondRetFaltouMemoria;
} else {
}
alt = currDist->dist + 1;
for (i=0; i < len; i++) {
in = 0;
for (j=0; j < lenV; j++) {
if (visitados[j] == vizinhos[i]) {
in = 1;
}
}
if (!in) {
dist = getDist(dists, vizinhos[i]);
if (dist == NULL) { //infinity
dists[lenD] = newDist(vizinhos[i], alt);
dists[lenD]->prev = currDist;
dist = dists[lenD];
lenD++;
} else if (alt < dist->dist) {
dist->dist = alt;
dist->prev = currDist;
}
if (idVerticeDestino == vizinhos[i]) {
currDist = dist;
achou = 1;
}
visitados[lenV] = vizinhos[i];
lenV++;
LIS_InserirElementoAntes(Q, newInt(vizinhos[i]));
}
}
free(vizinhos);
if (achou) {
currDist = dist;
break;
}
if(lenV == LIS_NumeroDeElementos(pGrafo->vertices)) {
break;
}
}
if (achou) {
//printf("\n");
// for(i=0; i < lenD; i++) {
// printf("endr: %p, id: %d, dist: %d, prev: %p \n", *(dists+i), dists[i]->id, dists[i]->dist, dists[i]->prev);
// }
while (currDist) {
LIS_InserirElementoAntes(retorno, newInt(currDist->id));
currDist = currDist->prev;
}
}
//Limpando a memória
for (i=0; i < lenD; i++) {
free(dists[i]);
}
free(dists);
free(visitados);
LIS_DestruirLista(Q);
*pLista = retorno;
return GRA_CondRetOK;
}
void PDCRT_Push( LIS_tppCabeca * cb, Crt * carta )
{
LIS_IrInicioLista( cb ) ;
LIS_InserirElementoAntes( cb, carta ) ;
} /* Fim função: PDCRT Push */
TAB_tpCondRet TAB_VerificarTabuleiro(Tabuleiro* tabuleiro)
{
int condRet, linha, coluna;
Peca*peca;
LIS_tppLista lista;
if(!tabuleiro) {
CNT_CONTAR("Tabuleiro Inexistente");
TST_NotificarFalha("Tentou verificar tabuleiro inexistente.");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tabuleiro Existente");
if(!CED_VerificarEspaco(tabuleiro, NULL)) {
CNT_CONTAR("Tabuleiro possui alguma falha");
TST_NotificarFalha("Controle do espaço acusou erro.");
return TAB_CondRetErroEstrutura ;
}
else
CNT_CONTAR("Tabuleiro nao possui falha");
if(TST_CompararInt(TAB_Tabuleiro, CED_ObterTipoEspaco(tabuleiro),
"Tipo do espaço de dados nao e tabuleiro.") != TST_CondRetOK) {
CNT_CONTAR("Tipo nao e Tabuleiro");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tipo e Tabuleiro");
CED_MarcarEspacoAtivo(tabuleiro);
CNT_CONTAR("Tipo Tabuleiro OK");
/*Verificar a lista das listas, primária*/
if(LIS_VerificarLista(tabuleiro->lista) == LIS_CondRetErroEstrutura)
{
CNT_CONTAR("Lista de listas com erro");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista, ou seja, cada linha*/
LIS_IrInicioLista(tabuleiro->lista);
for(linha = 0; linha < TabuleiroAltura; ++linha) {
lista = LIS_ObterValor(tabuleiro->lista);
condRet = LIS_VerificarLista(lista);
if(condRet == LIS_CondRetErroEstrutura) {
CNT_CONTAR("Uma das listas de pecas possui algum problema");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista secundária, ou seja, cada casa do tabuleiro*/
LIS_IrInicioLista(lista);
for(coluna = 0; coluna < TabuleiroLargura; ++coluna) {
peca = LIS_ObterValor(lista);
if(peca) {
CNT_CONTAR("Casa nao Vazia");
if(TST_CompararInt(PEC_Peca, CED_ObterTipoEspaco(peca), "Tipo do espaço de dados nao e peca.") != TST_CondRetOK) {
TST_NotificarFalha("Tipo numa casa do tabuleiro nao e peca");
CNT_CONTAR("Tipo nao e peca");
return TAB_CondRetErroEstrutura;
}
else
{
CNT_CONTAR("Tipo e peca");
CED_MarcarEspacoAtivo(peca);
}
}
else
CNT_CONTAR("Casa Vazia");
LIS_AvancarElementoCorrente(lista, 1);
}
if(LIS_IrIndice(lista, 7) == LIS_CondRetOK && LIS_IrIndice(lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 colunas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 colunas");
TST_NotificarFalha("Tabuleiro nao tem 8 colunas");
return TAB_CondRetErroEstrutura;
}
LIS_AvancarElementoCorrente(tabuleiro->lista, 1);
}
if(LIS_IrIndice(tabuleiro->lista, 7) == LIS_CondRetOK && LIS_IrIndice(tabuleiro->lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 linhas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 linhas");
TST_NotificarFalha("Tabuleiro nao tem 8 linhas");
return TAB_CondRetErroEstrutura;
}
CNT_CONTAR("Ha uma lista de listas e a sublista de pecas sem problemas");
return TAB_CondRetOK;
}
int main(void)
{
char cond = '*';
LIS_tppCabeca * completas;
LIS_tppCabeca * Princ;
Princ = LIS_CriaLista(DestruirValor);
inicializa_estrutura(Princ);
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 1);
completas = (LIS_tppCabeca *)LIS_ObterValor(Princ);
do
{
system("cls");
printf("Aperte N - para comecar um novo jogo!\n");
printf("Aperte C - para continuar um jogo salvo!\n");
printf("Escolha: ");
scanf(" %c", &cond);
if (cond == 'N' || cond == 'n')
{
criar_novo_jogo(Princ);
}
else if (cond == 'C' || cond == 'c')
{
SV_LoadGame(Princ);
}
else
{
printf("Opcao invalida!");
Sleep(2500);
}
} while (cond != 'N' && cond != 'n' && cond != 'C' && cond != 'c');
system("cls");
imprime(Princ);
printf("Digite P - para pedir cartas do monte\n");
printf("Digite M - para mover cartas\n");
printf("Digite S - para Sair e salvar o jogo corrente\n");
printf("Escolha: ");
scanf(" %c", &cond);
while (cond != 'S' && cond != 's')
{
if (cond == 'P' || cond == 'p')
{
pedir_monte(Princ, completas);
if (LIS_AcessaNumElem(completas) == 104)
{
cond = 'E';
break;
}
}
else if (cond == 'M' || cond == 'm')
{
move_cartas_sequencias(Princ, completas);
if (LIS_AcessaNumElem(completas) == 104)
{
cond = 'E';
break;
}
}
system("cls");
imprime(Princ);
printf("Digite P - para pedir cartas do monte\n");
printf("Digite M - para mover cartas\n");
printf("Digite S - para Sair e salvar o jogo corrente\n");
printf("Escolha: ");
scanf(" %c", &cond);
}
if (cond == 'S' || cond == 's')
{
SV_SaveGame(Princ);
}
else if (cond == 'E')
{
system("cls");
printf("Parabens, voce terminou o jogo!\n\n\n\t\tYou are a champion!\n");
}
LIS_DestroiLista(Princ);
return 0;
}/* Fim Função: Main*/
void move_cartas_sequencias(LIS_tppCabeca * Princ, LIS_tppCabeca * completas)
{
char naipe_desejado;
char valor_desejado[3];
int sequencia_fonte;
int sequencia_destino;
int NumElem;
LIS_tppCabeca * destino, *fonte;
LIS_tppLista * lista;
Crt ** vCarta;
printf("Digite o valor da carta que deseja mover: ");
scanf(" %[^\n]", valor_desejado);
printf("Digite o naipe da carta que deseja mover: ");
scanf(" %c", &naipe_desejado);
printf("Digite o numero da sequencia em que a carta se encontra: ");
scanf("%d", &sequencia_fonte);
printf("Digite o numero da sequencia de destino: ");
scanf("%d", &sequencia_destino);
if ((sequencia_fonte > 10 || sequencia_fonte < 1))
{
printf("Posicao fonte invalida!");
Sleep(2500);
}
else if (sequencia_destino > 10 || sequencia_destino < 1)
{
printf("Posicao destino invalida!");
Sleep(2500);
}
else
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 6 + sequencia_fonte);
fonte = (LIS_tppCabeca *)LIS_ObterValor(Princ);
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 6 + sequencia_destino);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
LIS_IrInicioLista(destino);
lista = LIS_AcessaListaIni(destino);
if (lista == NULL || (CTA_VerificaValor(CTA_AcessaValor((Crt *)LIS_AcessaStruct(lista))) - 1) == (CTA_VerificaValor(valor_desejado)))
{
vCarta = SEQ_RetiraCartas(fonte, valor_desejado, naipe_desejado, &NumElem);
if (vCarta == NULL)
{
printf("Carta nao encontrada!");
Sleep(2500);
}
else
{
SEQ_InsereCartas(destino, vCarta, NumElem);
SEC_VerificaSequenciasCompletas(destino, completas);
ModificaBloqueio(destino);
ModificaBloqueio(fonte);
}
}
else
{
printf("Esta carta nao pode ser movida para a poisicao desejada!");
Sleep(2500);
}
}
}/* Fim da Função: Mover Cartas das Sequências*/
/***********************************************************************
*
* Função: Pedir Monte
*
***********************************************************************/
void pedir_monte(LIS_tppCabeca * Princ, LIS_tppCabeca * completas)
{
int verificador, i;
LIS_tppCabeca * destino, *montes;
verificador = 1;
for (i = 0; i < 10; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 7 + i);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
if (LIS_AcessaListaIni(destino) == NULL)
{
verificador = 0;
printf("Voce nao deve ter sequencias vazias para pedir o monte!");
Sleep(2500);
}
}
if (verificador == 1)
{
for (i = 0; i < 5; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 2 + i);
montes = (LIS_tppCabeca *)LIS_ObterValor(Princ);
if (LIS_AcessaListaIni(montes) != NULL)
{
break;
}
}
if (LIS_AcessaListaIni(montes) == NULL)
{
printf("Voce nao pode mais pedir cartas do monte!");
Sleep(2500);
}
else
{
for (i = 0; i < 10; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 7 + i);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
MNT_PedeMonte(destino, montes);
SEC_VerificaSequenciasCompletas(destino, completas);
ModificaBloqueio(destino);
}
}
}
}/* Fim Função: Pedir Monte*/
void criar_novo_jogo(LIS_tppCabeca * Princ)
{
int modojg;
int i;
LIS_tppCabeca * baralho, *destino;
system("cls");
printf("Aperte 1 - para modo facil (1 naipe)!\n");
printf("Aperte 2 - para modo mediano (2 naipes)!\n");
printf("Aperte 3 - para modo dificil (3 naipes)!\n");
printf("Aperte 4 - para modo muito dificil (4 naipes)!\n");
printf("Escolha: ");
scanf(" %d", &modojg);
baralho = (LIS_tppCabeca *)LIS_AcessaStruct(LIS_AcessaListaIni(Princ));
BAR_CriaBaralho(baralho, modojg);
system("cls");
BAR_Embaralhar(baralho);
for (i = 0; i < 5; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 2 + i);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
BAR_DistribuiBaralho(baralho, destino, 10);
}
for (i = 0; i < 4; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 7 + i);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
BAR_DistribuiBaralho(baralho, destino, 6);
CTA_AlteraEstado((Crt *)LIS_AcessaStruct(LIS_AcessaListaIni(destino)));
CTA_AlteraSituacao((Crt *)LIS_AcessaStruct(LIS_AcessaListaIni(destino)));
}
for (i = 0; i < 6; i++)
{
LIS_IrInicioLista(Princ);
LIS_AvancarElementoCorrente(Princ, 11 + i);
destino = (LIS_tppCabeca *)LIS_ObterValor(Princ);
BAR_DistribuiBaralho(baralho, destino, 5);
CTA_AlteraEstado((Crt *)LIS_AcessaStruct(LIS_AcessaListaIni(destino)));
CTA_AlteraSituacao((Crt *)LIS_AcessaStruct(LIS_AcessaListaIni(destino)));
}
}/* Fim função: Criar Novo Jogo*/
