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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/*
Minetest
Copyright (C) 2016 MillersMan <millersman@users.noreply.github.com>
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.
*/
#include "reflowscan.h"
#include "map.h"
#include "mapblock.h"
#include "nodedef.h"
#include "util/timetaker.h"
#include "util/cpp11.h"
ReflowScan::ReflowScan(Map *map, INodeDefManager *ndef) :
m_map(map),
m_ndef(ndef),
m_liquid_queue(nullptr)
{
}
void ReflowScan::scan(MapBlock *block, UniqueQueue<v3s16> *liquid_queue)
{
m_block_pos = block->getPos();
m_rel_block_pos = block->getPosRelative();
m_liquid_queue = liquid_queue;
// Prepare the lookup which is a 3x3x3 array of the blocks surrounding the
// scanned block. Blocks are only added to the lookup if they are really
// needed. The lookup is indexed manually to use the same index in a
// bit-array (of uint32 type) which stores for unloaded blocks that they
// were already fetched from Map but were actually nullptr.
memset(m_lookup, 0, sizeof(m_lookup));
int block_idx = 1 + (1 * 9) + (1 * 3);
m_lookup[block_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));
}
}
}
}
|
