MetzNet
/
dfhack
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use CoreSuspender and namespace df::enums

develop
Quietust 2012-01-21 18:31:15 -06:00
parent ccf22bed10
commit 2cc6bcf0e9
21 changed files with 582 additions and 621 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
plugins/autodump.cpp
Unescape Escape View File

@ -26,6 +26,8 @@ using namespace std;
#include "df/general_ref.h" #include "df/general_ref.h"
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using MapExtras::Block; using MapExtras::Block;
using MapExtras::MapCache; using MapExtras::MapCache;
using df::global::world; using df::global::world;
@ -291,9 +293,9 @@ DFhackCExport command_result df_autodump_destroy_item(Core * c, vector <string>
return CR_FAILURE; return CR_FAILURE;
// Allow undoing the destroy // Allow undoing the destroy
if (df::global::world->frame_counter != last_frame) if (world->frame_counter != last_frame)
{ {
last_frame = df::global::world->frame_counter; last_frame = world->frame_counter;
pending_destroy.clear(); pending_destroy.clear();
} }
@ -327,7 +329,7 @@ DFhackCExport command_result df_autodump_destroy_item(Core * c, vector <string>
for (unsigned i = 0; i < item->itemrefs.size(); i++) for (unsigned i = 0; i < item->itemrefs.size(); i++)
{ {
df::general_ref *ref = item->itemrefs[i]; df::general_ref *ref = item->itemrefs[i];
if (ref->getType() == df::general_ref_type::UNIT_HOLDER) if (ref->getType() == general_ref_type::UNIT_HOLDER)
{ {
c->con.printerr("Choosing not to destroy items in unit inventory.\n"); c->con.printerr("Choosing not to destroy items in unit inventory.\n");
return CR_FAILURE; return CR_FAILURE;

18
plugins/cleaners.cpp
Unescape Escape View File

@ -17,6 +17,7 @@ using std::vector;
using std::string; using std::string;
using namespace DFHack; using namespace DFHack;
using namespace DFHack::Simple; using namespace DFHack::Simple;
using namespace df::enums;
using df::global::world; using df::global::world;
using df::global::cursor; using df::global::cursor;
@ -40,20 +41,20 @@ command_result cleanmap (Core * c, bool snow, bool mud)
for (int j = 0; j < block->block_events.size(); j++) for (int j = 0; j < block->block_events.size(); j++)
{ {
df::block_square_event *evt = block->block_events[j]; df::block_square_event *evt = block->block_events[j];
if (evt->getType() != df::block_square_event_type::material_spatter) if (evt->getType() != block_square_event_type::material_spatter)
continue; continue;
// type verified - recast to subclass // type verified - recast to subclass
df::block_square_event_material_spatterst *spatter = (df::block_square_event_material_spatterst *)evt; df::block_square_event_material_spatterst *spatter = (df::block_square_event_material_spatterst *)evt;
// filter snow // filter snow
if(!snow if(!snow
&& spatter->mat_type == df::builtin_mats::WATER && spatter->mat_type == builtin_mats::WATER
&& spatter->mat_state == df::matter_state::Powder) && spatter->mat_state == matter_state::Powder)
continue; continue;
// filter mud // filter mud
if(!mud if(!mud
&& spatter->mat_type == df::builtin_mats::MUD && spatter->mat_type == builtin_mats::MUD
&& spatter->mat_state == df::matter_state::Solid) && spatter->mat_state == matter_state::Solid)
continue; continue;
delete evt; delete evt;
@ -119,7 +120,7 @@ DFhackCExport command_result spotclean (Core * c, vector <string> & parameters)
if (cursor->x == -30000) if (cursor->x == -30000)
{ {
c->con.printerr("The cursor is not active.\n"); c->con.printerr("The cursor is not active.\n");
return CR_FAILURE; return CR_WRONG_USAGE;
} }
df::map_block *block = Maps::getBlockAbs(cursor->x, cursor->y, cursor->z); df::map_block *block = Maps::getBlockAbs(cursor->x, cursor->y, cursor->z);
if (block == NULL) if (block == NULL)
@ -131,7 +132,7 @@ DFhackCExport command_result spotclean (Core * c, vector <string> & parameters)
for (int i = 0; i < block->block_events.size(); i++) for (int i = 0; i < block->block_events.size(); i++)
{ {
df::block_square_event *evt = block->block_events[i]; df::block_square_event *evt = block->block_events[i];
if (evt->getType() != df::block_square_event_type::material_spatter) if (evt->getType() != block_square_event_type::material_spatter)
continue; continue;
// type verified - recast to subclass // type verified - recast to subclass
df::block_square_event_material_spatterst *spatter = (df::block_square_event_material_spatterst *)evt; df::block_square_event_material_spatterst *spatter = (df::block_square_event_material_spatterst *)evt;
@ -189,14 +190,13 @@ DFhackCExport command_result clean (Core * c, vector <string> & parameters)
); );
return CR_OK; return CR_OK;
} }
c->Suspend(); CoreSuspender suspend(c);
if(map) if(map)
cleanmap(c,snow,mud); cleanmap(c,snow,mud);
if(units) if(units)
cleanunits(c); cleanunits(c);
if(items) if(items)
cleanitems(c); cleanitems(c);
c->Resume();
return CR_OK; return CR_OK;
} }

25
plugins/cleanowned.cpp
Unescape Escape View File

@ -18,11 +18,13 @@ using namespace std;
#include "modules/Units.h" #include "modules/Units.h"
#include "modules/Materials.h" #include "modules/Materials.h"
#include "modules/Translation.h" #include "modules/Translation.h"
using namespace DFHack;
using namespace DFHack::Simple;
#include "DataDefs.h" #include "DataDefs.h"
#include "df/world.h" #include "df/world.h"
using namespace DFHack;
using namespace DFHack::Simple;
using namespace df::enums;
using df::global::world; using df::global::world;
DFhackCExport command_result df_cleanowned (Core * c, vector <string> & parameters); DFhackCExport command_result df_cleanowned (Core * c, vector <string> & parameters);
@ -91,7 +93,9 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
return CR_FAILURE; return CR_FAILURE;
} }
} }
c->Suspend();
CoreSuspender suspend(c);
DFHack::Materials *Materials = c->getMaterials(); DFHack::Materials *Materials = c->getMaterials();
DFHack::Units *Creatures = c->getUnits(); DFHack::Units *Creatures = c->getUnits();
DFHack::Translation *Tran = c->getTranslation(); DFHack::Translation *Tran = c->getTranslation();
@ -132,13 +136,13 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
else if (item->flags.bits.on_ground) else if (item->flags.bits.on_ground)
{ {
int32_t type = item->getType(); int32_t type = item->getType();
if(type == df::item_type::MEAT || if(type == item_type::MEAT ||
type == df::item_type::FISH || type == item_type::FISH ||
type == df::item_type::VERMIN || type == item_type::VERMIN ||
type == df::item_type::PET || type == item_type::PET ||
type == df::item_type::PLANT || type == item_type::PLANT ||
type == df::item_type::CHEESE || type == item_type::CHEESE ||
type == df::item_type::FOOD type == item_type::FOOD
) )
{ {
confiscate = true; confiscate = true;
@ -207,6 +211,5 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
c->con.print("\n"); c->con.print("\n");
} }
} }
c->Resume();
return CR_OK; return CR_OK;
} }

22
plugins/colonies.cpp
Unescape Escape View File

@ -23,8 +23,8 @@ DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand>
{ {
commands.clear(); commands.clear();
commands.push_back(PluginCommand("colonies", commands.push_back(PluginCommand("colonies",
"List or change wild colonies (ants hills and such)", "List or change wild colonies (ants hills and such)",
colonies)); colonies));
return CR_OK; return CR_OK;
} }
@ -57,19 +57,18 @@ DFhackCExport command_result colonies (Core * c, vector <string> & parameters)
if(help) if(help)
{ {
c->con.print("Without any options, this command lists all the vermin colonies present.\n" c->con.print("Without any options, this command lists all the vermin colonies present.\n"
"Options:\n" "Options:\n"
"kill - destroy colonies\n" "kill - destroy colonies\n"
"bees - turn colonies into honey bees\n" "bees - turn colonies into honey bees\n"
); );
return CR_OK; return CR_OK;
} }
if (destroy && convert) if (destroy && convert)
{ {
c->con.printerr("Kill or make bees? DECIDE!\n"); c->con.printerr("Kill or make bees? DECIDE!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
c->Suspend(); CoreSuspender suspend(c);
Materials * materials = c->getMaterials(); Materials * materials = c->getMaterials();
@ -84,7 +83,6 @@ DFhackCExport command_result colonies (Core * c, vector <string> & parameters)
materials->Finish(); materials->Finish();
c->Resume();
return CR_OK; return CR_OK;
} }
@ -110,11 +108,13 @@ void convertColonies(Materials *Materials)
{ {
int bee_idx = -1; int bee_idx = -1;
for (size_t i = 0; i < Materials->raceEx.size(); i++) for (size_t i = 0; i < Materials->raceEx.size(); i++)
{
if (Materials->raceEx[i].id == "HONEY_BEE") if (Materials->raceEx[i].id == "HONEY_BEE")
{ {
bee_idx = i; bee_idx = i;
break; break;
} }
}
if (bee_idx == -1) if (bee_idx == -1)
{ {
@ -153,8 +153,8 @@ void showColonies(Core *c, Materials *Materials)
if(sp.race != -1) if(sp.race != -1)
race = Materials->raceEx[sp.race].id; race = Materials->raceEx[sp.race].id;
c->con.print("Colony %u: %s at %d:%d:%d\n", i, c->con.print("Colony %u: %s at %d:%d:%d\n", i,
race.c_str(), sp.x, sp.y, sp.z); race.c_str(), sp.x, sp.y, sp.z);
} }
} }

8
plugins/deramp.cpp
Unescape Escape View File

@ -12,10 +12,10 @@
using std::vector; using std::vector;
using std::string; using std::string;
using namespace DFHack; using namespace DFHack;
using namespace DFHack::Simple;
using namespace df::enums;
using df::global::world; using df::global::world;
using namespace DFHack;
using namespace DFHack::Simple;
DFhackCExport command_result df_deramp (Core * c, vector <string> & parameters) DFhackCExport command_result df_deramp (Core * c, vector <string> & parameters)
{ {
@ -48,7 +48,7 @@ DFhackCExport command_result df_deramp (Core * c, vector <string> & parameters)
{ {
int16_t oldT = block->tiletype[x][y]; int16_t oldT = block->tiletype[x][y];
if ((tileShape(oldT) == RAMP) && if ((tileShape(oldT) == RAMP) &&
(block->designation[x][y].bits.dig == df::tile_dig_designation::Default)) (block->designation[x][y].bits.dig == tile_dig_designation::Default))
{ {
// Current tile is a ramp. // Current tile is a ramp.
// Set current tile, as accurately as can be expected // Set current tile, as accurately as can be expected
@ -59,7 +59,7 @@ DFhackCExport command_result df_deramp (Core * c, vector <string> & parameters)
continue; continue;
// Set new tile type, clear designation // Set new tile type, clear designation
block->tiletype[x][y] = newT; block->tiletype[x][y] = newT;
block->designation[x][y].bits.dig = df::tile_dig_designation::No; block->designation[x][y].bits.dig = tile_dig_designation::No;
// Check the tile above this one, in case a downward slope needs to be removed. // Check the tile above this one, in case a downward slope needs to be removed.
if ((above) && (tileShape(above->tiletype[x][y]) == RAMP_TOP)) if ((above) && (tileShape(above->tiletype[x][y]) == RAMP_TOP))

47
plugins/drybuckets.cpp
Unescape Escape View File

@ -13,44 +13,45 @@
using std::string; using std::string;
using std::vector; using std::vector;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using df::global::world; using df::global::world;
DFhackCExport command_result df_drybuckets (Core * c, vector <string> & parameters) DFhackCExport command_result df_drybuckets (Core * c, vector <string> & parameters)
{ {
if (!parameters.empty()) if (!parameters.empty())
return CR_WRONG_USAGE; return CR_WRONG_USAGE;
CoreSuspender suspend(c); CoreSuspender suspend(c);
int dried_total = 0; int dried_total = 0;
for (int i = 0; i < world->items.all.size(); i++) for (int i = 0; i < world->items.all.size(); i++)
{ {
df::item *item = world->items.all[i]; df::item *item = world->items.all[i];
if ((item->getType() == df::item_type::LIQUID_MISC) && (item->getMaterial() == df::builtin_mats::WATER)) if ((item->getType() == item_type::LIQUID_MISC) && (item->getMaterial() == builtin_mats::WATER))
{ {
item->flags.bits.garbage_colect = 1; item->flags.bits.garbage_colect = 1;
dried_total++; dried_total++;
} }
} }
if (dried_total) if (dried_total)
c->con.print("Done. %d buckets of water marked for emptying.\n", dried_total); c->con.print("Done. %d buckets of water marked for emptying.\n", dried_total);
return CR_OK; return CR_OK;
} }
DFhackCExport const char * plugin_name ( void ) DFhackCExport const char * plugin_name ( void )
{ {
return "drybuckets"; return "drybuckets";
} }
DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands) DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands)
{ {
commands.clear(); commands.clear();
commands.push_back(PluginCommand("drybuckets", "Removes water from buckets.", df_drybuckets)); commands.push_back(PluginCommand("drybuckets", "Removes water from buckets.", df_drybuckets));
return CR_OK; return CR_OK;
} }
DFhackCExport command_result plugin_shutdown ( Core * c ) DFhackCExport command_result plugin_shutdown ( Core * c )
{ {
return CR_OK; return CR_OK;
} }

399
plugins/filltraffic.cpp
Unescape Escape View File

@ -15,6 +15,7 @@
using std::stack; using std::stack;
using MapExtras::MapCache; using MapExtras::MapCache;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
//Function pointer type for whole-map tile checks. //Function pointer type for whole-map tile checks.
typedef void (*checkTile)(DFHack::DFCoord, MapExtras::MapCache &); typedef void (*checkTile)(DFHack::DFCoord, MapExtras::MapCache &);
@ -25,8 +26,8 @@ DFhackCExport command_result alltraffic(DFHack::Core * c, std::vector<std::strin
//Forward Declarations for Utility Functions //Forward Declarations for Utility Functions
DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkProc, DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkProc,
DFHack::DFCoord minCoord = DFHack::DFCoord(0, 0, 0), DFHack::DFCoord minCoord = DFHack::DFCoord(0, 0, 0),
DFHack::DFCoord maxCoord = DFHack::DFCoord(0xFFFF, 0xFFFF, 0xFFFF)); DFHack::DFCoord maxCoord = DFHack::DFCoord(0xFFFF, 0xFFFF, 0xFFFF));
void allHigh(DFHack::DFCoord coord, MapExtras::MapCache & map); void allHigh(DFHack::DFCoord coord, MapExtras::MapCache & map);
void allNormal(DFHack::DFCoord coord, MapExtras::MapCache & map); void allNormal(DFHack::DFCoord coord, MapExtras::MapCache & map);
@ -41,8 +42,8 @@ DFhackCExport const char * plugin_name ( void )
DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands) DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands)
{ {
commands.clear(); commands.clear();
commands.push_back(PluginCommand("filltraffic","Flood-fill with selected traffic designation from cursor",filltraffic)); commands.push_back(PluginCommand("filltraffic","Flood-fill with selected traffic designation from cursor",filltraffic));
commands.push_back(PluginCommand("alltraffic","Set traffic for the entire map",alltraffic)); commands.push_back(PluginCommand("alltraffic","Set traffic for the entire map",alltraffic));
return CR_OK; return CR_OK;
} }
@ -54,69 +55,68 @@ DFhackCExport command_result plugin_shutdown ( Core * c )
DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::string> & params) DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::string> & params)
{ {
//Maximum map size. //Maximum map size.
uint32_t x_max,y_max,z_max; uint32_t x_max,y_max,z_max;
//Source and target traffic types. //Source and target traffic types.
df::tile_traffic source = df::tile_traffic::Normal; df::tile_traffic source = tile_traffic::Normal;
df::tile_traffic target = df::tile_traffic::Normal; df::tile_traffic target = tile_traffic::Normal;
//Option flags //Option flags
bool updown = false; bool updown = false;
bool checkpit = true; bool checkpit = true;
bool checkbuilding = true; bool checkbuilding = true;
//Loop through parameters //Loop through parameters
for(int i = 0; i < params.size();i++) for(int i = 0; i < params.size();i++)
{ {
if(params[i] == "help" || params[i] == "?") if(params[i] == "help" || params[i] == "?")
{ {
c->con.print("Flood-fill selected traffic type from the cursor.\n" c->con.print("Flood-fill selected traffic type from the cursor.\n"
"Traffic Type Codes:\n" "Traffic Type Codes:\n"
"\tH: High Traffic\n" "\tH: High Traffic\n"
"\tN: Normal Traffic\n" "\tN: Normal Traffic\n"
"\tL: Low Traffic\n" "\tL: Low Traffic\n"
"\tR: Restricted Traffic\n" "\tR: Restricted Traffic\n"
"Other Options:\n" "Other Options:\n"
"\tX: Fill across z-levels.\n" "\tX: Fill across z-levels.\n"
"\tB: Include buildings and stockpiles.\n" "\tB: Include buildings and stockpiles.\n"
"\tP: Include empty space.\n" "\tP: Include empty space.\n"
"Example:\n" "Example:\n"
"'filltraffic H' - When used in a room with doors,\n" "'filltraffic H' - When used in a room with doors,\n"
" it will set traffic to HIGH in just that room." " it will set traffic to HIGH in just that room."
); );
return CR_OK; return CR_OK;
} }
switch (toupper(params[i][0])) switch (toupper(params[i][0]))
{ {
case 'H': case 'H':
target = df::tile_traffic::High; break; target = tile_traffic::High; break;
case 'N': case 'N':
target = df::tile_traffic::Normal; break; target = tile_traffic::Normal; break;
case 'L': case 'L':
target = df::tile_traffic::Low; break; target = tile_traffic::Low; break;
case 'R': case 'R':
target = df::tile_traffic::Restricted; break; target = tile_traffic::Restricted; break;
case 'X': case 'X':
updown = true; break; updown = true; break;
case 'B': case 'B':
checkbuilding = false; break; checkbuilding = false; break;
case 'P': case 'P':
checkpit = false; break; checkpit = false; break;
} }
} }
//Initialization. //Initialization.
c->Suspend(); CoreSuspender suspend(c);
DFHack::Gui * Gui = c->getGui(); DFHack::Gui * Gui = c->getGui();
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
int32_t cx, cy, cz; int32_t cx, cy, cz;
Maps::getSize(x_max,y_max,z_max); Maps::getSize(x_max,y_max,z_max);
uint32_t tx_max = x_max * 16; uint32_t tx_max = x_max * 16;
uint32_t ty_max = y_max * 16; uint32_t ty_max = y_max * 16;
@ -124,7 +124,6 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
while(cx == -30000) while(cx == -30000)
{ {
c->con.printerr("Cursor is not active.\n"); c->con.printerr("Cursor is not active.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -142,96 +141,91 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
if(source == target) if(source == target)
{ {
c->con.printerr("This tile is already set to the target traffic type.\n"); c->con.printerr("This tile is already set to the target traffic type.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if(DFHack::isWallTerrain(tt)) if(DFHack::isWallTerrain(tt))
{ {
c->con.printerr("This tile is a wall. Please select a passable tile.\n"); c->con.printerr("This tile is a wall. Please select a passable tile.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if(checkpit && DFHack::isOpenTerrain(tt)) if(checkpit && DFHack::isOpenTerrain(tt))
{ {
c->con.printerr("This tile is a hole. Please select a passable tile.\n"); c->con.printerr("This tile is a hole. Please select a passable tile.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if(checkbuilding && oc.bits.building) if(checkbuilding && oc.bits.building)
{ {
c->con.printerr("This tile contains a building. Please select an empty tile.\n"); c->con.printerr("This tile contains a building. Please select an empty tile.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
c->con.print("%d/%d/%d ... FILLING!\n", cx,cy,cz); c->con.print("%d/%d/%d ... FILLING!\n", cx,cy,cz);
//Naive four-way or six-way flood fill with possible tiles on a stack. //Naive four-way or six-way flood fill with possible tiles on a stack.
stack <DFHack::DFCoord> flood; stack <DFHack::DFCoord> flood;
flood.push(xy); flood.push(xy);
while(!flood.empty()) while(!flood.empty())
{ {
xy = flood.top(); xy = flood.top();
flood.pop(); flood.pop();
des = MCache.designationAt(xy); des = MCache.designationAt(xy);
if (des.bits.traffic != source) continue; if (des.bits.traffic != source) continue;
tt = MCache.tiletypeAt(xy); tt = MCache.tiletypeAt(xy);
if(DFHack::isWallTerrain(tt)) continue; if(DFHack::isWallTerrain(tt)) continue;
if(checkpit && DFHack::isOpenTerrain(tt)) continue; if(checkpit && DFHack::isOpenTerrain(tt)) continue;
if (checkbuilding) if (checkbuilding)
{ {
oc = MCache.occupancyAt(xy); oc = MCache.occupancyAt(xy);
if(oc.bits.building) continue; if(oc.bits.building) continue;
} }
//This tile is ready. Set its traffic level and add surrounding tiles. //This tile is ready. Set its traffic level and add surrounding tiles.
if (MCache.testCoord(xy)) if (MCache.testCoord(xy))
{ {
des.bits.traffic = target; des.bits.traffic = target;
MCache.setDesignationAt(xy,des); MCache.setDesignationAt(xy,des);
if (xy.x > 0) if (xy.x > 0)
{ {
flood.push(DFHack::DFCoord(xy.x - 1, xy.y, xy.z)); flood.push(DFHack::DFCoord(xy.x - 1, xy.y, xy.z));
} }
if (xy.x < tx_max - 1) if (xy.x < tx_max - 1)
{ {
flood.push(DFHack::DFCoord(xy.x + 1, xy.y, xy.z)); flood.push(DFHack::DFCoord(xy.x + 1, xy.y, xy.z));
} }
if (xy.y > 0) if (xy.y > 0)
{ {
flood.push(DFHack::DFCoord(xy.x, xy.y - 1, xy.z)); flood.push(DFHack::DFCoord(xy.x, xy.y - 1, xy.z));
} }
if (xy.y < ty_max - 1) if (xy.y < ty_max - 1)
{ {
flood.push(DFHack::DFCoord(xy.x, xy.y + 1, xy.z)); flood.push(DFHack::DFCoord(xy.x, xy.y + 1, xy.z));
} }
if (updown) if (updown)
{ {
if (xy.z > 0 && DFHack::LowPassable(tt)) if (xy.z > 0 && DFHack::LowPassable(tt))
{ {
flood.push(DFHack::DFCoord(xy.x, xy.y, xy.z - 1)); flood.push(DFHack::DFCoord(xy.x, xy.y, xy.z - 1));
} }
if (xy.z < z_max && DFHack::HighPassable(tt)) if (xy.z < z_max && DFHack::HighPassable(tt))
{ {
flood.push(DFHack::DFCoord(xy.x, xy.y, xy.z + 1)); flood.push(DFHack::DFCoord(xy.x, xy.y, xy.z + 1));
} }
} }
} }
} }
MCache.WriteAll(); MCache.WriteAll();
c->Resume();
return CR_OK; return CR_OK;
} }
@ -239,35 +233,35 @@ enum e_checktype {no_check, check_equal, check_nequal};
DFhackCExport command_result alltraffic(DFHack::Core * c, std::vector<std::string> & params) DFhackCExport command_result alltraffic(DFHack::Core * c, std::vector<std::string> & params)
{ {
void (*proc)(DFHack::DFCoord, MapExtras::MapCache &) = allNormal; void (*proc)(DFHack::DFCoord, MapExtras::MapCache &) = allNormal;
//Loop through parameters //Loop through parameters
for(int i = 0; i < params.size();i++) for(int i = 0; i < params.size();i++)
{ {
if(params[i] == "help" || params[i] == "?") if(params[i] == "help" || params[i] == "?")
{ {
c->con.print("Set traffic types for all tiles on the map.\n" c->con.print("Set traffic types for all tiles on the map.\n"
"Traffic Type Codes:\n" "Traffic Type Codes:\n"
" H: High Traffic\n" " H: High Traffic\n"
" N: Normal Traffic\n" " N: Normal Traffic\n"
" L: Low Traffic\n" " L: Low Traffic\n"
" R: Restricted Traffic\n" " R: Restricted Traffic\n"
); );
return CR_OK; return CR_OK;
} }
//Pick traffic type. Possibly set bounding rectangle later. //Pick traffic type. Possibly set bounding rectangle later.
switch (toupper(params[i][0])) switch (toupper(params[i][0]))
{ {
case 'H': case 'H':
proc = allHigh; break; proc = allHigh; break;
case 'N': case 'N':
proc = allNormal; break; proc = allNormal; break;
case 'L': case 'L':
proc = allLow; break; proc = allLow; break;
case 'R': case 'R':
proc = allRestricted; break; proc = allRestricted; break;
} }
} }
return setAllMatching(c, proc); return setAllMatching(c, proc);
@ -278,95 +272,90 @@ DFhackCExport command_result alltraffic(DFHack::Core * c, std::vector<std::strin
//check takes a coordinate and the map cache as arguments, and returns true if the criteria is met. //check takes a coordinate and the map cache as arguments, and returns true if the criteria is met.
//minCoord and maxCoord can be used to specify a bounding cube. //minCoord and maxCoord can be used to specify a bounding cube.
DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkProc, DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkProc,
DFHack::DFCoord minCoord, DFHack::DFCoord maxCoord) DFHack::DFCoord minCoord, DFHack::DFCoord maxCoord)
{ {
//Initialization. //Initialization.
c->Suspend(); CoreSuspender suspend(c);
DFHack::Gui * Gui = c->getGui(); DFHack::Gui * Gui = c->getGui();
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
//Maximum map size. //Maximum map size.
uint32_t x_max,y_max,z_max; uint32_t x_max,y_max,z_max;
Maps::getSize(x_max,y_max,z_max); Maps::getSize(x_max,y_max,z_max);
uint32_t tx_max = x_max * 16; uint32_t tx_max = x_max * 16;
uint32_t ty_max = y_max * 16; uint32_t ty_max = y_max * 16;
//Ensure maximum coordinate is within map. Truncate to map edge. //Ensure maximum coordinate is within map. Truncate to map edge.
maxCoord.x = std::min((uint32_t) maxCoord.x, tx_max); maxCoord.x = std::min((uint32_t) maxCoord.x, tx_max);
maxCoord.y = std::min((uint32_t) maxCoord.y, ty_max); maxCoord.y = std::min((uint32_t) maxCoord.y, ty_max);
maxCoord.z = std::min((uint32_t) maxCoord.z, z_max); maxCoord.z = std::min((uint32_t) maxCoord.z, z_max);
//Check minimum co-ordinates against maximum map size //Check minimum co-ordinates against maximum map size
if (minCoord.x > maxCoord.x) if (minCoord.x > maxCoord.x)
{ {
c->con.printerr("Minimum x coordinate is greater than maximum x coordinate.\n"); c->con.printerr("Minimum x coordinate is greater than maximum x coordinate.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if (minCoord.y > maxCoord.y) if (minCoord.y > maxCoord.y)
{ {
c->con.printerr("Minimum y coordinate is greater than maximum y coordinate.\n"); c->con.printerr("Minimum y coordinate is greater than maximum y coordinate.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if (minCoord.z > maxCoord.y) if (minCoord.z > maxCoord.y)
{ {
c->con.printerr("Minimum z coordinate is greater than maximum z coordinate.\n"); c->con.printerr("Minimum z coordinate is greater than maximum z coordinate.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
MapExtras::MapCache MCache; MapExtras::MapCache MCache;
c->con.print("Setting traffic...\n"); c->con.print("Setting traffic...\n");
//Loop through every single tile //Loop through every single tile
for(uint32_t x = minCoord.x; x <= maxCoord.x; x++) for(uint32_t x = minCoord.x; x <= maxCoord.x; x++)
{ {
for(uint32_t y = minCoord.y; y <= maxCoord.y; y++) for(uint32_t y = minCoord.y; y <= maxCoord.y; y++)
{ {
for(uint32_t z = minCoord.z; z <= maxCoord.z; z++) for(uint32_t z = minCoord.z; z <= maxCoord.z; z++)
{ {
DFHack::DFCoord tile = DFHack::DFCoord(x, y, z); DFHack::DFCoord tile = DFHack::DFCoord(x, y, z);
checkProc(tile, MCache); checkProc(tile, MCache);
} }
} }
} }
MCache.WriteAll(); MCache.WriteAll();
c->con.print("Complete!\n"); c->con.print("Complete!\n");
c->Resume();
return CR_OK; return CR_OK;
} }
//Unconditionally set map to target traffic type //Unconditionally set map to target traffic type
void allHigh(DFHack::DFCoord coord, MapExtras::MapCache &map) void allHigh(DFHack::DFCoord coord, MapExtras::MapCache &map)
{ {
df::tile_designation des = map.designationAt(coord); df::tile_designation des = map.designationAt(coord);
des.bits.traffic = df::tile_traffic::High; des.bits.traffic = tile_traffic::High;
map.setDesignationAt(coord, des); map.setDesignationAt(coord, des);
} }
void allNormal(DFHack::DFCoord coord, MapExtras::MapCache &map) void allNormal(DFHack::DFCoord coord, MapExtras::MapCache &map)
{ {
df::tile_designation des = map.designationAt(coord); df::tile_designation des = map.designationAt(coord);
des.bits.traffic = df::tile_traffic::Normal; des.bits.traffic = tile_traffic::Normal;
map.setDesignationAt(coord, des); map.setDesignationAt(coord, des);
} }
void allLow(DFHack::DFCoord coord, MapExtras::MapCache &map) void allLow(DFHack::DFCoord coord, MapExtras::MapCache &map)
{ {
df::tile_designation des = map.designationAt(coord); df::tile_designation des = map.designationAt(coord);
des.bits.traffic = df::tile_traffic::Low; des.bits.traffic = tile_traffic::Low;
map.setDesignationAt(coord, des); map.setDesignationAt(coord, des);
} }
void allRestricted(DFHack::DFCoord coord, MapExtras::MapCache &map) void allRestricted(DFHack::DFCoord coord, MapExtras::MapCache &map)
{ {
df::tile_designation des = map.designationAt(coord); df::tile_designation des = map.designationAt(coord);
des.bits.traffic = df::tile_traffic::Restricted; des.bits.traffic = tile_traffic::Restricted;
map.setDesignationAt(coord, des); map.setDesignationAt(coord, des);
} }

139
plugins/fixwagons.cpp
Unescape Escape View File

@ -15,92 +15,93 @@
using std::string; using std::string;
using std::vector; using std::vector;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using df::global::world; using df::global::world;
command_result df_fixwagons (Core *c, vector<string> &parameters) command_result df_fixwagons (Core *c, vector<string> &parameters)
{ {
if (!parameters.empty()) if (!parameters.empty())
return CR_WRONG_USAGE; return CR_WRONG_USAGE;
CoreSuspender suspend(c); CoreSuspender suspend(c);
int32_t wagon_creature = -1, wagon_puller_creature = -1; int32_t wagon_creature = -1, wagon_puller_creature = -1;
df::creature_raw *wagon, *wagon_puller; df::creature_raw *wagon, *wagon_puller;
for (int i = 0; i < world->raws.creatures.all.size(); i++) for (int i = 0; i < world->raws.creatures.all.size(); i++)
{ {
df::creature_raw *cr = world->raws.creatures.all[i]; df::creature_raw *cr = world->raws.creatures.all[i];
if (cr->flags.is_set(df::creature_raw_flags::EQUIPMENT_WAGON) && (wagon_creature == -1)) if (cr->flags.is_set(creature_raw_flags::EQUIPMENT_WAGON) && (wagon_creature == -1))
{ {
wagon = cr; wagon = cr;
wagon_creature = i; wagon_creature = i;
} }
if ((cr->creature_id == "HORSE") && (wagon_puller_creature == -1)) if ((cr->creature_id == "HORSE") && (wagon_puller_creature == -1))
{ {
wagon_puller = cr; wagon_puller = cr;
wagon_puller_creature = i; wagon_puller_creature = i;
} }
} }
if (wagon_creature == -1) if (wagon_creature == -1)
{ {
c->con.printerr("Couldn't find a valid wagon creature!\n"); c->con.printerr("Couldn't find a valid wagon creature!\n");
return CR_FAILURE; return CR_FAILURE;
} }
if (wagon_puller_creature == -1) if (wagon_puller_creature == -1)
{ {
c->con.printerr("Couldn't find 'HORSE' creature for default wagon puller!\n"); c->con.printerr("Couldn't find 'HORSE' creature for default wagon puller!\n");
return CR_FAILURE; return CR_FAILURE;
} }
int count = 0; int count = 0;
for (int i = 0; i < world->entities.all.size(); i++) for (int i = 0; i < world->entities.all.size(); i++)
{ {
bool updated = false; bool updated = false;
df::historical_entity *ent = world->entities.all[i]; df::historical_entity *ent = world->entities.all[i];
if (!ent->entity_raw->flags.is_set(df::entity_raw_flags::COMMON_DOMESTIC_PULL)) if (!ent->entity_raw->flags.is_set(entity_raw_flags::COMMON_DOMESTIC_PULL))
continue; continue;
if (ent->resources.animals.wagon_races.size() == 0) if (ent->resources.animals.wagon_races.size() == 0)
{ {
updated = true; updated = true;
for (int j = 0; j < wagon->caste.size(); j++) for (int j = 0; j < wagon->caste.size(); j++)
{ {
ent->resources.animals.wagon_races.push_back(wagon_creature); ent->resources.animals.wagon_races.push_back(wagon_creature);
ent->resources.animals.wagon_castes.push_back(j); ent->resources.animals.wagon_castes.push_back(j);
} }
} }
if (ent->resources.animals.wagon_puller_races.size() == 0) if (ent->resources.animals.wagon_puller_races.size() == 0)
{ {
updated = true; updated = true;
for (int j = 0; j < wagon_puller->caste.size(); j++) for (int j = 0; j < wagon_puller->caste.size(); j++)
{ {
ent->resources.animals.wagon_puller_races.push_back(wagon_puller_creature); ent->resources.animals.wagon_puller_races.push_back(wagon_puller_creature);
ent->resources.animals.wagon_puller_castes.push_back(j); ent->resources.animals.wagon_puller_castes.push_back(j);
} }
} }
if (updated) if (updated)
count++; count++;
} }
if(count) if(count)
c->con.print("Fixed %d civilizations to bring wagons once again.\n", count); c->con.print("Fixed %d civilizations to bring wagons once again.\n", count);
return CR_OK; return CR_OK;
} }
DFhackCExport const char * plugin_name ( void ) DFhackCExport const char * plugin_name ( void )
{ {
return "fixwagons"; return "fixwagons";
} }
DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands) DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand> &commands)
{ {
commands.clear(); commands.clear();
commands.push_back(PluginCommand( commands.push_back(PluginCommand(
"fixwagons", "Fix all civilizations to be able to bring wagons.", "fixwagons", "Fix all civilizations to be able to bring wagons.",
df_fixwagons, false, df_fixwagons, false,
" Since DF v0.31.1 merchants no longer bring wagons due to a bug.\n" " Since DF v0.31.1 merchants no longer bring wagons due to a bug.\n"
" This command re-enables them for all appropriate civilizations.\n" " This command re-enables them for all appropriate civilizations.\n"
)); ));
return CR_OK; return CR_OK;
} }
DFhackCExport command_result plugin_shutdown ( Core * c ) DFhackCExport command_result plugin_shutdown ( Core * c )
{ {
return CR_OK; return CR_OK;
} }

11
plugins/flows.cpp
Unescape Escape View File

@ -13,6 +13,7 @@
using std::string; using std::string;
using std::vector; using std::vector;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using df::global::world; using df::global::world;
@ -26,11 +27,11 @@ DFhackCExport command_result df_flows (Core * c, vector <string> & parameters)
for (int i = 0; i < world->map.map_blocks.size(); i++) for (int i = 0; i < world->map.map_blocks.size(); i++)
{ {
df::map_block *cur = world->map.map_blocks[i]; df::map_block *cur = world->map.map_blocks[i];
if (cur->flags.is_set(df::block_flags::UpdateLiquid)) if (cur->flags.is_set(block_flags::UpdateLiquid))
flow1++; flow1++;
if (cur->flags.is_set(df::block_flags::UpdateLiquidTwice)) if (cur->flags.is_set(block_flags::UpdateLiquidTwice))
flow2++; flow2++;
if (cur->flags.is_set(df::block_flags::UpdateLiquid) && cur->flags.is_set(df::block_flags::UpdateLiquidTwice)) if (cur->flags.is_set(block_flags::UpdateLiquid) && cur->flags.is_set(block_flags::UpdateLiquidTwice))
flowboth++; flowboth++;
for (int x = 0; x < 16; x++) for (int x = 0; x < 16; x++)
{ {
@ -39,9 +40,9 @@ DFhackCExport command_result df_flows (Core * c, vector <string> & parameters)
// only count tiles with actual liquid in them // only count tiles with actual liquid in them
if (cur->designation[x][y].bits.flow_size == 0) if (cur->designation[x][y].bits.flow_size == 0)
continue; continue;
if (cur->designation[x][y].bits.liquid_type == df::tile_liquid::Magma) if (cur->designation[x][y].bits.liquid_type == tile_liquid::Magma)
magma++; magma++;
if (cur->designation[x][y].bits.liquid_type == df::tile_liquid::Water) if (cur->designation[x][y].bits.liquid_type == tile_liquid::Water)
water++; water++;
} }
} }

2
plugins/initflags.cpp
Unescape Escape View File

@ -43,7 +43,7 @@ DFhackCExport command_result plugin_shutdown ( Core * c )
DFhackCExport command_result twaterlvl(Core * c, vector <string> & parameters) DFhackCExport command_result twaterlvl(Core * c, vector <string> & parameters)
{ {
// HOTKEY COMMAND: CORE ALREADY SUSPENDED // HOTKEY COMMAND: CORE ALREADY SUSPENDED
df::global::d_init->flags1.toggle(d_init_flags1::SHOW_FLOW_AMOUNTS); d_init->flags1.toggle(d_init_flags1::SHOW_FLOW_AMOUNTS);
c->con << "Toggled the display of water/magma depth." << endl; c->con << "Toggled the display of water/magma depth." << endl;
return CR_OK; return CR_OK;
} }

13
plugins/liquids.cpp
Unescape Escape View File

@ -20,8 +20,8 @@ using std::set;
#include "modules/MapCache.h" #include "modules/MapCache.h"
using namespace MapExtras; using namespace MapExtras;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
typedef vector <DFHack::DFCoord> coord_vec; typedef vector <df::coord> coord_vec;
class Brush class Brush
{ {
@ -358,7 +358,7 @@ DFhackCExport command_result df_liquids (Core * c, vector <string> & parameters)
amount = 7; amount = 7;
else if(command.empty()) else if(command.empty())
{ {
c->Suspend(); CoreSuspender suspend(c);
Maps::getSize(x_max,y_max,z_max); Maps::getSize(x_max,y_max,z_max);
Position = c->getGui(); Position = c->getGui();
do do
@ -409,7 +409,7 @@ DFhackCExport command_result df_liquids (Core * c, vector <string> & parameters)
mcache.setTiletypeAt(*iter, 90); mcache.setTiletypeAt(*iter, 90);
df::tile_designation a = mcache.designationAt(*iter); df::tile_designation a = mcache.designationAt(*iter);
a.bits.liquid_type = df::tile_liquid::Water; a.bits.liquid_type = tile_liquid::Water;
a.bits.liquid_static = false; a.bits.liquid_static = false;
a.bits.flow_size = 7; a.bits.flow_size = 7;
mcache.setTemp1At(*iter,10015); mcache.setTemp1At(*iter,10015);
@ -478,13 +478,13 @@ DFhackCExport command_result df_liquids (Core * c, vector <string> & parameters)
} }
if(amount != 0 && mode == "magma") if(amount != 0 && mode == "magma")
{ {
des.bits.liquid_type = df::tile_liquid::Magma; des.bits.liquid_type = tile_liquid::Magma;
mcache.setTemp1At(current,12000); mcache.setTemp1At(current,12000);
mcache.setTemp2At(current,12000); mcache.setTemp2At(current,12000);
} }
else if(amount != 0 && mode == "water") else if(amount != 0 && mode == "water")
{ {
des.bits.liquid_type = df::tile_liquid::Water; des.bits.liquid_type = tile_liquid::Water;
mcache.setTemp1At(current,10015); mcache.setTemp1At(current,10015);
mcache.setTemp2At(current,10015); mcache.setTemp2At(current,10015);
} }
@ -528,7 +528,6 @@ DFhackCExport command_result df_liquids (Core * c, vector <string> & parameters)
else else
c->con << "Something failed horribly! RUN!" << endl; c->con << "Something failed horribly! RUN!" << endl;
} while (0); } while (0);
c->Resume();
} }
else else
{ {

11
plugins/plants.cpp
Unescape Escape View File

@ -18,7 +18,6 @@
using std::vector; using std::vector;
using std::string; using std::string;
using namespace DFHack; using namespace DFHack;
using df::global::world; using df::global::world;
DFhackCExport command_result df_grow (Core * c, vector <string> & parameters); DFhackCExport command_result df_grow (Core * c, vector <string> & parameters);
@ -100,11 +99,10 @@ static command_result immolations (Core * c, do_what what, bool shrubs, bool tre
); );
return CR_OK; return CR_OK;
} }
c->Suspend(); CoreSuspender suspend(c);
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
DFHack::Gui * Gui = c->getGui(); DFHack::Gui * Gui = c->getGui();
@ -161,8 +159,6 @@ static command_result immolations (Core * c, do_what what, bool shrubs, bool tre
c->con.printerr("No mass destruction and no cursor...\n" ); c->con.printerr("No mass destruction and no cursor...\n" );
} }
} }
// Cleanup
c->Resume();
return CR_OK; return CR_OK;
} }
@ -204,12 +200,11 @@ DFhackCExport command_result df_grow (Core * c, vector <string> & parameters)
return CR_OK; return CR_OK;
} }
} }
c->Suspend(); CoreSuspender suspend(c);
Console & con = c->con; Console & con = c->con;
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
MapExtras::MapCache map; MapExtras::MapCache map;
@ -248,8 +243,6 @@ DFhackCExport command_result df_grow (Core * c, vector <string> & parameters)
} }
} }
// Cleanup
c->Resume();
return CR_OK; return CR_OK;
} }

13
plugins/probe.cpp
Unescape Escape View File

@ -24,6 +24,7 @@ using namespace std;
using std::vector; using std::vector;
using std::string; using std::string;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
DFhackCExport command_result df_probe (Core * c, vector <string> & parameters); DFhackCExport command_result df_probe (Core * c, vector <string> & parameters);
DFhackCExport command_result df_cprobe (Core * c, vector <string> & parameters); DFhackCExport command_result df_cprobe (Core * c, vector <string> & parameters);
@ -53,7 +54,7 @@ DFhackCExport command_result plugin_shutdown ( Core * c )
DFhackCExport command_result df_cprobe (Core * c, vector <string> & parameters) DFhackCExport command_result df_cprobe (Core * c, vector <string> & parameters)
{ {
Console & con = c->con; Console & con = c->con;
c->Suspend(); CoreSuspender suspend(c);
DFHack::Gui *Gui = c->getGui(); DFHack::Gui *Gui = c->getGui();
DFHack::Units * cr = c->getUnits(); DFHack::Units * cr = c->getUnits();
int32_t cursorX, cursorY, cursorZ; int32_t cursorX, cursorY, cursorZ;
@ -76,7 +77,6 @@ DFhackCExport command_result df_cprobe (Core * c, vector <string> & parameters)
} }
} }
} }
c->Resume();
return CR_OK; return CR_OK;
} }
@ -93,8 +93,7 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
} }
*/ */
BEGIN_PROBE: CoreSuspender suspend(c);
c->Suspend();
DFHack::Gui *Gui = c->getGui(); DFHack::Gui *Gui = c->getGui();
DFHack::Materials *Materials = c->getMaterials(); DFHack::Materials *Materials = c->getMaterials();
@ -105,7 +104,6 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
MapExtras::MapCache mc; MapExtras::MapCache mc;
@ -118,7 +116,6 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
if(cursorX == -30000) if(cursorX == -30000)
{ {
con.printerr("No cursor; place cursor over tile to probe.\n"); con.printerr("No cursor; place cursor over tile to probe.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
DFCoord cursor (cursorX,cursorY,cursorZ); DFCoord cursor (cursorX,cursorY,cursorZ);
@ -132,7 +129,6 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
if(!b && !b->valid) if(!b && !b->valid)
{ {
con.printerr("No data.\n"); con.printerr("No data.\n");
c->Resume();
return CR_OK; return CR_OK;
} }
mapblock40d & block = b->raw; mapblock40d & block = b->raw;
@ -220,7 +216,7 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
// liquids // liquids
if(des.bits.flow_size) if(des.bits.flow_size)
{ {
if(des.bits.liquid_type == df::tile_liquid::Magma) if(des.bits.liquid_type == tile_liquid::Magma)
con <<"magma: "; con <<"magma: ";
else con <<"water: "; else con <<"water: ";
con << des.bits.flow_size << std::endl; con << des.bits.flow_size << std::endl;
@ -275,6 +271,5 @@ DFhackCExport command_result df_probe (Core * c, vector <string> & parameters)
<< endl; << endl;
con << "mystery: " << block.mystery << endl; con << "mystery: " << block.mystery << endl;
con << std::endl; con << std::endl;
c->Resume();
return CR_OK; return CR_OK;
} }

17
plugins/prospector.cpp
Unescape Escape View File

@ -23,6 +23,7 @@ using namespace std;
#include "df/world.h" #include "df/world.h"
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using df::global::world; using df::global::world;
struct matdata struct matdata
@ -223,11 +224,10 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
} }
} }
uint32_t x_max = 0, y_max = 0, z_max = 0; uint32_t x_max = 0, y_max = 0, z_max = 0;
c->Suspend(); CoreSuspender suspend(c);
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
Maps::getSize(x_max, y_max, z_max); Maps::getSize(x_max, y_max, z_max);
@ -283,7 +283,7 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
Maps::GetLocalFeature(blockFeatureLocal, blockCoord, index); Maps::GetLocalFeature(blockFeatureLocal, blockCoord, index);
} }
int global_z = df::global::world->map.region_z + z; int global_z = world->map.region_z + z;
// Iterate over all the tiles in the block // Iterate over all the tiles in the block
for(uint32_t y = 0; y < 16; y++) for(uint32_t y = 0; y < 16; y++)
@ -316,7 +316,7 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
// Check for liquid // Check for liquid
if (des.bits.flow_size) if (des.bits.flow_size)
{ {
if (des.bits.liquid_type == df::tile_liquid::Magma) if (des.bits.liquid_type == tile_liquid::Magma)
liquidMagma.add(global_z); liquidMagma.add(global_z);
else else
liquidWater.add(global_z); liquidWater.add(global_z);
@ -344,7 +344,7 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
so as to exclude any holes mined by the player. */ so as to exclude any holes mined by the player. */
if (info->material == DFHack::AIR && if (info->material == DFHack::AIR &&
des.bits.feature_local && des.bits.hidden && des.bits.feature_local && des.bits.hidden &&
blockFeatureLocal.type == df::feature_type::deep_special_tube) blockFeatureLocal.type == feature_type::deep_special_tube)
{ {
tubeTiles.add(global_z); tubeTiles.add(global_z);
} }
@ -368,20 +368,20 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
case DFHack::FEATSTONE: case DFHack::FEATSTONE:
if (blockFeatureLocal.type != -1 && des.bits.feature_local) if (blockFeatureLocal.type != -1 && des.bits.feature_local)
{ {
if (blockFeatureLocal.type == df::feature_type::deep_special_tube if (blockFeatureLocal.type == feature_type::deep_special_tube
&& blockFeatureLocal.main_material == 0) // stone && blockFeatureLocal.main_material == 0) // stone
{ {
veinMats[blockFeatureLocal.sub_material].add(global_z); veinMats[blockFeatureLocal.sub_material].add(global_z);
} }
else if (showTemple else if (showTemple
&& blockFeatureLocal.type == df::feature_type::deep_surface_portal) && blockFeatureLocal.type == feature_type::deep_surface_portal)
{ {
hasDemonTemple = true; hasDemonTemple = true;
} }
} }
if (showSlade && blockFeatureGlobal.type != -1 && des.bits.feature_global if (showSlade && blockFeatureGlobal.type != -1 && des.bits.feature_global
&& blockFeatureGlobal.type == df::feature_type::feature_underworld_from_layer && blockFeatureGlobal.type == feature_type::feature_underworld_from_layer
&& blockFeatureGlobal.main_material == 0) // stone && blockFeatureGlobal.main_material == 0) // stone
{ {
layerMats[blockFeatureGlobal.sub_material].add(global_z); layerMats[blockFeatureGlobal.sub_material].add(global_z);
@ -494,7 +494,6 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
veg->Finish(); veg->Finish();
} }
mats->Finish(); mats->Finish();
c->Resume();
con << std::endl; con << std::endl;
return CR_OK; return CR_OK;
} }

90
plugins/regrass.cpp
Unescape Escape View File

@ -19,64 +19,64 @@ using df::global::world;
DFhackCExport command_result df_regrass (Core * c, vector <string> & parameters) DFhackCExport command_result df_regrass (Core * c, vector <string> & parameters)
{ {
if (!parameters.empty()) if (!parameters.empty())
return CR_WRONG_USAGE; return CR_WRONG_USAGE;
CoreSuspender suspend(c); CoreSuspender suspend(c);
int count = 0; int count = 0;
for (int i = 0; i < world->map.map_blocks.size(); i++) for (int i = 0; i < world->map.map_blocks.size(); i++)
{ {
df::map_block *cur = world->map.map_blocks[i]; df::map_block *cur = world->map.map_blocks[i];
for (int x = 0; x < 16; x++) for (int x = 0; x < 16; x++)
{ {
for (int y = 0; y < 16; y++) for (int y = 0; y < 16; y++)
{ {
if (DFHack::tileShape(cur->tiletype[x][y]) != DFHack::FLOOR) if (DFHack::tileShape(cur->tiletype[x][y]) != DFHack::FLOOR)
continue; continue;
if (DFHack::tileMaterial(cur->tiletype[x][y]) != DFHack::SOIL) if (DFHack::tileMaterial(cur->tiletype[x][y]) != DFHack::SOIL)
continue; continue;
if (cur->designation[x][y].bits.subterranean) if (cur->designation[x][y].bits.subterranean)
continue; continue;
if (cur->occupancy[x][y].bits.building) if (cur->occupancy[x][y].bits.building)
continue; continue;
switch (rand() % 8) switch (rand() % 8)
{ {
// light grass // light grass
case 0: cur->tiletype[x][y] = 0x015C; break; case 0: cur->tiletype[x][y] = 0x015C; break;
case 1: cur->tiletype[x][y] = 0x015D; break; case 1: cur->tiletype[x][y] = 0x015D; break;
case 2: cur->tiletype[x][y] = 0x015E; break; case 2: cur->tiletype[x][y] = 0x015E; break;
case 3: cur->tiletype[x][y] = 0x015F; break; case 3: cur->tiletype[x][y] = 0x015F; break;
// dark grass // dark grass
case 4: cur->tiletype[x][y] = 0x018E; break; case 4: cur->tiletype[x][y] = 0x018E; break;
case 5: cur->tiletype[x][y] = 0x018F; break; case 5: cur->tiletype[x][y] = 0x018F; break;
case 6: cur->tiletype[x][y] = 0x0190; break; case 6: cur->tiletype[x][y] = 0x0190; break;
case 7: cur->tiletype[x][y] = 0x0191; break; case 7: cur->tiletype[x][y] = 0x0191; break;
} }
count++; count++;
} }
} }
} }
if (count) if (count)
c->con.print("Regrew %d tiles of grass.\n", count); c->con.print("Regrew %d tiles of grass.\n", count);
return CR_OK; return CR_OK;
} }
DFhackCExport const char *plugin_name ( void ) DFhackCExport const char *plugin_name ( void )
{ {
return "regrass"; return "regrass";
} }
DFhackCExport command_result plugin_init (Core *c, std::vector<PluginCommand> &commands) DFhackCExport command_result plugin_init (Core *c, std::vector<PluginCommand> &commands)
{ {
commands.clear(); commands.clear();
commands.push_back(PluginCommand("regrass", "Regrows all surface grass, restoring outdoor plant growth for pre-0.31.19 worlds.", df_regrass)); commands.push_back(PluginCommand("regrass", "Regrows all surface grass, restoring outdoor plant growth for pre-0.31.19 worlds.", df_regrass));
return CR_OK; return CR_OK;
} }
DFhackCExport command_result plugin_shutdown ( Core * c ) DFhackCExport command_result plugin_shutdown ( Core * c )
{ {
return CR_OK; return CR_OK;
} }

24
plugins/reveal.cpp
Unescape Escape View File

@ -12,6 +12,7 @@
#include "modules/Gui.h" #include "modules/Gui.h"
using MapExtras::MapCache; using MapExtras::MapCache;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
using df::global::world; using df::global::world;
/* /*
@ -27,10 +28,10 @@ bool isSafe(df::coord c)
return false; return false;
// Adamantine tubes and temples lead to Hell // Adamantine tubes and temples lead to Hell
if (local_feature.type == df::feature_type::deep_special_tube || local_feature.type == df::feature_type::deep_surface_portal) if (local_feature.type == feature_type::deep_special_tube || local_feature.type == feature_type::deep_surface_portal)
return false; return false;
// And Hell *is* Hell. // And Hell *is* Hell.
if (global_feature.type == df::feature_type::feature_underworld_from_layer) if (global_feature.type == feature_type::feature_underworld_from_layer)
return false; return false;
// otherwise it's safe. // otherwise it's safe.
return true; return true;
@ -157,20 +158,18 @@ DFhackCExport command_result reveal(DFHack::Core * c, std::vector<std::string> &
return CR_FAILURE; return CR_FAILURE;
} }
c->Suspend(); CoreSuspender suspend(c);
DFHack::World *World =c->getWorld(); DFHack::World *World =c->getWorld();
t_gamemodes gm; t_gamemodes gm;
World->ReadGameMode(gm); World->ReadGameMode(gm);
if(gm.g_mode != GAMEMODE_DWARF) if(gm.g_mode != GAMEMODE_DWARF)
{ {
con.printerr("Only in fortress mode.\n"); con.printerr("Only in fortress mode.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -209,7 +208,6 @@ DFhackCExport command_result reveal(DFHack::Core * c, std::vector<std::string> &
else else
revealed = DEMON_REVEALED; revealed = DEMON_REVEALED;
} }
c->Resume();
con.print("Map revealed.\n"); con.print("Map revealed.\n");
if(!no_hell) if(!no_hell)
con.print("Unpausing can unleash the forces of hell, so it has been temporarily disabled.\n"); con.print("Unpausing can unleash the forces of hell, so it has been temporarily disabled.\n");
@ -233,7 +231,7 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
con.printerr("There's nothing to revert!\n"); con.printerr("There's nothing to revert!\n");
return CR_FAILURE; return CR_FAILURE;
} }
c->Suspend(); CoreSuspender suspend(c);
DFHack::World *World =c->getWorld(); DFHack::World *World =c->getWorld();
t_gamemodes gm; t_gamemodes gm;
@ -241,13 +239,11 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
if(gm.g_mode != GAMEMODE_DWARF) if(gm.g_mode != GAMEMODE_DWARF)
{ {
con.printerr("Only in fortress mode.\n"); con.printerr("Only in fortress mode.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -257,7 +253,6 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
if(x_max != x_max_b || y_max != y_max_b || z_max != z_max_b) if(x_max != x_max_b || y_max != y_max_b || z_max != z_max_b)
{ {
con.printerr("The map is not of the same size...\n"); con.printerr("The map is not of the same size...\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -274,7 +269,6 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
hidesaved.clear(); hidesaved.clear();
revealed = NOT_REVEALED; revealed = NOT_REVEALED;
con.print("Map hidden!\n"); con.print("Map hidden!\n");
c->Resume();
return CR_OK; return CR_OK;
} }
@ -310,20 +304,18 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
return CR_OK; return CR_OK;
} }
} }
c->Suspend(); CoreSuspender suspend(c);
uint32_t x_max,y_max,z_max; uint32_t x_max,y_max,z_max;
Gui * Gui = c->getGui(); Gui * Gui = c->getGui();
World * World = c->getWorld(); World * World = c->getWorld();
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if(revealed != NOT_REVEALED) if(revealed != NOT_REVEALED)
{ {
c->con.printerr("This is only safe to use with non-revealed map.\n"); c->con.printerr("This is only safe to use with non-revealed map.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
t_gamemodes gm; t_gamemodes gm;
@ -331,7 +323,6 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
if(gm.g_type != GAMETYPE_DWARF_MAIN && gm.g_mode != GAMEMODE_DWARF ) if(gm.g_type != GAMETYPE_DWARF_MAIN && gm.g_mode != GAMEMODE_DWARF )
{ {
c->con.printerr("Only in proper dwarf mode.\n"); c->con.printerr("Only in proper dwarf mode.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
int32_t cx, cy, cz; int32_t cx, cy, cz;
@ -343,7 +334,6 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
if(cx == -30000) if(cx == -30000)
{ {
c->con.printerr("Cursor is not active. Point the cursor at some empty space you want to be unhidden.\n"); c->con.printerr("Cursor is not active. Point the cursor at some empty space you want to be unhidden.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
DFCoord xy ((uint32_t)cx,(uint32_t)cy,cz); DFCoord xy ((uint32_t)cx,(uint32_t)cy,cz);
@ -353,7 +343,6 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
{ {
c->con.printerr("Point the cursor at some empty space you want to be unhidden.\n"); c->con.printerr("Point the cursor at some empty space you want to be unhidden.\n");
delete MCache; delete MCache;
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
// hide all tiles, flush cache // hide all tiles, flush cache
@ -467,6 +456,5 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
} }
MCache->WriteAll(); MCache->WriteAll();
delete MCache; delete MCache;
c->Resume();
return CR_OK; return CR_OK;
} }

21
plugins/seedwatch.cpp
Unescape Escape View File

@ -17,7 +17,7 @@
using namespace DFHack; using namespace DFHack;
using namespace DFHack::Simple; using namespace DFHack::Simple;
using namespace df::enums;
using df::global::world; using df::global::world;
const int buffer = 20; // seed number buffer - 20 is reasonable const int buffer = 20; // seed number buffer - 20 is reasonable
@ -48,11 +48,11 @@ void printHelp(Core& core) // prints help
"Each plant type can be assigned a limit. If their number falls below,\n" "Each plant type can be assigned a limit. If their number falls below,\n"
"the plants and seeds of that type will be excluded from cookery.\n" "the plants and seeds of that type will be excluded from cookery.\n"
"If the number rises above the limit + %i, then cooking will be allowed.\n", buffer "If the number rises above the limit + %i, then cooking will be allowed.\n", buffer
); );
core.con.printerr( core.con.printerr(
"The plugin needs a fortress to be loaded and will deactivate automatically otherwise.\n" "The plugin needs a fortress to be loaded and will deactivate automatically otherwise.\n"
"You have to reactivate with 'seedwatch start' after you load the game.\n" "You have to reactivate with 'seedwatch start' after you load the game.\n"
); );
core.con.print( core.con.print(
"Options:\n" "Options:\n"
"seedwatch all - Adds all plants from the abbreviation list to the watch list.\n" "seedwatch all - Adds all plants from the abbreviation list to the watch list.\n"
@ -60,7 +60,7 @@ void printHelp(Core& core) // prints help
"seedwatch stop - Stop watching.\n" "seedwatch stop - Stop watching.\n"
"seedwatch info - Display whether seedwatch is watching, and the watch list.\n" "seedwatch info - Display whether seedwatch is watching, and the watch list.\n"
"seedwatch clear - Clears the watch list.\n\n" "seedwatch clear - Clears the watch list.\n\n"
); );
if(!abbreviations.empty()) if(!abbreviations.empty())
{ {
core.con.print("You can use these abbreviations for the plant tokens:\n"); core.con.print("You can use these abbreviations for the plant tokens:\n");
@ -79,7 +79,7 @@ void printHelp(Core& core) // prints help
" is the same as 'seedwatch MUSHROOM_HELMET_PLUMP 30'\n" " is the same as 'seedwatch MUSHROOM_HELMET_PLUMP 30'\n"
"seedwatch all 30\n" "seedwatch all 30\n"
" adds all plants from the abbreviation list to the watch list, the limit being 30.\n" " adds all plants from the abbreviation list to the watch list, the limit being 30.\n"
); );
}; };
// searches abbreviations, returns expansion if so, returns original if not // searches abbreviations, returns expansion if so, returns original if not
@ -102,7 +102,7 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
{ {
return CR_FAILURE; return CR_FAILURE;
} }
core.Suspend(); CoreSuspender suspend(pCore);
std::map<std::string, t_materialIndex> materialsReverser; std::map<std::string, t_materialIndex> materialsReverser;
for(std::size_t i = 0; i < world->raws.plants.all.size(); ++i) for(std::size_t i = 0; i < world->raws.plants.all.size(); ++i)
@ -119,7 +119,6 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
{ {
// just print the help // just print the help
printHelp(core); printHelp(core);
core.Resume();
return CR_OK; return CR_OK;
} }
@ -184,7 +183,6 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
/* /*
else if(par == "dumpmaps") else if(par == "dumpmaps")
{ {
core.con.print("Plants:\n"); core.con.print("Plants:\n");
for(auto i = plantMaterialTypes.begin(); i != plantMaterialTypes.end(); i++) for(auto i = plantMaterialTypes.begin(); i != plantMaterialTypes.end(); i++)
{ {
@ -242,7 +240,6 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
break; break;
} }
core.Resume();
return CR_OK; return CR_OK;
} }
@ -328,10 +325,10 @@ DFhackCExport command_result plugin_onupdate(Core* pCore)
t_materialIndex materialIndex = item->getMaterialIndex(); t_materialIndex materialIndex = item->getMaterialIndex();
switch(item->getType()) switch(item->getType())
{ {
case df::item_type::SEEDS: case item_type::SEEDS:
if(!ignoreSeeds(item->flags)) ++seedCount[materialIndex]; if(!ignoreSeeds(item->flags)) ++seedCount[materialIndex];
break; break;
case df::item_type::PLANT: case item_type::PLANT:
break; break;
} }
} }
@ -356,4 +353,4 @@ DFhackCExport command_result plugin_onupdate(Core* pCore)
DFhackCExport command_result plugin_shutdown(Core* pCore) DFhackCExport command_result plugin_shutdown(Core* pCore)
{ {
return CR_OK; return CR_OK;
} }

8
plugins/tiletypes.cpp
Unescape Escape View File

@ -22,6 +22,7 @@ using std::set;
#include "df/tile_dig_designation.h" #include "df/tile_dig_designation.h"
using namespace MapExtras; using namespace MapExtras;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
//zilpin: These two functions were giving me compile errors in VS2008, so I cheated with the C style loop below, just to get it to build. //zilpin: These two functions were giving me compile errors in VS2008, so I cheated with the C style loop below, just to get it to build.
//Original code is commented out. //Original code is commented out.
@ -753,12 +754,11 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
continue; continue;
} }
c->Suspend(); CoreSuspender suspend(c);
gui = c->getGui(); gui = c->getGui();
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
Maps::getSize(x_max, y_max, z_max); Maps::getSize(x_max, y_max, z_max);
@ -766,7 +766,6 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
if (!(gui->Start() && gui->getCursorCoords(x,y,z))) if (!(gui->Start() && gui->getCursorCoords(x,y,z)))
{ {
c->con.printerr("Can't get cursor coords! Make sure you have a cursor active in DF.\n"); c->con.printerr("Can't get cursor coords! Make sure you have a cursor active in DF.\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
c->con.print("Cursor coords: (%d, %d, %d)\n",x,y,z); c->con.print("Cursor coords: (%d, %d, %d)\n",x,y,z);
@ -785,7 +784,7 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
|| (filter.material > -1 && filter.material != source->material) || (filter.material > -1 && filter.material != source->material)
|| (filter.special > -1 && filter.special != source->special) || (filter.special > -1 && filter.special != source->special)
|| (filter.variant > -1 && filter.variant != source->variant) || (filter.variant > -1 && filter.variant != source->variant)
|| (filter.dig > -1 && (filter.dig != 0) != (des.bits.dig != df::tile_dig_designation::No)) || (filter.dig > -1 && (filter.dig != 0) != (des.bits.dig != tile_dig_designation::No))
) )
{ {
continue; continue;
@ -890,7 +889,6 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
{ {
c->con.printerr("Something failed horribly! RUN!\n"); c->con.printerr("Something failed horribly! RUN!\n");
} }
c->Resume();
} }
} }
return CR_OK; return CR_OK;

11
plugins/tubefill.cpp
Unescape Escape View File

@ -15,6 +15,7 @@
using namespace DFHack; using namespace DFHack;
using namespace DFHack::Simple; using namespace DFHack::Simple;
using namespace df::enums;
using df::global::world; using df::global::world;
DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string> & params); DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string> & params);
@ -45,16 +46,15 @@ DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string>
if(params[i] == "help" || params[i] == "?") if(params[i] == "help" || params[i] == "?")
{ {
c->con.print("Replenishes mined out adamantine and hollow adamantine tubes.\n" c->con.print("Replenishes mined out adamantine and hollow adamantine tubes.\n"
"May cause !!FUN!!\n" "May cause !!FUN!!\n"
); );
return CR_OK; return CR_OK;
} }
} }
c->Suspend(); CoreSuspender suspend(c);
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -69,7 +69,7 @@ DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string>
DFCoord coord(block->map_pos.x >> 4, block->map_pos.y >> 4, block->map_pos.z); DFCoord coord(block->map_pos.x >> 4, block->map_pos.y >> 4, block->map_pos.z);
if (!Maps::GetLocalFeature(feature, coord, block->local_feature)) if (!Maps::GetLocalFeature(feature, coord, block->local_feature))
continue; continue;
if (feature.type != df::feature_type::deep_special_tube) if (feature.type != feature_type::deep_special_tube)
continue; continue;
for (uint32_t x = 0; x < 16; x++) for (uint32_t x = 0; x < 16; x++)
{ {
@ -106,7 +106,6 @@ DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string>
} }
} }
} }
c->Resume();
c->con.print("Found and changed %d tiles.\n", count); c->con.print("Found and changed %d tiles.\n", count);
return CR_OK; return CR_OK;
} }

277
plugins/vdig.cpp
Unescape Escape View File

@ -14,6 +14,7 @@ using std::vector;
using std::string; using std::string;
using std::stack; using std::stack;
using namespace DFHack; using namespace DFHack;
using namespace df::enums;
DFhackCExport command_result vdig (Core * c, vector <string> & parameters); DFhackCExport command_result vdig (Core * c, vector <string> & parameters);
DFhackCExport command_result vdigx (Core * c, vector <string> & parameters); DFhackCExport command_result vdigx (Core * c, vector <string> & parameters);
@ -35,12 +36,12 @@ DFhackCExport command_result plugin_init ( Core * c, std::vector <PluginCommand>
" Designates a whole vein under the cursor for digging.\n" " Designates a whole vein under the cursor for digging.\n"
"Options:\n" "Options:\n"
" x - follow veins through z-levels with stairs.\n" " x - follow veins through z-levels with stairs.\n"
)); ));
commands.push_back(PluginCommand( commands.push_back(PluginCommand(
"vdigx","Dig a whole vein, following through z-levels.",vdigx,cursor_hotkey, "vdigx","Dig a whole vein, following through z-levels.",vdigx,cursor_hotkey,
" Designates a whole vein under the cursor for digging.\n" " Designates a whole vein under the cursor for digging.\n"
" Also follows the vein between z-levels with stairs, like 'vdig x' would.\n" " Also follows the vein between z-levels with stairs, like 'vdig x' would.\n"
)); ));
commands.push_back(PluginCommand("expdig","Select or designate an exploratory pattern. Use 'expdig ?' for help.",expdig)); commands.push_back(PluginCommand("expdig","Select or designate an exploratory pattern. Use 'expdig ?' for help.",expdig));
commands.push_back(PluginCommand("digcircle","Dig desingate a circle (filled or hollow) with given radius.",digcircle)); commands.push_back(PluginCommand("digcircle","Dig desingate a circle (filled or hollow) with given radius.",digcircle));
//commands.push_back(PluginCommand("autodig","Mark a tile for continuous digging.",autodig)); //commands.push_back(PluginCommand("autodig","Mark a tile for continuous digging.",autodig));
@ -53,9 +54,9 @@ DFhackCExport command_result plugin_shutdown ( Core * c )
} }
template <class T> template <class T>
bool from_string(T& t, bool from_string(T& t,
const std::string& s, const std::string& s,
std::ios_base& (*f)(std::ios_base&)) std::ios_base& (*f)(std::ios_base&))
{ {
std::istringstream iss(s); std::istringstream iss(s);
return !(iss >> f >> t).fail(); return !(iss >> f >> t).fail();
@ -69,11 +70,11 @@ enum circle_what
}; };
bool dig (MapExtras::MapCache & MCache, bool dig (MapExtras::MapCache & MCache,
circle_what what, circle_what what,
df::tile_dig_designation type, df::tile_dig_designation type,
int32_t x, int32_t y, int32_t z, int32_t x, int32_t y, int32_t z,
int x_max, int y_max int x_max, int y_max
) )
{ {
DFCoord at (x,y,z); DFCoord at (x,y,z);
auto b = MCache.BlockAt(at/16); auto b = MCache.BlockAt(at/16);
@ -107,15 +108,15 @@ bool dig (MapExtras::MapCache & MCache,
break; break;
} }
if(isFloorTerrain(tt) if(isFloorTerrain(tt)
&& (type == df::tile_dig_designation::DownStair || type == df::tile_dig_designation::Channel) && (type == tile_dig_designation::DownStair || type == tile_dig_designation::Channel)
&& ts != TREE_OK && ts != TREE_OK
&& ts != TREE_DEAD && ts != TREE_DEAD
) )
{ {
std::cerr << "allowing tt" << tt << ", is floor\n"; std::cerr << "allowing tt" << tt << ", is floor\n";
break; break;
} }
if(isStairTerrain(tt) && type == df::tile_dig_designation::Channel ) if(isStairTerrain(tt) && type == tile_dig_designation::Channel )
break; break;
return false; return false;
} }
@ -123,28 +124,28 @@ bool dig (MapExtras::MapCache & MCache,
} }
switch(what) switch(what)
{ {
case circle_set: case circle_set:
if(des.bits.dig == df::tile_dig_designation::No) if(des.bits.dig == tile_dig_designation::No)
{ {
des.bits.dig = type; des.bits.dig = type;
} }
break; break;
case circle_unset: case circle_unset:
if (des.bits.dig != df::tile_dig_designation::No) if (des.bits.dig != tile_dig_designation::No)
{ {
des.bits.dig = df::tile_dig_designation::No; des.bits.dig = tile_dig_designation::No;
} }
break; break;
case circle_invert: case circle_invert:
if(des.bits.dig == df::tile_dig_designation::No) if(des.bits.dig == tile_dig_designation::No)
{ {
des.bits.dig = type; des.bits.dig = type;
} }
else else
{ {
des.bits.dig = df::tile_dig_designation::No; des.bits.dig = tile_dig_designation::No;
} }
break; break;
} }
std::cerr << "allowing tt" << tt << "\n"; std::cerr << "allowing tt" << tt << "\n";
MCache.setDesignationAt(at,des); MCache.setDesignationAt(at,des);
@ -152,11 +153,11 @@ bool dig (MapExtras::MapCache & MCache,
}; };
bool lineX (MapExtras::MapCache & MCache, bool lineX (MapExtras::MapCache & MCache,
circle_what what, circle_what what,
df::tile_dig_designation type, df::tile_dig_designation type,
int32_t y1, int32_t y2, int32_t x, int32_t z, int32_t y1, int32_t y2, int32_t x, int32_t z,
int x_max, int y_max int x_max, int y_max
) )
{ {
for(int32_t y = y1; y <= y2; y++) for(int32_t y = y1; y <= y2; y++)
{ {
@ -166,11 +167,11 @@ bool lineX (MapExtras::MapCache & MCache,
}; };
bool lineY (MapExtras::MapCache & MCache, bool lineY (MapExtras::MapCache & MCache,
circle_what what, circle_what what,
df::tile_dig_designation type, df::tile_dig_designation type,
int32_t x1, int32_t x2, int32_t y, int32_t z, int32_t x1, int32_t x2, int32_t y, int32_t z,
int x_max, int y_max int x_max, int y_max
) )
{ {
for(int32_t x = x1; x <= x2; x++) for(int32_t x = x1; x <= x2; x++)
{ {
@ -183,7 +184,7 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
{ {
static bool filled = false; static bool filled = false;
static circle_what what = circle_set; static circle_what what = circle_set;
static df::tile_dig_designation type = df::tile_dig_designation::Default; static df::tile_dig_designation type = tile_dig_designation::Default;
static int diameter = 0; static int diameter = 0;
auto saved_d = diameter; auto saved_d = diameter;
bool force_help = false; bool force_help = false;
@ -215,27 +216,27 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
} }
else if(parameters[i] == "dig") else if(parameters[i] == "dig")
{ {
type = df::tile_dig_designation::Default; type = tile_dig_designation::Default;
} }
else if(parameters[i] == "ramp") else if(parameters[i] == "ramp")
{ {
type = df::tile_dig_designation::Ramp; type = tile_dig_designation::Ramp;
} }
else if(parameters[i] == "dstair") else if(parameters[i] == "dstair")
{ {
type = df::tile_dig_designation::DownStair; type = tile_dig_designation::DownStair;
} }
else if(parameters[i] == "ustair") else if(parameters[i] == "ustair")
{ {
type = df::tile_dig_designation::UpStair; type = tile_dig_designation::UpStair;
} }
else if(parameters[i] == "xstair") else if(parameters[i] == "xstair")
{ {
type = df::tile_dig_designation::UpDownStair; type = tile_dig_designation::UpDownStair;
} }
else if(parameters[i] == "chan") else if(parameters[i] == "chan")
{ {
type = df::tile_dig_designation::Channel; type = tile_dig_designation::Channel;
} }
else if (!from_string(diameter,parameters[i], std::dec)) else if (!from_string(diameter,parameters[i], std::dec))
{ {
@ -246,39 +247,39 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
diameter = -diameter; diameter = -diameter;
if(force_help || diameter == 0) if(force_help || diameter == 0)
{ {
c->con.print( "A command for easy designation of filled and hollow circles.\n" c->con.print(
"\n" "A command for easy designation of filled and hollow circles.\n"
"Options:\n" "\n"
" hollow = Set the circle to hollow (default)\n" "Options:\n"
" filled = Set the circle to filled\n" " hollow = Set the circle to hollow (default)\n"
"\n" " filled = Set the circle to filled\n"
" set = set designation\n" "\n"
" unset = unset current designation\n" " set = set designation\n"
" invert = invert current designation\n" " unset = unset current designation\n"
"\n" " invert = invert current designation\n"
" dig = normal digging\n" "\n"
" ramp = ramp digging\n" " dig = normal digging\n"
" ustair = staircase up\n" " ramp = ramp digging\n"
" dstair = staircase down\n" " ustair = staircase up\n"
" xstair = staircase up/down\n" " dstair = staircase down\n"
" chan = dig channel\n" " xstair = staircase up/down\n"
"\n" " chan = dig channel\n"
" # = diameter in tiles (default = 0)\n" "\n"
"\n" " # = diameter in tiles (default = 0)\n"
"After you have set the options, the command called with no options\n" "\n"
"repeats with the last selected parameters:\n" "After you have set the options, the command called with no options\n"
"'digcircle filled 3' = Dig a filled circle with radius = 3.\n" "repeats with the last selected parameters:\n"
"'digcircle' = Do it again.\n" "'digcircle filled 3' = Dig a filled circle with radius = 3.\n"
); "'digcircle' = Do it again.\n"
);
return CR_OK; return CR_OK;
} }
int32_t cx, cy, cz; int32_t cx, cy, cz;
c->Suspend(); CoreSuspender suspend(c);
Gui * gui = c->getGui(); Gui * gui = c->getGui();
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
@ -288,7 +289,6 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
MapExtras::MapCache MCache; MapExtras::MapCache MCache;
if(!gui->getCursorCoords(cx,cy,cz) || cx == -30000) if(!gui->getCursorCoords(cx,cy,cz) || cx == -30000)
{ {
c->Resume();
c->con.printerr("Can't get the cursor coords...\n"); c->con.printerr("Can't get the cursor coords...\n");
return CR_FAILURE; return CR_FAILURE;
} }
@ -359,7 +359,6 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
lastwhole = whole; lastwhole = whole;
} }
MCache.WriteAll(); MCache.WriteAll();
c->Resume();
return CR_OK; return CR_OK;
} }
typedef char digmask[16][16]; typedef char digmask[16][16];
@ -477,8 +476,8 @@ static digmask diag5r[5] =
{0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0}, {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0},
{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1}, {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1},
{0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0}, {0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0},
}, },
{ {
{0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0}, {0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0}, {0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0},
{0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0}, {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0},
@ -495,8 +494,8 @@ static digmask diag5r[5] =
{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1}, {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1},
{0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0}, {0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0},
{0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0}, {0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0},
}, },
{ {
{0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0}, {0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0},
{0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0}, {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0},
{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1}, {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1},
@ -513,8 +512,8 @@ static digmask diag5r[5] =
{0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0}, {0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0},
{0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0}, {0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0}, {0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0},
}, },
{ {
{0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0}, {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0},
{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1}, {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1},
{0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0}, {0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0},
@ -531,8 +530,8 @@ static digmask diag5r[5] =
{0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0}, {0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0}, {0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0},
{0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0}, {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0},
}, },
{ {
{1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1}, {1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1},
{0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0}, {0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0},
{0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0}, {0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0},
@ -726,9 +725,9 @@ enum explo_what
}; };
bool stamp_pattern (uint32_t bx, uint32_t by, int z_level, bool stamp_pattern (uint32_t bx, uint32_t by, int z_level,
digmask & dm, explo_how how, explo_what what, digmask & dm, explo_how how, explo_what what,
int x_max, int y_max int x_max, int y_max
) )
{ {
df::map_block * bl = Maps::getBlock(bx,by,z_level); df::map_block * bl = Maps::getBlock(bx,by,z_level);
if(!bl) if(!bl)
@ -756,25 +755,25 @@ bool stamp_pattern (uint32_t bx, uint32_t by, int z_level,
continue; continue;
if(how == EXPLO_CLEAR) if(how == EXPLO_CLEAR)
{ {
des.bits.dig = df::tile_dig_designation::No; des.bits.dig = tile_dig_designation::No;
continue; continue;
} }
if(dm[y][x]) if(dm[y][x])
{ {
if(what == EXPLO_ALL if(what == EXPLO_ALL
|| des.bits.dig == df::tile_dig_designation::Default && what == EXPLO_DESIGNATED || des.bits.dig == tile_dig_designation::Default && what == EXPLO_DESIGNATED
|| des.bits.hidden && what == EXPLO_HIDDEN) || des.bits.hidden && what == EXPLO_HIDDEN)
{ {
des.bits.dig = df::tile_dig_designation::Default; des.bits.dig = tile_dig_designation::Default;
} }
} }
else if(what == EXPLO_DESIGNATED) else if(what == EXPLO_DESIGNATED)
{ {
des.bits.dig = df::tile_dig_designation::No; des.bits.dig = tile_dig_designation::No;
} }
} }
} }
bl->flags.set(df::block_flags::Designated); bl->flags.set(block_flags::Designated);
return true; return true;
}; };
@ -828,42 +827,41 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
} }
if(force_help || how == EXPLO_NOTHING) if(force_help || how == EXPLO_NOTHING)
{ {
c->con.print("This command can be used for exploratory mining.\n" c->con.print(
"http://df.magmawiki.com/index.php/DF2010:Exploratory_mining\n" "This command can be used for exploratory mining.\n"
"\n" "http://df.magmawiki.com/index.php/DF2010:Exploratory_mining\n"
"There are two variables that can be set: pattern and filter.\n" "\n"
"Patterns:\n" "There are two variables that can be set: pattern and filter.\n"
" diag5 = diagonals separated by 5 tiles\n" "Patterns:\n"
" diag5r = diag5 rotated 90 degrees\n" " diag5 = diagonals separated by 5 tiles\n"
" ladder = A 'ladder' pattern\n" " diag5r = diag5 rotated 90 degrees\n"
"ladderr = ladder rotated 90 degrees\n" " ladder = A 'ladder' pattern\n"
" clear = Just remove all dig designations\n" "ladderr = ladder rotated 90 degrees\n"
" cross = A cross, exactly in the middle of the map.\n" " clear = Just remove all dig designations\n"
"Filters:\n" " cross = A cross, exactly in the middle of the map.\n"
" all = designate whole z-level\n" "Filters:\n"
" hidden = designate only hidden tiles of z-level (default)\n" " all = designate whole z-level\n"
" designated = Take current designation and apply pattern to it.\n" " hidden = designate only hidden tiles of z-level (default)\n"
"\n" " designated = Take current designation and apply pattern to it.\n"
"After you have a pattern set, you can use 'expdig' to apply it:\n" "\n"
"'expdig diag5 hidden' = set filter to hidden, pattern to diag5.\n" "After you have a pattern set, you can use 'expdig' to apply it:\n"
"'expdig' = apply the pattern with filter.\n" "'expdig diag5 hidden' = set filter to hidden, pattern to diag5.\n"
); "'expdig' = apply the pattern with filter.\n"
);
return CR_OK; return CR_OK;
} }
c->Suspend(); CoreSuspender suspend(c);
Gui * gui = c->getGui(); Gui * gui = c->getGui();
uint32_t x_max, y_max, z_max; uint32_t x_max, y_max, z_max;
if (!Maps::IsValid()) if (!Maps::IsValid())
{ {
c->con.printerr("Map is not available!\n"); c->con.printerr("Map is not available!\n");
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
Maps::getSize(x_max,y_max,z_max); Maps::getSize(x_max,y_max,z_max);
int32_t xzzz,yzzz,z_level; int32_t xzzz,yzzz,z_level;
if(!gui->getViewCoords(xzzz,yzzz,z_level)) if(!gui->getViewCoords(xzzz,yzzz,z_level))
{ {
c->Resume();
c->con.printerr("Can't get view coords...\n"); c->con.printerr("Can't get view coords...\n");
return CR_FAILURE; return CR_FAILURE;
} }
@ -876,7 +874,7 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
{ {
which = (4*x + y) % 5; which = (4*x + y) % 5;
stamp_pattern(x,y_max - 1 - y, z_level, diag5[which], stamp_pattern(x,y_max - 1 - y, z_level, diag5[which],
how, what, x_max, y_max); how, what, x_max, y_max);
} }
} }
} }
@ -889,7 +887,7 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
{ {
which = (4*x + 1000-y) % 5; which = (4*x + 1000-y) % 5;
stamp_pattern(x,y_max - 1 - y, z_level, diag5r[which], stamp_pattern(x,y_max - 1 - y, z_level, diag5r[which],
how, what, x_max, y_max); how, what, x_max, y_max);
} }
} }
} }
@ -915,7 +913,7 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
for(uint32_t x = 0; x < x_max; x++) for(uint32_t x = 0; x < x_max; x++)
{ {
stamp_pattern(x, y, z_level, ladderr[which], stamp_pattern(x, y, z_level, ladderr[which],
how, what, x_max, y_max); how, what, x_max, y_max);
} }
} }
} }
@ -939,21 +937,20 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
continue; continue;
if(cross[y][x]) if(cross[y][x])
{ {
des.bits.dig = df::tile_dig_designation::Default; des.bits.dig = tile_dig_designation::Default;
mx.setDesignationAt(pos,des); mx.setDesignationAt(pos,des);
} }
} }
mx.WriteAll(); mx.WriteAll();
} }
else for(uint32_t x = 0; x < x_max; x++) else for(uint32_t x = 0; x < x_max; x++)
{ {
for(int32_t y = 0 ; y < y_max; y++) for(int32_t y = 0 ; y < y_max; y++)
{ {
stamp_pattern(x, y, z_level, all_tiles, stamp_pattern(x, y, z_level, all_tiles,
how, what, x_max, y_max); how, what, x_max, y_max);
} }
} }
c->Resume();
return CR_OK; return CR_OK;
} }
@ -1090,32 +1087,32 @@ DFhackCExport command_result vdig (Core * c, vector <string> & parameters)
{ {
flood.push(current-1); flood.push(current-1);
if(des_minus.bits.dig == df::tile_dig_designation::DownStair) if(des_minus.bits.dig == tile_dig_designation::DownStair)
des_minus.bits.dig = df::tile_dig_designation::UpDownStair; des_minus.bits.dig = tile_dig_designation::UpDownStair;
else else
des_minus.bits.dig = df::tile_dig_designation::UpStair; des_minus.bits.dig = tile_dig_designation::UpStair;
MCache->setDesignationAt(current-1,des_minus); MCache->setDesignationAt(current-1,des_minus);
des.bits.dig = df::tile_dig_designation::DownStair; des.bits.dig = tile_dig_designation::DownStair;
} }
if(current.z < z_max - 1 && above && vmat_plus == vmat2) if(current.z < z_max - 1 && above && vmat_plus == vmat2)
{ {
flood.push(current+ 1); flood.push(current+ 1);
if(des_plus.bits.dig == df::tile_dig_designation::UpStair) if(des_plus.bits.dig == tile_dig_designation::UpStair)
des_plus.bits.dig = df::tile_dig_designation::UpDownStair; des_plus.bits.dig = tile_dig_designation::UpDownStair;
else else
des_plus.bits.dig = df::tile_dig_designation::DownStair; des_plus.bits.dig = tile_dig_designation::DownStair;
MCache->setDesignationAt(current+1,des_plus); MCache->setDesignationAt(current+1,des_plus);
if(des.bits.dig == df::tile_dig_designation::DownStair) if(des.bits.dig == tile_dig_designation::DownStair)
des.bits.dig = df::tile_dig_designation::UpDownStair; des.bits.dig = tile_dig_designation::UpDownStair;
else else
des.bits.dig = df::tile_dig_designation::UpStair; des.bits.dig = tile_dig_designation::UpStair;
} }
} }
if(des.bits.dig == df::tile_dig_designation::No) if(des.bits.dig == tile_dig_designation::No)
des.bits.dig = df::tile_dig_designation::Default; des.bits.dig = tile_dig_designation::Default;
MCache->setDesignationAt(current,des); MCache->setDesignationAt(current,des);
} }
} }

39
plugins/weather.cpp
Unescape Escape View File

@ -59,11 +59,11 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
if(help) if(help)
{ {
c->con.print("Prints the current weather map by default.\n" c->con.print("Prints the current weather map by default.\n"
"Options:\n" "Options:\n"
"snow - make it snow everywhere.\n" "snow - make it snow everywhere.\n"
"rain - make it rain.\n" "rain - make it rain.\n"
"clear - clear the sky.\n" "clear - clear the sky.\n"
); );
return CR_OK; return CR_OK;
} }
if(lock && unlock) if(lock && unlock)
@ -81,12 +81,12 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
return CR_FAILURE; return CR_FAILURE;
} }
bool something = lock || unlock || rain || snow || clear; bool something = lock || unlock || rain || snow || clear;
c->Suspend();
CoreSuspender suspend(c);
DFHack::World * w = c->getWorld(); DFHack::World * w = c->getWorld();
if(!w->wmap) if(!w->wmap)
{ {
con << "Weather support seems broken :(" << std::endl; con << "Weather support seems broken :(" << std::endl;
c->Resume();
return CR_FAILURE; return CR_FAILURE;
} }
if(!something) if(!something)
@ -99,18 +99,18 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
{ {
switch((*w->wmap)[x][y]) switch((*w->wmap)[x][y])
{ {
case DFHack::CLEAR: case CLEAR:
con << "C "; con << "C ";
break; break;
case DFHack::RAINING: case RAINING:
con << "R "; con << "R ";
break; break;
case DFHack::SNOWING: case SNOWING:
con << "S "; con << "S ";
break; break;
default: default:
con << (int) (*w->wmap)[x][y] << " "; con << (int) (*w->wmap)[x][y] << " ";
break; break;
} }
} }
con << std::endl; con << std::endl;
@ -136,6 +136,5 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
} }
// FIXME: weather lock needs map ID to work reliably... needs to be implemented. // FIXME: weather lock needs map ID to work reliably... needs to be implemented.
} }
c->Resume();
return CR_OK; return CR_OK;
} }