/*
Written by ChromeCrusher for finding bases on 2b2t.org

This program requires you to know a top-level bedrock pattern.
A chunk-aligned 16x16 pattern (a complete chunk) is preferable and is the fastest method, but it can find any smaller pattern too (it just takes longer)
You could technically search for an area larger than 16x16 (up to 48x48), but it will be slower and the chances of finding two identical 16x16 bedrock patterns is basically zero.
An 8x8 pattern is usually enough to uniquely identify a location with a fairly low chance of false positives.

You'll need to know which direction is north. This can be found by looking at the textures of some blocks (cobblestone for example, see http://gaming.stackexchange.com/a/23103)
If you can't find which direction is north, you'll have to search for all 4 rotations of the pattern separately. I did not include a function to do it automatically because I haven't needed it.

This program assumes that the chunks being searched were generated in a fairly recent version of Minecraft (probably newer than 1.7)
It will not find 1.3.2 or 1.6.4 chunks, but I don't know exactly when the algorithm changed (it had to do with the structure generation limit changing from y=127 to y=255).

It will work on any Minecraft world that uses normal terrain generation (with the version caveat mentioned above)
It will also work regardless of the world seed, since bedrock patterns are the same in every world.

This program is standalone and doesn't depend on any Java or Minecraft code.

compile with:
   gcc bedrock.c -O3 -o bedrock
run with one of the following for the demos:
  ./bedrock full
  ./bedrock sub
  ./bedrock any

To change the search pattern, edit one of the arrays below and recompile.
*/

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>

// the pattern at chunk 123, -456 (real: 1968x, -7296z)
int full_pattern[16*16] = {1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,
                           1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,
                           1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,
                           1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,
                           0,1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,
                           0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,
                           0,0,1,1,0,1,1,0,0,0,0,1,0,1,0,1,
                           0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,
                           0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
                           0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,
                           1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,
                           0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,
                           0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,
                           0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,
                           0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,
                           0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0};

// a sub pattern of chunk -98, 76 (real: -1568x, 1216x)
int sub_pattern[8*8] = {0,0,1,0,0,0,1,0,
                             0,0,0,0,0,0,0,0,
                             0,0,1,1,0,0,0,0,
                             0,1,1,0,0,0,0,0,
                             0,0,0,1,0,0,0,0,
                             0,0,0,0,0,1,0,1,
                             1,0,0,0,1,0,0,0,
                             0,0,1,0,0,1,0,1};

// a pattern that is part of 4 different chunks (worse case scenario)
// from chunk 34, -56 (real: 544x, -896z)
int any_pattern[8*8] = {0,0,0,0,0,0,0,0,
                        0,0,0,1,0,0,0,0,
                        0,1,0,0,0,0,0,0,
                        0,0,0,1,0,0,0,0,
                        0,1,1,0,0,0,0,0,
                        0,0,0,1,1,0,0,0,
                        0,0,0,0,0,0,0,0,
                        1,0,1,0,0,1,0,0};