Recently I've programmed an auto-tile system for my game engine, which use 47 possible tile combinations. The technique is to check each of the eight adjacent cells ariound the center tile which are represented as a power of two, like so:

128, 001, 002
064, 000, 004
032, 016, 008

This method work great so far for me, the autotile system is assembled with the proper edge tiles automatically in real-time.

The real issue was to write the hash table of keys and values, which was EXTREMELY time-consuming. It took me nearly 6 hours to enter the values and make sure they're exact. See my hash table below.

My question: is there a way to auto-generate the keys/values of that hash table with an algorithm so that next time I don't have to enter it manually? I feel it's very important to ask because I will probably have to do it again for something else similar.

[source lang="csharp"]public void create_hash()
{
hash_table.Add( 0 , 47 );
hash_table.Add( 1 , 35 );
hash_table.Add( 2 , 47 );
hash_table.Add( 3 , 35 );
hash_table.Add( 4 , 7 );
hash_table.Add( 5 , 36 );
hash_table.Add( 6 , 7 );
hash_table.Add( 7 , 32 );
hash_table.Add( 8 , 47 );
hash_table.Add( 9 , 35 );
hash_table.Add( 10 , 47 );
hash_table.Add( 11 , 35 );
hash_table.Add( 12 , 7 );
hash_table.Add( 13 , 36 );
hash_table.Add( 14 , 7 );
hash_table.Add( 15 , 32 );
hash_table.Add( 16 , 3 );
hash_table.Add( 17 , 19 );
hash_table.Add( 18 , 3 );
hash_table.Add( 19 , 19 );
hash_table.Add( 20 , 4 );
hash_table.Add( 21 , 20 );
hash_table.Add( 22 , 4 );
hash_table.Add( 23 , 14 );
hash_table.Add( 24 , 3 );
hash_table.Add( 25 , 19 );
hash_table.Add( 26 , 3 );
hash_table.Add( 27 , 19 );
hash_table.Add( 28 , 0 );
hash_table.Add( 29 , 12 );
hash_table.Add( 30 , 0 );
hash_table.Add( 31 , 16 );
hash_table.Add( 32 , 47 );
hash_table.Add( 33 , 35 );
hash_table.Add( 34 , 47 );
hash_table.Add( 35 , 35 );
hash_table.Add( 36 , 7 );
hash_table.Add( 37 , 36 );
hash_table.Add( 38 , 7 );
hash_table.Add( 39 , 32 );
hash_table.Add( 40 , 47 );
hash_table.Add( 41 , 35 );
hash_table.Add( 42 , 47 );
hash_table.Add( 43 , 35 );
hash_table.Add( 44 , 7 );
hash_table.Add( 45 , 36 );
hash_table.Add( 46 , 7 );
hash_table.Add( 47 , 32 );
hash_table.Add( 48 , 3 );
hash_table.Add( 49 , 19 );
hash_table.Add( 50 , 3 );
hash_table.Add( 51 , 19 );
hash_table.Add( 52 , 4 );
hash_table.Add( 53 , 20 );
hash_table.Add( 54 , 4 );
hash_table.Add( 55 , 14 );
hash_table.Add( 56 , 3 );
hash_table.Add( 57 , 19 );
hash_table.Add( 58 , 3 );
hash_table.Add( 59 , 19 );
hash_table.Add( 60 , 0 );
hash_table.Add( 61 , 12 );
hash_table.Add( 62 , 0 );
hash_table.Add( 63 , 16 );
hash_table.Add( 64 , 9 );
hash_table.Add( 65 , 38 );
hash_table.Add( 66 , 9 );
hash_table.Add( 67 , 38 );
hash_table.Add( 68 , 8 );
hash_table.Add( 69 , 37 );
hash_table.Add( 70 , 8 );
hash_table.Add( 71 , 45 );
hash_table.Add( 72 , 9 );
hash_table.Add( 73 , 38 );
hash_table.Add( 74 , 9 );
hash_table.Add( 75 , 38 );
hash_table.Add( 76 , 8 );
hash_table.Add( 77 , 37 );
hash_table.Add( 78 , 8 );
hash_table.Add( 79 , 45 );
hash_table.Add( 80 , 6 );
hash_table.Add( 81 , 22 );
hash_table.Add( 82 , 6 );
hash_table.Add( 83 , 22 );
hash_table.Add( 84 , 5 );
hash_table.Add( 85 , 21 );
hash_table.Add( 86 , 6 );
hash_table.Add( 87 , 42 );
hash_table.Add( 88 , 6 );
hash_table.Add( 89 , 22 );
hash_table.Add( 90 , 6 );
hash_table.Add( 91 , 22 );
hash_table.Add( 92 , 29 );
hash_table.Add( 93 , 26 );
hash_table.Add( 94 , 29 );
hash_table.Add( 95 , 11 );
hash_table.Add( 96 , 9 );
hash_table.Add( 97 , 38 );
hash_table.Add( 98 , 9 );
hash_table.Add( 99 , 38 );
hash_table.Add( 100 , 8 );
hash_table.Add( 101 , 37 );
hash_table.Add( 102 , 8 );
hash_table.Add( 103 , 45 );
hash_table.Add( 104 , 9 );
hash_table.Add( 105 , 38 );
hash_table.Add( 106 , 9 );
hash_table.Add( 107 , 38 );
hash_table.Add( 108 , 8 );
hash_table.Add( 109 , 37 );
hash_table.Add( 110 , 8 );
hash_table.Add( 111 , 45 );
hash_table.Add( 112 , 2 );
hash_table.Add( 113 , 13 );
hash_table.Add( 114 , 2 );
hash_table.Add( 115 , 13 );
hash_table.Add( 116 , 30 );
hash_table.Add( 117 , 27 );
hash_table.Add( 118 , 30 );
hash_table.Add( 119 , 39 );
hash_table.Add( 120 , 2 );
hash_table.Add( 121 , 13 );
hash_table.Add( 122 , 2 );
hash_table.Add( 123 , 13 );
hash_table.Add( 124 , 1 );
hash_table.Add( 125 , 44 );
hash_table.Add( 126 , 1 );
hash_table.Add( 127 , 41 );
hash_table.Add( 128 , 47 );
hash_table.Add( 129 , 35 );
hash_table.Add( 130 , 47 );
hash_table.Add( 131 , 35 );
hash_table.Add( 132 , 7 );
hash_table.Add( 133 , 36 );
hash_table.Add( 134 , 7 );
hash_table.Add( 135 , 32 );
hash_table.Add( 136 , 47 );
hash_table.Add( 137 , 35 );
hash_table.Add( 138 , 47 );
hash_table.Add( 139 , 35 );
hash_table.Add( 140 , 7 );
hash_table.Add( 141 , 36 );
hash_table.Add( 142 , 7 );
hash_table.Add( 143 , 32 );
hash_table.Add( 144 , 3 );
hash_table.Add( 145 , 19 );
hash_table.Add( 146 , 3 );
hash_table.Add( 147 , 19 );
hash_table.Add( 148 , 4 );
hash_table.Add( 149 , 20 );
hash_table.Add( 150 , 4 );
hash_table.Add( 151 , 14 );
hash_table.Add( 152 , 3 );
hash_table.Add( 153 , 19 );
hash_table.Add( 154 , 3 );
hash_table.Add( 155 , 19 );
hash_table.Add( 156 , 0 );
hash_table.Add( 157 , 12 );
hash_table.Add( 158 , 0 );
hash_table.Add( 159 , 16 );
hash_table.Add( 160 , 47 );
hash_table.Add( 161 , 35 );
hash_table.Add( 162 , 47 );
hash_table.Add( 163 , 35 );
hash_table.Add( 164 , 7 );
hash_table.Add( 165 , 36 );
hash_table.Add( 166 , 7 );
hash_table.Add( 167 , 32 );
hash_table.Add( 168 , 47 );
hash_table.Add( 169 , 35 );
hash_table.Add( 170 , 47 );
hash_table.Add( 171 , 35 );
hash_table.Add( 172 , 7 );
hash_table.Add( 173 , 36 );
hash_table.Add( 174 , 7 );
hash_table.Add( 175 , 32 );
hash_table.Add( 176 , 3 );
hash_table.Add( 177 , 19 );
hash_table.Add( 178 , 3 );
hash_table.Add( 179 , 19 );
hash_table.Add( 180 , 4 );
hash_table.Add( 181 , 20 );
hash_table.Add( 182 , 4 );
hash_table.Add( 183 , 14 );
hash_table.Add( 184 , 3 );
hash_table.Add( 185 , 19 );
hash_table.Add( 186 , 3 );
hash_table.Add( 187 , 19 );
hash_table.Add( 188 , 0 );
hash_table.Add( 189 , 12 );
hash_table.Add( 190 , 0 );
hash_table.Add( 191 , 16 );
hash_table.Add( 192 , 9 );
hash_table.Add( 193 , 34 );
hash_table.Add( 194 , 9 );
hash_table.Add( 195 , 34 );
hash_table.Add( 196 , 8 );
hash_table.Add( 197 , 46 );
hash_table.Add( 198 , 8 );
hash_table.Add( 199 , 33 );
hash_table.Add( 200 , 9 );
hash_table.Add( 201 , 34 );
hash_table.Add( 202 , 9 );
hash_table.Add( 203 , 34 );
hash_table.Add( 204 , 8 );
hash_table.Add( 205 , 46 );
hash_table.Add( 206 , 8 );
hash_table.Add( 207 , 33 );
hash_table.Add( 208 , 6 );
hash_table.Add( 209 , 15 );
hash_table.Add( 210 , 6 );
hash_table.Add( 211 , 15 );
hash_table.Add( 212 , 5 );
hash_table.Add( 213 , 43 );
hash_table.Add( 214 , 5 );
hash_table.Add( 215 , 28 );
hash_table.Add( 216 , 6 );
hash_table.Add( 217 , 15 );
hash_table.Add( 218 , 6 );
hash_table.Add( 219 , 15 );
hash_table.Add( 220 , 29 );
hash_table.Add( 221 , 23 );
hash_table.Add( 222 , 29 );
hash_table.Add( 223 , 25 );
hash_table.Add( 224 , 9 );
hash_table.Add( 225 , 34 );
hash_table.Add( 226 , 9 );
hash_table.Add( 227 , 34 );
hash_table.Add( 228 , 8 );
hash_table.Add( 229 , 46 );
hash_table.Add( 230 , 8 );
hash_table.Add( 231 , 33 );
hash_table.Add( 232 , 9 );
hash_table.Add( 233 , 34 );
hash_table.Add( 234 , 9 );
hash_table.Add( 235 , 34 );
hash_table.Add( 236 , 8 );
hash_table.Add( 237 , 46 );
hash_table.Add( 238 , 8 );
hash_table.Add( 239 , 33 );
hash_table.Add( 240 , 2 );
hash_table.Add( 241 , 18 );
hash_table.Add( 242 , 2 );
hash_table.Add( 243 , 18 );
hash_table.Add( 244 , 30 );
hash_table.Add( 245 , 10 );
hash_table.Add( 246 , 30 );
hash_table.Add( 247 , 24 );
hash_table.Add( 248 , 2 );
hash_table.Add( 249 , 18 );
hash_table.Add( 250 , 2 );
hash_table.Add( 251 , 18 );
hash_table.Add( 252 , 1 );
hash_table.Add( 253 , 40 );
hash_table.Add( 254 , 1 );
hash_table.Add( 255 , 17 );

}[/source]

Its kind of hard to tell what's going on without more description....

What does the hash table store? Each tile's value? If so, I can only assume the tiles are in some sort of array to begin with, so you would be able to


i = 0
j = 0
for each row
for each column
hash_table.Add( ((i * numCols) + j), tile_array[j])
j++
i++


And since your keys are 0-255 with no gaps, why do you need a hash table? A 1-d array would serve you just as well...

Edit: from reading your previous question, I take it you are trying to generate one of 47 unique ids based on a 3x3 pattern?

Yes, I would like to create an auto-tile system by filling it with patterns. for example, the larger the field gets, larger tile patterns are inserted (rather than always repeating 1x1 pattern.

So rather than using constantly 32x32 tiles for the middle part of the autotile, I would like to use other patterns like 2x2, 3x3, etc.

But I know how complex it is, so I try to ask my questions at the most basic level as possible.

And since your keys are 0-255 with no gaps, why do you need a hash table? A 1-d array would serve you just as well...[/quote]

It's because the keys are the bit signature for all tile possibilities, so the same tile id can be used for many type of connections depending of the adjacent tiles around the middle tile.