struct Tile {
    uint8_t byteA; // tile type, like stone, copper_bar, actuator_head, or air
    uint8_t byteB; // welding and movement
    uint8_t byteC; // tile-type defined
    uint8_t byteD; // tile-type defined
    uint8_t byteE; // either stack-count, OR 7 bits of light level and a 1 bit flag for actively being extracted/heated
//tiles have 3 more bytes for various gameplay algorithms, but since these always get reset to 0 at the end of the algorithm, they aren't saved.
};
struct regionV2D {  // region-scale "vector 2 dimensional"
    int64_t x;      // one unit of regionV2D is 32 chunkV2D units
    int64_t y;      // the file names of .rsv files use these coordinates
};
struct chunkV2D {   // chunk-scale "vector 2 dimensional"
    int64_t x;      // one unit of chunkV2D is 64 tileV2D units
    int64_t y;
};
struct tileV2D {    // tile-scale "vector 2 dimensional"
    int64_t x;      // one unit of tileV2d is 16 pixels
    int64_t y;      // tileV2D is the most commonly used scale. It is the gameplay grid of Roody:2d
};
// other smaller scale V2D units exist for entities and pixels. One unit of pixelV2D is 16 entityV2D units. These aren't important for the .rsv format

struct Region_Header {
    int32_t version;            // 1

    //region offsets are relative to here

    uint32_t file_size;         // total region file size, including this header
    char rsv[4] = {'.', 'r','s','v'}; // padding

    regionV2D position;         // absolute coordinates of region

    uint32_t locations_offset;  // start of the chunk-location table in the file, relative to the start of the region data, including this header, but NOT including the 4 byte version
    uint32_t locations_size;    // size  of the chunk-location table in the file

    uint32_t chunks_offset;     // start of chunk data pool, relative to the start of the region data, including this header, but NOT including the 4 byte version
    uint32_t chunks_size;       // size  of chunk data pool
};

struct Region_Chunk_location {
    chunkV2D position; // relative to the region position
    uint32_t offset;   // relative to the region chunks_offset
};
static_assert(sizeof(Region_Chunk_location) == 24);

struct Chunk_Header {
    uint32_t size;                      // total chunk data size, including this header
    char chnk[4] = {'c','h','n','k'};   // padding

    chunkV2D position;                  // absolute coordinates of chunk. This is redundant when using Region_Header.position and Region_Chunk_location.position

    uint32_t generation_stage;          // Chunks are only saved if they reach the final generation stage, so this should always be the same value.
    uint32_t last_randomTick_timestamp; // used to make plants instantly grow if a chunk has been unloaded while the rest of the world has been loaded for some time

    uint32_t tilegrid_offset;           // start of the tilegrid data, relative to the start of the region data, including this header
    uint32_t tilegrid_size;             // size  of the tilegrid data

    uint32_t tile_dynamic_data_offset;  // start of the tile_dynamic data, relative to the start of the region data, including this header
    uint32_t tile_dynamic_data_size;    // size  of the tile_dynamic data. This dynamic tile data is a single human-readable askii-string, with individual tile_dynamic inside [] brackets

    uint32_t entities_offset;           // start of the entity data, relative to the start of the region data, including this header
    uint32_t entities_size;             // size  of the entity data. This dynamic tile data is a single human-readable askii-string, with individual entities inside [] brackets
};

struct TileGrid_Header {
    uint32_t size;                      // total tilegrid data size, including this header
    char tile[4] = {'t','i','l','e'};   // padding
    tileV2D bounds;                     // always 64, 64

    uint32_t byteA_offset;              // offset is relative to this header
    uint32_t byteA_size;
    uint32_t byteB_offset;
    uint32_t byteB_size;
    uint32_t byteC_offset;
    uint32_t byteC_size;
    uint32_t byteD_offset;
    uint32_t byteD_size;
    uint32_t byteE_offset;
    uint32_t byteE_size;
    uint32_t byteF_offset_spacer = 0;   // unused, should always be 0
    uint32_t byteF_size_spacer = 0;
    uint32_t byteG_offset_spacer = 0;
    uint32_t byteG_size_spacer = 0;
    uint32_t byteH_offset_spacer = 0;
    uint32_t byteH_size_spacer = 0;
    uint32_t byteI_offset_spacer = 0;
    uint32_t byteI_size_spacer = 0;
};