aboutsummaryrefslogtreecommitdiff
path: root/src/mg_schematic.h
blob: 9d4d4a71681e262ba2d4bd3320b119e1f29ad0e6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/*
Minetest
Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef MG_SCHEMATIC_HEADER
#define MG_SCHEMATIC_HEADER

#include <map>
#include "mg_decoration.h"
#include "util/string.h"

class Map;
class Mapgen;
class ManualMapVoxelManipulator;
class PseudoRandom;
class NodeResolver;

/////////////////// Schematic flags
#define SCHEM_CIDS_UPDATED 0x08


#define MTSCHEM_FILE_SIGNATURE 0x4d54534d // 'MTSM'
#define MTSCHEM_FILE_VER_HIGHEST_READ  3
#define MTSCHEM_FILE_VER_HIGHEST_WRITE 3

#define MTSCHEM_PROB_NEVER  0x00
#define MTSCHEM_PROB_ALWAYS 0xFF


class Schematic : public GenElement {
public:
	std::vector<content_t> c_nodes;

	u32 flags;
	v3s16 size;
	MapNode *schemdata;
	u8 *slice_probs;

	Schematic();
	~Schematic();

	void updateContentIds();

	void blitToVManip(v3s16 p, ManualMapVoxelManipulator *vm,
		Rotation rot, bool force_placement, INodeDefManager *ndef);

	bool loadSchematicFromFile(const char *filename, NodeResolver *resolver,
		std::map<std::string, std::string> &replace_names);
	void saveSchematicToFile(const char *filename, INodeDefManager *ndef);
	bool getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2);

	void placeStructure(Map *map, v3s16 p, u32 flags,
		Rotation rot, bool force_placement, INodeDefManager *nef);
	void applyProbabilities(v3s16 p0,
		std::vector<std::pair<v3s16, u8> > *plist,
		std::vector<std::pair<s16, u8> > *splist);
};

class SchematicManager : public GenElementManager {
public:
	static const char *ELEMENT_TITLE;
	static const size_t ELEMENT_LIMIT = 0x10000;

	SchematicManager(IGameDef *gamedef) {}
	~SchematicManager() {}

	Schematic *create(int type)
	{
		return new Schematic;
	}
};

void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,
					std::vector<content_t> *usednodes);


#endif
k_idx] = block; m_lookup_state_bitset = 1 << block_idx; // Scan the columns in the block for (s16 z = 0; z < MAP_BLOCKSIZE; z++) for (s16 x = 0; x < MAP_BLOCKSIZE; x++) { scanColumn(x, z); } // Scan neighbouring columns from the nearby blocks as they might contain // liquid nodes that weren't allowed to flow to prevent gaps. for (s16 i = 0; i < MAP_BLOCKSIZE; i++) { scanColumn(i, -1); scanColumn(i, MAP_BLOCKSIZE); scanColumn(-1, i); scanColumn(MAP_BLOCKSIZE, i); } } inline MapBlock *ReflowScan::lookupBlock(int x, int y, int z) { // Gets the block that contains (x,y,z) relativ to the scanned block. // This uses a lookup as there might be many lookups into the same // neighbouring block which makes fetches from Map costly. int bx = (MAP_BLOCKSIZE + x) / MAP_BLOCKSIZE; int by = (MAP_BLOCKSIZE + y) / MAP_BLOCKSIZE; int bz = (MAP_BLOCKSIZE + z) / MAP_BLOCKSIZE; int idx = (bx + (by * 9) + (bz * 3)); MapBlock *result = m_lookup[idx]; if (!result && (m_lookup_state_bitset & (1 << idx)) == 0) { // The block wasn't requested yet so fetch it from Map and store it // in the lookup v3s16 pos = m_block_pos + v3s16(bx - 1, by - 1, bz - 1); m_lookup[idx] = result = m_map->getBlockNoCreateNoEx(pos); m_lookup_state_bitset |= (1 << idx); } return result; } inline bool ReflowScan::isLiquidFlowableTo(int x, int y, int z) { // Tests whether (x,y,z) is a node to which liquid might flow. bool valid_position; MapBlock *block = lookupBlock(x, y, z); if (block) { int dx = (MAP_BLOCKSIZE + x) % MAP_BLOCKSIZE; int dy = (MAP_BLOCKSIZE + y) % MAP_BLOCKSIZE; int dz = (MAP_BLOCKSIZE + z) % MAP_BLOCKSIZE; MapNode node = block->getNodeNoCheck(dx, dy, dz, &valid_position); if (node.getContent() != CONTENT_IGNORE) { const ContentFeatures &f = m_ndef->get(node); // NOTE: No need to check for flowing nodes with lower liquid level // as they should only occur on top of other columns where they // will be added to the queue themselves. return f.floodable; } } return false; } inline bool ReflowScan::isLiquidHorizontallyFlowable(int x, int y, int z) { // Check if the (x,y,z) might spread to one of the horizontally // neighbouring nodes return isLiquidFlowableTo(x - 1, y, z) || isLiquidFlowableTo(x + 1, y, z) || isLiquidFlowableTo(x, y, z - 1) || isLiquidFlowableTo(x, y, z + 1); } void ReflowScan::scanColumn(int x, int z) { bool valid_position; // Is the column inside a loaded block? MapBlock *block = lookupBlock(x, 0, z); if (!block) return; MapBlock *above = lookupBlock(x, MAP_BLOCKSIZE, z); int dx = (MAP_BLOCKSIZE + x) % MAP_BLOCKSIZE; int dz = (MAP_BLOCKSIZE + z) % MAP_BLOCKSIZE; // Get the state from the node above the scanned block bool was_ignore, was_liquid; if (above) { MapNode node = above->getNodeNoCheck(dx, 0, dz, &valid_position); was_ignore = node.getContent() == CONTENT_IGNORE; was_liquid = m_ndef->get(node).isLiquid(); } else { was_ignore = true; was_liquid = false; } bool was_checked = false; bool was_pushed = false; // Scan through the whole block for (s16 y = MAP_BLOCKSIZE - 1; y >= 0; y--) { MapNode node = block->getNodeNoCheck(dx, y, dz, &valid_position); const ContentFeatures &f = m_ndef->get(node); bool is_ignore = node.getContent() == CONTENT_IGNORE; bool is_liquid = f.isLiquid(); if (is_ignore || was_ignore || is_liquid == was_liquid) { // Neither topmost node of liquid column nor topmost node below column was_checked = false; was_pushed = false; } else if (is_liquid) { // This is the topmost node in the column bool is_pushed = false; if (f.liquid_type == LIQUID_FLOWING || isLiquidHorizontallyFlowable(x, y, z)) { m_liquid_queue->push_back(m_rel_block_pos + v3s16(x, y, z)); is_pushed = true; } // Remember waschecked and waspushed to avoid repeated // checks/pushes in case the column consists of only this node was_checked = true; was_pushed = is_pushed; } else { // This is the topmost node below a liquid column if (!was_pushed && (f.floodable || (!was_checked && isLiquidHorizontallyFlowable(x, y + 1, z)))) { // Activate the lowest node in the column which is one // node above this one m_liquid_queue->push_back(m_rel_block_pos + v3s16(x, y + 1, z)); } } was_liquid = is_liquid; was_ignore = is_ignore; } // Check the node below the current block MapBlock *below = lookupBlock(x, -1, z); if (below) { MapNode node = below->getNodeNoCheck(dx, MAP_BLOCKSIZE - 1, dz, &valid_position); const ContentFeatures &f = m_ndef->get(node); bool is_ignore = node.getContent() == CONTENT_IGNORE; bool is_liquid = f.isLiquid(); if (is_ignore || was_ignore || is_liquid == was_liquid) { // Neither topmost node of liquid column nor topmost node below column } else if (is_liquid) { // This is the topmost node in the column and might want to flow away if (f.liquid_type == LIQUID_FLOWING || isLiquidHorizontallyFlowable(x, -1, z)) { m_liquid_queue->push_back(m_rel_block_pos + v3s16(x, -1, z)); } } else { // This is the topmost node below a liquid column if (!was_pushed && (f.floodable || (!was_checked && isLiquidHorizontallyFlowable(x, 0, z)))) { // Activate the lowest node in the column which is one // node above this one m_liquid_queue->push_back(m_rel_block_pos + v3s16(x, 0, z)); } } } }