- schematic

Copies a box of MapNodes from a specified schematic file (or raw description). Can specify a

probability of a node randomly appearing when placed. This decoration type is intended to be used

for multi-node sized discrete structures, such as trees, cave spikes, rocks, and so on.

Schematic specifier

--------------------

A schematic specifier identifies a schematic by either a filename to a Minetest Schematic file (.mts)

or through raw data supplied through Lua, in the form of a table. This table must specify two fields:

- The 'size' field is a 3d vector containing the dimensions of the provided schematic.

- The 'data' field is a flat table of MapNodes making up the schematic, in the order of [z [y [x]]].

In the bulk MapNode data, param1, instead of the typical light values, instead represents the

probability of that node appearing in the structure. It is an integer with a value from 0-255; 0 means

that node will always appear. If the probability value p is non-zero, then there is a

(p / 256 * 100)% chance that node will appear when the schematic is placed on the map.

Important note: Node aliases cannot be used for a raw schematic provided when registering as a decoration.

Schematic attributes

-----------------

Currently supported flags: place_center_x, place_center_y, place_center_z

- place_center_x

Placement of this decoration is centered along the X axis.

- place_center_y

Placement of this decoration is centered along the Y axis.

- place_center_z

Placement of this decoration is centered along the Z axis.

minetest.add_to_creative_inventory(itemstring)

Schematics:

minetest.create_schematic(p1, p2, probability_list, filename)

^ Create a schematic from the volume of map specified by the box formed by p1 and p2.

^ Apply the specified probability values to the specified nodes in probability_list.

^ probability_list is an array of tables containing two fields, pos and prob.

^ pos is the 3d vector specifying the absolute coordinates of the node being modified,

^ and prob is the integer value from 0 to 255 of the probability (see: Schematic specifier).

^ If there are two or more entries with the same pos value, the last occuring in the array is used.

^ If pos is not inside the box formed by p1 and p2, it is ignored.

^ If probability_list is nil, no probabilities are applied.

^ Saves schematic in the Minetest Schematic format to filename.

minetest.place_schematic(pos, schematic)

^ Place the schematic specified by schematic (see: Schematic specifier) at pos.

Deprecated but defined for backwards compatibility:

minetest.digprop_constanttime(time)

minetest.digprop_stonelike(toughness)

minetest.digprop_dirtlike(toughness)

minetest.digprop_gravellike(toughness)

minetest.digprop_woodlike(toughness)

minetest.digprop_leaveslike(toughness)

minetest.digprop_glasslike(toughness)

----- Schematic-type parameters

schematic = "foobar.mts",

^ If schematic is a string, it is the filepath relative to the current working directory of the

^ specified Minetest schematic file.

^ - OR -, could instead be a table containing two fields, size and data:

schematic = {size = {x=4, y=6, z=4}, data = { {"cobble", 0, 0}, {"dirt_with_grass", 0, 0}, ...}},

^ See 'Schematic specifier' for details.

flags = "place_center_x, place_center_z",

^ Flags for schematic decorations. See 'Schematic attributes'.

#include "util/serialize.h"

FlagDesc flagdesc_deco_schematic[] = {

{"place_center_x", DECO_PLACE_CENTER_X},

{"place_center_y", DECO_PLACE_CENTER_Y},

{"place_center_z", DECO_PLACE_CENTER_Z},

{NULL, 0}

};

case DECO_SCHEMATIC:

return new DecoSchematic;

Decoration::Decoration() {

mapseed = 0;

np = NULL;

fill_ratio = 0;

sidelen = 1;

}

<< deco_name << "' not defined" << std::endl;

<< deco_name << "' not defined" << std::endl;

<< decolist_names[i] << "' not defined" << std::endl;

void DecoSimple::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y,

s16 start_y, v3s16 p) {

DecoSchematic::DecoSchematic() {

node_names = NULL;

schematic = NULL;

flags = 0;

size = v3s16(0, 0, 0);

}

DecoSchematic::~DecoSchematic() {

delete node_names;

delete []schematic;

}

void DecoSchematic::resolveNodeNames(INodeDefManager *ndef) {

Decoration::resolveNodeNames(ndef);

if (filename.empty())

return;

if (!node_names) {

errorstream << "DecoSchematic::resolveNodeNames: node name list was "

"not created" << std::endl;

return;

}

for (size_t i = 0; i != node_names->size(); i++) {

content_t c = ndef->getId(node_names->at(i));

if (c == CONTENT_IGNORE) {

errorstream << "DecoSchematic::resolveNodeNames: node '"

<< node_names->at(i) << "' not defined" << std::endl;

c = CONTENT_AIR;

}

c_nodes.push_back(c);

}

for (int i = 0; i != size.X * size.Y * size.Z; i++)

schematic[i].setContent(c_nodes[schematic[i].getContent()]);

delete node_names;

node_names = NULL;

}

void DecoSchematic::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y,

s16 start_y, v3s16 p) {

ManualMapVoxelManipulator *vm = mg->vm;

if (flags & DECO_PLACE_CENTER_X)

p.X -= (size.X + 1) / 2;

if (flags & DECO_PLACE_CENTER_Y)

p.Y -= (size.Y + 1) / 2;

if (flags & DECO_PLACE_CENTER_Z)

p.Z -= (size.Z + 1) / 2;

u32 vi = vm->m_area.index(p);

if (vm->m_data[vi].getContent() != c_place_on &&

c_place_on != CONTENT_IGNORE)

return;

u32 i = 0;

for (s16 z = 0; z != size.Z; z++)

for (s16 y = 0; y != size.Y; y++) {

vi = vm->m_area.index(p.X, p.Y + y, p.Z + z);

for (s16 x = 0; x != size.X; x++, i++, vi++) {

if (!vm->m_area.contains(vi))

continue;

content_t c = vm->m_data[vi].getContent();

if (c != CONTENT_AIR && c != CONTENT_IGNORE)

continue;

if (schematic[i].param1 && myrand_range(1, 256) > schematic[i].param1)

continue;

vm->m_data[vi] = schematic[i];

vm->m_data[vi].param1 = 0;

}

}

}

int DecoSchematic::getHeight() {

return size.Y;

}

std::string DecoSchematic::getName() {

return filename;

}

void DecoSchematic::placeStructure(Map *map, v3s16 p) {

assert(schematic != NULL);

ManualMapVoxelManipulator *vm = new ManualMapVoxelManipulator(map);

if (flags & DECO_PLACE_CENTER_X)

p.X -= (size.X + 1) / 2;

if (flags & DECO_PLACE_CENTER_Y)

p.Y -= (size.Y + 1) / 2;

if (flags & DECO_PLACE_CENTER_Z)

p.Z -= (size.Z + 1) / 2;

v3s16 bp1 = getNodeBlockPos(p);

v3s16 bp2 = getNodeBlockPos(p + size - v3s16(1,1,1));

vm->initialEmerge(bp1, bp2);

u32 i = 0;

for (s16 z = 0; z != size.Z; z++)

for (s16 y = 0; y != size.Y; y++) {

u32 vi = vm->m_area.index(p.X, p.Y + y, p.Z + z);

for (s16 x = 0; x != size.X; x++, i++, vi++) {

if (!vm->m_area.contains(vi))

continue;

if (schematic[i].param1 && myrand_range(1, 256) > schematic[i].param1)

continue;

vm->m_data[vi] = schematic[i];

vm->m_data[vi].param1 = 0;

}

}

std::map<v3s16, MapBlock *> lighting_modified_blocks;

std::map<v3s16, MapBlock *> modified_blocks;

vm->blitBackAll(&modified_blocks);

// TODO: Optimize this by using Mapgen::calcLighting() instead

lighting_modified_blocks.insert(modified_blocks.begin(), modified_blocks.end());

map->updateLighting(lighting_modified_blocks, modified_blocks);

MapEditEvent event;

event.type = MEET_OTHER;

for (std::map<v3s16, MapBlock *>::iterator

it = modified_blocks.begin();

it != modified_blocks.end(); ++it)

event.modified_blocks.insert(it->first);

map->dispatchEvent(&event);

}

bool DecoSchematic::loadSchematicFile() {

std::ifstream is(filename.c_str(), std::ios_base::binary);

u32 signature = readU32(is);

if (signature != 'MTSM') {

errorstream << "loadSchematicFile: invalid schematic "

"file" << std::endl;

return false;

}

u16 version = readU16(is);

if (version != 1) {

errorstream << "loadSchematicFile: unsupported schematic "

"file version" << std::endl;

return false;

}

size = readV3S16(is);

int nodecount = size.X * size.Y * size.Z;

u16 nidmapcount = readU16(is);

node_names = new std::vector<std::string>;

for (int i = 0; i != nidmapcount; i++) {

std::string name = deSerializeString(is);

node_names->push_back(name);

}

delete schematic;

schematic = new MapNode[nodecount];

MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST, schematic,

nodecount, 2, 2, true);

return true;

}

void DecoSchematic::saveSchematicFile(INodeDefManager *ndef) {

std::ofstream os(filename.c_str(), std::ios_base::binary);

writeU32(os, 'MTSM'); // signature

writeU16(os, 1); // version

writeV3S16(os, size); // schematic size

std::vector<content_t> usednodes;

int nodecount = size.X * size.Y * size.Z;

build_nnlist_and_update_ids(schematic, nodecount, &usednodes);

u16 numids = usednodes.size();

writeU16(os, numids); // name count

for (int i = 0; i != numids; i++)

os << serializeString(ndef->get(usednodes[i]).name); // node names

// compressed bulk node data

MapNode::serializeBulk(os, SER_FMT_VER_HIGHEST, schematic,

nodecount, 2, 2, true);

}

void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,

std::vector<content_t> *usednodes) {

std::map<content_t, content_t> nodeidmap;

content_t numids = 0;

for (u32 i = 0; i != nodecount; i++) {

content_t id;

content_t c = nodes[i].getContent();

std::map<content_t, content_t>::const_iterator it = nodeidmap.find(c);

if (it == nodeidmap.end()) {

id = numids;

numids++;

usednodes->push_back(c);

nodeidmap.insert(std::make_pair(c, id));

} else {

id = it->second;

}

nodes[i].setContent(id);

}

}

bool DecoSchematic::getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2) {

ManualMapVoxelManipulator *vm = new ManualMapVoxelManipulator(map);

v3s16 bp1 = getNodeBlockPos(p1);

v3s16 bp2 = getNodeBlockPos(p2);

vm->initialEmerge(bp1, bp2);

size = p2 - p1 + 1;

schematic = new MapNode[size.X * size.Y * size.Z];

u32 i = 0;

for (s16 z = p1.Z; z <= p2.Z; z++)

for (s16 y = p1.Y; y <= p2.Y; y++) {

u32 vi = vm->m_area.index(p1.X, y, z);

for (s16 x = p1.X; x <= p2.X; x++, i++, vi++) {

schematic[i] = vm->m_data[vi];

schematic[i].param1 = 0;

}

}

delete vm;

return true;

}

void DecoSchematic::applyProbabilities(std::vector<std::pair<v3s16, u8> > *plist, v3s16 p0) {

for (size_t i = 0; i != plist->size(); i++) {

v3s16 p = (*plist)[i].first - p0;

int index = p.Z * (size.Y * size.X) + p.Y * size.X + p.X;

if (index < size.Z * size.Y * size.X)

schematic[index].param1 = (*plist)[i].second;

}

}

#define DECO_PLACE_CENTER_X 1

#define DECO_PLACE_CENTER_Y 2

#define DECO_PLACE_CENTER_Z 4

extern FlagDesc flagdesc_deco_schematic[];

class Map;

Decoration();

std::string filename;

std::vector<std::string> *node_names;

std::vector<content_t> c_nodes;

u32 flags;

v3s16 size;

MapNode *schematic;

DecoSchematic();

~DecoSchematic();

void resolveNodeNames(INodeDefManager *ndef);

virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y,

s16 start_y, v3s16 p);

virtual int getHeight();

virtual std::string getName();

bool loadSchematicFile();

void saveSchematicFile(INodeDefManager *ndef);

bool getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2);

void placeStructure(Map *map, v3s16 p);

void applyProbabilities(std::vector<std::pair<v3s16, u8> > *plist, v3s16 p0);

void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,

std::vector<content_t> *usednodes);

#include "mapgen.h"

bool read_schematic(lua_State *L, int index, DecoSchematic *dschem, Server *server) {

if (index < 0)

index = lua_gettop(L) + 1 + index;

INodeDefManager *ndef = server->getNodeDefManager();

if (lua_istable(L, index)) {

lua_getfield(L, index, "size");

v3s16 size = read_v3s16(L, -1);

lua_pop(L, 1);

int numnodes = size.X * size.Y * size.Z;

MapNode *schemdata = new MapNode[numnodes];

int i = 0;

lua_getfield(L, index, "data");

luaL_checktype(L, -1, LUA_TTABLE);

lua_pushnil(L);

while (lua_next(L, -2)) {

if (i < numnodes)

schemdata[i] = readnode(L, -1, ndef);

i++;

lua_pop(L, 1);

}

dschem->size = size;

dschem->schematic = schemdata;

if (i != numnodes) {

errorstream << "read_schematic: incorrect number of "

"nodes provided in raw schematic data (got " << i <<

", expected " << numnodes << ")." << std::endl;

return false;

}

} else if (lua_isstring(L, index)) {

dschem->filename = std::string(lua_tostring(L, index));