Use CoreSuspender and namespace df::enums

plugins/autodump.cpp

@@ -26,6 +26,8 @@ using namespace std;
 #include "df/general_ref.h"
 
 using namespace DFHack;
+using namespace df::enums;
+
 using MapExtras::Block;
 using MapExtras::MapCache;
 using df::global::world;
@@ -291,9 +293,9 @@ DFhackCExport command_result df_autodump_destroy_item(Core * c, vector <string>
         return CR_FAILURE;
 
     // 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();
     }
 
@@ -327,7 +329,7 @@ DFhackCExport command_result df_autodump_destroy_item(Core * c, vector <string>
     for (unsigned i = 0; i < item->itemrefs.size(); 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");
             return CR_FAILURE;

plugins/cleaners.cpp

@@ -17,6 +17,7 @@ using std::vector;
 using std::string;
 using namespace DFHack;
 using namespace DFHack::Simple;
+using namespace df::enums;
 
 using df::global::world;
 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++)
         {
             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;
             // type verified - recast to subclass
             df::block_square_event_material_spatterst *spatter = (df::block_square_event_material_spatterst *)evt;
 
             // filter snow
             if(!snow
-                && spatter->mat_type == df::builtin_mats::WATER
-                && spatter->mat_state == df::matter_state::Powder)
+                && spatter->mat_type == builtin_mats::WATER
+                && spatter->mat_state == matter_state::Powder)
                 continue;
             // filter mud
             if(!mud
-                && spatter->mat_type == df::builtin_mats::MUD
-                && spatter->mat_state == df::matter_state::Solid)
+                && spatter->mat_type == builtin_mats::MUD
+                && spatter->mat_state == matter_state::Solid)
                 continue;
 
             delete evt;
@@ -119,7 +120,7 @@ DFhackCExport command_result spotclean (Core * c, vector <string> & parameters)
     if (cursor->x == -30000)
     {
         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);
     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++)
     {
         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;
         // type verified - recast to subclass
         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;
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     if(map)
         cleanmap(c,snow,mud);
     if(units)
         cleanunits(c);
     if(items)
         cleanitems(c);
-    c->Resume();
     return CR_OK;
 }
 

plugins/cleanowned.cpp

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

plugins/colonies.cpp

@@ -66,10 +66,9 @@ DFhackCExport command_result colonies (Core * c, vector <string> & parameters)
     if (destroy && convert)
     {
         c->con.printerr("Kill or make bees? DECIDE!\n");
-        c->Resume();
         return CR_FAILURE;
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
 
     Materials * materials = c->getMaterials();
 
@@ -84,7 +83,6 @@ DFhackCExport command_result colonies (Core * c, vector <string> & parameters)
 
     materials->Finish();
 
-    c->Resume();
     return CR_OK;
 }
 
@@ -110,11 +108,13 @@ void convertColonies(Materials *Materials)
 {
     int bee_idx = -1;
     for (size_t i = 0; i < Materials->raceEx.size(); i++)
+    {
         if (Materials->raceEx[i].id == "HONEY_BEE")
         {
             bee_idx = i;
             break;
         }
+    }
 
     if (bee_idx == -1)
     {

plugins/deramp.cpp

@@ -12,10 +12,10 @@
 using std::vector;
 using std::string;
 using namespace DFHack;
+using namespace DFHack::Simple;
+using namespace df::enums;
 
 using df::global::world;
-using namespace DFHack;
-using namespace DFHack::Simple;
 
 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];
                 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.
                     // Set current tile, as accurately as can be expected
@@ -59,7 +59,7 @@ DFhackCExport command_result df_deramp (Core * c, vector <string> & parameters)
                         continue;
                     // Set new tile type, clear designation
                     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.
                     if ((above) && (tileShape(above->tiletype[x][y]) == RAMP_TOP))

plugins/drybuckets.cpp

@@ -13,6 +13,7 @@
 using std::string;
 using std::vector;
 using namespace DFHack;
+using namespace df::enums;
 
 using df::global::world;
 
@@ -27,7 +28,7 @@ DFhackCExport command_result df_drybuckets (Core * c, vector <string> & paramete
     for (int i = 0; i < world->items.all.size(); 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;
             dried_total++;

plugins/filltraffic.cpp

@@ -15,6 +15,7 @@
 using std::stack;
 using MapExtras::MapCache;
 using namespace DFHack;
+using namespace df::enums;
 
 //Function pointer type for whole-map tile checks.
 typedef void (*checkTile)(DFHack::DFCoord, MapExtras::MapCache &);
@@ -57,8 +58,8 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
     //Maximum map size.
     uint32_t x_max,y_max,z_max;
     //Source and target traffic types.
-	df::tile_traffic source = df::tile_traffic::Normal;
-	df::tile_traffic target = df::tile_traffic::Normal;
+    df::tile_traffic source = tile_traffic::Normal;
+    df::tile_traffic target = tile_traffic::Normal;
     //Option flags
     bool updown        = false;
     bool checkpit      = true;
@@ -89,13 +90,13 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
         switch (toupper(params[i][0]))
         {
         case 'H':
-                target = df::tile_traffic::High; break;
+            target = tile_traffic::High; break;
         case 'N':
-                target = df::tile_traffic::Normal; break;
+            target = tile_traffic::Normal; break;
         case 'L':
-                target = df::tile_traffic::Low; break;
+            target = tile_traffic::Low; break;
         case 'R':
-                target = df::tile_traffic::Restricted; break;
+            target = tile_traffic::Restricted; break;
         case 'X':
             updown = true; break;
         case 'B':
@@ -106,13 +107,12 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
     }
 
     //Initialization.
-    c->Suspend();
+    CoreSuspender suspend(c);
 
     DFHack::Gui * Gui = c->getGui();
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -124,7 +124,6 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
     while(cx == -30000)
     {
         c->con.printerr("Cursor is not active.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -142,28 +141,24 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
     if(source == target)
     {
         c->con.printerr("This tile is already set to the target traffic type.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
     if(DFHack::isWallTerrain(tt))
     {
         c->con.printerr("This tile is a wall. Please select a passable tile.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
     if(checkpit && DFHack::isOpenTerrain(tt))
     {
         c->con.printerr("This tile is a hole. Please select a passable tile.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
     if(checkbuilding && oc.bits.building)
     {
         c->con.printerr("This tile contains a building. Please select an empty tile.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -231,7 +226,6 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vector<std::stri
     }
 
     MCache.WriteAll();
-    c->Resume();
     return CR_OK;
 }
 
@@ -281,13 +275,12 @@ DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkPro
     DFHack::DFCoord minCoord, DFHack::DFCoord maxCoord)
 {
     //Initialization.
-	c->Suspend();
+    CoreSuspender suspend(c);
 
     DFHack::Gui * Gui = c->getGui();
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -306,19 +299,16 @@ DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkPro
     if (minCoord.x > maxCoord.x)
     {
         c->con.printerr("Minimum x coordinate is greater than maximum x coordinate.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     if (minCoord.y > maxCoord.y)
     {
         c->con.printerr("Minimum y coordinate is greater than maximum y coordinate.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     if (minCoord.z > maxCoord.y)
     {
         c->con.printerr("Minimum z coordinate is greater than maximum z coordinate.\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -341,7 +331,6 @@ DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkPro
 
     MCache.WriteAll();
     c->con.print("Complete!\n");
-    c->Resume();
     return CR_OK;
 }
 
@@ -349,24 +338,24 @@ DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkPro
 void allHigh(DFHack::DFCoord coord, MapExtras::MapCache &map)
 {
     df::tile_designation des = map.designationAt(coord);
-	des.bits.traffic = df::tile_traffic::High;
+    des.bits.traffic = tile_traffic::High;
     map.setDesignationAt(coord, des);
 }
 void allNormal(DFHack::DFCoord coord, MapExtras::MapCache &map)
 {
     df::tile_designation des = map.designationAt(coord);
-	des.bits.traffic = df::tile_traffic::Normal;
+    des.bits.traffic = tile_traffic::Normal;
     map.setDesignationAt(coord, des);
 }
 void allLow(DFHack::DFCoord coord, MapExtras::MapCache &map)
 {
     df::tile_designation des = map.designationAt(coord);
-	des.bits.traffic = df::tile_traffic::Low;
+    des.bits.traffic = tile_traffic::Low;
     map.setDesignationAt(coord, des);
 }
 void allRestricted(DFHack::DFCoord coord, MapExtras::MapCache &map)
 {
     df::tile_designation des = map.designationAt(coord);
-	des.bits.traffic = df::tile_traffic::Restricted;
+    des.bits.traffic = tile_traffic::Restricted;
     map.setDesignationAt(coord, des);
 }

plugins/fixwagons.cpp

@@ -15,6 +15,7 @@
 using std::string;
 using std::vector;
 using namespace DFHack;
+using namespace df::enums;
 
 using df::global::world;
 
@@ -29,7 +30,7 @@ command_result df_fixwagons (Core *c, vector<string> &parameters)
     for (int i = 0; i < world->raws.creatures.all.size(); 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_creature = i;
@@ -55,7 +56,7 @@ command_result df_fixwagons (Core *c, vector<string> &parameters)
     {
         bool updated = false;
         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;
         if (ent->resources.animals.wagon_races.size() == 0)
         {

plugins/flows.cpp

@@ -13,6 +13,7 @@
 using std::string;
 using std::vector;
 using namespace DFHack;
+using namespace df::enums;
 
 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++)
     {
         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++;
-        if (cur->flags.is_set(df::block_flags::UpdateLiquidTwice))
+        if (cur->flags.is_set(block_flags::UpdateLiquidTwice))
             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++;
         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
                 if (cur->designation[x][y].bits.flow_size == 0)
                     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++;
-                if (cur->designation[x][y].bits.liquid_type == df::tile_liquid::Water)
+                if (cur->designation[x][y].bits.liquid_type == tile_liquid::Water)
                     water++;
             }
         }

plugins/initflags.cpp

@@ -43,7 +43,7 @@ DFhackCExport command_result plugin_shutdown ( Core * c )
 DFhackCExport command_result twaterlvl(Core * c, vector <string> & parameters)
 {
     // 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;
     return CR_OK;
 }

plugins/liquids.cpp

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

plugins/plants.cpp

@@ -18,7 +18,6 @@
 using std::vector;
 using std::string;
 using namespace DFHack;
-
 using df::global::world;
 
 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;
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
     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" );
         }
     }
-    // Cleanup
-    c->Resume();
     return CR_OK;
 }
 
@@ -204,12 +200,11 @@ DFhackCExport command_result df_grow (Core * c, vector <string> & parameters)
             return CR_OK;
         }
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     Console & con = c->con;
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
     MapExtras::MapCache map;
@@ -248,8 +243,6 @@ DFhackCExport command_result df_grow (Core * c, vector <string> & parameters)
         }
     }
 
-    // Cleanup
-    c->Resume();
     return CR_OK;
 }
 

plugins/probe.cpp

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

plugins/prospector.cpp

@@ -23,6 +23,7 @@ using namespace std;
 #include "df/world.h"
 
 using namespace DFHack;
+using namespace df::enums;
 using df::global::world;
 
 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;
-    c->Suspend();
+    CoreSuspender suspend(c);
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
     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);
                 }
 
-                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
                 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
                         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);
                             else
                                 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. */
                             if (info->material == DFHack::AIR &&
                                 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);
                             }
@@ -368,20 +368,20 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
                         case DFHack::FEATSTONE:
                             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
                                 {
                                     veinMats[blockFeatureLocal.sub_material].add(global_z);
                                 }
                                 else if (showTemple
-                                         && blockFeatureLocal.type == df::feature_type::deep_surface_portal)
+                                         && blockFeatureLocal.type == feature_type::deep_surface_portal)
                                 {
                                     hasDemonTemple = true;
                                 }
                             }
 
                             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
                             {
                                 layerMats[blockFeatureGlobal.sub_material].add(global_z);
@@ -494,7 +494,6 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector <string> & par
         veg->Finish();
     }
     mats->Finish();
-    c->Resume();
     con << std::endl;
     return CR_OK;
 }

plugins/reveal.cpp

@@ -12,6 +12,7 @@
 #include "modules/Gui.h"
 using MapExtras::MapCache;
 using namespace DFHack;
+using namespace df::enums;
 using df::global::world;
 
 /*
@@ -27,10 +28,10 @@ bool isSafe(df::coord c)
         return false;
 
     // 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;
     // 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;
     // otherwise it's safe.
     return true;
@@ -157,20 +158,18 @@ DFhackCExport command_result reveal(DFHack::Core * c, std::vector<std::string> &
         return CR_FAILURE;
     }
 
-    c->Suspend();
+    CoreSuspender suspend(c);
     DFHack::World *World =c->getWorld();
     t_gamemodes gm;
     World->ReadGameMode(gm);
     if(gm.g_mode != GAMEMODE_DWARF)
     {
         con.printerr("Only in fortress mode.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -209,7 +208,6 @@ DFhackCExport command_result reveal(DFHack::Core * c, std::vector<std::string> &
         else
             revealed = DEMON_REVEALED;
     }
-    c->Resume();
     con.print("Map revealed.\n");
     if(!no_hell)
         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");
         return CR_FAILURE;
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
 
     DFHack::World *World =c->getWorld();
     t_gamemodes gm;
@@ -241,13 +239,11 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
     if(gm.g_mode != GAMEMODE_DWARF)
     {
         con.printerr("Only in fortress mode.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         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)
     {
         con.printerr("The map is not of the same size...\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -274,7 +269,6 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector<std::string>
     hidesaved.clear();
     revealed = NOT_REVEALED;
     con.print("Map hidden!\n");
-    c->Resume();
     return CR_OK;
 }
 
@@ -310,20 +304,18 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
             return CR_OK;
         }
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     uint32_t x_max,y_max,z_max;
     Gui * Gui = c->getGui();
     World * World = c->getWorld();
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
     if(revealed != NOT_REVEALED)
     {
         c->con.printerr("This is only safe to use with non-revealed map.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     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 )
     {
         c->con.printerr("Only in proper dwarf mode.\n");
-        c->Resume();
         return CR_FAILURE;
     }
     int32_t cx, cy, cz;
@@ -343,7 +334,6 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
     if(cx == -30000)
     {
         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;
     }
     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");
         delete MCache;
-        c->Resume();
         return CR_FAILURE;
     }
     // hide all tiles, flush cache
@@ -467,6 +456,5 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector<std::string>
     }
     MCache->WriteAll();
     delete MCache;
-    c->Resume();
     return CR_OK;
 }

plugins/seedwatch.cpp

@@ -17,7 +17,7 @@
 
 using namespace DFHack;
 using namespace DFHack::Simple;
-
+using namespace df::enums;
 using df::global::world;
 
 const int buffer = 20; // seed number buffer - 20 is reasonable
@@ -102,7 +102,7 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
     {
         return CR_FAILURE;
     }
-    core.Suspend();
+    CoreSuspender suspend(pCore);
 
     std::map<std::string, t_materialIndex> materialsReverser;
     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
         printHelp(core);
-        core.Resume();
         return CR_OK;
     }
 
@@ -184,7 +183,6 @@ DFhackCExport command_result df_seedwatch(Core* pCore, std::vector<std::string>&
         /*
         else if(par == "dumpmaps")
         {
-            
             core.con.print("Plants:\n");
             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;
     }
 
-    core.Resume();
     return CR_OK;
 }
 
@@ -328,10 +325,10 @@ DFhackCExport command_result plugin_onupdate(Core* pCore)
             t_materialIndex materialIndex = item->getMaterialIndex();
             switch(item->getType())
             {
-            case df::item_type::SEEDS:
+            case item_type::SEEDS:
                 if(!ignoreSeeds(item->flags)) ++seedCount[materialIndex];
                 break;
-            case df::item_type::PLANT:
+            case item_type::PLANT:
                 break;
             }
         }

plugins/tiletypes.cpp

@@ -22,6 +22,7 @@ using std::set;
 #include "df/tile_dig_designation.h"
 using namespace MapExtras;
 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.
 //Original code is commented out.
@@ -753,12 +754,11 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
                 continue;
             }
 
-            c->Suspend();
+            CoreSuspender suspend(c);
             gui = c->getGui();
             if (!Maps::IsValid())
             {
                 c->con.printerr("Map is not available!\n");
-                c->Resume();
                 return CR_FAILURE;
             }
             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)))
             {
                 c->con.printerr("Can't get cursor coords! Make sure you have a cursor active in DF.\n");
-                c->Resume();
                 return CR_FAILURE;
             }
             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.special > -1 && filter.special != source->special)
                  || (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;
@@ -890,7 +889,6 @@ DFhackCExport command_result df_tiletypes (Core * c, vector <string> & parameter
             {
                 c->con.printerr("Something failed horribly! RUN!\n");
             }
-            c->Resume();
         }
     }
     return CR_OK;

plugins/tubefill.cpp

@@ -15,6 +15,7 @@
 
 using namespace DFHack;
 using namespace DFHack::Simple;
+using namespace df::enums;
 using df::global::world;
 
 DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string> & params);
@@ -50,11 +51,10 @@ DFhackCExport command_result tubefill(DFHack::Core * c, std::vector<std::string>
             return CR_OK;
         }
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         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);
         if (!Maps::GetLocalFeature(feature, coord, block->local_feature))
             continue;
-        if (feature.type != df::feature_type::deep_special_tube)
+        if (feature.type != feature_type::deep_special_tube)
             continue;
         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);
     return CR_OK;
 }

plugins/vdig.cpp

@@ -14,6 +14,7 @@ using std::vector;
 using std::string;
 using std::stack;
 using namespace DFHack;
+using namespace df::enums;
 
 DFhackCExport command_result vdig (Core * c, vector <string> & parameters);
 DFhackCExport command_result vdigx (Core * c, vector <string> & parameters);
@@ -107,7 +108,7 @@ bool dig (MapExtras::MapCache & MCache,
                 break;
             }
             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_DEAD
                 )
@@ -115,7 +116,7 @@ bool dig (MapExtras::MapCache & MCache,
                 std::cerr << "allowing tt" << tt << ", is floor\n";
                 break;
             }
-            if(isStairTerrain(tt) && type == df::tile_dig_designation::Channel )
+            if(isStairTerrain(tt) && type == tile_dig_designation::Channel )
                 break;
             return false;
         }
@@ -124,25 +125,25 @@ bool dig (MapExtras::MapCache & MCache,
     switch(what)
     {
     case circle_set:
-            if(des.bits.dig == df::tile_dig_designation::No)
+        if(des.bits.dig == tile_dig_designation::No)
         {
             des.bits.dig = type;
         }
         break;
     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;
     case circle_invert:
-            if(des.bits.dig == df::tile_dig_designation::No)
+        if(des.bits.dig == tile_dig_designation::No)
         {
             des.bits.dig = type;
         }
         else
         {
-                des.bits.dig = df::tile_dig_designation::No;
+            des.bits.dig = tile_dig_designation::No;
         }
         break;
     }
@@ -183,7 +184,7 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
 {
     static bool filled = false;
     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;
     auto saved_d = diameter;
     bool force_help = false;
@@ -215,27 +216,27 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
         }
         else if(parameters[i] == "dig")
         {
-            type = df::tile_dig_designation::Default;
+            type = tile_dig_designation::Default;
         }
         else if(parameters[i] == "ramp")
         {
-            type = df::tile_dig_designation::Ramp;
+            type = tile_dig_designation::Ramp;
         }
         else if(parameters[i] == "dstair")
         {
-            type = df::tile_dig_designation::DownStair;
+            type = tile_dig_designation::DownStair;
         }
         else if(parameters[i] == "ustair")
         {
-            type = df::tile_dig_designation::UpStair;
+            type = tile_dig_designation::UpStair;
         }
         else if(parameters[i] == "xstair")
         {
-            type = df::tile_dig_designation::UpDownStair;
+            type = tile_dig_designation::UpDownStair;
         }
         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))
         {
@@ -246,7 +247,8 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
         diameter = -diameter;
     if(force_help || diameter == 0)
     {
-        c->con.print(   "A command for easy designation of filled and hollow circles.\n"
+        c->con.print(
+            "A command for easy designation of filled and hollow circles.\n"
             "\n"
             "Options:\n"
             " hollow = Set the circle to hollow (default)\n"
@@ -273,12 +275,11 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
         return CR_OK;
     }
     int32_t cx, cy, cz;
-    c->Suspend();
+    CoreSuspender suspend(c);
     Gui * gui = c->getGui();
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
 
@@ -288,7 +289,6 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
     MapExtras::MapCache MCache;
     if(!gui->getCursorCoords(cx,cy,cz) || cx == -30000)
     {
-        c->Resume();
         c->con.printerr("Can't get the cursor coords...\n");
         return CR_FAILURE;
     }
@@ -359,7 +359,6 @@ DFhackCExport command_result digcircle (Core * c, vector <string> & parameters)
         lastwhole = whole;
     }
     MCache.WriteAll();
-    c->Resume();
     return CR_OK;
 }
 typedef char digmask[16][16];
@@ -756,25 +755,25 @@ bool stamp_pattern (uint32_t bx, uint32_t by, int z_level,
                 continue;
             if(how == EXPLO_CLEAR)
             {
-                des.bits.dig = df::tile_dig_designation::No;
+                des.bits.dig = tile_dig_designation::No;
                 continue;
             }
             if(dm[y][x])
             {
                 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.dig = df::tile_dig_designation::Default;
+                    des.bits.dig = tile_dig_designation::Default;
                 }
             }
             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;
 };
 
@@ -828,7 +827,8 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
     }
     if(force_help || how == EXPLO_NOTHING)
     {
-        c->con.print("This command can be used for exploratory mining.\n"
+        c->con.print(
+            "This command can be used for exploratory mining.\n"
             "http://df.magmawiki.com/index.php/DF2010:Exploratory_mining\n"
             "\n"
             "There are two variables that can be set: pattern and filter.\n"
@@ -850,20 +850,18 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
             );
         return CR_OK;
     }
-    c->Suspend();
+    CoreSuspender suspend(c);
     Gui * gui = c->getGui();
     uint32_t x_max, y_max, z_max;
     if (!Maps::IsValid())
     {
         c->con.printerr("Map is not available!\n");
-        c->Resume();
         return CR_FAILURE;
     }
     Maps::getSize(x_max,y_max,z_max);
     int32_t xzzz,yzzz,z_level;
     if(!gui->getViewCoords(xzzz,yzzz,z_level))
     {
-        c->Resume();
         c->con.printerr("Can't get view coords...\n");
         return CR_FAILURE;
     }
@@ -939,7 +937,7 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
                     continue;
                 if(cross[y][x])
                 {
-                    des.bits.dig = df::tile_dig_designation::Default;
+                    des.bits.dig = tile_dig_designation::Default;
                     mx.setDesignationAt(pos,des);
                 }
             }
@@ -953,7 +951,6 @@ DFhackCExport command_result expdig (Core * c, vector <string> & parameters)
                 how, what, x_max, y_max);
         }
     }
-    c->Resume();
     return CR_OK;
 }
 
@@ -1090,32 +1087,32 @@ DFhackCExport command_result vdig (Core * c, vector <string> & parameters)
                 {
                     flood.push(current-1);
 
-                    if(des_minus.bits.dig == df::tile_dig_designation::DownStair)
-                        des_minus.bits.dig = df::tile_dig_designation::UpDownStair;
+                    if(des_minus.bits.dig == tile_dig_designation::DownStair)
+                        des_minus.bits.dig = tile_dig_designation::UpDownStair;
                     else
-                        des_minus.bits.dig = df::tile_dig_designation::UpStair;
+                        des_minus.bits.dig = tile_dig_designation::UpStair;
                     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)
                 {
                     flood.push(current+ 1);
 
-                    if(des_plus.bits.dig == df::tile_dig_designation::UpStair)
-                        des_plus.bits.dig = df::tile_dig_designation::UpDownStair;
+                    if(des_plus.bits.dig == tile_dig_designation::UpStair)
+                        des_plus.bits.dig = tile_dig_designation::UpDownStair;
                     else
-                        des_plus.bits.dig = df::tile_dig_designation::DownStair;
+                        des_plus.bits.dig = tile_dig_designation::DownStair;
                     MCache->setDesignationAt(current+1,des_plus);
 
-                    if(des.bits.dig == df::tile_dig_designation::DownStair)
-                        des.bits.dig = df::tile_dig_designation::UpDownStair;
+                    if(des.bits.dig == tile_dig_designation::DownStair)
+                        des.bits.dig = tile_dig_designation::UpDownStair;
                     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)
-                des.bits.dig = df::tile_dig_designation::Default;
+            if(des.bits.dig == tile_dig_designation::No)
+                des.bits.dig = tile_dig_designation::Default;
             MCache->setDesignationAt(current,des);
         }
     }

plugins/weather.cpp

@@ -81,12 +81,12 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
         return CR_FAILURE;
     }
     bool something = lock || unlock || rain || snow || clear;
-    c->Suspend();
+
+    CoreSuspender suspend(c);
     DFHack::World * w = c->getWorld();
     if(!w->wmap)
     {
         con << "Weather support seems broken :(" << std::endl;
-        c->Resume();
         return CR_FAILURE;
     }
     if(!something)
@@ -99,13 +99,13 @@ DFhackCExport command_result weather (Core * c, vector <string> & parameters)
             {
                 switch((*w->wmap)[x][y])
                 {
-                    case DFHack::CLEAR:
+                case CLEAR:
                     con << "C ";
                     break;
-                    case DFHack::RAINING:
+                case RAINING:
                     con << "R ";
                     break;
-                    case DFHack::SNOWING:
+                case SNOWING:
                     con << "S ";
                     break;
                 default:
@@ -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.
     }
-    c->Resume();
     return CR_OK;
 }