Altera o jogador

Makefile

@@ -10,7 +10,7 @@ test: main
 	chmod +x runTests.sh; \
 	./runTests.sh
 
-main: main.c libs/tabuleiro.o libs/grafo.o libs/vertice.o libs/filha.o libs/lista.o libs/no.o
+main: main.c libs/jogador.o libs/tabuleiro.o libs/grafo.o libs/vertice.o libs/filha.o libs/lista.o libs/no.o
 	$(CC) $(CFLAGS) -o $@ $^
 
 clean:

libs/jogador.c

@@ -2,60 +2,22 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include "jogador.h"
+#include "lista.h"
+#include "grafo.h"
 
-struct Nodo {
-    // Jogada que foi tomada para chegar neste nodo (ou seja, cor do grupo de posicoes atual)
-    int jogada;
-    // Filhos deste nodo, sera um array de structs Nodo
-    Nodo * filhos;
-    // "Quadrados pintados" ate aquele nodo(que sera um vetor contendo certas posicoes do vetor "celulas")
-    int * quadradosPintados;
-    // peso eh a quantidade de quadrados pintados deste grupo
-    int peso;
-};
-
-int checaCor(Tblr t, int posicao){
-	return (t->celulas[posicao]->cor);
-}
-
-int * verAdjacentes(Tblr t, int posicao, int cor){
-	//TODO: criar algoritmo que encontra quais sao os quadrados adjacentes a este dado quadrado
-}
-
-void alocaFilhos(Nodo n){
-	//TODO: criar algoritmo que, dado um nodo, aloca seus filhos
-}
-
-Nodo criaGrafo(Tblr t){
-	Nodo n = malloc(sizeof(struct Nodo));
-	if(!n) return NULL;
-
-	n->jogada = checaCor(t, 0);
-	if(n->jogada == -1) return NULL;
-
-	// Ver quais sao os quadrados pintados deste nodo(grupo de quadrados adjacentes da mesma cor, dada uma posicao)
-	n->quadradosPintados = verAdjacentes(t, 0, n->jogada);
-	if(n->quadradosPintados == NULL) return NULL;
-	n->peso = (sizeof(n->quadradosPintados)/sizeof(int));
-
-	// Ver qual e a quantidade de filhos deste Nodo e aloca espaco para eles
-	alocaFilhos(n);
-	if(n->filhos == NULL) return NULL;
-
-	return n; 
-}
-
-int * Joga(Nodo n, Tblr t){
+Lista Joga(Grafo g, Lista grupo){
 	//TODO: A Logica toda do jogo vai ficar aqui
 
-      // printf("Enquanto pilha não vazia:\n");
-      // printf("\tPega os adjacentes do grupo (retorna os pesos dos filhos = montar o grafo)\n");
-      // printf("\tEscolhe filho de maior peso\n");
-      // printf("\tEmpilha os outros filhos\n");
-      // printf("\tSE tamanho do caminho atual + filhos do nodo atual >= menor caminho: VOLTA!\n");
-      // printf("\tSE soma do peso total = tamanho do tabuleiro: VOLTA! Retorna o caminho encontrado\n");
-      // printf("\n\n\n##BONUS##\n");
-      // printf("Olhar os vizinhos dos vizinhos no estado atual e atribuir bônus:\n");
-      // printf("\tSe vizinho tem vizinho que não tenho: adicionar valor do vizinho do vizinho como bônus\n");
-      // printf("\tSe vizinho tem vizinho que tenho, mas em número maior: adicionar diferença\n");
+    // Pega os filhos do grupo
+    // Monta a árvore de busca:
+    //      - RAIZ: grupo
+    //      - FILHOS: Cores alcancáveis a partir da raiz
+    //      - NETOS: Cores alcançáveis a partir dos filhos que NÃO são alcançáveis a partir da raiz
+    // Seleciona o melhor filho baseado em peso(filho) + bônus(filho) // (filho com a maior soma de filho e peso)
+    // O bônus e calculado da seguinte forma:
+    //      - Soma o valor de cada neto (que não é alcançável pela raiz)
+    //      - Em caso de empate da soma peso + bônus:
+    //          - Escolher o filho que tem mais netos da mesma cor de um filho
+    // Após escolher um filho, repete o algoritmo até não terem mais filhos do grupo
+    return constroiLista();
 }

libs/jogador.h

 #ifndef _PLAYER_
 #define _PLAYER_
 #include <stdbool.h>
-#include "tabuleiro.h"
+#include "grafo.h"
+#include "lista.h"
 
-// Nodo do grafo que permitira encontrar o menor numero de jogadas
-typedef struct Nodo *Nodo;
+// Pega os vizinhos da lista Grupo e seleciona o melhor filho baseado no peso e no bônus
+//      até consumir todos os vértices do grafo. Retorna a lista de jogadas
+Lista Joga(Grafo g, Lista grupo);
 
-// Cria um grafo ponderado com o primeiro nodo e retorna
-Nodo criaGrafo(Tblr t);
-
-// Encontra o menor caminho no grafo de pesos (ate que a soma dos pesos bruta seja igual ao numero de casas na matriz) 
-// e retorna este menor caminho em um vetor de inteiros
-int * Joga(Nodo n, Tblr t);
-
-// ------- Funcoes auxiliares --------
-
-// Checa cor de uma posicao da matriz.
-int checaCor(Tblr t, int posicao);
-
-// Checa quais sao os quadrados adjacentes a um quadrado especifico, e retorna as posicoes dos adjacentes no vetor
-// que representa a matriz do jogo. 
-int * verAdjacentes(Tblr t, int posicao, int cor);
-
-// Ve quais sao os filhos deste nodo, ou seja, os grupos de cores que estao ligados ao grupo de quadrados referentes a este nodo. 
-void alocaFilhos(Nodo n);
 #endif

main.c

@@ -7,6 +7,7 @@
 #include "libs/no.h"
 #include "libs/lista.h"
 #include "libs/grafo.h"
+#include "libs/jogador.h"
 
 int main() {
     Tblr t = criaTblr();
@@ -26,11 +27,10 @@ int main() {
     // Desaloca tabuleiro
     destroiTblr(t);
 
-    Lista jogadas = constroiLista();
+    Lista jogadas = Joga(g, grupo);
 
     // PARA DEBUGAR: Imprime o grafo tabuleiro em formato dot com os vértices já
     // "consumidos" pintados de vermelho
-    printf("Número de grupos: %d\n", tamanhoLista(g->vertices));
     FILE* debug = fopen("./debug.out", "w+");
     if(debug) {
         grafoParaDot(g, grupo, debug);