command_result prospector (color_ostream &con, vector <string> & parameters)
{
bool showHidden = false;
bool showPlants = true;
bool showSlade = true;
bool showTemple = true;
bool showValue = false;
bool showTube = false;
for(size_t i = 0; i < parameters.size();i++)
{
if (parameters[i] == "all")
{
showHidden = true;
}
else if (parameters[i] == "value")
{
showValue = true;
}
else if (parameters[i] == "hell")
{
showHidden = showTube = true;
}
else
return CR_WRONG_USAGE;
}
CoreSuspender suspend;
// Embark screen active: estimate using world geology data
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_choose_start_sitest, Core::getTopViewscreen()))
return embark_prospector(con, screen, showHidden, showValue);
if (!Maps::IsValid())
{
con.printerr("Map is not available!\n");
return CR_FAILURE;
}
uint32_t x_max = 0, y_max = 0, z_max = 0;
Maps::getSize(x_max, y_max, z_max);
MapExtras::MapCache map;
DFHack::Materials *mats = Core::getInstance().getMaterials();
DFHack::t_feature blockFeatureGlobal;
DFHack::t_feature blockFeatureLocal;
bool hasAquifer = false;
bool hasDemonTemple = false;
bool hasLair = false;
MatMap baseMats;
MatMap layerMats;
MatMap veinMats;
MatMap plantMats;
MatMap treeMats;
matdata liquidWater;
matdata liquidMagma;
matdata aquiferTiles;
matdata tubeTiles;
uint32_t vegCount = 0;
for(uint32_t z = 0; z < z_max; z++)
{
for(uint32_t b_y = 0; b_y < y_max; b_y++)
{
for(uint32_t b_x = 0; b_x < x_max; b_x++)
{
// Get the map block
df::coord2d blockCoord(b_x, b_y);
MapExtras::Block *b = map.BlockAt(DFHack::DFCoord(b_x, b_y, z));
if (!b || !b->is_valid())
{
continue;
}
// Find features
b->GetGlobalFeature(&blockFeatureGlobal);
b->GetLocalFeature(&blockFeatureLocal);
int global_z = world->map.region_z + z;
// Iterate over all the tiles in the block
for(uint32_t y = 0; y < 16; y++)
{
for(uint32_t x = 0; x < 16; x++)
{
df::coord2d coord(x, y);
df::tile_designation des = b->DesignationAt(coord);
df::tile_occupancy occ = b->OccupancyAt(coord);
// Skip hidden tiles
if (!showHidden && des.bits.hidden)
{
continue;
}
// Check for aquifer
if (des.bits.water_table)
{
hasAquifer = true;
aquiferTiles.add(global_z);
}
// Check for lairs
if (occ.bits.monster_lair)
{
hasLair = true;
}
// Check for liquid
if (des.bits.flow_size)
{
if (des.bits.liquid_type == tile_liquid::Magma)
liquidMagma.add(global_z);
else
liquidWater.add(global_z);
}
df::tiletype type = b->tiletypeAt(coord);
df::tiletype_shape tileshape = tileShape(type);
df::tiletype_material tilemat = tileMaterial(type);
// We only care about these types
switch (tileshape)
{
case tiletype_shape::WALL:
case tiletype_shape::FORTIFICATION:
break;
case tiletype_shape::EMPTY:
/* A heuristic: tubes inside adamantine have EMPTY:AIR tiles which
still have feature_local set. Also check the unrevealed status,
so as to exclude any holes mined by the player. */
if (tilemat == tiletype_material::AIR &&
des.bits.feature_local && des.bits.hidden &&
blockFeatureLocal.type == feature_type::deep_special_tube)
{
tubeTiles.add(global_z);
}
default:
continue;
}
// Count the material type
baseMats[tilemat].add(global_z);
// Find the type of the tile
switch (tilemat)
{
case tiletype_material::SOIL:
case tiletype_material::STONE:
layerMats[b->layerMaterialAt(coord)].add(global_z);
break;
case tiletype_material::MINERAL:
veinMats[b->veinMaterialAt(coord)].add(global_z);
break;
case tiletype_material::FEATURE:
if (blockFeatureLocal.type != -1 && des.bits.feature_local)
{
if (blockFeatureLocal.type == feature_type::deep_special_tube
&& blockFeatureLocal.main_material == 0) // stone
{
veinMats[blockFeatureLocal.sub_material].add(global_z);
}
else if (showTemple
&& blockFeatureLocal.type == feature_type::deep_surface_portal)
{
hasDemonTemple = true;
}
}
if (showSlade && blockFeatureGlobal.type != -1 && des.bits.feature_global
&& blockFeatureGlobal.type == feature_type::feature_underworld_from_layer
&& blockFeatureGlobal.main_material == 0) // stone
{
layerMats[blockFeatureGlobal.sub_material].add(global_z);
}
break;
case tiletype_material::LAVA_STONE:
// TODO ?
break;
default:
break;
}
}
}
// Check plants this way, as the other way wasn't getting them all
// and we can check visibility more easily here
if (showPlants)
{
auto block = Maps::getBlockColumn(b_x,b_y);
vector<df::plant *> *plants = block ? &block->plants : NULL;
if(plants)
{
for (PlantList::const_iterator it = plants->begin(); it != plants->end(); it++)
{
const df::plant & plant = *(*it);
if (plant.pos.z != z)
continue;
df::coord2d loc(plant.pos.x, plant.pos.y);
loc = loc % 16;
if (showHidden || !b->DesignationAt(loc).bits.hidden)
{
if(plant.flags.bits.is_shrub)
plantMats[plant.material].add(global_z);
else
treeMats[plant.material].add(global_z);
}
}
}
}
// Block end
} // block x
// Clean uneeded memory
map.trash();
} // block y
} // z
MatMap::const_iterator it;
con << "Base materials:" << std::endl;
for (it = baseMats.begin(); it != baseMats.end(); ++it)
{
con << std::setw(25) << ENUM_KEY_STR(tiletype_material,(df::tiletype_material)it->first) << " : " << it->second.count << std::endl;
}
if (liquidWater.count || liquidMagma.count)
{
con << std::endl << "Liquids:" << std::endl;
if (liquidWater.count)
{
con << std::setw(25) << "WATER" << " : ";
printMatdata(con, liquidWater);
}
if (liquidWater.count)
{
con << std::setw(25) << "MAGMA" << " : ";
printMatdata(con, liquidMagma);
}
}
con << std::endl << "Layer materials:" << std::endl;
printMats<df::inorganic_raw, shallower>(con, layerMats, world->raws.inorganics, showValue);
printVeins(con, veinMats, mats, showValue);
if (showPlants)
{
con << "Shrubs:" << std::endl;
printMats<df::plant_raw, std::greater>(con, plantMats, world->raws.plants.all, showValue);
con << "Wood in trees:" << std::endl;
printMats<df::plant_raw, std::greater>(con, treeMats, world->raws.plants.all, showValue);
}
if (hasAquifer)
{
con << "Has aquifer";
if (aquiferTiles.count)
{
con << " : ";
printMatdata(con, aquiferTiles);
}
else
con << std::endl;
}
if (showTube && tubeTiles.count)
{
con << "Has HFS tubes : ";
printMatdata(con, tubeTiles);
}
if (hasDemonTemple)
{
con << "Has demon temple" << std::endl;
}
if (hasLair)
{
con << "Has lair" << std::endl;
}
// Cleanup
mats->Finish();
con << std::endl;
return CR_OK;
}
