#pragma once

#include "TileTypes.h"

#include "modules/Maps.h"

#include "df/block_square_event_mineralst.h"

#include "df/inclusion_type.h"

#include "df/tile_bitmask.h"

#include "df/tile_designation.h"

#include "df/tile_occupancy.h"

#include <bitset>

#include <cstring>

#include <stdint.h>

namespace df {

struct map_block;

struct map_block_column;

struct construction;

struct item;

struct world_region_details;

}

namespace MapExtras

{

using namespace DFHack;

class DFHACK_EXPORT MapCache;

class Block;

struct BiomeInfo {

};

typedef uint8_t t_veintype[16][16];

typedef df::tiletype t_tilearr[16][16];

class BlockInfo

};

class DFHACK_EXPORT Block

{

Block(MapCache *parent, DFCoord _bcoord);

~Block();

DFCoord getCoord() { return bcoord; }

void enableBlockUpdates(bool flow = false, bool temp = false) {

Maps::enableBlockUpdates(block, flow, temp);

}

/*

/// Arbitrary tag field for flood fills etc.

int16_t &tag(df::coord2d p) {

if (!tags) init_tags();

return index_tile(tags, p);

}

/// Base layer tile type (i.e. layer stone, veins, feature stone)

df::tiletype baseTiletypeAt(df::coord2d p)

}

/// Base layer material (i.e. layer stone, veins, feature stone)

t_matpair baseMaterialAt(df::coord2d p)

}

/// Check if the base layer tile is a vein

bool isVeinAt(df::coord2d p)

}

/// Check if the base layer tile is layer stone or soil

bool isLayerAt(df::coord2d p)

}

/// Vein material at pos (even if there is no vein tile), or -1 if none

int16_t veinMaterialAt(df::coord2d p)

}

/// Vein type at pos (even if there is no vein tile)

df::inclusion_type veinTypeAt(df::coord2d p)

}

/** Sets the vein material at the specified tile position.

bool setVeinMaterialAt(df::coord2d p, int16_t mat, df::inclusion_type type = df::enums::inclusion_type::CLUSTER);

/// Geological layer soil or stone material at pos

int16_t layerMaterialAt(df::coord2d p) {

return biomeInfoAt(p).layer_stone[layerIndexAt(p)];

}

/// Biome-specific lava stone at pos

int16_t lavaStoneAt(df::coord2d p) { return biomeInfoAt(p).lava_stone; }

/**

bool setStoneAt(df::coord2d p, df::tiletype tile, int16_t mat, df::inclusion_type type = df::enums::inclusion_type::CLUSTER, bool force_type = false, bool kill_veins = false);

/**

bool setSoilAt(df::coord2d p, df::tiletype tile, bool kill_veins = false);

/// Static layer tile (i.e. base + constructions)

df::tiletype staticTiletypeAt(df::coord2d p)

}

/// Static layer material (i.e. base + constructions)

t_matpair staticMaterialAt(df::coord2d p)

}

bool hasConstructionAt(df::coord2d p)

}

df::tiletype tiletypeAt(df::coord2d p);

bool setTiletypeAt(df::coord2d, df::tiletype tt, bool force = false);

uint16_t temperature1At(df::coord2d p)

{

return index_tile(temp1,p);

}

bool setTemp1At(df::coord2d p, uint16_t temp)

}

uint16_t temperature2At(df::coord2d p)

{

return index_tile(temp2,p);

}

bool setTemp2At(df::coord2d p, uint16_t temp)

}

df::tile_designation DesignationAt(df::coord2d p)

{

return index_tile(designation,p);

}

bool setDesignationAt(df::coord2d p, df::tile_designation des, int32_t priority = 0);

int32_t priorityAt(df::coord2d p);

bool setPriorityAt(df::coord2d p, int32_t priority);

df::tile_occupancy OccupancyAt(df::coord2d p)

{

return index_tile(occupancy,p);

}

bool setOccupancyAt(df::coord2d p, df::tile_occupancy des)

}

bool getFlagAt(df::coord2d p, df::tile_designation::Mask mask) {

return (index_tile(designation,p).whole & mask) != 0;

}

bool getFlagAt(df::coord2d p, df::tile_occupancy::Mask mask) {

return (index_tile(occupancy,p).whole & mask) != 0;

}

bool setFlagAt(df::coord2d p, df::tile_designation::Mask mask, bool set);

bool setFlagAt(df::coord2d p, df::tile_occupancy::Mask mask, bool set);

int itemCountAt(df::coord2d p)

}

t_blockflags BlockFlags();

bool Write();

bool isDirty();

int biomeIndexAt(df::coord2d p);

int layerIndexAt(df::coord2d p) {

return index_tile(designation,p).bits.geolayer_index;

}

df::coord2d biomeRegionAt(df::coord2d p);

const BiomeInfo &biomeInfoAt(df::coord2d p);

int16_t GeoIndexAt(df::coord2d p) { return biomeInfoAt(p).geo_index; }

bool GetGlobalFeature(t_feature *out);

bool GetLocalFeature(t_feature *out);

bool is_valid() { return valid; }

df::map_block *getRaw() { return block; }

bool Allocate();

MapCache *getParent() { return parent; }

friend class MapCache;

friend class BlockInfo;

MapCache *parent;

df::map_block *block;

void init();

bool valid:1;

bool dirty_designations:1;

bool dirty_tiles:1;

bool dirty_veins:1;

bool dirty_temperatures:1;

bool dirty_occupancies:1;

std::bitset<16*16> designated_tiles;

DFCoord bcoord;

// Custom tags for floodfill

typedef int16_t T_tags[16];

T_tags *tags;

void init_tags();

// On-ground item count info

typedef int T_item_counts[16];

T_item_counts *item_counts;

void init_item_counts();

bool addItemOnGround(df::item *item);

bool removeItemOnGround(df::item *item);

struct IceInfo {

df::tile_bitmask frozen;

df::tile_bitmask dirty;

};

struct ConInfo {

};

struct TileInfo {

};

struct BasematInfo {

};

TileInfo *tiles;

BasematInfo *basemats;

void init_tiles(bool basemat = false);

void ParseTiles(TileInfo *tiles);

void WriteTiles(TileInfo*);

void ParseBasemats(TileInfo *tiles, BasematInfo *bmats);

void WriteVeins(TileInfo *tiles, BasematInfo *bmats);

designations40d designation;

occupancies40d occupancy;

t_temperatures temp1;

t_temperatures temp2;

};

class DFHACK_EXPORT MapCache

{

public:

MapCache();

~MapCache()

{

trash();

}

bool isValid ()

{

return valid;

}

/// get the map block at a *block* coord. Block coord = tile coord / 16

Block *BlockAt(DFCoord blockcoord);

/// get the map block at a tile coord.

Block *BlockAtTile(DFCoord coord) {

return BlockAt(df::coord(coord.x>>4,coord.y>>4,coord.z));

}

bool ensureBlockAt(df::coord coord)

}

/// delete the block from memory

void discardBlock(Block *block);

df::tiletype baseTiletypeAt (DFCoord tilecoord)

}

t_matpair baseMaterialAt (DFCoord tilecoord)

}

int16_t veinMaterialAt (DFCoord tilecoord)

}

int16_t layerMaterialAt (DFCoord tilecoord)

}

bool isVeinAt (DFCoord tilecoord)

}

bool isLayerAt (DFCoord tilecoord)

}

df::tiletype staticTiletypeAt (DFCoord tilecoord)

}

t_matpair staticMaterialAt (DFCoord tilecoord)

}

bool hasConstructionAt (DFCoord tilecoord)

}

df::tiletype tiletypeAt (DFCoord tilecoord)

}

bool setTiletypeAt (DFCoord tilecoord, df::tiletype tt, bool force = false)

}

uint16_t temperature1At (DFCoord tilecoord)

}

bool setTemp1At(DFCoord tilecoord, uint16_t temperature)

}

uint16_t temperature2At (DFCoord tilecoord)

}

bool setTemp2At(DFCoord tilecoord, uint16_t temperature)

}

int16_t tagAt(DFCoord tilecoord)

}

void setTagAt(DFCoord tilecoord, int16_t val)

}

void resetTags();

df::tile_designation designationAt (DFCoord tilecoord)

}

// if priority is 0, it is kept unchanged if previously set, otherwise 4000

bool setDesignationAt (DFCoord tilecoord, df::tile_designation des, int32_t priority = 0)

}

int32_t priorityAt (DFCoord tilecoord)

}

bool setPriorityAt (DFCoord tilecoord, int32_t priority)

}

df::tile_occupancy occupancyAt (DFCoord tilecoord)

}

bool setOccupancyAt (DFCoord tilecoord, df::tile_occupancy occ)

}

bool testCoord (DFCoord tilecoord)

}

bool addItemOnGround(df::item *item);

bool removeItemOnGround(df::item *item);

bool WriteAll();

void trash()

}

uint32_t maxBlockX() { return x_bmax; }

uint32_t maxBlockY() { return y_bmax; }

uint32_t maxTileX() { return x_tmax; }

uint32_t maxTileY() { return y_tmax; }

uint32_t maxZ() { return z_max; }

size_t getBiomeCount() { return biomes.size(); }

const BiomeInfo &getBiomeByIndex(unsigned idx) {

return (idx < biomes.size()) ? biomes[idx] : biome_stub;

}

friend class Block;

friend class BlockInfo;

static const BiomeInfo biome_stub;

bool valid;

bool validgeo;

uint32_t x_bmax;

uint32_t y_bmax;

uint32_t x_tmax;

uint32_t y_tmax;

uint32_t z_max;

std::vector<BiomeInfo> biomes;

std::map<df::coord2d, df::world_region_details*> region_details;

std::map<DFCoord, Block *> blocks;

};

}