Class cuboid

library/include/modules/Maps.h:182–242

* Utility class representing a cuboid of df::coord. * \ingroup grp_maps */

 * \ingroup grp_maps
 */
class cuboid {
    public:
    // Bounds
    int16_t x_min = -1;
    int16_t x_max = -1;
    int16_t y_min = -1;
    int16_t y_max = -1;
    int16_t z_min = -1;
    int16_t z_max = -1;

    // Default constructor.
    DFHACK_EXPORT cuboid() {}

    // Construct from two corners.
    DFHACK_EXPORT cuboid(int16_t x1, int16_t y1, int16_t z1, int16_t x2, int16_t y2, int16_t z2);
    DFHACK_EXPORT cuboid(const df::coord &p1, const df::coord &p2) : cuboid(p1.x, p1.y, p1.z, p2.x, p2.y, p2.z) {}

    // Construct as single tile.
    DFHACK_EXPORT cuboid(int16_t x, int16_t y, int16_t z);
    DFHACK_EXPORT cuboid(const df::coord &p) : cuboid(p.x, p.y, p.z) {}

    // Construct from map block.
    DFHACK_EXPORT cuboid(const df::map_block *block);

    // Valid cuboid? True if all max >= min >= 0.
    DFHACK_EXPORT bool isValid() const;

    // Clear cuboid dimensions, making it invalid.
    DFHACK_EXPORT void clear() { x_min = x_max = y_min = y_max = z_min = z_max = -1; }

    // Clamp this cuboid within another cuboid. Invalid result implies no intersection or invalid input.
    DFHACK_EXPORT cuboid clamp(const cuboid &other);

    // Return a new cuboid representing overlapping volume. Invalid result implies no intersection or invalid input.
    DFHACK_EXPORT cuboid clampNew(const cuboid &other) const { return cuboid(*this).clamp(other); }

    /// Clamp this cuboid within map area. Invalid result implies no intersection or invalid input (e.g., no map).
    /// Can optionally treat cuboid as map blocks instead of tiles.
    /// Note: A point being in map area isn't sufficient to know that a tile block is allocated there!
    DFHACK_EXPORT cuboid clampMap(bool block = false);

    // Expand cuboid to include point. Returns true if bounds changed. Fails if x/y/z < 0.
    DFHACK_EXPORT bool addPos(int16_t x, int16_t y, int16_t z);
    DFHACK_EXPORT bool addPos(const df::coord &pos) { return addPos(pos.x, pos.y, pos.z); }

    // Return true if point inside cuboid. Make sure cuboid is valid first!
    DFHACK_EXPORT bool containsPos(int16_t x, int16_t y, int16_t z) const;
    DFHACK_EXPORT bool containsPos(const df::coord &pos) const { return containsPos(pos.x, pos.y, pos.z); }

    /// Iterate over every point in the cuboid. Doesn't guarantee valid map tile!
    /// "fn" should return true to keep iterating. Won't iterate if cuboid invalid.
    /// If row_major is false, iterates from top-down (z), N-S (y), then W-E (x).
    /// If row_major is true, iterates from top-down (z), W-E (x), then N-S (y).
    DFHACK_EXPORT void forCoord(std::function<bool(df::coord)> fn, bool row_major = false) const;

    /// Iterate over every non-NULL map block intersecting the tile cuboid from top-down, N-S, then W-E.
    /// Will also supply the intersection of this cuboid and block to your "fn" for use with cuboid::forCoord.
    /// Can optionally attempt to create map blocks if they aren't allocated.