big refactor

1 files changed, 46 insertions, 105 deletions

diff --git a/src/main.c b/src/main.c
index 1725434..353efe1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -2,88 +2,38 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include "tiles.h"
+#include "typedef.h"
 #include "ppm.h"
+#include "tiles.h"
+#include "tilemap.h"
 
-#define TILES_CAP 63
 size_t TILES;
+
 size_t TILE_WIDTH;
 size_t TILE_HEIGHT;
 
-small_t *(tiles[TILES_CAP]) = {0};
-
-// each bit is if the tile has a connections or not
-// from most signifact to least it is up, right, left, down
-small_t tile_connections[TILES_CAP];
-
-// 0 up   1 right
-// 2 left 3 down
-// each bit of the numbers is for every tiles
-// if the tile is a possibility
-// least significant bit is tile index 0
-size_t tile_masks[TILES_CAP][4] = {0};
-
-#define WIDTH_SCALER  30
-#define HEIGHT_SCALER 30
-
-size_t tiles_board[WIDTH_SCALER * HEIGHT_SCALER] = {0};
-
-void generate_tile_masks()
-{
-    size_t wt_con[4] = {0};
-    size_t no_con[4] = {0};
-
-    for(int n = 0; n < 4; n++)
-    {
-        for(size_t i = 0; i < TILES; i++)
-            wt_con[n] |= ((tile_connections[i] >> n) & 1) << i;
-
-        no_con[n] = (~wt_con[n]) & ((1 << TILES) - 1);
-    }
-
-    for(size_t i = 0; i < TILES; i++)
-    {
-        for(int n = 0; n < 4; n++)
-        {
-            if((tile_connections[i] >> (3-n)) & 1)
-                tile_masks[i][n] = wt_con[n];
-            else tile_masks[i][n] = no_con[n];
-        }
-    }
-}
-
-size_t count_1s(int v)
-{
-    if(((v >> TILES) & 1) == 1) return TILES+1;
-
-    v &= (1 << TILES) - 1;
-
-    size_t c = 0;
-    for (c = 0; v; v >>= 1)
-        c += v & 1;
-
-    return c;
-}
+size_t SWIDTH  = 10;
+size_t SHEIGHT = 10;
 
 int get_least_entropy_index()
 {
     // array of indexes with the least entropy
-    int least_entpy[WIDTH_SCALER * HEIGHT_SCALER];
+    int least_entpy[TILEMAP_CAP];
     size_t least_entpy_sz = 0;
 
-    for(int i = 0; i < HEIGHT_SCALER; i++)
+    for(size_t i = 0; i < SHEIGHT; i++)
     {
-        for (int j = 0; j < WIDTH_SCALER; j++)
+        for (size_t j = 0; j < SWIDTH; j++)
         {
-            int index = i * WIDTH_SCALER + j;
+            size_t index = i * SWIDTH + j;
 
             if(least_entpy_sz == 0) {
                 least_entpy[least_entpy_sz++] = index;
                 continue;
             }
 
-            int b1s = count_1s(tiles_board[index]);
-            int l1s = count_1s(tiles_board[least_entpy[least_entpy_sz-1]]);
+            size_t b1s = count_entropy(index);
+            size_t l1s = count_entropy(least_entpy[least_entpy_sz-1]);
 
             if(b1s == l1s) {
                 least_entpy[least_entpy_sz++] = index;
@@ -98,11 +48,11 @@ int get_least_entropy_index()
 
 }
 
-void set_index(int i)
+void collapse_this(int i)
 {
     int n = 0;
 
-    if(count_1s(tiles_board[i]) == 0) {
+    if(count_entropy(i) == 0) {
         fprintf(stderr, "ERROR: No possible tiles for this position: %d\n", i);
         exit(EXIT_FAILURE);
     }
@@ -110,80 +60,71 @@ void set_index(int i)
     // this bad
     do {
         n = rand() % TILES;
-        if(((tiles_board[i] >> n) & 1) != 1)
+        if(!(is_set(i, n)))
             continue;
 
-        tiles_board[i] = 0;
-        tiles_board[i] |= (1 << n);
-        tiles_board[i] |= (1 << TILES);
-    } while(((tiles_board[i] >> TILES) & 1) != 1);
+        collapse(i, n);
+    } while(!(has_collapsed(i)));
 
-    if(i / WIDTH_SCALER != 0) // up
-        if(count_1s(tiles_board[i-WIDTH_SCALER]) != (TILES + 1))
-            tiles_board[i-WIDTH_SCALER] &= tile_masks[n][0];
+    if(i / SWIDTH != 0) // up
+        if(!(has_collapsed(i-SWIDTH)))
+            mask(i-SWIDTH, n, 0);
 
-    if(i % WIDTH_SCALER != (WIDTH_SCALER - 1)) // right
-        if(count_1s(tiles_board[i+1]) != (TILES + 1))
-            tiles_board[i+1] &= tile_masks[n][1];
+    if(i % SWIDTH != (SWIDTH - 1)) // right
+        if(!(has_collapsed(i+1)))
+            mask(i+1, n, 1);
 
-    if(i % WIDTH_SCALER != 0) // left
-        if(count_1s(tiles_board[i-1]) != (TILES + 1))
-            tiles_board[i-1] &= tile_masks[n][2];
+    if(i % SWIDTH != 0) // left
+        if(!(has_collapsed(i-1)))
+            mask(i-1, n, 2);
 
-    if(i / WIDTH_SCALER != (HEIGHT_SCALER - 1)) // down
-        if(count_1s(tiles_board[i+WIDTH_SCALER]) != (TILES + 1))
-            tiles_board[i+WIDTH_SCALER] &= tile_masks[n][3];
+    if(i / SWIDTH != (SHEIGHT - 1)) // down
+        if(!(has_collapsed(i+SWIDTH)))
+            mask(i+SWIDTH, n, 3);
 }
 
 int main(void)
 {
-    TILES = calc_tiles();
+    calc_tiles();
     if(TILES > TILES_CAP) {
         printf("ERROR: Too many tiles: %ld\n", TILES);
         exit(EXIT_FAILURE);
     }
 
-    time_t seed = time(0);
+    time_t seed = 420;
     srand(seed);
     printf("The Seed is %ld\n", seed);
 
-    load_connections();
-    generate_tile_masks();
-
-    // init tiles board
-    for(int i = 0; i < WIDTH_SCALER * HEIGHT_SCALER; i++)
-        tiles_board[i] = (1 << TILES) - 1;
+    generate_tile_masks(load_tile_connections());
+    init_tilemap();
 
     while(1) {
         int lei;
         lei = get_least_entropy_index();
 
-        if(count_1s(tiles_board[lei]) == TILES+1)
+        if(has_collapsed(lei))
             break; // every index is set
         else
-            set_index(lei);
+            collapse_this(lei);
     }
 
     load_tiles();
 
-    size_t  img_wdt = TILE_WIDTH  * WIDTH_SCALER;
-    size_t  img_hgt = TILE_HEIGHT * HEIGHT_SCALER;
-    small_t *image = malloc(img_wdt * img_hgt);
+    size_t  img_wdt = TILE_WIDTH  * SWIDTH;
+    size_t  img_hgt = TILE_HEIGHT * SHEIGHT;
+    small_t *image = malloc(img_wdt * img_hgt * sizeof(small_t));
     memset(image, 0, img_wdt * img_hgt);
 
-    for(size_t i = 0; i < HEIGHT_SCALER; i++)
+    for(size_t i = 0; i < SHEIGHT; i++)
     {
-        for(size_t j = 0; j < WIDTH_SCALER; j++)
+        for(size_t j = 0; j < SWIDTH; j++)
         {
-            size_t t;
-            for(t = 0; t < TILES; t++)
-                if(((tiles_board[i * WIDTH_SCALER + j] >> t) & 1) == 1) break;
-
-            for(size_t y = 0; y < TILE_HEIGHT; y++) {
-                for(size_t x = 0; x < TILE_WIDTH; x++) {
-                    image[(y+(i*TILE_HEIGHT)) * img_wdt + (x+(j*TILE_WIDTH))] = tiles[t][y * TILE_WIDTH + x];
-                }
-            }
+            size_t t = get_collapsed_tile(i * SWIDTH + j);
+            if(t == TILES) exit(-124);
+
+            for(size_t y = 0; y < TILE_HEIGHT; y++)
+                for(size_t x = 0; x < TILE_WIDTH; x++)
+                    image[(y+(i*TILE_HEIGHT)) * img_wdt + (x+(j*TILE_WIDTH))] = get_tile_pixel(t, x, y);
         }
     }