1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#include <stdlib.h>
#include <string.h>
#include "typedef.h"
#include "tilemap.h"
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define BIG_SZ (sizeof(big_t) * 8)
extern size_t TILES;
extern size_t SWIDTH;
extern size_t SHEIGHT;
big_t (*tilemap)[TILEMAP_CAP];
size_t tsz = 0;
// 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
big_t (*tile_masks)[TILES_CAP][4];
void set(int t, int n)
{
tilemap[(n/BIG_SZ)][t] |= (1 << (n%BIG_SZ));
}
int is_set(int t, int n)
{
return (tilemap[(n/BIG_SZ)][t] >> (n%BIG_SZ)) & 1;
}
void init_tilemap()
{
tsz = (TILES/BIG_SZ) + 1;
#include <stdio.h>
printf("tsz %ld\n", tsz);
tilemap = malloc(sizeof(big_t[tsz][TILEMAP_CAP]));
for(size_t i = 0; i < tsz; i++)
for(size_t n = 0; n < SWIDTH * SHEIGHT; n++)
tilemap[i][n] = ((1 << MIN(BIG_SZ, (TILES - (i*BIG_SZ)))) - 1);
}
void destroy_tilemap()
{
free(tilemap);
free(tile_masks);
}
int has_collapsed(int t)
{
return is_set(t, TILES);
}
int get_collapsed_tile(int t)
{
for(size_t i = 0; i < TILES; i++)
if(is_set(t, i)) return i;
return TILES;
}
void collapse(int t, int n)
{
for(size_t i = 0; i < tsz; i++)
tilemap[i][t] = 0;
set(t, n);
set(t, TILES);
}
size_t count_entropy(int t)
{
if(has_collapsed(t)) return TILES+1;
size_t c = 0;
for (size_t j = 0; j < TILES; j++)
c += is_set(t, j);
return c;
}
void mask(int t, int m, int r)
{
for(size_t i = 0; i < tsz; i++)
tilemap[i][t] &= tile_masks[i][m][r];
}
void generate_tile_masks(small_t* tile_connections)
{
size_t (*wt_con)[4];
size_t (*no_con)[4];
wt_con = malloc(sizeof(size_t[tsz][4]));
no_con = malloc(sizeof(size_t[tsz][4]));
for(int n = 0; n < 4; n++)
{
for(size_t i = 0; i < tsz; i++) {
wt_con[i][n] = 0;
no_con[i][n] = 0;
}
for(size_t i = 0; i < TILES; i++)
wt_con[(i/BIG_SZ)][n] |= ((tile_connections[i] >> n) & 1) << (i%BIG_SZ);
for(size_t i = 0; i < TILES; i++)
no_con[(i/BIG_SZ)][n] |= ((wt_con[(i/BIG_SZ)][n] >> (i%BIG_SZ)) & 1) ? 0 : 1 << (i % BIG_SZ);
}
tile_masks = malloc(sizeof(big_t[tsz][TILES_CAP][4]));
for(size_t i = 0; i < TILES; i++)
{
for(int n = 0; n < 4; n++)
{
if((tile_connections[i] >> (3-n)) & 1)
for(size_t t = 0; t < tsz; t++)
tile_masks[t][i][n] = wt_con[t][n];
else
for(size_t t = 0; t < tsz; t++)
tile_masks[t][i][n] = no_con[t][n];
}
}
for(size_t t = 0; t < tsz; t++)
for(size_t i = 0; i < TILES; i++) {
for(int n = 0; n < 4; n++)
printf("%9b ", tile_masks[t][i][n]);
putchar('\n');
}
free(wt_con);
free(no_con);
}
|
