dfhack/library/include/modules/MapCache.h

/*
https://github.com/peterix/dfhack
Copyright (c) 2009-2012 Petr Mrázek (peterix@gmail.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/

#pragma once
#ifndef MAPEXTRAS_H
#define MAPEXTRAS_H

#include "modules/Maps.h"
#include "TileTypes.h"
#include <stdint.h>
#include <cstring>
#include "df/map_block.h"
#include "df/tile_bitmask.h"
#include "df/block_square_event_mineralst.h"
#include "df/construction.h"
#include "df/item.h"

using namespace DFHack;

namespace df {
    struct world_region_details;
}

namespace MapExtras
{

class DFHACK_EXPORT MapCache;

class Block;

class BlockInfo
{
    Block *mblock;
    MapCache *parent;
    df::map_block *block;

public:
    t_blockmaterials veinmats;
    t_blockmaterials basemats;
    t_blockmaterials grass;
    std::map<df::coord,df::plant*> plants;

    df::feature_init *global_feature;
    df::feature_init *local_feature;

    BlockInfo()
        : mblock(NULL), parent(NULL), block(NULL),
        global_feature(NULL), local_feature(NULL) {}

    void prepare(Block *mblock);

    t_matpair getBaseMaterial(df::tiletype tt, df::coord2d pos);

    static void SquashVeins(df::map_block *mb, t_blockmaterials & materials);
    static void SquashFrozenLiquids (df::map_block *mb, tiletypes40d & frozen);
    static void SquashRocks (df::map_block *mb, t_blockmaterials & materials,
                             std::vector< std::vector <int16_t> > * layerassign);
    static void SquashGrass(df::map_block *mb, t_blockmaterials &materials);
};

class DFHACK_EXPORT Block
{
public:
    Block(MapCache *parent, DFCoord _bcoord);
    ~Block();

    DFCoord getCoord() { return bcoord; }

    void enableBlockUpdates(bool flow = false, bool temp = false) {
        Maps::enableBlockUpdates(block, flow, temp);
    }

    /*
     * All coordinates are taken mod 16.
     */

    //Arbitrary tag field for flood fills etc.
    int16_t &tag(df::coord2d p) {
        if (!tags) init_tags();
        return index_tile<int16_t&>(tags, p);
    }

    // Base layer
    df::tiletype baseTiletypeAt(df::coord2d p)
    {
        if (!tiles) init_tiles();
        return index_tile<df::tiletype>(tiles->base_tiles,p);
    }
    t_matpair baseMaterialAt(df::coord2d p)
    {
        if (!basemats) init_tiles(true);
        return t_matpair(
            index_tile<int16_t>(basemats->mat_type,p),
            index_tile<int16_t>(basemats->mat_index,p)
        );
    }
    bool isVeinAt(df::coord2d p)
    {
        using namespace df::enums::tiletype_material;
        auto tm = tileMaterial(baseTiletypeAt(p));
        return tm == MINERAL;
    }
    bool isLayerAt(df::coord2d p)
    {
        using namespace df::enums::tiletype_material;
        auto tm = tileMaterial(baseTiletypeAt(p));
        return tm == STONE || tm == SOIL;
    }

    int16_t veinMaterialAt(df::coord2d p)
    {
        return isVeinAt(p) ? baseMaterialAt(p).mat_index : -1;
    }
    int16_t layerMaterialAt(df::coord2d p)
    {
        if (!basemats) init_tiles(true);
        return index_tile<int16_t>(basemats->layermat,p);
    }

    // Static layer (base + constructions)
    df::tiletype staticTiletypeAt(df::coord2d p)
    {
        if (!tiles) init_tiles();
        if (tiles->con_info)
            return index_tile<df::tiletype>(tiles->con_info->tiles,p);
        return baseTiletypeAt(p);
    }
    t_matpair staticMaterialAt(df::coord2d p)
    {
        if (!basemats) init_tiles(true);
        if (tiles->con_info)
            return t_matpair(
                index_tile<int16_t>(tiles->con_info->mat_type,p),
                index_tile<int16_t>(tiles->con_info->mat_index,p)
            );
        return baseMaterialAt(p);
    }
    bool hasConstructionAt(df::coord2d p)
    {
        if (!tiles) init_tiles();
        return tiles->con_info &&
               tiles->con_info->constructed.getassignment(p);
    }

    df::tiletype tiletypeAt(df::coord2d p)
    {
        if (!block) return tiletype::Void;
        if (tiles)
            return index_tile<df::tiletype>(tiles->raw_tiles,p);
        return index_tile<df::tiletype>(block->tiletype,p);
    }
    bool setTiletypeAt(df::coord2d, df::tiletype tt, bool force = false);

    uint16_t temperature1At(df::coord2d p)
    {
        return index_tile<uint16_t>(temp1,p);
    }
    bool setTemp1At(df::coord2d p, uint16_t temp)
    {
        if(!valid) return false;
        dirty_temperatures = true;
        index_tile<uint16_t&>(temp1,p) = temp;
        return true;
    }

    uint16_t temperature2At(df::coord2d p)
    {
        return index_tile<uint16_t>(temp2,p);
    }
    bool setTemp2At(df::coord2d p, uint16_t temp)
    {
        if(!valid) return false;
        dirty_temperatures = true;
        index_tile<uint16_t&>(temp2,p) = temp;
        return true;
    }

    df::tile_designation DesignationAt(df::coord2d p)
    {
        return index_tile<df::tile_designation>(designation,p);
    }
    bool setDesignationAt(df::coord2d p, df::tile_designation des)
    {
        if(!valid) return false;
        dirty_designations = true;
        //printf("setting block %d/%d/%d , %d %d\n",x,y,z, p.x, p.y);
        index_tile<df::tile_designation&>(designation,p) = des;
        if(des.bits.dig && block)
            block->flags.bits.designated = true;
        return true;
    }

    df::tile_occupancy OccupancyAt(df::coord2d p)
    {
        return index_tile<df::tile_occupancy>(occupancy,p);
    }
    bool setOccupancyAt(df::coord2d p, df::tile_occupancy des)
    {
        if(!valid) return false;
        dirty_occupancies = true;
        index_tile<df::tile_occupancy&>(occupancy,p) = des;
        return true;
    }

    int itemCountAt(df::coord2d p)
    {
        if (!item_counts) init_item_counts();
        return index_tile<int>(item_counts,p);
    }

    t_blockflags BlockFlags()
    {
        return block ? block->flags : t_blockflags();
    }

    bool Write();

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

    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; }

private:
    friend class MapCache;
    friend class BlockInfo;

    MapCache *parent;
    df::map_block *block;

    void init();

    int biomeIndexAt(df::coord2d p);

    bool valid;
    bool dirty_designations:1;
    bool dirty_tiles:1;
    bool dirty_temperatures:1;
    bool dirty_occupancies:1;

    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 ConInfo {
        df::tile_bitmask constructed;
        df::tiletype tiles[16][16];
        t_blockmaterials mat_type;
        t_blockmaterials mat_index;
    };
    struct TileInfo {
        df::tile_bitmask frozen;
        df::tile_bitmask dirty_raw;
        df::tiletype raw_tiles[16][16];

        ConInfo *con_info;

        df::tile_bitmask dirty_base;
        df::tiletype base_tiles[16][16];

        TileInfo();
        ~TileInfo();

        void init_coninfo();
    };
    struct BasematInfo {
        df::tile_bitmask dirty;
        t_blockmaterials mat_type;
        t_blockmaterials mat_index;
        t_blockmaterials layermat;

        BasematInfo();
    };
    TileInfo *tiles;
    BasematInfo *basemats;
    void init_tiles(bool basemat = false);
    void ParseTiles(TileInfo *tiles);
    void ParseBasemats(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)
    {
        Block *b = BlockAtTile(coord);
        return b ? b->Allocate() : false;
    }

    df::tiletype baseTiletypeAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->baseTiletypeAt(tilecoord) : tiletype::Void;
    }
    t_matpair baseMaterialAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->baseMaterialAt(tilecoord) : t_matpair();
    }
    int16_t veinMaterialAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->veinMaterialAt(tilecoord) : -1;
    }
    int16_t layerMaterialAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->layerMaterialAt(tilecoord) : -1;
    }
    bool isVeinAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b && b->isVeinAt(tilecoord);
    }
    bool isLayerAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b && b->isLayerAt(tilecoord);
    }

    df::tiletype staticTiletypeAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->staticTiletypeAt(tilecoord) : tiletype::Void;
    }
    t_matpair staticMaterialAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->staticMaterialAt(tilecoord) : t_matpair();
    }
    bool hasConstructionAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b && b->hasConstructionAt(tilecoord);
    }

    df::tiletype tiletypeAt (DFCoord tilecoord)
    {
        Block *b = BlockAtTile(tilecoord);
        return b ? b->tiletypeAt(tilecoord) : tiletype::Void;
    }
    bool setTiletypeAt (DFCoord tilecoord, df::tiletype tt, bool force = false)
    {
        Block *b = BlockAtTile(tilecoord);
        return b && b->setTiletypeAt(tilecoord, tt, force);
    }

    uint16_t temperature1At (DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return b ? b->temperature1At(tilecoord) : 0;
    }
    bool setTemp1At(DFCoord tilecoord, uint16_t temperature)
    {
        if (Block * b= BlockAtTile(tilecoord))
            return b->setTemp1At(tilecoord, temperature);
        return false;
    }

    uint16_t temperature2At (DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return b ? b->temperature2At(tilecoord) : 0;
    }
    bool setTemp2At(DFCoord tilecoord, uint16_t temperature)
    {
        if (Block * b= BlockAtTile(tilecoord))
            return b->setTemp2At(tilecoord, temperature);
        return false;
    }

    int16_t tagAt(DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return b ? b->tag(tilecoord) : 0;
    }
    void setTagAt(DFCoord tilecoord, int16_t val)
    {
        Block * b= BlockAtTile(tilecoord);
        if (b) b->tag(tilecoord) = val;
    }
    void resetTags();

    df::tile_designation designationAt (DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return b ? b->DesignationAt(tilecoord) : df::tile_designation(0);
    }
    bool setDesignationAt (DFCoord tilecoord, df::tile_designation des)
    {
        if(Block * b= BlockAtTile(tilecoord))
            return b->setDesignationAt(tilecoord, des);
        return false;
    }

    df::tile_occupancy occupancyAt (DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return b ? b->OccupancyAt(tilecoord) : df::tile_occupancy(0);
    }
    bool setOccupancyAt (DFCoord tilecoord, df::tile_occupancy occ)
    {
        if (Block * b= BlockAtTile(tilecoord))
            return b->setOccupancyAt(tilecoord, occ);
        return false;
    }

    bool testCoord (DFCoord tilecoord)
    {
        Block * b= BlockAtTile(tilecoord);
        return (b && b->valid);
    }

    bool addItemOnGround(df::item *item) {
        Block * b= BlockAtTile(item->pos);
        return b ? b->addItemOnGround(item) : false;
    }
    bool removeItemOnGround(df::item *item) {
        Block * b= BlockAtTile(item->pos);
        return b ? b->removeItemOnGround(item) : false;
    }

    bool WriteAll()
    {
        std::map<DFCoord, Block *>::iterator p;
        for(p = blocks.begin(); p != blocks.end(); p++)
        {
            p->second->Write();
        }
        return true;
    }
    void trash()
    {
        std::map<DFCoord, Block *>::iterator p;
        for(p = blocks.begin(); p != blocks.end(); p++)
        {
            delete p->second;
        }
        blocks.clear();
    }

    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; }

private:
    friend class Block;
    friend class BlockInfo;

    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<df::coord2d> geoidx;
    std::vector<int> default_soil;
    std::vector<int> default_stone;
    std::vector< std::vector <int16_t> > layer_mats;
    std::map<df::coord2d, df::world_region_details*> region_details;
    std::map<DFCoord, Block *> blocks;
};
}
#endif