int firstFit(Memory *mem, LIS_tppLista lisProntos)
{
Processo *aux;
int cnt = 0, fail = 0,i;
IrInicioLista(lisProntos);
aux = (Processo*)LIS_ObterValor(lisProntos);
cnt = LIS_ObterTamanho(lisProntos);
fail = 1;
while(cnt > 0)
{
for(i = 0; i < 5; i++)
{
if((aux->tamanho <= mem->s[i].tam) && (mem->s[i].proc == NULL) && (aux->naMemoria == 0)) // se o tamanho do process é menor q o segmento da memoria
{
InsereProcessosMem(mem, aux, mem->s[i].tam);
fail = 0;
break;
}
}
LIS_AvancarElementoCorrente(lisProntos, 1);
aux = (Processo*)LIS_ObterValor(lisProntos);
cnt--;
}
return fail;
}
MTZ_tpCondRet MTZ_DestruirMatriz ( LIS_tppLista Tab )
{
LIS_tppLista Col;
PLH_tppPilha p;
while ( Tab != NULL) {
IrFinalLista( Tab );
Col = (LIS_tppLista) LIS_ObterValor( Tab );
while (Col != NULL) {
IrFinalLista( Col );
p = (PLH_tppPilha) LIS_ObterValor( Col );
PLH_Libera( p );
LIS_ExcluirElemento( Col );
IrInicioLista( Col );
}
LIS_ExcluirElemento( Tab );
IrInicioLista( Tab );
}
free ( Tab );
return MTZ_CondRetOK;
}
int ListaDePassosSaoIguais(LIS_tppLista pPassos1, LIS_tppLista pPassos2)
{
PAS_tppPasso pPasso1;
PAS_tppPasso pPasso2;
LIS_tpCondRet ret1 = LIS_CondRetOK;
LIS_tpCondRet ret2 = LIS_CondRetOK;
LIS_IrInicioLista(pPassos1);
LIS_IrInicioLista(pPassos2);
while (ret1 == LIS_CondRetOK && ret2 == LIS_CondRetOK)
{
int saoIguais;
LIS_ObterValor(pPassos1, (void **) &pPasso1);
LIS_ObterValor(pPassos2, (void **) &pPasso2);
PAS_CompararPassos(pPasso1, pPasso2, &saoIguais);
if (!saoIguais)
{
return FALSE;
}
ret1 = LIS_AvancarElementoCorrente(pPassos1, 1);
ret2 = LIS_AvancarElementoCorrente(pPassos2, 1);
}
if (ret1 != ret2)
{
return FALSE;
}
return TRUE;
}
TAB_tpCondRet TAB_setarCasa(Tabuleiro *tabuleiro, int linha, char coluna, Peca *peca, int limpar)
{
LIS_tppLista lista;
Peca *antiga;
--linha;
coluna = tolower(coluna) - 'a';
if(LIS_IrIndice(tabuleiro->lista, linha) != LIS_CondRetOK)
return TAB_CondRetLinhaInexistente;
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
if(!lista)
return TAB_CondRetLinhaInexistente;
if(LIS_IrIndice(lista, coluna) != LIS_CondRetOK)
return TAB_CondRetColunaInexistente;
if(limpar) {
antiga = LIS_ObterValor(lista);
if(antiga)
ListaExcluirPeca(antiga);
}
LIS_SetarValor(lista, peca);
return TAB_CondRetOK;
}/* Fim função: TAB &Setar valor de uma peça no tabuleiro */
void get_pair_by_id(GRA_tppGrafo pGrafo, int idAresta, tpVertice ** u, tpVertice ** v){
tpAresta * aresta = NULL;
tpVertice * vertice = NULL;
LIS_IrInicioLista( pGrafo->vertices );
// Para cada vértice
do{
vertice = (tpVertice*)LIS_ObterValor( pGrafo->vertices ) ;
if(vertice == NULL) break;
LIS_IrInicioLista( vertice->pNode->arestas ) ;
// Procura em todos os seus vizinhos
do{
aresta = (tpAresta*)LIS_ObterValor( vertice->pNode->arestas ) ;
if(aresta == NULL){
continue;
}
if ( aresta->id == idAresta ){
*u = vertice ;
*v = aresta->pVizinho ;
break;
}
}while(LIS_AvancarElementoCorrente( vertice->pNode->arestas , 1) == LIS_CondRetOK );
}while ( LIS_AvancarElementoCorrente( pGrafo->vertices , 1) == LIS_CondRetOK ) ;
}
/***************************************************************************
*
* Função: TAB &Imprimir estado atual de um tabuleiro
* ****/
void TAB_imprimir(Tabuleiro *tabuleiro)
{
int x, y;
//Assertivas de entrada
#ifdef _DEBUG
if(tabuleiro == NULL)
printf("\n Não foi possível imprimir o tabuleiro (não existe) \n");
#endif
LIS_IrFinalLista(tabuleiro->lista);
for(y = TabuleiroAltura - 1; y >= 0; --y) {
LIS_tppLista lista;
printf("%d|", y+1);
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
LIS_IrInicioLista(lista);
for(x = 0; x < TabuleiroLargura; ++x) {
Peca *peca = LIS_ObterValor(lista);
if(peca)
PEC_imprimir(peca);
else
printf(" |");
LIS_AvancarElementoCorrente(lista, 1);
}
printf("\n");
LIS_AvancarElementoCorrente(tabuleiro->lista, -1);
}
printf(" |A|B|C|D|E|F|G|H|\n");
}/* Fim função: TAB &Imprimir estado atual de um tabuleiro */
int WorstFit (Memory *mem, LIS_tppLista lisProntos){
Processo *aux;
int cnt = 0, fail = 0, i;
IrInicioLista(lisProntos);
aux = (Processo*)LIS_ObterValor(lisProntos);
cnt = LIS_ObterTamanho(lisProntos);
fail = 1;
while (cnt > 0)
{
int diferenca = 0;
int BestInd = -1;
for (i = 0; i < 5; i++)
{
if ((aux->tamanho <= mem->s[i].tam) && (mem->s[i].proc == NULL) && (aux->naMemoria == 0)) // se o tamanho do process é menor q o segmento da memoria
{
if (mem->s[i].tam - aux->tamanho >= diferenca){
BestInd = i;
diferenca = mem->s[i].tam - aux->tamanho;
}
}
}
if (BestInd != -1){
InsereProcessosMem(mem, aux, mem->s[BestInd].tam);
fail = 0;
}
LIS_AvancarElementoCorrente(lisProntos, 1);
aux = (Processo*)LIS_ObterValor(lisProntos);
cnt--;
}
return fail;
}
void GRA_DelNode (Graph *g)
{
Node *n;
#ifdef _DEBUG
int nOfNodesAntigo = g->nOfNodes;
AssertGraph(g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_delNode - Inicializao");
assert(g->currentNode);
n = (Node *) LIS_ObterValor(g->currentNode);
assert( n!=NULL );
#ifdef _DEBUG
AssertNode(n,g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_delNode - Deletando no");
delNode(g,n);
LIS_ExcluirElemento(g->nodes);
g->currentNode = LIS_ObterValor(g->nodes);
#ifdef _DEBUG
g->nOfNodes--;
assert ( g->nOfNodes == (nOfNodesAntigo - 1) );
AssertGraph(g);
#endif /* _DEBUG */
}
void *GRA_NodesGetNext (Graph *g)
{
void *ret;
LIS_tppLista l;
CNT_CONTAR("GRA_NodesGetNext - inicio");
#ifdef _DEBUG
AssertGraph(g);
#endif /* _DEBUG */
if (!g->currentNode){
return NULL;
}
CNT_CONTAR("GRA_NodesGetNext - guardando g->nodes");
l = g->nodes;
if (!l){
CNT_CONTAR("GRA_NodesGetNext - Nao existe g->nodes");
return NULL;
}
CNT_CONTAR("GRA_NodesGetNext - Obtendo dado");
ret = ((Node*)LIS_ObterValor (LIS_ObterValor(l)))->data;
if (g->nodesOld == ret){ /* Se esse dado ja' repitiu, ja terminou a lista */
CNT_CONTAR("GRA_NodesGetNext - Dado repetido, fim da lista");
return NULL;
}
CNT_CONTAR("GRA_NodesGetNext - Avanando elemento corrente");
g->nodesOld = ret;
LIS_AvancarElementoCorrente (l, 1);
#ifdef _DEBUG
AssertGraph(g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_NodesGetNext - Finalizando");
return ret;
}
void getNext(LIS_tppLista lisProc)
{
Processo *aux;
IrInicioLista(lisProc);
aux = (Processo*)LIS_ObterValor(lisProc);
while(aux->naMemoria == 0)
{
LIS_AvancarElementoCorrente(lisProc, 1);
aux = (Processo*)LIS_ObterValor(lisProc);
}
}
static int BFS(tpVertice* v, tpVertice* u) {
LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
tpVertice* s = NULL;
tpAresta* a = NULL;
int achou = 0;
int achou_V = 0;
V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
LIS_InserirElementoApos(V, v);
LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
while (LIS_NumeroDeElementos(Q) > 0) {
LIS_IrInicioLista(Q);
t = (tpVertice *)LIS_ObterValor(Q);
LIS_ExcluirElemento(Q);
if (t == u) {
achou = 1;
break;
}
arestas = t->pNode->arestas;
LIS_IrInicioLista(arestas);
do {
a = (tpAresta *)LIS_ObterValor(arestas);
if(a == NULL) continue;
s = a->pVizinho;
LIS_IrInicioLista(V);
achou_V = 0;
do {
tpVertice * re = (tpVertice *)LIS_ObterValor(V);
if (re == NULL) {
continue;
}
if(re == s) achou_V = 1;
} while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
if (!achou_V) {
if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
}
} while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
}
LIS_DestruirLista(V);
LIS_DestruirLista(Q);
return achou;
}
GRA_tpCondRet GRA_BuscarVertice( GRA_tppGrafo pGrafo , int* idVertice , int predicado(void* pDado, void* _parametro), void* parametro )
{
LIS_tppLista vertices;
tpVertice* vertice;
vertices = pGrafo->vertices;
if(LIS_NumeroDeElementos(vertices) == 0){
*idVertice = -1;
return GRA_CondRetGrafoVazio;
}
LIS_IrInicioLista(vertices);
do
{
vertice = (tpVertice*)LIS_ObterValor(vertices);
if (predicado(vertice->pNode->pValor, parametro))
{
*idVertice = vertice->id;
return GRA_CondRetOK;
}
}
while (LIS_AvancarElementoCorrente(vertices, 1) == LIS_CondRetOK);
return GRA_CondRetNaoEhVertice;
}
void GRA_Del (Graph *g)
{
#ifdef _DEBUG
AssertGraph(g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_Del - Inicializao");
IrInicioLista ( g->nodes );
if ( !g->currentNode || !LIS_AvancarElementoCorrente ( g->nodes , 1)){
CNT_CONTAR("GRA_Del - Grafo vazio");
return;
}
IrInicioLista ( g->nodes );
do {
CNT_CONTAR("GRA_Del - Deletando nos");
g->currentNode = LIS_ObterValor( g->nodes );
GRA_DelNode( g );
} while ( LIS_AvancarElementoCorrente ( g->nodes , 1)
== LIS_CondRetOK );
/* == 0 ); */
CNT_CONTAR("GRA_Del - Destruindo, finalizao");
LIS_DestruirLista( g->nodes );
free(g);
return;
}
int GRA_comparaVerticeConteudo( void * pVerticeO , void * pValorO )
{
int ret = 0;
char * Corrente ;
char * Buscado ;
tpVerticeGrafo * pValorVert ;
LIS_tppLista pVerticeLista ;
Corrente = "";
Buscado = "";
pVerticeLista = ( LIS_tppLista ) pVerticeO ;
LIS_ObterValor (pVerticeLista , (void**)&pValorVert);
VER_RetornaValor ((VER_tppVerticeCont)pValorVert->pConteudo , Corrente) ;
VER_RetornaValor ((VER_tppVerticeCont)pValorO , Buscado) ;
if(strcmp(Corrente , Buscado) == 0){
return 0;
}
return 1;
} /* Fim função: GRA &Compara valores */
GRA_tpCondRet GRA_DefinirCorrente(GRA_tppGrafo pGrafo, char IdVert)
{
tpVerticeGrafo * pVerticeBusca ;
ListaRet = LIS_IrInicioLista(pGrafo->pListaVertices);
while(ListaRet == LIS_CondRetOK || ListaRet == LIS_CondRetFimLista){
LIS_ObterValor (pGrafo->pListaVertices , (void**)&pVerticeBusca);
if(pVerticeBusca->pIdVertice == IdVert){
pGrafo->pCorrente = pVerticeBusca;
return GRA_CondRetOK;
} /* if */
if(ListaRet==LIS_CondRetFimLista){
break;
} /* if */
ListaRet = LIS_AvancarElementoCorrente(pGrafo->pListaVertices, 1);
} /* while */
return GRA_CondRetNaoAchou ;
}
void TAB_Deturpar(Tabuleiro *tabuleiro, TAB_tpModosDeturpacao ModoDeturpar, int linha, char coluna, TAB_tpModosDeturpacaoLista ModoDeturparLista)
{
LIS_tppLista lista, lista2;
if(!tabuleiro)
return;
linha--;
coluna = tolower(coluna) - 'a';
lista = tabuleiro->lista;
switch(ModoDeturpar) {
case TAB_DeturpaTipoTabuleiro:
{
CED_DefinirTipoEspaco(tabuleiro, CED_ID_TIPO_VALOR_NULO);
break;
}
case TAB_DeturparListaPrimaria:
{
LIS_IrIndice(lista, linha);
LIS_Deturpar(lista, ModoDeturparLista);
break;
}
case TAB_DeturparListaSecundaria:
{
LIS_IrIndice(lista, linha);
lista2 = (LIS_tppLista)LIS_ObterValor(lista);
LIS_IrIndice(lista2, coluna);
LIS_Deturpar(lista2, ModoDeturparLista);
break;
}
}
}
int ChecaArestaExiste(tpVerticeGrafo * pVertice , char * String, char Dest)
{
tpArestaGrafo * pAres ;
if(pVertice==NULL){
return 0;
} /* if */
ListaRetCaminho=LIS_IrInicioLista(pVertice->pVerSuc);
while(ListaRetCaminho==LIS_CondRetOK || ListaRetCaminho==LIS_CondRetFimLista){
LIS_ObterValor(pVertice->pVerSuc , (void**)&pAres);
if(strcmp(pAres->Nome , String)==0 && pAres->pVerticeDest->pIdVertice == Dest){
return 1;
} /* if */
if(ListaRetCaminho == LIS_CondRetFimLista){
return 0;
} /* if */
ListaRetCaminho = LIS_AvancarElementoCorrente(pVertice->pVerSuc, 1);
} /* while */
pAres = NULL;
return 0;
} /* Fim função: GRA &Checa se aresta existe */
LIS_tpCondRet LIS_InserirElementoOrdenado( LIS_tppLista pLista ,
void *pValor,
int (*pComp) (void *a, void *b))
{
LIS_tpElemLista *pElem ;
#ifdef _DEBUG
assert( pLista != NULL ) ;
#endif
/* Criar elemento a inserir antes */
pElem = CriarElemento( pLista , pValor ) ;
if ( pElem == NULL )
{
return LIS_CondRetFaltouMemoria ;
} /* if */
/* Ir para o comeco da lista */
IrInicioLista (pLista);
/* Percorrer a lista até encontrar um valor superior ou igual */
while (LIS_AvancarElementoCorrente(pLista, 1) != LIS_CondRetFimLista)
{
if (pComp(LIS_ObterValor(pLista), pValor) > 0)
{
break ;
} /* if */
} /* while */
/* Encadear o elemento antes do elemento superior */
return LIS_InserirElementoAntes(pLista, pValor);
} /* Fim funcao: LIS &Inserir elemento antes */
static tpVertice* ObterOrigem (GRA_tppGrafo grafo, tpVertice* v) {
tpVertice** us = NULL; //Vetor com componentes a iterar;
tpVertice* u = NULL;
LIS_tppLista origens = grafo->componentes;
int i = 0;
LIS_IrInicioLista(grafo->vertices);
LIS_IrInicioLista(origens);
if (LIS_ProcurarValor(origens, v) == LIS_CondRetOK) {
return v; //é a origem da própria componente
}
if(LIS_NumeroDeElementos(origens) > 0) {
us = (tpVertice**) calloc(LIS_NumeroDeElementos(origens), sizeof(tpVertice*));
LIS_IrInicioLista(origens);
do {
u = (tpVertice *)LIS_ObterValor(origens);
if(u == NULL) break;
us[i] = u;
i++;
} while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);
for ( i;i; i--) {
if (BFS(us[i-1],v) == 1) {
u = us[i-1];
}
}
free(us);
}
return u;
}
GRA_tpCondRet GRA_DestruirGrafo( GRA_tppGrafo pGrafo )
{
tpVertice* pVertice = NULL;
#ifdef _DEBUG
assert( pGrafo != NULL ) ;
#endif
LIS_DestruirLista(pGrafo->componentes); //Lista que não mexe com "ninguém"
LIS_IrInicioLista(pGrafo->vertices);
do {
pVertice = (tpVertice *)LIS_ObterValor(pGrafo->vertices);
if(pVertice == NULL) continue;
if (pVertice->pNode->pValor != NULL && pGrafo->ExcluirValor != NULL) {
pGrafo->ExcluirValor(pVertice->pNode->pValor);
}
LIS_DestruirLista(pVertice->pNode->arestas);
free(pVertice->pNode);
}
while(LIS_AvancarElementoCorrente(pGrafo->vertices, 1) == LIS_CondRetOK);
LIS_DestruirLista(pGrafo->vertices);
free( pGrafo ) ;
return GRA_CondRetOK;
}
/* Essa funcao e' responsavel por criar e compor 2 links ligando
* 2 nos.
*/
enum GRA_Ret linkTwoNodes(Node *node1, Node *node2)
{
Link *link1, *link2, *link;
IrInicioLista(node1->links);
CNT_CONTAR("linkTwoNodes - Inicializacao");
do{ /* Assertiva: Nao repetir links */
CNT_CONTAR("linkTwoNodes - Procurando link igual");
link = LIS_ObterValor(node1->links);
if( link && link->n2 == node2 ){
CNT_CONTAR("linkTwoNodes - Links iguais");
return GRA_InvalidLink;
}
}while (LIS_CondRetOK == LIS_AvancarElementoCorrente (node1->links,1));
CNT_CONTAR("linkTwoNodes - Compondo Links");
link1 = (Link*) malloc (sizeof(Link));
if (!link1){
CNT_CONTAR("linkTwoNodes - Alocacao de link1 falhou");
return GRA_MemoryError;
}
link2 = (Link*) malloc (sizeof(Link));
if (!link2){
/* Muito improvavel de cair aqui num teste
CNT_CNTAR("linkTwoNodes - Alocacao de link2 falhou"); */
free (link1);
return GRA_MemoryError;
}
/* Compoe os dois links */
link1->n1 = node1;
link1->n2 = node2;
link1->brother = link2;
link2->n1 = node2;
link2->n2 = node1;
link2->brother = link1;
IrFinalLista(node1->links);
IrFinalLista(node2->links);
/* Tenta inserir cada link em uma lista, limpa se nao der certo */
CNT_CONTAR("linkTwoNodes - Inserindo link 1 na lista");
if( LIS_CondRetOK != LIS_InserirElementoApos(node1->links, link1) ){
CNT_CONTAR("linkTwoNodes - Nao inseriu link 1 na lista");
return GRA_MemoryError;
}
CNT_CONTAR("linkTwoNodes - Inserindo link 2 na lista");
if( LIS_CondRetOK != LIS_InserirElementoApos(node2->links, link2) ){
CNT_CONTAR("linkTwoNodes - Nao inseriu link 2 na lista");
LIS_ExcluirElemento(node1->links);
return GRA_MemoryError;
}
#ifdef _DEBUG
AssertLink(link1);
AssertLink(link2);
#endif /* _DEBUG */
CNT_CONTAR("linkTwoNodes - Finalizando");
return GRA_Ok;
}
int ChecaVerticeExiste(GRA_tppGrafo pGrafo, char Vert)
{
tpVerticeGrafo * pVertice;
if(pGrafo==NULL){
return 0;
} /* if */
ListaRetCaminho=LIS_IrInicioLista(pGrafo->pListaVertices);
while(ListaRetCaminho==LIS_CondRetOK || ListaRetCaminho==LIS_CondRetFimLista){
LIS_ObterValor(pGrafo->pListaVertices , (void**)&pVertice);
if(pVertice->pIdVertice == Vert){
return 1;
} /* if */
if(ListaRetCaminho == LIS_CondRetFimLista){
return 0;
} /* if */
ListaRetCaminho = LIS_AvancarElementoCorrente(pGrafo->pListaVertices, 1);
} /* while */
pVertice = NULL;
return 0;
} /* Fim função: GRA &Checa se vertice existe */
PIL_tpCondRet PIL_VerCarta( PIL_tppPilha pPilha , CAR_tppCarta * pCarta , int posicao )
{
LIS_tpCondRet Ret ;
*pCarta = NULL ;
if ( posicao < 0 )
{
return PIL_CondRetParamIncorreto ;
}
LIS_IrFinalLista( pPilha->pListaCartas ) ;
Ret = LIS_AvancarElementoCorrente( pPilha->pListaCartas , - posicao ) ;
if ( Ret == LIS_CondRetFimLista )
{
return PIL_CondRetFimPilha ;
}
if ( Ret == LIS_CondRetListaVazia )
{
return PIL_CondRetPilhaVazia ;
}
LIS_ObterValor( pPilha->pListaCartas , pCarta ) ;
return PIL_CondRetOK ;
}/* Fim função: PIL VerCarta */
void TAB_inicializar(Tabuleiro *tabuleiro, char idJogador1, char idJogador2)
{
int x, y;
//Assertivas de entrada
#ifdef _DEBUG
if(tabuleiro == NULL){
printf("\n tabuleiro não existe \n");
return;
}
if(idJogador1 != 'x' || idJogador2 != 'o'){
printf("\n Erro na associação de caracteres correspondentes ao jogador1 e/ou jogador2 \n");
return;
}
#endif
LIS_IrInicioLista(tabuleiro->lista);
for(y = 0; y < TabuleiroAltura; ++y) {
LIS_tppLista lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
LIS_IrInicioLista(lista);
for(x = 0; x < TabuleiroLargura; ++x) {
Peca *peca = NULL;
if(y < 2 && (x + y) % 2 == 1)
peca = PEC_criar(PecaNormal, idJogador1);
else if(y > TabuleiroAltura - 3 && (x + y) % 2 == 1)
peca = PEC_criar(PecaNormal, idJogador2);
LIS_SetarValor(lista, peca);
LIS_AvancarElementoCorrente(lista, 1);
}
LIS_AvancarElementoCorrente(tabuleiro->lista, 1);
}
}/* Fim função: TAB &Inicializar tabuleiro para início de uma partida */
Peca *TAB_obterCasa(Tabuleiro *tabuleiro, int linha, char coluna)
{
LIS_tppLista lista;
--linha;
coluna = tolower(coluna) - 'a';
if(LIS_IrIndice(tabuleiro->lista, linha) != LIS_CondRetOK)
return NULL;
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
if(!lista)
return NULL;
if(LIS_IrIndice(lista, coluna) != LIS_CondRetOK)
return NULL;
return LIS_ObterValor(lista);
}/* Fim função: TAB &Obter valor de uma peça no tabuleiro */
/***************************************************************************
*
* Função: TAB &mover uma peça no tabuleiro
* ****/
int TAB_verificaVencedor(Tabuleiro *tabuleiro, char idJogador1, char idJogador2)
{
int x, y;
int existe1 = 0, existe2 = 0;
//Assertivas de entrada
#ifdef _DEBUG
if(!tabuleiro)
printf("\n tabuleiro não existe \n");
if(idJogador1 != 'x' || idJogador2 != 'o')
printf("\n Erro na associação de caracteres correspondentes ao jogador1 e/ou jogador2 \n");
#endif
LIS_IrFinalLista(tabuleiro->lista);
for(y = TabuleiroAltura - 1; y >= 0; --y) {
LIS_tppLista lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
LIS_IrInicioLista(lista);
for(x = 0; x < TabuleiroLargura; ++x) {
Peca *peca = LIS_ObterValor(lista);
if(peca) {
if(PEC_obterCaracter(peca) == idJogador1)
existe1 = 1;
else if(PEC_obterCaracter(peca) == idJogador2)
existe2 = 1;
if(existe1 && existe2) // existe peca dos 2 jogadores no tabuleiro. jogo continua
return -1;
}
LIS_AvancarElementoCorrente(lista, 1);
}
LIS_AvancarElementoCorrente(tabuleiro->lista, -1);
}
if(existe1 && !existe2) // so ha pecas do jogador 1 presentes. ele ganhou
return 0;
if(!existe1 && existe2) // so ha pecas do jogador 2 presentes. ele ganhou
return 1;
//Assertivas de saida
#ifdef _DEBUG
printf("Caso indefinido em TAB_verificaVencedor");
#endif
return -2;
}/* Fim função: TAB verifica vencedor */
enum GRA_Ret searchData(LIS_tppLista l, void *data)
{
Node* n;
CNT_CONTAR("searchData - Inicializao");
IrInicioLista(l);
do{
CNT_CONTAR("searchData - Procurando dado");
n = LIS_ObterValor(LIS_ObterValor(l));
if(data == n->data){
CNT_CONTAR("searchData - Achou o dado");
return GRA_Ok;
}
} while(LIS_CondRetOK == LIS_AvancarElementoCorrente (l, 1));
CNT_CONTAR("searchData - Finalizacao");
return GRA_InvalidArgNode;
}
void AssertNode(Node *n, Graph *g)
{
CNT_CONTAR("AssertNode - Verificando assertivas");
IrInicioLista(g->nodes);
do{
CNT_CONTAR("AssertNode - Procurando valor");
if (n == LIS_ObterValor(LIS_ObterValor( g->nodes ))){
CNT_CONTAR("AssertNode - Valor encontrado");
assert( n->delData == g->delData );
return;
}
} while(LIS_CondRetOK == LIS_AvancarElementoCorrente ( g->nodes , 1));
/* Nao deveria cruzar esse ponto: Significa que nao foi encontrado
* n na lista g->nodes
*/
assert( 0 );
}
enum GRA_Ret GRA_AddLink (Graph *g, void *n)
{
Node *n1, *n2;
enum GRA_Ret ret;
CNT_CONTAR("GRA_AddLink - Inicio");
#ifdef _DEBUG
AssertGraph(g);
#endif /* _DEBUG */
if (!n){
CNT_CONTAR("GRA_AddLink - Nao existe n");
return GRA_NullData;
}
if (!g->currentNode){
CNT_CONTAR("GRA_AddLink - Nao existe g->currentNode");
return GRA_InvalidCurrentNode;
}
n1 = LIS_ObterValor(g->currentNode);
assert(n1);
CNT_CONTAR("GRA_AddLink - Procurando no");
if (searchData (g->nodes, n) != GRA_Ok){
CNT_CONTAR("GRA_AddLink - Nao encontrou no");
return GRA_InvalidArgNode;
}
n2 = LIS_ObterValor(LIS_ObterValor(g->nodes));
if (n2 == n1){
CNT_CONTAR("GRA_AddLink - Tentando criar link de n1 pra n1");
return GRA_InvalidArgNode;
}
#ifdef _DEBUG
AssertNode(n1,g);
AssertNode(n2,g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_AddLink - Ligando 2 nos");
ret = linkTwoNodes(n1, n2);
#ifdef _DEBUG
if (ret == GRA_Ok){
CNT_CONTAR("GRA_AddLink - Ligou os nos");
g->nOfLinks += 2;
}
AssertNode(n1,g);
AssertNode(n2,g);
AssertGraph(g);
#endif /* _DEBUG */
return ret;
}
enum GRA_Ret GRA_RemLink (Graph *g, void *d)
{
Node *curr;
Link *l;
CNT_CONTAR("GRA_RemLink - Inicio");
if (!d){
CNT_CONTAR("GRA_RemLink - Nao existe d");
return GRA_NullData;
}
if (!g->currentNode){
CNT_CONTAR("GRA_RemLink - Nao existe g->currentNode");
return GRA_InvalidCurrentNode;
}
#ifdef _DEBUG
AssertGraph(g);
#endif /* _DEBUG */
curr = LIS_ObterValor (g->currentNode);
#ifdef _DEBUG
AssertNode(curr,g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_RemLink - Procurando elemento");
IrInicioLista (curr->links);
do{
CNT_CONTAR("GRA_RemLink - Avanando na lista");
l = (Link*)LIS_ObterValor (curr->links);
#ifdef _DEBUG
AssertLink(l);
#endif /* _DEBUG */
if (l->n2->data == d){
CNT_CONTAR("GRA_RemLink - Deletando elemento");
/* deleta de curr -> n2 */
LIS_ExcluirElemento(curr->links);
/* isso deleta link e link->brother */
#ifdef _DEBUG
g->nOfLinks -= 2 ;
AssertGraph(g);
#endif /* _DEBUG */
return GRA_Ok;
}
}while (LIS_AvancarElementoCorrente(curr->links, 1)
== LIS_CondRetOK);
CNT_CONTAR("GRA_RemLink - Finalizando");
return GRA_InvalidArgNode;
}
