minetest/src/treegen.cpp

879 lines
24 KiB
C++
Raw Normal View History

2012-12-29 16:20:09 +01:00
/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>,
2012-2013 RealBadAngel, Maciej Kasatkin <mk@realbadangel.pl>
2012-12-29 16:20:09 +01:00
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 "irr_v3d.h"
2012-12-29 16:20:09 +01:00
#include <stack>
#include "util/pointer.h"
#include "util/numeric.h"
2012-12-29 16:20:09 +01:00
#include "map.h"
#include "serverenvironment.h"
2012-12-29 16:20:09 +01:00
#include "nodedef.h"
#include "treegen.h"
namespace treegen
{
2013-03-12 02:32:52 +01:00
void make_tree(MMVManip &vmanip, v3s16 p0,
bool is_apple_tree, INodeDefManager *ndef, s32 seed)
2012-12-29 16:20:09 +01:00
{
/*
NOTE: Tree-placing code is currently duplicated in the engine
and in games that have saplings; both are deprecated but not
replaced yet
*/
2012-12-29 16:20:09 +01:00
MapNode treenode(ndef->getId("mapgen_tree"));
MapNode leavesnode(ndef->getId("mapgen_leaves"));
MapNode applenode(ndef->getId("mapgen_apple"));
2013-03-12 02:32:52 +01:00
PseudoRandom pr(seed);
s16 trunk_h = pr.range(4, 5);
2012-12-29 16:20:09 +01:00
v3s16 p1 = p0;
for (s16 ii = 0; ii < trunk_h; ii++) {
if (vmanip.m_area.contains(p1)) {
u32 vi = vmanip.m_area.index(p1);
vmanip.m_data[vi] = treenode;
}
2012-12-29 16:20:09 +01:00
p1.Y++;
}
// p1 is now the last piece of the trunk
p1.Y -= 1;
VoxelArea leaves_a(v3s16(-2, -1, -2), v3s16(2, 2, 2));
2012-12-29 16:20:09 +01:00
//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
Buffer<u8> leaves_d(leaves_a.getVolume());
for (s32 i = 0; i < leaves_a.getVolume(); i++)
2012-12-29 16:20:09 +01:00
leaves_d[i] = 0;
// Force leaves at near the end of the trunk
s16 d = 1;
for (s16 z = -d; z <= d; z++)
for (s16 y = -d; y <= d; y++)
for (s16 x = -d; x <= d; x++) {
leaves_d[leaves_a.index(v3s16(x, y, z))] = 1;
2012-12-29 16:20:09 +01:00
}
// Add leaves randomly
for (u32 iii = 0; iii < 7; iii++) {
2012-12-29 16:20:09 +01:00
v3s16 p(
pr.range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X - d),
pr.range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y - d),
pr.range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z - d)
2012-12-29 16:20:09 +01:00
);
for (s16 z = 0; z <= d; z++)
for (s16 y = 0; y <= d; y++)
for (s16 x = 0; x <= d; x++) {
leaves_d[leaves_a.index(p + v3s16(x, y, z))] = 1;
2012-12-29 16:20:09 +01:00
}
}
// Blit leaves to vmanip
for (s16 z = leaves_a.MinEdge.Z; z <= leaves_a.MaxEdge.Z; z++)
for (s16 y = leaves_a.MinEdge.Y; y <= leaves_a.MaxEdge.Y; y++) {
v3s16 pmin(leaves_a.MinEdge.X, y, z);
u32 i = leaves_a.index(pmin);
u32 vi = vmanip.m_area.index(pmin + p1);
for (s16 x = leaves_a.MinEdge.X; x <= leaves_a.MaxEdge.X; x++) {
v3s16 p(x, y, z);
if (vmanip.m_area.contains(p + p1) == true &&
(vmanip.m_data[vi].getContent() == CONTENT_AIR ||
vmanip.m_data[vi].getContent() == CONTENT_IGNORE)) {
if (leaves_d[i] == 1) {
bool is_apple = pr.range(0, 99) < 10;
if (is_apple_tree && is_apple)
vmanip.m_data[vi] = applenode;
else
vmanip.m_data[vi] = leavesnode;
}
2012-12-29 16:20:09 +01:00
}
vi++;
i++;
2012-12-29 16:20:09 +01:00
}
}
}
2012-12-29 16:20:09 +01:00
// L-System tree LUA spawner
treegen::error spawn_ltree(ServerEnvironment *env, v3s16 p0,
INodeDefManager *ndef, TreeDef tree_definition)
2012-12-29 16:20:09 +01:00
{
ServerMap *map = &env->getServerMap();
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> modified_blocks;
MMVManip vmanip(map);
2012-12-29 16:20:09 +01:00
v3s16 tree_blockp = getNodeBlockPos(p0);
treegen::error e;
vmanip.initialEmerge(tree_blockp - v3s16(1, 1, 1), tree_blockp + v3s16(1, 3, 1));
e = make_ltree(vmanip, p0, ndef, tree_definition);
if (e != SUCCESS)
return e;
2012-12-29 16:20:09 +01:00
vmanip.blitBackAll(&modified_blocks);
// update lighting
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> lighting_modified_blocks;
lighting_modified_blocks.insert(modified_blocks.begin(), modified_blocks.end());
2012-12-29 16:20:09 +01:00
map->updateLighting(lighting_modified_blocks, modified_blocks);
// Send a MEET_OTHER event
MapEditEvent event;
event.type = MEET_OTHER;
for (std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
2012-12-20 18:19:49 +01:00
event.modified_blocks.insert(i->first);
2012-12-29 16:20:09 +01:00
map->dispatchEvent(&event);
return SUCCESS;
2012-12-29 16:20:09 +01:00
}
2012-12-29 16:20:09 +01:00
//L-System tree generator
treegen::error make_ltree(MMVManip &vmanip, v3s16 p0,
INodeDefManager *ndef, TreeDef tree_definition)
2012-12-29 16:20:09 +01:00
{
MapNode dirtnode(ndef->getId("mapgen_dirt"));
s32 seed;
if (tree_definition.explicit_seed)
seed = tree_definition.seed + 14002;
else
seed = p0.X * 2 + p0.Y * 4 + p0.Z; // use the tree position to seed PRNG
PseudoRandom ps(seed);
2012-12-29 16:20:09 +01:00
// chance of inserting abcd rules
double prop_a = 9;
double prop_b = 8;
double prop_c = 7;
double prop_d = 6;
//randomize tree growth level, minimum=2
s16 iterations = tree_definition.iterations;
if (tree_definition.iterations_random_level > 0)
iterations -= ps.range(0, tree_definition.iterations_random_level);
if (iterations < 2)
iterations = 2;
2012-12-29 16:20:09 +01:00
s16 MAX_ANGLE_OFFSET = 5;
double angle_in_radians = (double)tree_definition.angle * M_PI / 180;
double angleOffset_in_radians = (s16)(ps.range(0, 1) % MAX_ANGLE_OFFSET) * M_PI / 180;
2012-12-29 16:20:09 +01:00
//initialize rotation matrix, position and stacks for branches
core::matrix4 rotation;
rotation = setRotationAxisRadians(rotation, M_PI / 2, v3f(0, 0, 1));
v3f position;
position.X = p0.X;
position.Y = p0.Y;
position.Z = p0.Z;
2012-12-29 16:20:09 +01:00
std::stack <core::matrix4> stack_orientation;
std::stack <v3f> stack_position;
//generate axiom
std::string axiom = tree_definition.initial_axiom;
for (s16 i = 0; i < iterations; i++) {
2012-12-29 16:20:09 +01:00
std::string temp = "";
for (s16 j = 0; j < (s16)axiom.size(); j++) {
2012-12-29 16:20:09 +01:00
char axiom_char = axiom.at(j);
switch (axiom_char) {
2012-12-29 16:20:09 +01:00
case 'A':
temp += tree_definition.rules_a;
2012-12-29 16:20:09 +01:00
break;
case 'B':
temp += tree_definition.rules_b;
2012-12-29 16:20:09 +01:00
break;
case 'C':
temp += tree_definition.rules_c;
2012-12-29 16:20:09 +01:00
break;
case 'D':
temp += tree_definition.rules_d;
2012-12-29 16:20:09 +01:00
break;
case 'a':
if (prop_a >= ps.range(1, 10))
temp += tree_definition.rules_a;
2012-12-29 16:20:09 +01:00
break;
case 'b':
if (prop_b >= ps.range(1, 10))
temp += tree_definition.rules_b;
2012-12-29 16:20:09 +01:00
break;
case 'c':
if (prop_c >= ps.range(1, 10))
temp += tree_definition.rules_c;
2012-12-29 16:20:09 +01:00
break;
case 'd':
if (prop_d >= ps.range(1, 10))
temp += tree_definition.rules_d;
2012-12-29 16:20:09 +01:00
break;
default:
temp += axiom_char;
2012-12-29 16:20:09 +01:00
break;
}
}
axiom = temp;
2012-12-29 16:20:09 +01:00
}
//make sure tree is not floating in the air
if (tree_definition.trunk_type == "double") {
tree_node_placement(
vmanip,
v3f(position.X + 1, position.Y - 1, position.Z),
dirtnode
);
tree_node_placement(
vmanip,
v3f(position.X, position.Y - 1, position.Z + 1),
dirtnode
);
tree_node_placement(
vmanip,
v3f(position.X + 1, position.Y - 1, position.Z + 1),
dirtnode
);
} else if (tree_definition.trunk_type == "crossed") {
tree_node_placement(
vmanip,
v3f(position.X + 1, position.Y - 1, position.Z),
dirtnode
);
tree_node_placement(
vmanip,
v3f(position.X - 1, position.Y - 1, position.Z),
dirtnode
);
tree_node_placement(
vmanip,
v3f(position.X, position.Y - 1, position.Z + 1),
dirtnode
);
tree_node_placement(
vmanip,
v3f(position.X, position.Y - 1, position.Z - 1),
dirtnode
);
2012-12-29 16:20:09 +01:00
}
/* build tree out of generated axiom
Key for Special L-System Symbols used in Axioms
2013-01-07 01:35:05 +01:00
G - move forward one unit with the pen up
F - move forward one unit with the pen down drawing trunks and branches
f - move forward one unit with the pen down drawing leaves (100% chance)
T - move forward one unit with the pen down drawing trunks only
R - move forward one unit with the pen down placing fruit
2012-12-29 16:20:09 +01:00
A - replace with rules set A
B - replace with rules set B
C - replace with rules set C
D - replace with rules set D
a - replace with rules set A, chance 90%
b - replace with rules set B, chance 80%
c - replace with rules set C, chance 70%
d - replace with rules set D, chance 60%
+ - yaw the turtle right by angle degrees
- - yaw the turtle left by angle degrees
& - pitch the turtle down by angle degrees
^ - pitch the turtle up by angle degrees
/ - roll the turtle to the right by angle degrees
* - roll the turtle to the left by angle degrees
[ - save in stack current state info
] - recover from stack state info
*/
s16 x,y,z;
for (s16 i = 0; i < (s16)axiom.size(); i++) {
2012-12-29 16:20:09 +01:00
char axiom_char = axiom.at(i);
core::matrix4 temp_rotation;
temp_rotation.makeIdentity();
v3f dir;
switch (axiom_char) {
2012-12-29 16:20:09 +01:00
case 'G':
dir = v3f(1, 0, 0);
dir = transposeMatrix(rotation, dir);
position += dir;
2012-12-29 16:20:09 +01:00
break;
case 'T':
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z),
tree_definition
);
if (tree_definition.trunk_type == "double" &&
!tree_definition.thin_branches) {
tree_trunk_placement(
vmanip,
v3f(position.X + 1, position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z + 1),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X + 1, position.Y, position.Z + 1),
tree_definition
);
} else if (tree_definition.trunk_type == "crossed" &&
!tree_definition.thin_branches) {
tree_trunk_placement(
vmanip,
v3f(position.X + 1, position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X - 1, position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z + 1),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z - 1),
tree_definition
);
}
dir = v3f(1, 0, 0);
dir = transposeMatrix(rotation, dir);
position += dir;
break;
2012-12-29 16:20:09 +01:00
case 'F':
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z),
tree_definition
);
if ((stack_orientation.empty() &&
tree_definition.trunk_type == "double") ||
(!stack_orientation.empty() &&
tree_definition.trunk_type == "double" &&
!tree_definition.thin_branches)) {
tree_trunk_placement(
vmanip,
v3f(position.X +1 , position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z + 1),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X + 1, position.Y, position.Z + 1),
tree_definition
);
} else if ((stack_orientation.empty() &&
tree_definition.trunk_type == "crossed") ||
(!stack_orientation.empty() &&
tree_definition.trunk_type == "crossed" &&
!tree_definition.thin_branches)) {
tree_trunk_placement(
vmanip,
v3f(position.X + 1, position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X - 1, position.Y, position.Z),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z + 1),
tree_definition
);
tree_trunk_placement(
vmanip,
v3f(position.X, position.Y, position.Z - 1),
tree_definition
);
} if (stack_orientation.empty() == false) {
2012-12-29 16:20:09 +01:00
s16 size = 1;
for (x = -size; x <= size; x++)
for (y = -size; y <= size; y++)
for (z = -size; z <= size; z++) {
if (abs(x) == size &&
abs(y) == size &&
abs(z) == size) {
tree_leaves_placement(
vmanip,
v3f(position.X + x + 1, position.Y + y,
position.Z + z),
ps.next(),
tree_definition
);
tree_leaves_placement(
vmanip,
v3f(position.X + x - 1, position.Y + y,
position.Z + z),
ps.next(),
tree_definition
);
tree_leaves_placement(
vmanip,v3f(position.X + x, position.Y + y,
position.Z + z + 1),
ps.next(),
tree_definition
);
tree_leaves_placement(
vmanip,v3f(position.X + x, position.Y + y,
position.Z + z - 1),
ps.next(),
tree_definition
);
}
}
2012-12-29 16:20:09 +01:00
}
dir = v3f(1, 0, 0);
dir = transposeMatrix(rotation, dir);
position += dir;
2012-12-29 16:20:09 +01:00
break;
2013-01-07 01:35:05 +01:00
case 'f':
tree_single_leaves_placement(
vmanip,
v3f(position.X, position.Y, position.Z),
ps.next(),
tree_definition
);
dir = v3f(1, 0, 0);
dir = transposeMatrix(rotation, dir);
position += dir;
2013-01-07 01:35:05 +01:00
break;
case 'R':
tree_fruit_placement(
vmanip,
v3f(position.X, position.Y, position.Z),
tree_definition
);
dir = v3f(1, 0, 0);
dir = transposeMatrix(rotation, dir);
position += dir;
break;
// turtle orientation commands
2012-12-29 16:20:09 +01:00
case '[':
stack_orientation.push(rotation);
stack_position.push(position);
break;
case ']':
if (stack_orientation.empty())
return UNBALANCED_BRACKETS;
rotation = stack_orientation.top();
2012-12-29 16:20:09 +01:00
stack_orientation.pop();
position = stack_position.top();
2012-12-29 16:20:09 +01:00
stack_position.pop();
break;
case '+':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians + angleOffset_in_radians, v3f(0, 0, 1));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
case '-':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians + angleOffset_in_radians, v3f(0, 0, -1));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
case '&':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians + angleOffset_in_radians, v3f(0, 1, 0));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
case '^':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians + angleOffset_in_radians, v3f(0, -1, 0));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
case '*':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians, v3f(1, 0, 0));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
case '/':
temp_rotation.makeIdentity();
temp_rotation = setRotationAxisRadians(temp_rotation,
angle_in_radians, v3f(-1, 0, 0));
rotation *= temp_rotation;
2012-12-29 16:20:09 +01:00
break;
default:
break;
}
}
return SUCCESS;
2012-12-29 16:20:09 +01:00
}
void tree_node_placement(MMVManip &vmanip, v3f p0, MapNode node)
2012-12-29 16:20:09 +01:00
{
v3s16 p1 = v3s16(myround(p0.X), myround(p0.Y), myround(p0.Z));
if (vmanip.m_area.contains(p1) == false)
2012-12-29 16:20:09 +01:00
return;
u32 vi = vmanip.m_area.index(p1);
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
2012-12-29 16:20:09 +01:00
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
return;
vmanip.m_data[vmanip.m_area.index(p1)] = node;
}
void tree_trunk_placement(MMVManip &vmanip, v3f p0, TreeDef &tree_definition)
2012-12-29 16:20:09 +01:00
{
v3s16 p1 = v3s16(myround(p0.X), myround(p0.Y), myround(p0.Z));
if (vmanip.m_area.contains(p1) == false)
2012-12-29 16:20:09 +01:00
return;
u32 vi = vmanip.m_area.index(p1);
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
2012-12-29 16:20:09 +01:00
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
return;
vmanip.m_data[vmanip.m_area.index(p1)] = tree_definition.trunknode;
}
void tree_leaves_placement(MMVManip &vmanip, v3f p0,
PseudoRandom ps, TreeDef &tree_definition)
2012-12-29 16:20:09 +01:00
{
MapNode leavesnode = tree_definition.leavesnode;
if (ps.range(1, 100) > 100 - tree_definition.leaves2_chance)
leavesnode = tree_definition.leaves2node;
v3s16 p1 = v3s16(myround(p0.X), myround(p0.Y), myround(p0.Z));
if (vmanip.m_area.contains(p1) == false)
2012-12-29 16:20:09 +01:00
return;
u32 vi = vmanip.m_area.index(p1);
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
2012-12-29 16:20:09 +01:00
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
return;
if (tree_definition.fruit_chance > 0) {
if (ps.range(1, 100) > 100 - tree_definition.fruit_chance)
2012-12-29 16:20:09 +01:00
vmanip.m_data[vmanip.m_area.index(p1)] = tree_definition.fruitnode;
else
2013-01-07 01:35:05 +01:00
vmanip.m_data[vmanip.m_area.index(p1)] = leavesnode;
} else if (ps.range(1, 100) > 20) {
2013-01-07 01:35:05 +01:00
vmanip.m_data[vmanip.m_area.index(p1)] = leavesnode;
}
2012-12-29 16:20:09 +01:00
}
void tree_single_leaves_placement(MMVManip &vmanip, v3f p0,
PseudoRandom ps, TreeDef &tree_definition)
{
MapNode leavesnode = tree_definition.leavesnode;
if (ps.range(1, 100) > 100 - tree_definition.leaves2_chance)
leavesnode = tree_definition.leaves2node;
v3s16 p1 = v3s16(myround(p0.X), myround(p0.Y), myround(p0.Z));
if (vmanip.m_area.contains(p1) == false)
return;
u32 vi = vmanip.m_area.index(p1);
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
return;
vmanip.m_data[vmanip.m_area.index(p1)] = leavesnode;
}
void tree_fruit_placement(MMVManip &vmanip, v3f p0, TreeDef &tree_definition)
{
v3s16 p1 = v3s16(myround(p0.X), myround(p0.Y), myround(p0.Z));
if (vmanip.m_area.contains(p1) == false)
return;
u32 vi = vmanip.m_area.index(p1);
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
return;
vmanip.m_data[vmanip.m_area.index(p1)] = tree_definition.fruitnode;
}
2012-12-29 16:20:09 +01:00
irr::core::matrix4 setRotationAxisRadians(irr::core::matrix4 M, double angle, v3f axis)
{
double c = cos(angle);
double s = sin(angle);
double t = 1.0 - c;
double tx = t * axis.X;
double ty = t * axis.Y;
double tz = t * axis.Z;
double sx = s * axis.X;
double sy = s * axis.Y;
double sz = s * axis.Z;
M[0] = tx * axis.X + c;
M[1] = tx * axis.Y + sz;
M[2] = tx * axis.Z - sy;
M[4] = ty * axis.X - sz;
M[5] = ty * axis.Y + c;
M[6] = ty * axis.Z + sx;
M[8] = tz * axis.X + sy;
M[9] = tz * axis.Y - sx;
M[10] = tz * axis.Z + c;
return M;
}
2012-12-29 16:20:09 +01:00
v3f transposeMatrix(irr::core::matrix4 M, v3f v)
{
v3f translated;
double x = M[0] * v.X + M[4] * v.Y + M[8] * v.Z +M[12];
double y = M[1] * v.X + M[5] * v.Y + M[9] * v.Z +M[13];
double z = M[2] * v.X + M[6] * v.Y + M[10] * v.Z +M[14];
translated.X = x;
translated.Y = y;
translated.Z = z;
2012-12-29 16:20:09 +01:00
return translated;
}
void make_jungletree(MMVManip &vmanip, v3s16 p0, INodeDefManager *ndef, s32 seed)
2012-12-29 16:20:09 +01:00
{
/*
NOTE: Tree-placing code is currently duplicated in the engine
and in games that have saplings; both are deprecated but not
replaced yet
*/
content_t c_tree = ndef->getId("mapgen_jungletree");
content_t c_leaves = ndef->getId("mapgen_jungleleaves");
if (c_tree == CONTENT_IGNORE)
c_tree = ndef->getId("mapgen_tree");
if (c_leaves == CONTENT_IGNORE)
c_leaves = ndef->getId("mapgen_leaves");
MapNode treenode(c_tree);
MapNode leavesnode(c_leaves);
2012-12-29 16:20:09 +01:00
2013-03-12 02:32:52 +01:00
PseudoRandom pr(seed);
for (s16 x= -1; x <= 1; x++)
for (s16 z= -1; z <= 1; z++) {
if (pr.range(0, 2) == 0)
2012-12-29 16:20:09 +01:00
continue;
v3s16 p1 = p0 + v3s16(x, 0, z);
v3s16 p2 = p0 + v3s16(x, -1, z);
u32 vi1 = vmanip.m_area.index(p1);
u32 vi2 = vmanip.m_area.index(p2);
if (vmanip.m_area.contains(p2) &&
vmanip.m_data[vi2].getContent() == CONTENT_AIR)
vmanip.m_data[vi2] = treenode;
else if (vmanip.m_area.contains(p1) &&
vmanip.m_data[vi1].getContent() == CONTENT_AIR)
vmanip.m_data[vi1] = treenode;
2012-12-29 16:20:09 +01:00
}
vmanip.m_data[vmanip.m_area.index(p0)] = treenode;
2012-12-29 16:20:09 +01:00
2013-03-12 02:32:52 +01:00
s16 trunk_h = pr.range(8, 12);
2012-12-29 16:20:09 +01:00
v3s16 p1 = p0;
for (s16 ii = 0; ii < trunk_h; ii++) {
if (vmanip.m_area.contains(p1)) {
u32 vi = vmanip.m_area.index(p1);
vmanip.m_data[vi] = treenode;
}
2012-12-29 16:20:09 +01:00
p1.Y++;
}
// p1 is now the last piece of the trunk
p1.Y -= 1;
VoxelArea leaves_a(v3s16(-3, -2, -3), v3s16(3, 2, 3));
2012-12-29 16:20:09 +01:00
//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
Buffer<u8> leaves_d(leaves_a.getVolume());
for (s32 i = 0; i < leaves_a.getVolume(); i++)
2012-12-29 16:20:09 +01:00
leaves_d[i] = 0;
// Force leaves at near the end of the trunk
s16 d = 1;
for (s16 z = -d; z <= d; z++)
for (s16 y = -d; y <= d; y++)
for (s16 x = -d; x <= d; x++) {
leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
2012-12-29 16:20:09 +01:00
}
// Add leaves randomly
for (u32 iii = 0; iii < 30; iii++) {
2012-12-29 16:20:09 +01:00
v3s16 p(
pr.range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X - d),
pr.range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y - d),
pr.range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z - d)
2012-12-29 16:20:09 +01:00
);
for (s16 z = 0; z <= d; z++)
for (s16 y = 0; y <= d; y++)
for (s16 x = 0; x <= d; x++) {
leaves_d[leaves_a.index(p + v3s16(x, y, z))] = 1;
2012-12-29 16:20:09 +01:00
}
}
// Blit leaves to vmanip
for (s16 z = leaves_a.MinEdge.Z; z <= leaves_a.MaxEdge.Z; z++)
for (s16 y = leaves_a.MinEdge.Y; y <= leaves_a.MaxEdge.Y; y++) {
v3s16 pmin(leaves_a.MinEdge.X, y, z);
u32 i = leaves_a.index(pmin);
u32 vi = vmanip.m_area.index(pmin + p1);
for (s16 x = leaves_a.MinEdge.X; x <= leaves_a.MaxEdge.X; x++) {
v3s16 p(x, y, z);
if (vmanip.m_area.contains(p + p1) == true &&
(vmanip.m_data[vi].getContent() == CONTENT_AIR ||
vmanip.m_data[vi].getContent() == CONTENT_IGNORE)) {
if (leaves_d[i] == 1)
vmanip.m_data[vi] = leavesnode;
}
vi++;
i++;
}
}
}
void make_pine_tree(MMVManip &vmanip, v3s16 p0, INodeDefManager *ndef, s32 seed)
{
/*
NOTE: Tree-placing code is currently duplicated in the engine
and in games that have saplings; both are deprecated but not
replaced yet
*/
2015-08-09 10:17:11 +02:00
content_t c_tree = ndef->getId("mapgen_pine_tree");
content_t c_leaves = ndef->getId("mapgen_pine_needles");
content_t c_snow = ndef->getId("mapgen_snow");
if (c_tree == CONTENT_IGNORE)
c_tree = ndef->getId("mapgen_tree");
if (c_leaves == CONTENT_IGNORE)
c_leaves = ndef->getId("mapgen_leaves");
if (c_snow == CONTENT_IGNORE)
c_snow = CONTENT_AIR;
MapNode treenode(c_tree);
MapNode leavesnode(c_leaves);
MapNode snownode(c_snow);
PseudoRandom pr(seed);
u16 trunk_h = pr.range(9, 13);
v3s16 p1 = p0;
for (u16 ii = 0; ii < trunk_h; ii++) {
if (vmanip.m_area.contains(p1)) {
u32 vi = vmanip.m_area.index(p1);
vmanip.m_data[vi] = treenode;
}
p1.Y++;
}
// Make p1 the top node of the trunk
p1.Y -= 1;
VoxelArea leaves_a(v3s16(-3, -6, -3), v3s16(3, 3, 3));
//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
Buffer<u8> leaves_d(leaves_a.getVolume());
for (s32 i = 0; i < leaves_a.getVolume(); i++)
leaves_d[i] = 0;
// Upper branches
u16 dev = 3;
for (s16 yy = -1; yy <= 1; yy++) {
for (s16 zz = -dev; zz <= dev; zz++) {
u32 i = leaves_a.index(v3s16(-dev, yy, zz));
u32 ia = leaves_a.index(v3s16(-dev, yy+1, zz));
for (s16 xx = -dev; xx <= dev; xx++) {
if (pr.range(0, 20) <= 19 - dev) {
leaves_d[i] = 1;
leaves_d[ia] = 2;
}
i++;
ia++;
}
}
dev--;
}
// Centre top nodes
u32 i = leaves_a.index(v3s16(0, 1, 0));
leaves_d[i] = 1;
i = leaves_a.index(v3s16(0, 2, 0));
leaves_d[i] = 1;
i = leaves_a.index(v3s16(0, 3, 0));
leaves_d[i] = 2;
// Lower branches
s16 my = -6;
for (u32 iii = 0; iii < 20; iii++) {
s16 xi = pr.range(-3, 2);
s16 yy = pr.range(-6, -5);
s16 zi = pr.range(-3, 2);
if (yy > my)
my = yy;
for (s16 zz = zi; zz <= zi + 1; zz++) {
u32 i = leaves_a.index(v3s16(xi, yy, zz));
u32 ia = leaves_a.index(v3s16(xi, yy + 1, zz));
for (s16 xx = xi; xx <= xi + 1; xx++) {
leaves_d[i] = 1;
if (leaves_d[ia] == 0)
leaves_d[ia] = 2;
i++;
ia++;
}
}
}
dev = 2;
for (s16 yy = my + 1; yy <= my + 2; yy++) {
for (s16 zz = -dev; zz <= dev; zz++) {
u32 i = leaves_a.index(v3s16(-dev, yy, zz));
u32 ia = leaves_a.index(v3s16(-dev, yy + 1, zz));
for (s16 xx = -dev; xx <= dev; xx++) {
if (pr.range(0, 20) <= 19 - dev) {
leaves_d[i] = 1;
leaves_d[ia] = 2;
}
i++;
ia++;
}
}
dev--;
}
// Blit leaves to vmanip
for (s16 z = leaves_a.MinEdge.Z; z <= leaves_a.MaxEdge.Z; z++)
for (s16 y = leaves_a.MinEdge.Y; y <= leaves_a.MaxEdge.Y; y++) {
v3s16 pmin(leaves_a.MinEdge.X, y, z);
u32 i = leaves_a.index(pmin);
u32 vi = vmanip.m_area.index(pmin + p1);
for (s16 x = leaves_a.MinEdge.X; x <= leaves_a.MaxEdge.X; x++) {
v3s16 p(x, y, z);
if (vmanip.m_area.contains(p + p1) == true &&
(vmanip.m_data[vi].getContent() == CONTENT_AIR ||
vmanip.m_data[vi].getContent() == CONTENT_IGNORE ||
vmanip.m_data[vi] == snownode)) {
if (leaves_d[i] == 1)
vmanip.m_data[vi] = leavesnode;
else if (leaves_d[i] == 2)
vmanip.m_data[vi] = snownode;
}
vi++;
i++;
}
2012-12-29 16:20:09 +01:00
}
}
2013-01-07 01:35:05 +01:00
}; // namespace treegen