523 lines
14 KiB
C++
523 lines
14 KiB
C++
/*
|
|
https://github.com/peterix/dfhack
|
|
Copyright (c) 2009-2011 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/block_square_event_mineralst.h"
|
|
#include "df/construction.h"
|
|
using namespace DFHack;
|
|
namespace MapExtras
|
|
{
|
|
void SquashVeins (DFCoord bcoord, mapblock40d & mb, t_blockmaterials & materials)
|
|
{
|
|
memset(materials,-1,sizeof(materials));
|
|
std::vector <df::block_square_event_mineralst *> veins;
|
|
Maps::SortBlockEvents(bcoord.x,bcoord.y,bcoord.z,&veins);
|
|
for (uint32_t x = 0;x<16;x++) for (uint32_t y = 0; y< 16;y++)
|
|
{
|
|
df::tiletype tt = mb.tiletypes[x][y];
|
|
if (tileMaterial(tt) == tiletype_material::MINERAL)
|
|
{
|
|
for (size_t i = 0; i < veins.size(); i++)
|
|
{
|
|
if (veins[i]->getassignment(x,y))
|
|
materials[x][y] = veins[i]->inorganic_mat;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SquashFrozenLiquids (DFCoord bcoord, mapblock40d & mb, tiletypes40d & frozen)
|
|
{
|
|
std::vector <df::block_square_event_frozen_liquidst *> ices;
|
|
Maps::SortBlockEvents(bcoord.x,bcoord.y,bcoord.z,NULL,&ices);
|
|
for (uint32_t x = 0; x < 16; x++) for (uint32_t y = 0; y < 16; y++)
|
|
{
|
|
df::tiletype tt = mb.tiletypes[x][y];
|
|
frozen[x][y] = tiletype::Void;
|
|
if (tileMaterial(tt) == tiletype_material::FROZEN_LIQUID)
|
|
{
|
|
for (size_t i = 0; i < ices.size(); i++)
|
|
{
|
|
df::tiletype tt2 = ices[i]->tiles[x][y];
|
|
if (tt2 != tiletype::Void)
|
|
{
|
|
frozen[x][y] = tt2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SquashConstructions (DFCoord bcoord, mapblock40d & mb, tiletypes40d & constructions)
|
|
{
|
|
for (uint32_t x = 0; x < 16; x++) for (uint32_t y = 0; y < 16; y++)
|
|
{
|
|
df::tiletype tt = mb.tiletypes[x][y];
|
|
constructions[x][y] = tiletype::Void;
|
|
if (tileMaterial(tt) == tiletype_material::CONSTRUCTION)
|
|
{
|
|
DFCoord coord(bcoord.x*16 + x, bcoord.y*16 + y, bcoord.z);
|
|
df::construction *con = df::construction::find(coord);
|
|
if (con)
|
|
constructions[x][y] = con->original_tile;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SquashRocks ( std::vector< std::vector <uint16_t> > * layerassign, mapblock40d & mb, t_blockmaterials & materials)
|
|
{
|
|
// get the layer materials
|
|
for (uint32_t x = 0; x < 16; x++) for (uint32_t y = 0; y < 16; y++)
|
|
{
|
|
materials[x][y] = -1;
|
|
uint8_t test = mb.designation[x][y].bits.biome;
|
|
if ((test < sizeof(mb.biome_indices)) && (mb.biome_indices[test] < layerassign->size()))
|
|
materials[x][y] = layerassign->at(mb.biome_indices[test])[mb.designation[x][y].bits.geolayer_index];
|
|
}
|
|
}
|
|
|
|
class Block
|
|
{
|
|
public:
|
|
Block(DFCoord _bcoord, std::vector< std::vector <uint16_t> > * layerassign = 0)
|
|
{
|
|
dirty_designations = false;
|
|
dirty_tiletypes = false;
|
|
dirty_temperatures = false;
|
|
dirty_blockflags = false;
|
|
dirty_occupancies = false;
|
|
valid = false;
|
|
bcoord = _bcoord;
|
|
if(Maps::ReadBlock40d(bcoord.x,bcoord.y,bcoord.z,&raw))
|
|
{
|
|
Maps::ReadTemperatures(bcoord.x,bcoord.y, bcoord.z,&temp1,&temp2);
|
|
SquashVeins(bcoord,raw,veinmats);
|
|
SquashConstructions(bcoord, raw, contiles);
|
|
SquashFrozenLiquids(bcoord, raw, icetiles);
|
|
if(layerassign)
|
|
SquashRocks(layerassign,raw,basemats);
|
|
else
|
|
memset(basemats,-1,sizeof(basemats));
|
|
valid = true;
|
|
}
|
|
}
|
|
int16_t veinMaterialAt(df::coord2d p)
|
|
{
|
|
return veinmats[p.x][p.y];
|
|
}
|
|
int16_t baseMaterialAt(df::coord2d p)
|
|
{
|
|
return basemats[p.x][p.y];
|
|
}
|
|
|
|
// the clear methods are used by the floodfill in digv and digl to mark tiles which were processed
|
|
void ClearBaseMaterialAt(df::coord2d p)
|
|
{
|
|
basemats[p.x][p.y] = -1;
|
|
}
|
|
void ClearVeinMaterialAt(df::coord2d p)
|
|
{
|
|
veinmats[p.x][p.y] = -1;
|
|
}
|
|
|
|
df::tiletype BaseTileTypeAt(df::coord2d p)
|
|
{
|
|
if (contiles[p.x][p.y] != tiletype::Void)
|
|
return contiles[p.x][p.y];
|
|
else if (icetiles[p.x][p.y] != tiletype::Void)
|
|
return icetiles[p.x][p.y];
|
|
else
|
|
return raw.tiletypes[p.x][p.y];
|
|
}
|
|
df::tiletype TileTypeAt(df::coord2d p)
|
|
{
|
|
return raw.tiletypes[p.x][p.y];
|
|
}
|
|
bool setTiletypeAt(df::coord2d p, df::tiletype tiletype)
|
|
{
|
|
if(!valid) return false;
|
|
dirty_tiletypes = true;
|
|
//printf("setting block %d/%d/%d , %d %d\n",x,y,z, p.x, p.y);
|
|
raw.tiletypes[p.x][p.y] = tiletype;
|
|
return true;
|
|
}
|
|
|
|
uint16_t temperature1At(df::coord2d p)
|
|
{
|
|
return temp1[p.x][p.y];
|
|
}
|
|
bool setTemp1At(df::coord2d p, uint16_t temp)
|
|
{
|
|
if(!valid) return false;
|
|
dirty_temperatures = true;
|
|
temp1[p.x][p.y] = temp;
|
|
return true;
|
|
}
|
|
|
|
uint16_t temperature2At(df::coord2d p)
|
|
{
|
|
return temp2[p.x][p.y];
|
|
}
|
|
bool setTemp2At(df::coord2d p, uint16_t temp)
|
|
{
|
|
if(!valid) return false;
|
|
dirty_temperatures = true;
|
|
temp2[p.x][p.y] = temp;
|
|
return true;
|
|
}
|
|
|
|
df::tile_designation DesignationAt(df::coord2d p)
|
|
{
|
|
return raw.designation[p.x][p.y];
|
|
}
|
|
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);
|
|
raw.designation[p.x][p.y] = des;
|
|
if(des.bits.dig)
|
|
{
|
|
dirty_blockflags = true;
|
|
raw.blockflags.bits.designated = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
df::tile_occupancy OccupancyAt(df::coord2d p)
|
|
{
|
|
return raw.occupancy[p.x][p.y];
|
|
}
|
|
bool setOccupancyAt(df::coord2d p, df::tile_occupancy des)
|
|
{
|
|
if(!valid) return false;
|
|
dirty_occupancies = true;
|
|
raw.occupancy[p.x][p.y] = des;
|
|
return true;
|
|
}
|
|
|
|
t_blockflags BlockFlags()
|
|
{
|
|
return raw.blockflags;
|
|
}
|
|
bool setBlockFlags(t_blockflags des)
|
|
{
|
|
if(!valid) return false;
|
|
dirty_blockflags = true;
|
|
//printf("setting block %d/%d/%d , %d %d\n",x,y,z, p.x, p.y);
|
|
raw.blockflags = des;
|
|
return true;
|
|
}
|
|
|
|
bool Write ()
|
|
{
|
|
if(!valid) return false;
|
|
if(dirty_designations)
|
|
{
|
|
Maps::WriteDesignations(bcoord.x,bcoord.y,bcoord.z, &raw.designation);
|
|
Maps::WriteDirtyBit(bcoord.x,bcoord.y,bcoord.z,true);
|
|
dirty_designations = false;
|
|
}
|
|
if(dirty_tiletypes)
|
|
{
|
|
Maps::WriteTileTypes(bcoord.x,bcoord.y,bcoord.z, &raw.tiletypes);
|
|
dirty_tiletypes = false;
|
|
}
|
|
if(dirty_temperatures)
|
|
{
|
|
Maps::WriteTemperatures(bcoord.x,bcoord.y,bcoord.z, &temp1, &temp2);
|
|
dirty_temperatures = false;
|
|
}
|
|
if(dirty_blockflags)
|
|
{
|
|
Maps::WriteBlockFlags(bcoord.x,bcoord.y,bcoord.z,raw.blockflags);
|
|
dirty_blockflags = false;
|
|
}
|
|
if(dirty_occupancies)
|
|
{
|
|
Maps::WriteOccupancy(bcoord.x,bcoord.y,bcoord.z,&raw.occupancy);
|
|
dirty_occupancies = false;
|
|
}
|
|
return true;
|
|
}
|
|
bool valid:1;
|
|
bool dirty_designations:1;
|
|
bool dirty_tiletypes:1;
|
|
bool dirty_temperatures:1;
|
|
bool dirty_blockflags:1;
|
|
bool dirty_occupancies:1;
|
|
mapblock40d raw;
|
|
DFCoord bcoord;
|
|
t_blockmaterials veinmats;
|
|
t_blockmaterials basemats;
|
|
t_temperatures temp1;
|
|
t_temperatures temp2;
|
|
tiletypes40d contiles; // what's underneath constructions
|
|
tiletypes40d icetiles; // what's underneath ice
|
|
};
|
|
|
|
class MapCache
|
|
{
|
|
public:
|
|
MapCache()
|
|
{
|
|
valid = 0;
|
|
Maps::getSize(x_bmax, y_bmax, z_max);
|
|
validgeo = Maps::ReadGeology( layerassign );
|
|
valid = true;
|
|
};
|
|
~MapCache()
|
|
{
|
|
trash();
|
|
}
|
|
bool isValid ()
|
|
{
|
|
return valid;
|
|
}
|
|
/// get the map block at a *block* coord. Block coord = tile coord / 16
|
|
Block * BlockAt (DFCoord blockcoord)
|
|
{
|
|
if(!valid)
|
|
return 0;
|
|
std::map <DFCoord, Block*>::iterator iter = blocks.find(blockcoord);
|
|
if(iter != blocks.end())
|
|
{
|
|
return (*iter).second;
|
|
}
|
|
else
|
|
{
|
|
if(blockcoord.x >= 0 && blockcoord.x < x_bmax &&
|
|
blockcoord.y >= 0 && blockcoord.y < y_bmax &&
|
|
blockcoord.z >= 0 && blockcoord.z < z_max)
|
|
{
|
|
Block * nblo;
|
|
if(validgeo)
|
|
nblo = new Block(blockcoord, &layerassign);
|
|
else
|
|
nblo = new Block(blockcoord);
|
|
blocks[blockcoord] = nblo;
|
|
return nblo;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
df::tiletype baseTiletypeAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->BaseTileTypeAt(tilecoord % 16);
|
|
}
|
|
return tiletype::Void;
|
|
}
|
|
df::tiletype tiletypeAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->TileTypeAt(tilecoord % 16);
|
|
}
|
|
return tiletype::Void;
|
|
}
|
|
bool setTiletypeAt(DFCoord tilecoord, df::tiletype tiletype)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->setTiletypeAt(tilecoord % 16, tiletype);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint16_t temperature1At (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->temperature1At(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
bool setTemp1At(DFCoord tilecoord, uint16_t temperature)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->setTemp1At(tilecoord % 16, temperature);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint16_t temperature2At (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->temperature2At(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
bool setTemp2At(DFCoord tilecoord, uint16_t temperature)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->setTemp2At(tilecoord % 16, temperature);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int16_t veinMaterialAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->veinMaterialAt(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
int16_t baseMaterialAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->baseMaterialAt(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
bool clearVeinMaterialAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->ClearVeinMaterialAt(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
bool clearBaseMaterialAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->ClearBaseMaterialAt(tilecoord % 16);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
df::tile_designation designationAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->DesignationAt(tilecoord % 16);
|
|
}
|
|
df::tile_designation temp;
|
|
temp.whole = 0;
|
|
return temp;
|
|
}
|
|
bool setDesignationAt (DFCoord tilecoord, df::tile_designation des)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->setDesignationAt(tilecoord % 16, des);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
df::tile_occupancy occupancyAt (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return b->OccupancyAt(tilecoord % 16);
|
|
}
|
|
df::tile_occupancy temp;
|
|
temp.whole = 0;
|
|
return temp;
|
|
}
|
|
bool setOccupancyAt (DFCoord tilecoord, df::tile_occupancy occ)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
b->setOccupancyAt(tilecoord % 16, occ);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool testCoord (DFCoord tilecoord)
|
|
{
|
|
Block * b= BlockAt(tilecoord / 16);
|
|
if(b && b->valid)
|
|
{
|
|
return true;
|
|
}
|
|
return 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();
|
|
}
|
|
private:
|
|
volatile bool valid;
|
|
volatile bool validgeo;
|
|
uint32_t x_bmax;
|
|
uint32_t y_bmax;
|
|
uint32_t x_tmax;
|
|
uint32_t y_tmax;
|
|
uint32_t z_max;
|
|
std::vector< std::vector <uint16_t> > layerassign;
|
|
std::map<DFCoord, Block *> blocks;
|
|
};
|
|
}
|
|
#endif |