Expose new MapCache features in probe and tiletypes.

2013-10-05 20:53:43 +04:00 · 2013-10-05 20:53:43 +04:00 · 6852adbd91
parent 63d8267606
commit 6852adbd91
4 changed files with 128 additions and 7 deletions
--- a/4
+++ b/4
@ -1,8 +1,11 @@
 DFHack future

+  Internals:
+    - Lua API for a better random number generator and perlin noise functions.
  New commands:
    - restrictliquid - Restrict traffic on every visible square with liquid.
    - restrictice - Restrict traffic on squares above visible ice.
+    - enable, disable - Built-in commands that can be used to enable/disable many plugins.
  New scripts:
    - masspit: designate caged creatures in a zone for pitting
    - locate_ore: scan the map for unmined ore veins
@ -15,6 +18,7 @@ DFHack future
    - ruby: add df.dfhack_run "somecommand"
    - magmasource: rename to 'source', allow water/magma sources/drains
    - core: fix SC_WORLD_(UN)LOADED event for arena mode
+    - tiletypes: support changing tile material to arbitrary stone.
  New tweaks:
    - hive-crash: Prevent crash if bees die in a hive with ungathered products (bug 6368).
  New plugins:
--- a/Readme.rst
+++ b/Readme.rst
@ -576,6 +576,33 @@ Or this:

 This will hide previously revealed tiles (or show hidden with the 0 option).

+More recently, the tool supports changing the base material of the tile to
+an arbitrary stone from the raws, by creating new veins as required. Note
+that this mode paints under ice and constructions, instead of overwriting
+them. To enable, use:
+
+::
+
+        paint stone MICROCLINE
+
+This mode is incompatible with the regular ``material`` setting, so changing
+it cancels the specific stone selection:
+
+::
+
+        paint material ANY
+
+Since different vein types have different drop rates, it is possible to choose
+which one to use in painting:
+
+::
+
+        paint veintype CLUSTER_SMALL
+
+When the chosen type is ``CLUSTER`` (the default), the tool may automatically
+choose to use layer stone or lava stone instead of veins if its material matches
+the desired one.
+
 Any paint or filter option (or the entire paint or filter) can be disabled entirely by using the ANY keyword:

 ::  
--- a/plugins/probe.cpp
+++ b/plugins/probe.cpp
@ -263,6 +263,9 @@ command_result df_probe (color_ostream &out, vector <string> & parameters)
            out << " / " << inorganic[vein_rock].id
                << " / "
                << inorganic[vein_rock].name
+                << " ("
+                << ENUM_KEY_STR(inclusion_type,b->veinTypeAt(cursor))
+                << ")"
                << endl;
        else
            out << endl;
--- a/plugins/tiletypes.cpp
+++ b/plugins/tiletypes.cpp
@ -97,6 +97,8 @@ void help( color_ostream & out, std::vector<std::string> &commands, int start, i
            << " Subterranean / st: set subterranean flag" << std::endl
            << " Skyview / sv: set skyview flag" << std::endl
            << " Aquifer / aqua: set aquifer flag" << std::endl
+            << " Stone: paint specific stone material" << std::endl
+            << " Veintype: use specific vein type for stone" << std::endl
            << "See help [option] for more information" << std::endl;
    }
    else if (option == "shape" || option == "s" ||option == "sh")
@ -165,6 +167,22 @@ void help( color_ostream & out, std::vector<std::string> &commands, int start, i
        out << "Available aquifer flags:" << std::endl
            << " ANY, 0, 1" << std::endl;
    }
+    else if (option == "stone")
+    {
+        out << "The stone option allows painting any specific stone material." << std::endl
+            << "The normal 'material' option is forced to STONE, and cannot" << std::endl
+            << "be changed without cancelling the specific stone selection." << std::endl
+            << "Note: this feature paints under ice and constructions," << std::endl
+            << "instead of replacing them with brute force." << std::endl;
+    }
+    else if (option == "veintype")
+    {
+        out << "Specifies which vein type to use when painting specific stone." << std::endl
+            << "The vein type determines stone drop rate. Available types:" << std::endl;
+        FOR_ENUM_ITEMS(inclusion_type,i)
+            out << " " << ENUM_KEY_STR(inclusion_type,i) << std::endl;
+        out << "Vein type other than CLUSTER forces creation of a vein." << std::endl;
+    }
 }

 struct TileType
@ -179,6 +197,8 @@ struct TileType
    int subterranean;
    int skyview;
    int aquifer;
+    int stone_material;
+    df::inclusion_type vein_type;

    TileType()
    {
@ -197,20 +217,26 @@ struct TileType
        subterranean = -1;
        skyview = -1;
        aquifer = -1;
+        stone_material = -1;
+        vein_type = inclusion_type::CLUSTER;
    }

    bool empty()
    {
        return shape == -1 && material == -1 && special == -1 && variant == -1
            && dig == -1 && hidden == -1 && light == -1 && subterranean == -1
-            && skyview == -1 && aquifer == -1;
+            && skyview == -1 && aquifer == -1 && stone_material == -1;
    }

    inline bool matches(const df::tiletype source,
-                        const df::tile_designation des)
+                        const df::tile_designation des,
+                        const t_matpair mat)
    {
        bool rv = true;
        rv &= (shape == -1 || shape == tileShape(source));
+        if (stone_material >= 0)
+            rv &= isStoneMaterial(source) && mat.mat_type == 0 && mat.mat_index == stone_material;
+        else
            rv &= (material == -1 || material == tileMaterial(source));
        rv &= (special == -1 || special == tileSpecial(source));
        rv &= (variant == -1 || variant == tileVariant(source));
@ -353,6 +379,20 @@ std::ostream &operator<<(std::ostream &stream, const TileType &paint)
        needSpace = true;
    }

+    if (paint.stone_material >= 0)
+    {
+        if (needSpace)
+        {
+            stream << " ";
+            needSpace = false;
+        }
+
+        stream << MaterialInfo(0,paint.stone_material).getToken()
+               << " " << ENUM_KEY_STR(inclusion_type, paint.vein_type);
+        used = true;
+        needSpace = true;
+    }
+
    if (!used)
    {
        stream << "any";
@ -497,6 +537,9 @@ bool processTileType(color_ostream & out, TileType &paint, std::vector<std::stri
    }
    else if (option == "material" || option == "mat" || option == "m")
    {
+        // Setting the material conflicts with stone_material
+        paint.stone_material = -1;
+
        if (is_valid_enum_item((df::tiletype_material)valInt))
        {
            paint.material = (df::tiletype_material)valInt;
@ -630,6 +673,25 @@ bool processTileType(color_ostream & out, TileType &paint, std::vector<std::stri

        found = true;
    }
+    else if (option == "stone")
+    {
+        MaterialInfo mat;
+
+        if (!mat.findInorganic(value))
+            out << "Unknown inorganic material: " << value << std::endl;
+        else if (!isStoneInorganic(mat.index))
+            out << "Not a stone material: " << value << std::endl;
+        else
+        {
+            paint.material = tiletype_material::STONE;
+            paint.stone_material = mat.index;
+        }
+    }
+    else if (option == "veintype")
+    {
+        if (!find_enum_item(&paint.vein_type, value))
+            out << "Unknown vein type: " << value << std::endl;
+    }
    else
    {
        out << "Unknown option: '" << option << "'" << std::endl;
@ -672,12 +734,24 @@ command_result executePaintJob(color_ostream &out)
    // Force the game to recompute its walkability cache
    df::global::world->reindex_pathfinding = true;

+    int failures = 0;
+
    for (coord_vec::iterator iter = all_tiles.begin(); iter != all_tiles.end(); ++iter)
    {
-        const df::tiletype source = map.tiletypeAt(*iter);
+        MapExtras::Block *blk = map.BlockAtTile(*iter);
+        if (!blk)
+            continue;
+
+        df::tiletype source = map.tiletypeAt(*iter);
        df::tile_designation des = map.designationAt(*iter);

-        if (!filter.matches(source, des))
+        // Stone painting operates on the base layer
+        if (paint.stone_material >= 0)
+            source = blk->baseTiletypeAt(*iter);
+
+        t_matpair basemat = blk->baseMaterialAt(*iter);
+
+        if (!filter.matches(source, des, basemat))
        {
            continue;
        }
@ -725,7 +799,7 @@ command_result executePaintJob(color_ostream &out)
        */
        // Remove direction from directionless tiles
        DFHack::TileDirection direction = tileDirection(source);
-        if (!(material == tiletype_material::RIVER || shape == tiletype_shape::BROOK_BED || shape == tiletype_shape::WALL && (material == tiletype_material::CONSTRUCTION || special == tiletype_special::SMOOTH)))
+        if (!(material == tiletype_material::RIVER || shape == tiletype_shape::BROOK_BED || special == tiletype_special::TRACK || shape == tiletype_shape::WALL && (material == tiletype_material::CONSTRUCTION || special == tiletype_special::SMOOTH)))
        {
            direction.whole = 0;
        }
@ -738,7 +812,15 @@ command_result executePaintJob(color_ostream &out)
        }
        // make sure it's not invalid
        if(type != tiletype::Void)
+        {
+            if (paint.stone_material >= 0)
+            {
+                if (!blk->setStoneAt(*iter, type, paint.stone_material, paint.vein_type, true, true))
+                    failures++;
+            }
+            else
                map.setTiletypeAt(*iter, type);
+        }

        if (paint.hidden > -1)
        {
@ -780,6 +862,11 @@ command_result executePaintJob(color_ostream &out)
        map.setDesignationAt(*iter, des);
    }

+    if (failures > 0)
+        out.printerr("Could not update %d tiles of %d.\n", failures, all_tiles.size());
+    else
+        out.print("Processed %d tiles.\n", all_tiles.size());
+
    if (map.WriteAll())
    {
        out.print("OK\n");