/***************************************************************************
* Função: TAB Copiar tabuleiro
* ****/
TAB_tpCondRet TAB_CopiarTabuleiro(TAB_tppTabuleiro pTabuleiro, TAB_tppTabuleiro *ppCopia)
{
TAB_tppTabuleiro pCopia = NULL;
int x, y;
TAB_CriarTabuleiro(&pCopia, pTabuleiro->destruirValor);
for (x = 0; x < LARGURA; x++)
{
for (y = 0; y < ALTURA; y++)
{
void *pValor;
TAB_IrCasa(pTabuleiro, NomeDaCasa(x, y));
TAB_IrCasa(pCopia, NomeDaCasa(x, y));
GRA_ObterValorCorrente(pTabuleiro->pGrafo, (void **) &pValor);
GRA_AlterarValorCorrente(pCopia->pGrafo, pValor);
}
}
*ppCopia = pCopia;
return TAB_CondRetOK;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int indice,
numLidos = -1,
CondRetEsp = -1,
indicePeca,
casa,
passos,
quantidadePecasEsp,
quantidadePecas;
void *valorPeca;
int * pecaRecebida;
int * vtPeca[10];
TST_tpCondRet Ret;
for (indice = 0; indice < 10; indice++){
vtPeca[indice] = (int*)malloc(sizeof(int));
if (vtPeca == NULL)
{
return TST_CondRetMemoria;
} /* if */
*vtPeca[indice] = indice;
} /* for */
TAB_tpCondRet CondRet ;
/* testar criar um tabuleiro */
if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp) ;
if ( numLidos != 1 ) {
return TST_CondRetParm ;
} /* if */
CondRet = TAB_CriarTabuleiro(&pTabuleiro);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao criar tabuleiro.");
} /* Fim ativa: Testar criar um tabuleiro */
/* Testar destruir um tabuleiro */
else if ( strcmp( ComandoTeste , DESTRUIR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp) ;
if ( numLidos != 1 ) {
return TST_CondRetParm ;
} /* if */
CondRet = TAB_DestruirTabuleiro(&pTabuleiro);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao destruir tabuleiro.");
} /* Fim ativa: Testar destruir tabuleiro */
/* Testar inserir peca */
else if (strcmp(ComandoTeste, INSERIR_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&indicePeca, &casa, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_InserirPeca(&pTabuleiro, vtPeca[indicePeca], casa);
if (CondRet != TAB_CondRetOK)
free(vtPeca[indicePeca]);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao inserir peca.");
} /* Fim ativa: Testar inserir peca */
/* Testar retirar peca */
else if (strcmp(ComandoTeste, RETIRAR_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&indicePeca, &casa, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_RetirarPeca(&pTabuleiro, &valorPeca, casa);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao retirar peca.");
if (Ret != TST_CondRetOK)
return Ret;
pecaRecebida = (int *)valorPeca;
Ret = TST_CompararInt(*vtPeca[indicePeca], *pecaRecebida, "peca recebida errada");
free(pecaRecebida);
return Ret;
} /* Fim ativa: Testar retirar peca */
/* Testar mover peca */
else if (strcmp(ComandoTeste, MOVER_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&casa, &passos, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_MoverPeca(&pTabuleiro, casa, passos);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao mover peca.");
} /* Fim ativa: Testar mover peca */
/* Testar quantidade peca */
else if (strcmp(ComandoTeste, QUANTIDADE_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&casa, &quantidadePecasEsp, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet =TAB_QuantidadePecasCasa(pTabuleiro, casa, &quantidadePecas);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao contar peca.");
if (Ret != TST_CondRetOK)
return Ret;
return TST_CompararInt(quantidadePecasEsp, quantidadePecas, "numero de pecas errado");
} /* Fim ativa: Testar quantidade peca */
/* Liberar espaco alocado teste */
else if (strcmp(ComandoTeste, LIBERAR_CMD) == 0)
{
for (indice = 0; indice < 10; indice++)
free(vtPeca[indice]);
return TST_CondRetOK;
} /* Fim ativa: Liberar espaco alocado teste */
return TST_CondRetNaoConhec ;
} /* Fim função: TTAB &Testar tabuleiro */
int main (void)
{
int contador = 0 ;
char opcaoEscolhidaModificar ;
int opcaoEscolhida ;
int Time;
/* Movimentos */
char NomePeca[MAX_NOME];
char NomePosicao[2];
char * NomeBusca;
int Diagonal;
int Reta;
int QtdeMov;
/* Disposicao */
int NumPecas;
int NumPecasA;
int NumPecasB;
TAB_tpCondRet TabRet;
TAB_tppTabuleiro pTabuleiro;
JOG_tpCondRet JogRet;
JOG_tppJogo pJogo;
JOG_tppPecaJogo pPecaBuscaJogo;
PEC_tpCondRet PecaRet;
PEC_tppPeca pPecaBusca;
while ( 1 )
{
imprimeMenuPrincipal () ;
scanf ( "%d", &opcaoEscolhida ) ;
system ( "cls" ) ;
switch ( opcaoEscolhida )
{
/* Cria tabuleiro */
case 1: /* Criando um segundo tabuleiro, o primeiro é destruído. */
puts ( " Voce escolheu: 1- Criar tabuleiro." ) ;
TabRet = TAB_CriarTabuleiro(&pTabuleiro);
if(pTabuleiro==NULL){
puts ( "O tabuleiro nao foi criado!" ) ;
break ;
}
puts ( "Tabuleiro criado" ) ;
break;
/* Apresenta tabuleiro */
case 2: /* Mostra visualmente o tabuleiro */
puts ( " Voce escolheu: 2- Apresentar tabuleiro." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
TabRet = TAB_ApresentaTabuleiro(pTabuleiro);
puts ( "Percurso no Tabuleiro" ) ;
break;
/* Criar peca */
case 3: /* Efetua a criacao de peca */
puts ( " Voce escolheu: 3- Criar peca." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
printf("Informe o nome da peca:");
scanf ( "%s", &NomePeca ) ;
printf("Sua peca anda para DIAGONAL? (1 - Sim | 0 - Nao):");
scanf ( "%d", &Diagonal ) ;
if(Diagonal > 1){
puts("Informacao errada!");
}
printf("Sua peca anda em linha RETA? (1 - Sim | 0 - Nao):");
scanf ( "%d", &Reta ) ;
if(Reta > 1){
puts("Informacao errada!");
}
printf("Qual a quantidade de casas que sua peca anda? ");
scanf ( "%d", &QtdeMov ) ;
if(QtdeMov > 7){
puts("Informacao inconsistente!");
}
TabRet = TAB_CriarTipoPeca(pTabuleiro , NomePeca , Diagonal , Reta , QtdeMov );
strcpy(NomePeca , "");
puts ( "Peca criada \n" ) ;
break;
/* Apresenta pecas */
case 4: /* Mostra visualmente as pecas */
puts ( " Voce escolheu: 4 - Apresentar tipo pecas." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
TabRet = TAB_ApresentaTipoPecas(pTabuleiro);
if(TabRet == TAB_CondRetOK){
puts ( "Pecas do Tabuleiro" ) ;
} /* if */
break;
/* Montar time */
case 5: /* Montar time com pecas */
puts ( " Voce escolheu: 5 - Montar time." ) ;
JOG_CriarJogo(&pJogo);
imprimeMenuEscolhaTime();
scanf ( "%d", &Time ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
printf ( "Informe o numero de pecas do time %d : " , Time ) ;
scanf ("%d" , &NumPecas);
while(NumPecas > 0){
printf( "Informe o nome da peca : " );
scanf ( "%s", &NomePeca ) ;
TabRet = TAB_ProcuraPeca (pTabuleiro , NomePeca , (void**)&pPecaBusca);
if(TabRet != TAB_CondRetOK){
puts("Peca nao localizada\n");
}else{
JogRet = JOG_InserirPecaTimeA(pJogo , pPecaBusca);
NumPecas--;
}
}
imprimeMenuEscolhaTime();
scanf ( "%d", &Time ) ;
printf ( "Informe o numero de pecas do time %d : " , Time ) ;
scanf ("%d" , &NumPecas);
while(NumPecas > 0){
printf( "Informe o nome da peca : " );
scanf ( "%s", &NomePeca ) ;
TabRet = TAB_ProcuraPeca (pTabuleiro , NomePeca , (void**)&pPecaBusca);
if(TabRet != TAB_CondRetOK){
puts("Peca nao localizada\n");
}else{
JogRet = JOG_InserirPecaTimeB(pJogo , pPecaBusca);
NumPecas--;
}
}
break;
/* Dispor pecas */
case 6: /* Colocar as pecas nas casas */
puts ( " Voce escolheu: 6 - Dispor pecas." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
JOG_NumPecasTime(pJogo , 'A' , &NumPecasA);
if(NumPecasA==0){
puts ( "Time A nao possui pecas definidas" ) ;
break ;
}
JOG_NumPecasTime(pJogo , 'B' , &NumPecasB);
if(NumPecasB==0){
puts ( "Time B nao possui pecas definidas" ) ;
break ;
}
/* Colocacao time A */
JOG_IrInicioPecas(pJogo , 'A');
puts("**** Disposicao das pecas do time A: ****\n");
while (NumPecasA > 0){
JOG_ObterTipoPeca(pJogo , 'A' , (void**)&pPecaBusca);
PEC_ObterNome(pPecaBusca , (void**)&NomePeca);
printf("Indique a posicao da peca %s : " , NomePeca);
scanf ( "%s", &NomePosicao ) ;
/** Colocar a peca na casa do tabuleiro **/
JOG_ObterPecaJogo(pJogo , 'A' , (void**)&pPecaBuscaJogo);
TAB_SetarCorrente(pTabuleiro , NomePosicao);
TAB_InserirConteudoCasa(pTabuleiro , pPecaBuscaJogo );
/** Fim do colocar a peca na casa do tabuleiro **/
JOG_AvancarCorrrenteTime(pJogo , 'A' , 1);
NumPecasA--;
}
/* Colocacao time B */
JOG_IrInicioPecas(pJogo , 'B');
puts("**** Disposicao das pecas do time B: ****\n");
while (NumPecasB > 0){
JOG_ObterTipoPeca(pJogo , 'B' , (void**)&pPecaBusca);
PEC_ObterNome(pPecaBusca , (void**)&NomePeca);
printf("Indique a posicao da peca %s : " , NomePeca);
scanf ( "%s", &NomePosicao ) ;
/** Colocar a peca na casa do tabuleiro **/
JOG_ObterPecaJogo(pJogo , 'B' , (void**)&pPecaBuscaJogo);
TAB_SetarCorrente(pTabuleiro , NomePosicao);
TAB_InserirConteudoCasa(pTabuleiro , pPecaBuscaJogo );
/** Fim do colocar a peca na casa do tabuleiro **/
JOG_AvancarCorrrenteTime(pJogo , 'B' , 1);
NumPecasB--;
}
JOG_PreencheCaminho(pJogo , pTabuleiro );
break;
/* Salvar partida */
case 7: /* Salvar atual configuração do jogo. */
puts ( " Voce escolheu: 7 - Salvar JOGO." ) ;
gravarArquivo(pTabuleiro , pJogo , pPecaBusca);
break;
case 10:
exit(1);
/* Usuário com caracter não esperado */
default: puts ( "Favor entre com uma das opcoes abaixo." ) ;
break ;
} /* switch */
} /* while */
return 0;
}
TST_tpCondRet TST_EfetuarComando( char *ComandoTeste )
{
int inxTab = -1 ,
numLidos = -1 ;
short int tamColuna = -1 ,
tamLinha = -1 ,
Coluna = -1 ,
Linha = -1 ,
ColunaDest = -1,
LinhaDest = -1;
PECA_tpCor cor;
TAB_tpTamanho tam;
TAB_tpPosicao pos,
posOrigem,
posDestino;
TAB_tpCondRet condEsp;
TAB_tpCondRet tabCondRet;
PECA_tppPeca pDado ;
int valEsp = -1 ;
#ifdef _DEBUG
TAB_tpModoDeturpacao modoDeturpacao;
#endif
int i ;
/* Efetuar reset de teste de tabuleiro */
if ( strcmp( ComandoTeste , RESETAR_TABULEIRO_CMD ) == 0 )
{
for ( i = 0 ; i < DIM_VT_TABULEIRO ; i++ )
{
vtTab[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de tabuleiro */
/* Testar Criar Tabuleiro */
else if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab, &tamColuna, &tamLinha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
vtTab[ inxTab ] =
TAB_CriarTabuleiro( tamColuna, tamLinha, DestruirPeca ) ;
return TST_CompararPonteiroNulo( 1 , vtTab[ inxTab ] ,
"Erro em ponteiro de nova tabuleiro." ) ;
} /* fim ativa: Testar CriarTabuleiro */
/* Testar Destruir Tabuleiro */
else if ( strcmp( ComandoTeste , DESTRUIR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxTab ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
TAB_DestruirTabuleiro( vtTab[ inxTab ] ) ;
vtTab[ inxTab ] = NULL;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir Tabuleiro*/
/* Testar Obter Tamanho */
else if ( strcmp( ComandoTeste , OBTER_TAMANHO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxTab, &tamColuna, &tamLinha ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
tam = TAB_ObterTamanho( vtTab[ inxTab ] ) ;
if ((tam.colunas == tamColuna) && (tam.linhas == tamLinha))
return TST_CondRetOK ;
return TST_CondRetErro;
} /* fim ativa: Testar Obter Tamanho */
/* Testar Incluir Peca */
else if ( strcmp( ComandoTeste , INCLUIR_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiiii" ,
&inxTab , &Coluna, &Linha, &cor , &condEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pDado = (PECA_tppPeca) PECA_CriarPeca (cor) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
}
pos.coluna = Coluna;
pos.linha = Linha;
tabCondRet = TAB_IncluirPeca( vtTab[ inxTab ] , pDado , pos) ;
if ( tabCondRet != TAB_CondRetOK )
{
PECA_DestruirPeca(pDado) ;
}
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao incluir peca no tabuleiro." ) ;
} /* fim ativa: Testar Incluir Peca*/
/* Testar Mover Peça*/
else if ( strcmp( ComandoTeste , MOVER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiiiii" ,
&inxTab , &Coluna, &Linha, &ColunaDest , &LinhaDest, &condEsp ) ;
if ( ( numLidos != 6 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
posOrigem.coluna = Coluna;
posOrigem.linha = Linha;
posDestino.coluna = ColunaDest;
posDestino.linha = LinhaDest;
tabCondRet = TAB_MoverPeca( vtTab[ inxTab ] , posOrigem , posDestino) ;
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao mover a peca no tabuleiro." ) ;
} /* fim ativa: Testar Mover Peca*/
/* Testar Obter Peca */
else if ( strcmp( ComandoTeste , OBTER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
pDado = (PECA_tppPeca) TAB_ObterPeca( vtTab[ inxTab ] , pos) ;
if ( valEsp == 0 )
{
return TST_CompararPonteiroNulo( 0, pDado,
"Peça não devia existir");
}
if ( pDado == NULL)
{
return TST_CompararPonteiroNulo( 1, pDado,
"Peça deveria existir");
}
return TST_CondRetOK;
} /* fim ativa: Testar Obter Peca*/
/* Testar Destruir Peca */
else if ( strcmp( ComandoTeste , DESTRUIR_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &condEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
tabCondRet = TAB_DestruirPeca( vtTab[ inxTab ] , pos) ;
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao excluir peca do tabuleiro." ) ;
} /* fim ativa: Testar Destruir Peca*/
/* Testar Remover Peca */
else if ( strcmp( ComandoTeste , REMOVER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
pDado = (PECA_tppPeca) TAB_RemoverPeca( vtTab[ inxTab ] , pos) ;
if ( valEsp == 0 )
{
return TST_CompararPonteiroNulo( 0, pDado, "Peça não devia existir");
}
if ( pDado == NULL )
{
return TST_CompararPonteiroNulo( 1, pDado, "Peça deveria existir");
}
return TST_CondRetOK;
} /* fim ativa: Testar Remover Peca*/
/* Início instrumentação */
#ifdef _DEBUG
/* Testar verificador de tabuleiro */
else if ( strcmp( ComandoTeste, VERIFICAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii",
&inxTab, &condEsp ) ;
if ( ( numLidos != 2 )
|| !ValidarInxTabuleiro( inxTab ))
{
return TST_CondRetParm;
}
return TST_CompararInt( condEsp ,
TAB_VerificarTabuleiro( vtTab[ inxTab ] ) ,
"Retorno incorreto ao verificar tabuleiro") ;
} /* fim ativa: Testar verificador de tabuleiro */
/* Deturpar um tabuleiro */
else if ( strcmp( ComandoTeste, DETURPAR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxTab , &modoDeturpacao ) ;
if ( ( numLidos != 2 )
|| !ValidarInxTabuleiro( inxTab ))
{
return TST_CondRetParm;
}
TAB_Deturpar( vtTab [ inxTab ] , modoDeturpacao ) ;
return TST_CondRetOK ;
} /* fim ativa: Deturpar um tabuleiro */
/* Verificar vazamento de memória */
else if ( strcmp( ComandoTeste, VERIFICAR_MEMORIA_CMD ) == 0 )
{
CED_ExibirTodosEspacos( CED_ExibirTodos ) ;
return TST_CondRetOK ;
} /* fim ativa: Verificar vazamento de memória */
#endif
/* Fim instrumentação */
return TST_CondRetNaoConhec ;
} /* Fim função: TTAB &Testar tabuleiro */
