switch to explicit game state & important bug fix & clang format

Previously the code base assumed that there was a single, global game
state which was the implicit target of all actions taken. Looking
ahead at architectural improvements, this has now been (almost
entirely) made explicit and functions take tak_state_p where
necessary (and also where unnecessary).

Two important fixes to actions.c were made:

- Previously when generating the possible stack moves, stack height
overflows (> 15) were not taken into account and this resulted in the
tree search corrupting the board state. Now action search does not
list all legal actions, rather the subset of these encodeable by the
implementation.

- The check for crushing on a stack move was incorrect (too strict),
and this resulted in many legitimate moves being igonored.

Finally, in other changes, weights have also been improved by training
all games instead of some subset for chosen players, and clang-format
was run on the codebase.

1 files changed, 13 insertions, 14 deletions

diff --git a/include/tt_llcht.c b/include/tt_llcht.c
index b80da39..7b2269b 100644
--- a/include/tt_llcht.c
+++ b/include/tt_llcht.c
@@ -21,30 +21,29 @@
 // Variables
 // ===================================================================
 
-static tt_entry_t *table[TT_LLCHT_SIZE+1];
+static tt_entry_t *table[TT_LLCHT_SIZE + 1];
 
 // ===================================================================
 // Helper declarations
 // ===================================================================
 
-tt_entry_t * new_ll_node(const uint64_t key, const enum TT_FLAG flag,
-			 const uint8_t depth, const float value,
-			 const action_t action);
-
+tt_entry_t *new_ll_node(const uint64_t key, const enum TT_FLAG flag,
+                        const uint8_t depth, const float value,
+                        const action_t action);
 
 // ===================================================================
 // Exported functions
 // ===================================================================
 
 int tt_init(void) {
-  for (uint32_t k=0; k<=TT_LLCHT_SIZE; k++)
+  for (uint32_t k = 0; k <= TT_LLCHT_SIZE; k++)
     table[k] = NULL;
   return EXIT_SUCCESS;
 }
 
 void tt_free(void) {
   tt_entry_t *n, *nn;
-  for (uint32_t k=0; k<=TT_LLCHT_SIZE; k++) {
+  for (uint32_t k = 0; k <= TT_LLCHT_SIZE; k++) {
     n = table[k];
     while (n) {
       nn = n->next;
@@ -61,15 +60,15 @@ tt_entry_t *tt_seek(const uint64_t key) {
   return lookup;
 }
 
-int tt_insert(const uint64_t key, const enum TT_FLAG flag,
-	      const uint8_t depth, const float value,
-	      const action_t action) {
+int tt_insert(const uint64_t key, const enum TT_FLAG flag, const uint8_t depth,
+              const float value, const action_t action) {
   tt_entry_t *new = new_ll_node(key, flag, depth, value, action), *n;
   // TODO: trap
 
   const uint32_t idx = key & TT_LLCHT_SIZE;
   if ((n = table[idx]) != NULL) {
-    for (; n->next != NULL; n = n->next);
+    for (; n->next != NULL; n = n->next)
+      ;
     n->next = new;
   } else {
     table[idx] = new;
@@ -82,9 +81,9 @@ int tt_insert(const uint64_t key, const enum TT_FLAG flag,
 // Helper function implementations
 // ===================================================================
 
-tt_entry_t * new_ll_node(const uint64_t key, const enum TT_FLAG flag,
-			 const uint8_t depth, const float value,
-			 const action_t action) {
+tt_entry_t *new_ll_node(const uint64_t key, const enum TT_FLAG flag,
+                        const uint8_t depth, const float value,
+                        const action_t action) {
   tt_entry_t *new = malloc(sizeof(struct tt_node_s));
   // TODO: trap errno
   new->key = key;