BRNSystems/minetest
1
0
Fork 0
forked from Mirrorlandia_minetest/minetest
Code Pull Requests 1 Activity

working nicely

Browse Source
This commit is contained in:
Perttu Ahola 2010-12-13 03:19:12 +02:00
parent 47a593b519
commit 571fb14f94
20 changed files with 938 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
makepackage_binary.sh
View File

@ -33,6 +33,12 @@ cp -r data/sign.png $PACKAGEPATH/data/
cp -r data/sign_back.png $PACKAGEPATH/data/
cp -r data/rat.png $PACKAGEPATH/data/
cp -r data/mud.png $PACKAGEPATH/data/
cp -r data/torch.png $PACKAGEPATH/data/
cp -r data/torch_floor.png $PACKAGEPATH/data/
cp -r data/torch_ceiling.png $PACKAGEPATH/data/
cp -r data/skybox1.png $PACKAGEPATH/data/
cp -r data/skybox2.png $PACKAGEPATH/data/
cp -r data/skybox3.png $PACKAGEPATH/data/
cp -r doc/README.txt $PACKAGEPATH/doc/README.txt

5
minetest.conf.example
View File

@ -54,5 +54,8 @@
#max_simultaneous_block_sends_server_total = 4
#max_block_send_distance = 8
#max_block_generate_distance = 5
#max_block_generate_distance = 6
#disable_water_climb = true
#endless_water = true

1
src/client.cpp
View File

@ -1651,6 +1651,7 @@ MapBlockObject * Client::getSelectedObject(
v3f from_pos_f_on_block = from_pos_f_on_map - block_pos_f_on_map;
block->getObjects(from_pos_f_on_block, max_d, objects);
//block->getPseudoObjects(from_pos_f_on_block, max_d, objects);
}
//dstream<<"Collected "<<objects.size()<<" nearby objects"<<std::endl;

4
src/environment.cpp
View File

@ -142,9 +142,9 @@ void Environment::step(float dtime)
v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0));
try{
MapNode n = m_map->getNode(bottompos);
if(n.d == MATERIAL_GRASS)
if(n.d == CONTENT_GRASS)
{
n.d = MATERIAL_GRASS_FOOTSTEPS;
n.d = CONTENT_GRASS_FOOTSTEPS;
m_map->setNode(bottompos, n);
// Update mesh on client

43
src/light.cpp
View File

@ -101,4 +101,47 @@ u8 light_decode_table[LIGHT_MAX+1] =
255,
};
/*
#!/usr/bin/python
from math import *
from sys import stdout
# We want 0 at light=0 and 255 at light=LIGHT_MAX
LIGHT_MAX = 14
#FACTOR = 0.69
FACTOR = 0.75
maxlight = 255
minlight = 8
L = []
for i in range(1,LIGHT_MAX+1):
L.append(minlight+int(round((maxlight-minlight) * FACTOR ** (i-1))))
#L.append(int(round(255.0 * FACTOR ** (i-1))))
L.append(minlight)
L.reverse()
for i in L:
stdout.write(str(i)+",\n")
*/
/*u8 light_decode_table[LIGHT_MAX+1] =
{
8,
14,
16,
18,
22,
27,
33,
41,
52,
67,
86,
112,
147,
193,
255,
};*/

177
src/main.cpp
View File

@ -186,13 +186,11 @@ SUGG: Implement a "Fast check queue" (a queue with a map for checking
TODO: Proper looking torches.
- Signs could be done in the same way?
TODO: A mapper to map contents to tile names (for each side)
Doing now:
======================================================================
TODO: A system for showing some nodes in some other way than cubes
- Needed for torches
- Also for signs, stairs, etc
======================================================================
*/
@ -257,22 +255,26 @@ TODO: A system for showing some nodes in some other way than cubes
IrrlichtDevice *g_device = NULL;
const char *g_material_filenames[MATERIALS_COUNT] =
const char *g_content_filenames[MATERIALS_COUNT] =
{
"../data/stone.png",
"../data/grass.png",
"../data/water.png",
"../data/light.png",
"../data/torch_on_floor.png",
"../data/tree.png",
"../data/leaves.png",
"../data/grass_footsteps.png",
"../data/mese.png",
"../data/mud.png",
"../data/water.png", // ocean
"../data/water.png", // CONTENT_OCEAN
};
// Material cache
video::SMaterial g_materials[MATERIALS_COUNT];
//video::SMaterial g_mesh_materials[3];
// Texture cache
TextureCache g_texturecache;
// All range-related stuff below is locked behind this
JMutex g_range_mutex;
@ -320,20 +322,22 @@ void set_default_settings()
g_settings.set("random_input", "false");
g_settings.set("client_delete_unused_sectors_timeout", "1200");
g_settings.set("max_block_send_distance", "8");
g_settings.set("max_block_generate_distance", "5");
g_settings.set("max_block_generate_distance", "6");
// Server stuff
g_settings.set("creative_mode", "false");
g_settings.set("heightmap_blocksize", "128");
g_settings.set("height_randmax", "constant 70.0");
g_settings.set("heightmap_blocksize", "32");
g_settings.set("height_randmax", "constant 50.0");
g_settings.set("height_randfactor", "constant 0.6");
g_settings.set("height_base", "linear 0 35 0");
g_settings.set("height_base", "linear 0 0 0");
g_settings.set("plants_amount", "1.0");
g_settings.set("ravines_amount", "1.0");
g_settings.set("objectdata_interval", "0.2");
g_settings.set("active_object_range", "2");
g_settings.set("max_simultaneous_block_sends_per_client", "1");
g_settings.set("max_simultaneous_block_sends_server_total", "4");
g_settings.set("disable_water_climb", "true");
g_settings.set("endless_water", "true");
}
/*
@ -673,7 +677,7 @@ public:
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1,10);
/*if(g_selected_material < USEFUL_MATERIAL_COUNT-1)
/*if(g_selected_material < USEFUL_CONTENT_COUNT-1)
g_selected_material++;
else
g_selected_material = 0;*/
@ -1297,7 +1301,7 @@ int main(int argc, char *argv[])
g_materials[i].Lighting = false;
g_materials[i].BackfaceCulling = false;
const char *filename = g_material_filenames[i];
const char *filename = g_content_filenames[i];
if(filename != NULL){
video::ITexture *t = driver->getTexture(filename);
if(t == NULL){
@ -1313,9 +1317,9 @@ int main(int argc, char *argv[])
//g_materials[i].setFlag(video::EMF_FOG_ENABLE, true);
}
g_materials[MATERIAL_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
//g_materials[MATERIAL_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
g_materials[MATERIAL_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
//g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
g_materials[CONTENT_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
/*g_mesh_materials[0].setTexture(0, driver->getTexture("../data/water.png"));
g_mesh_materials[1].setTexture(0, driver->getTexture("../data/grass.png"));
@ -1328,8 +1332,18 @@ int main(int argc, char *argv[])
g_mesh_materials[i].setFlag(video::EMF_FOG_ENABLE, true);
}*/
// Make a scope here for the client so that it gets removed
// before the irrlicht device
/*
Preload some random textures that are used in threads
*/
g_texturecache.set("torch", driver->getTexture("../data/torch.png"));
g_texturecache.set("torch_on_floor", driver->getTexture("../data/torch_on_floor.png"));
g_texturecache.set("torch_on_ceiling", driver->getTexture("../data/torch_on_ceiling.png"));
/*
Make a scope here for the client so that it gets removed
before the irrlicht device
*/
{
std::cout<<DTIME<<"Creating server and client"<<std::endl;
@ -1381,6 +1395,23 @@ int main(int argc, char *argv[])
return 0;
}
/*
Create skybox
*/
scene::ISceneNode* skybox = smgr->addSkyBoxSceneNode(
driver->getTexture("../data/skybox2.png"),
driver->getTexture("../data/skybox3.png"),
driver->getTexture("../data/skybox1.png"),
driver->getTexture("../data/skybox1.png"),
driver->getTexture("../data/skybox1.png"),
driver->getTexture("../data/skybox1.png"));
/* driver->getTexture("../data/irrlicht2_up.jpg"),
driver->getTexture("../data/irrlicht2_dn.jpg"),
driver->getTexture("../data/irrlicht2_lf.jpg"),
driver->getTexture("../data/irrlicht2_rt.jpg"),
driver->getTexture("../data/irrlicht2_ft.jpg"),
driver->getTexture("../data/irrlicht2_bk.jpg"));*/
/*
Create the camera node
*/
@ -1862,14 +1893,19 @@ int main(int argc, char *argv[])
s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);
s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);
for(s16 y = ystart; y <= yend; y++){
for(s16 z = zstart; z <= zend; z++){
for(s16 y = ystart; y <= yend; y++)
for(s16 z = zstart; z <= zend; z++)
for(s16 x = xstart; x <= xend; x++)
{
try{
if(material_pointable(client.getNode(v3s16(x,y,z)).d) == false)
MapNode n;
try
{
n = client.getNode(v3s16(x,y,z));
if(content_pointable(n.d) == false)
continue;
}catch(InvalidPositionException &e){
}
catch(InvalidPositionException &e)
{
continue;
}
@ -1878,26 +1914,80 @@ int main(int argc, char *argv[])
f32 d = 0.01;
v3s16 directions[6] = {
v3s16 dirs[6] = {
v3s16(0,0,1), // back
v3s16(0,1,0), // top
v3s16(1,0,0), // right
v3s16(0,0,-1),
v3s16(0,-1,0),
v3s16(-1,0,0),
v3s16(0,0,-1), // front
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
};
for(u16 i=0; i<6; i++){
//{u16 i=3;
v3f dir_f = v3f(directions[i].X,
directions[i].Y, directions[i].Z);
/*
Meta-objects
*/
if(n.d == CONTENT_LIGHT)
{
v3s16 dir = unpackDir(n.dir);
v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
dir_f *= BS/2 - BS/6 - BS/20;
v3f cpf = npf + dir_f;
f32 distance = (cpf - camera_position).getLength();
core::aabbox3d<f32> box;
// bottom
if(dir == v3s16(0,-1,0))
{
box = core::aabbox3d<f32>(
npf - v3f(BS/6, BS/2, BS/6),
npf + v3f(BS/6, -BS/2+BS/3*2, BS/6)
);
}
// top
else if(dir == v3s16(0,1,0))
{
box = core::aabbox3d<f32>(
npf - v3f(BS/6, -BS/2+BS/3*2, BS/6),
npf + v3f(BS/6, BS/2, BS/6)
);
}
// side
else
{
box = core::aabbox3d<f32>(
cpf - v3f(BS/6, BS/3, BS/6),
cpf + v3f(BS/6, BS/3, BS/6)
);
}
if(distance < mindistance)
{
if(box.intersectsWithLine(shootline))
{
nodefound = true;
nodepos = np;
neighbourpos = np;
mindistance = distance;
nodefacebox = box;
}
}
}
/*
Regular blocks
*/
else
{
for(u16 i=0; i<6; i++)
{
v3f dir_f = v3f(dirs[i].X,
dirs[i].Y, dirs[i].Z);
v3f centerpoint = npf + dir_f * BS/2;
f32 distance =
(centerpoint - camera_position).getLength();
if(distance < mindistance){
//std::cout<<DTIME<<"for centerpoint=("<<centerpoint.X<<","<<centerpoint.Y<<","<<centerpoint.Z<<"): distance < mindistance"<<std::endl;
//std::cout<<DTIME<<"npf=("<<npf.X<<","<<npf.Y<<","<<npf.Z<<")"<<std::endl;
if(distance < mindistance)
{
core::CMatrix4<f32> m;
m.buildRotateFromTo(v3f(0,0,1), dir_f);
@ -1907,26 +1997,27 @@ int main(int argc, char *argv[])
v3f(-BS/2, -BS/2, BS/2+d)
};
for(u16 j=0; j<2; j++){
for(u16 j=0; j<2; j++)
{
m.rotateVect(corners[j]);
corners[j] += npf;
//std::cout<<DTIME<<"box corners["<<j<<"]: ("<<corners[j].X<<","<<corners[j].Y<<","<<corners[j].Z<<")"<<std::endl;
}
//core::aabbox3d<f32> facebox(corners[0],corners[1]);
core::aabbox3d<f32> facebox(corners[0]);
facebox.addInternalPoint(corners[1]);
if(facebox.intersectsWithLine(shootline)){
if(facebox.intersectsWithLine(shootline))
{
nodefound = true;
nodepos = np;
neighbourpos = np + directions[i];
neighbourpos = np + dirs[i];
mindistance = distance;
nodefacebox = facebox;
}
}
}
}}}
} // if distance < mindistance
} // for dirs
} // regular block
} // for coords
if(nodefound)
{

4
src/main.h
View File

@ -55,7 +55,9 @@ extern std::ostream *derr_server_ptr;
// This header is only for MATERIALS_COUNT
#include "mapnode.h"
extern video::SMaterial g_materials[MATERIALS_COUNT];
//extern video::SMaterial g_mesh_materials[3];
#include "utility.h"
extern TextureCache g_texturecache;
extern IrrlichtDevice *g_device;

176
src/map.cpp
View File

@ -510,6 +510,10 @@ void Map::unspreadLight(core::map<v3s16, u8> & from_nodes,
light_sources.remove(n2pos);
}*/
}
/*// DEBUG
if(light_sources.find(n2pos) != NULL)
light_sources.remove(n2pos);*/
}
else{
light_sources.insert(n2pos, true);
@ -912,6 +916,8 @@ void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
// Yes, add it to light_sources... somehow.
// It has to be added at somewhere above, in the loop.
// TODO
// NOTE: This actually works quite fine without it
// - Find out why it works
{
//TimeTaker timer("spreadLight", g_device);
@ -1048,7 +1054,7 @@ void Map::removeNodeAndUpdate(v3s16 p,
v3s16 toppos = p + v3s16(0,1,0);
// Node will be replaced with this
u8 replace_material = MATERIAL_AIR;
u8 replace_material = CONTENT_AIR;
// NOTE: Water is now managed elsewhere
#if 0
@ -1099,7 +1105,7 @@ void Map::removeNodeAndUpdate(v3s16 p,
if(
c > highest_ranking ||
// Prefer something else than air
(c >= highest_ranking && m != MATERIAL_AIR)
(c >= highest_ranking && m != CONTENT_AIR)
)
{
@ -1722,17 +1728,91 @@ MapBlock * ServerMap::emergeBlock(
low_block_is_empty = true;*/
const s32 ued = 4;
//const s32 ued = 8;
bool underground_emptiness[ued*ued*ued];
for(s32 i=0; i<ued*ued*ued; i++)
{
underground_emptiness[i] = ((rand() % 4) == 0);
underground_emptiness[i] = ((rand() % 5) == 0);
}
#if 0
/*
This is a messy hack to sort the emptiness a bit
*/
for(s32 j=0; j<2; j++)
for(s32 y0=0; y0<ued; y0++)
for(s32 z0=0; z0<ued; z0++)
for(s32 x0=0; x0<ued; x0++)
{
v3s16 p0(x0,y0,z0);
bool &e0 = underground_emptiness[
ued*ued*(z0*ued/MAP_BLOCKSIZE)
+ued*(y0*ued/MAP_BLOCKSIZE)
+(x0*ued/MAP_BLOCKSIZE)];
v3s16 dirs[6] = {
v3s16(0,0,1), // back
v3s16(1,0,0), // right
v3s16(0,0,-1), // front
v3s16(-1,0,0), // left
/*v3s16(0,1,0), // top
v3s16(0,-1,0), // bottom*/
};
for(s32 i=0; i<4; i++)
{
v3s16 p1 = p0 + dirs[i];
if(isInArea(p1, ued) == false)
continue;
bool &e1 = underground_emptiness[
ued*ued*(p1.Z*ued/MAP_BLOCKSIZE)
+ued*(p1.Y*ued/MAP_BLOCKSIZE)
+(p1.X*ued/MAP_BLOCKSIZE)];
if(e0 == e1)
continue;
v3s16 dirs[6] = {
v3s16(0,1,0), // top
v3s16(0,-1,0), // bottom
/*v3s16(0,0,1), // back
v3s16(1,0,0), // right
v3s16(0,0,-1), // front
v3s16(-1,0,0), // left*/
};
for(s32 i=0; i<2; i++)
{
v3s16 p2 = p1 + dirs[i];
if(p2 == p0)
continue;
if(isInArea(p2, ued) == false)
continue;
bool &e2 = underground_emptiness[
ued*ued*(p2.Z*ued/MAP_BLOCKSIZE)
+ued*(p2.Y*ued/MAP_BLOCKSIZE)
+(p2.X*ued/MAP_BLOCKSIZE)];
if(e2 != e0)
continue;
bool t = e1;
e1 = e2;
e2 = t;
break;
}
//break;
}
}
#endif
// This is the basic material of what the visible flat ground
// will consist of
u8 material = MATERIAL_GRASS;
u8 material = CONTENT_GRASS;
u8 water_material = CONTENT_WATER;
if(g_settings.getBool("endless_water"))
water_material = CONTENT_OCEAN;
s32 lowest_ground_y = 32767;
s32 highest_ground_y = -32768;
// DEBUG
//sector->printHeightmaps();
@ -1755,14 +1835,19 @@ MapBlock * ServerMap::emergeBlock(
//avg_ground_y += surface_y;
if(surface_y < lowest_ground_y)
lowest_ground_y = surface_y;
if(surface_y > highest_ground_y)
highest_ground_y = surface_y;
s32 surface_depth = 0;
float slope = sector->getSlope(v2s16(x0,z0)).getLength();
float min_slope = 0.45;
float max_slope = 0.85;
float min_slope_depth = 5.0;
//float min_slope = 0.45;
//float max_slope = 0.85;
float min_slope = 0.70;
float max_slope = 1.20;
float min_slope_depth = 4.0;
//float min_slope_depth = 5.0;
float max_slope_depth = 0;
if(slope < min_slope)
surface_depth = min_slope_depth;
@ -1783,33 +1868,55 @@ MapBlock * ServerMap::emergeBlock(
*/
if(real_y > surface_y)
n.setLight(LIGHT_SUN);
/*
Calculate material
*/
// If node is very low
if(real_y <= surface_y - 7){
/*if(real_y <= surface_y - 7)
{
// Create dungeons
if(underground_emptiness[
ued*ued*(z0*ued/MAP_BLOCKSIZE)
+ued*(y0*ued/MAP_BLOCKSIZE)
+(x0*ued/MAP_BLOCKSIZE)])
{
n.d = MATERIAL_AIR;
n.d = CONTENT_AIR;
}
else
{
n.d = MATERIAL_STONE;
n.d = CONTENT_STONE;
}
}
// If node is under surface level
else if(real_y <= surface_y - surface_depth)
n.d = MATERIAL_STONE;
n.d = CONTENT_STONE;
*/
if(real_y <= surface_y - surface_depth)
{
// Create dungeons
if(underground_emptiness[
ued*ued*(z0*ued/MAP_BLOCKSIZE)
+ued*(y0*ued/MAP_BLOCKSIZE)
+(x0*ued/MAP_BLOCKSIZE)])
{
n.d = CONTENT_AIR;
}
else
{
n.d = CONTENT_STONE;
}
}
// If node is at or under heightmap y
else if(real_y <= surface_y)
{
// If under water level, it's mud
if(real_y < WATER_LEVEL)
n.d = MATERIAL_MUD;
n.d = CONTENT_MUD;
// Only the topmost node is grass
else if(real_y <= surface_y - 1)
n.d = CONTENT_MUD;
// Else it's the main material
else
n.d = material;
@ -1819,13 +1926,12 @@ MapBlock * ServerMap::emergeBlock(
// If under water level, it's water
if(real_y < WATER_LEVEL)
{
//n.d = MATERIAL_WATER;
n.d = MATERIAL_OCEAN;
n.d = water_material;
n.setLight(diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
}
// else air
else
n.d = MATERIAL_AIR;
n.d = CONTENT_AIR;
}
block->setNode(v3s16(x0,y0,z0), n);
}
@ -1836,15 +1942,17 @@ MapBlock * ServerMap::emergeBlock(
*/
// Probably underground if the highest part of block is under lowest
// ground height
bool is_underground = (block_y+1) * MAP_BLOCKSIZE < lowest_ground_y;
bool is_underground = (block_y+1) * MAP_BLOCKSIZE <= lowest_ground_y;
block->setIsUnderground(is_underground);
/*
Force lighting update if underground.
This is needed because of ravines.
Force lighting update if some part of block is underground
This is needed because of caves.
*/
if(is_underground)
bool some_part_underground = (block_y+0) * MAP_BLOCKSIZE < highest_ground_y;
if(some_part_underground)
//if(is_underground)
{
lighting_invalidated_blocks[block->getPos()] = block;
}
@ -1867,15 +1975,15 @@ MapBlock * ServerMap::emergeBlock(
);
MapNode n;
n.d = MATERIAL_MESE;
n.d = CONTENT_MESE;
if(is_ground_material(block->getNode(cp).d))
if(is_ground_content(block->getNode(cp).d))
if(rand()%8 == 0)
block->setNode(cp, n);
for(u16 i=0; i<26; i++)
{
if(is_ground_material(block->getNode(cp+g_26dirs[i]).d))
if(is_ground_content(block->getNode(cp+g_26dirs[i]).d))
if(rand()%8 == 0)
block->setNode(cp+g_26dirs[i], n);
}
@ -1897,7 +2005,7 @@ MapBlock * ServerMap::emergeBlock(
);
// Check that the place is empty
//if(!is_ground_material(block->getNode(cp).d))
//if(!is_ground_content(block->getNode(cp).d))
if(1)
{
RatObject *obj = new RatObject(NULL, -1, intToFloat(cp));
@ -1978,7 +2086,7 @@ MapBlock * ServerMap::emergeBlock(
p + v3s16(0,0,0), &changed_blocks_sector))
{
MapNode n;
n.d = MATERIAL_LIGHT;
n.d = CONTENT_LIGHT;
sector->setNode(p, n);
objects_to_remove.push_back(p);
}
@ -1991,13 +2099,13 @@ MapBlock * ServerMap::emergeBlock(
&changed_blocks_sector))
{
MapNode n;
n.d = MATERIAL_TREE;
n.d = CONTENT_TREE;
sector->setNode(p+v3s16(0,0,0), n);
sector->setNode(p+v3s16(0,1,0), n);
sector->setNode(p+v3s16(0,2,0), n);
sector->setNode(p+v3s16(0,3,0), n);
n.d = MATERIAL_LEAVES;
n.d = CONTENT_LEAVES;
sector->setNode(p+v3s16(0,4,0), n);
@ -2032,7 +2140,7 @@ MapBlock * ServerMap::emergeBlock(
p + v3s16(0,0,0), &changed_blocks_sector))
{
MapNode n;
n.d = MATERIAL_LEAVES;
n.d = CONTENT_LEAVES;
sector->setNode(p+v3s16(0,0,0), n);
objects_to_remove.push_back(p);
@ -2047,9 +2155,9 @@ MapBlock * ServerMap::emergeBlock(
&changed_blocks_sector))
{
MapNode n;
n.d = MATERIAL_STONE;
n.d = CONTENT_STONE;
MapNode n2;
n2.d = MATERIAL_AIR;
n2.d = CONTENT_AIR;
s16 depth = maxdepth + (rand()%10);
s16 z = 0;
s16 minz = -6 - (-2);
@ -2067,22 +2175,22 @@ MapBlock * ServerMap::emergeBlock(
<<std::endl;*/
{
v3s16 p2 = p + v3s16(x,y,z-2);
if(is_ground_material(sector->getNode(p2).d))
if(is_ground_content(sector->getNode(p2).d))
sector->setNode(p2, n);
}
{
v3s16 p2 = p + v3s16(x,y,z-1);
if(is_ground_material(sector->getNode(p2).d))
if(is_ground_content(sector->getNode(p2).d))
sector->setNode(p2, n2);
}
{
v3s16 p2 = p + v3s16(x,y,z+0);
if(is_ground_material(sector->getNode(p2).d))
if(is_ground_content(sector->getNode(p2).d))
sector->setNode(p2, n2);
}
{
v3s16 p2 = p + v3s16(x,y,z+1);
if(is_ground_material(sector->getNode(p2).d))
if(is_ground_content(sector->getNode(p2).d))
sector->setNode(p2, n);
}
@ -3100,7 +3208,7 @@ void ClientMap::updateMesh()
/*dstream<<"mesh_old refcount="<<mesh_old->getReferenceCount()
<<std::endl;
scene::IMeshBuffer *buf = mesh_new->getMeshBuffer
(g_materials[MATERIAL_GRASS]);
(g_materials[CONTENT_GRASS]);
if(buf != NULL)
dstream<<"grass buf refcount="<<buf->getReferenceCount()
<<std::endl;*/

157
src/mapblock.cpp
View File

@ -111,7 +111,7 @@ FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p,
u8 alpha = 255;
if(material == MATERIAL_WATER || material == MATERIAL_OCEAN)
if(material == CONTENT_WATER || material == CONTENT_OCEAN)
{
alpha = 128;
}
@ -152,7 +152,11 @@ u8 MapBlock::getFaceLight(v3s16 p, v3s16 face_dir)
MapNode n = getNodeParent(p);
MapNode n2 = getNodeParent(p + face_dir);
u8 light;
if(n.solidness() < n2.solidness())
/*if(n.solidness() < n2.solidness())
light = n.getLight();
else
light = n2.getLight();*/
if(n.getLight() > n2.getLight())
light = n.getLight();
else
light = n2.getLight();
@ -173,18 +177,18 @@ u8 MapBlock::getFaceLight(v3s16 p, v3s16 face_dir)
/*
Gets node material from any place relative to block.
Returns MATERIAL_IGNORE if doesn't exist or should not be drawn.
Returns CONTENT_IGNORE if doesn't exist or should not be drawn.
*/
u8 MapBlock::getNodeMaterial(v3s16 p)
u8 MapBlock::getNodeTile(v3s16 p)
{
try{
MapNode n = getNodeParent(p);
return content_cube_material(n.d);
return content_tile(n.d);
}
catch(InvalidPositionException &e)
{
return MATERIAL_IGNORE;
return CONTENT_IGNORE;
}
}
@ -216,82 +220,82 @@ void MapBlock::updateFastFaceRow(v3s16 startpos,
*/
u8 light = getFaceLight(p, face_dir);
u16 continuous_materials_count = 0;
u16 continuous_tiles_count = 0;
u8 material0 = getNodeMaterial(p);
u8 material1 = getNodeMaterial(p + face_dir);
u8 tile0 = getNodeTile(p);
u8 tile1 = getNodeTile(p + face_dir);
for(u16 j=0; j<length; j++)
{
bool next_is_different = true;
v3s16 p_next;
u8 material0_next = 0;
u8 material1_next = 0;
u8 tile0_next = 0;
u8 tile1_next = 0;
u8 light_next = 0;
if(j != length - 1){
p_next = p + translate_dir;
material0_next = getNodeMaterial(p_next);
material1_next = getNodeMaterial(p_next + face_dir);
tile0_next = getNodeTile(p_next);
tile1_next = getNodeTile(p_next + face_dir);
light_next = getFaceLight(p_next, face_dir);
if(material0_next == material0
&& material1_next == material1
if(tile0_next == tile0
&& tile1_next == tile1
&& light_next == light)
{
next_is_different = false;
}
}
continuous_materials_count++;
continuous_tiles_count++;
if(next_is_different)
{
/*
Create a face if there should be one
*/
u8 mf = face_materials(material0, material1);
u8 mf = face_contents(tile0, tile1);
if(mf != 0)
{
// Floating point conversion of the position vector
v3f pf(p.X, p.Y, p.Z);
// Center point of face (kind of)
v3f sp = pf - ((f32)continuous_materials_count / 2. - 0.5) * translate_dir_f;
v3f sp = pf - ((f32)continuous_tiles_count / 2. - 0.5) * translate_dir_f;
v3f scale(1,1,1);
if(translate_dir.X != 0){
scale.X = continuous_materials_count;
scale.X = continuous_tiles_count;
}
if(translate_dir.Y != 0){
scale.Y = continuous_materials_count;
scale.Y = continuous_tiles_count;
}
if(translate_dir.Z != 0){
scale.Z = continuous_materials_count;
scale.Z = continuous_tiles_count;
}
FastFace *f;
// If node at sp (material0) is more solid
// If node at sp (tile0) is more solid
if(mf == 1)
{
f = makeFastFace(material0, light,
f = makeFastFace(tile0, light,
sp, face_dir_f, scale,
posRelative_f);
}
// If node at sp is less solid (mf == 2)
else
{
f = makeFastFace(material1, light,
f = makeFastFace(tile1, light,
sp+face_dir_f, -1*face_dir_f, scale,
posRelative_f);
}
dest.push_back(f);
}
continuous_materials_count = 0;
material0 = material0_next;
material1 = material1_next;
continuous_tiles_count = 0;
tile0 = tile0_next;
tile1 = tile1_next;
light = light_next;
}
@ -451,6 +455,8 @@ void MapBlock::updateMesh()
scene::SMesh *mesh_new = NULL;
mesh_new = new scene::SMesh();
if(fastfaces_new->getSize() > 0)
{
MeshCollector collector;
@ -467,8 +473,6 @@ void MapBlock::updateMesh()
indices, 6);
}
mesh_new = new scene::SMesh();
collector.fillMesh(mesh_new);
// Use VBO for mesh (this just would set this for ever buffer)
@ -495,13 +499,103 @@ void MapBlock::updateMesh()
/*
Add special graphics:
- torches
TODO: Optimize by using same meshbuffer for same textures
*/
/*scene::ISceneManager *smgr = NULL;
video::IVideoDriver* driver = NULL;
if(g_device)
{
smgr = g_device->getSceneManager();
driver = smgr->getVideoDriver();
}*/
for(s16 z=0; z<MAP_BLOCKSIZE; z++)
for(s16 y=0; y<MAP_BLOCKSIZE; y++)
for(s16 x=0; x<MAP_BLOCKSIZE; x++)
{
v3s16 p(x,y,z);
MapNode &n = getNodeRef(x,y,z);
if(n.d == CONTENT_LIGHT)
{
//scene::IMeshBuffer *buf = new scene::SMeshBuffer();
scene::SMeshBuffer *buf = new scene::SMeshBuffer();
video::SColor c(255,255,255,255);
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c, 0,1),
video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c, 1,1),
video::S3DVertex(BS/2,BS/2,0, 0,0,0, c, 1,0),
video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c, 0,0),
};
v3s16 dir = unpackDir(n.dir);
for(s32 i=0; i<4; i++)
{
if(dir == v3s16(1,0,0))
vertices[i].Pos.rotateXZBy(0);
if(dir == v3s16(-1,0,0))
vertices[i].Pos.rotateXZBy(180);
if(dir == v3s16(0,0,1))
vertices[i].Pos.rotateXZBy(90);
if(dir == v3s16(0,0,-1))
vertices[i].Pos.rotateXZBy(-90);
if(dir == v3s16(0,-1,0))
vertices[i].Pos.rotateXZBy(45);
if(dir == v3s16(0,1,0))
vertices[i].Pos.rotateXZBy(-45);
vertices[i].Pos += intToFloat(p + getPosRelative());
}
u16 indices[] = {0,1,2,2,3,0};
buf->append(vertices, 4, indices, 6);
// Set material
buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
//buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
buf->getMaterial().MaterialType
= video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
if(dir == v3s16(0,-1,0))
buf->getMaterial().setTexture(0,
g_texturecache.get("torch_on_floor"));
else if(dir == v3s16(0,1,0))
buf->getMaterial().setTexture(0,
g_texturecache.get("torch_on_ceiling"));
// For backwards compatibility
else if(dir == v3s16(0,0,0))
buf->getMaterial().setTexture(0,
g_texturecache.get("torch_on_floor"));
else
buf->getMaterial().setTexture(0, g_texturecache.get("torch"));
// Add to mesh
mesh_new->addMeshBuffer(buf);
buf->drop();
}
}
/*
Do some stuff to the mesh
*/
mesh_new->recalculateBoundingBox();
/*
Delete new mesh if it is empty
*/
if(mesh_new->getMeshBufferCount() == 0)
{
mesh_new->drop();
mesh_new = NULL;
}
/*
@ -681,6 +775,11 @@ void MapBlock::copyTo(VoxelManipulator &dst)
getPosRelative(), data_size);
}
/*void getPseudoObjects(v3f origin, f32 max_d,
core::array<DistanceSortedObject> &dest)
{
}*/
/*
Serialization
*/

9
src/mapblock.h
View File

@ -288,11 +288,7 @@ public:
u8 getFaceLight(v3s16 p, v3s16 face_dir);
/*
Gets node material from any place relative to block.
Returns MATERIAL_AIR if doesn't exist.
*/
u8 getNodeMaterial(v3s16 p);
u8 getNodeTile(v3s16 p);
/*
startpos:
@ -376,6 +372,9 @@ public:
m_objects.getObjects(origin, max_d, dest);
}
/*void getPseudoObjects(v3f origin, f32 max_d,
core::array<DistanceSortedObject> &dest);*/
s32 getObjectCount()
{
return m_objects.getCount();

2
src/mapblockobject.cpp
View File

@ -145,7 +145,7 @@ void MovingObject::move(float dtime, v3f acceleration)
for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++)
{
try{
if(material_walkable(m_block->getNodeParent(v3s16(x,y,z)).d)
if(content_walkable(m_block->getNodeParent(v3s16(x,y,z)).d)
== false)
continue;
}

64
src/mapblockobject.h
View File

@ -28,13 +28,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "constants.h"
#include "debug.h"
enum
{
MAPBLOCKOBJECT_TYPE_TEST=0,
MAPBLOCKOBJECT_TYPE_TEST2=1,
MAPBLOCKOBJECT_TYPE_SIGN=2,
MAPBLOCKOBJECT_TYPE_RAT=3,
};
#define MAPBLOCKOBJECT_TYPE_TEST 0
#define MAPBLOCKOBJECT_TYPE_TEST2 1
#define MAPBLOCKOBJECT_TYPE_SIGN 2
#define MAPBLOCKOBJECT_TYPE_RAT 3
// Used for handling selecting special stuff
//#define MAPBLOCKOBJECT_TYPE_PSEUDO 4
class MapBlock;
@ -170,6 +169,57 @@ protected:
friend class MapBlockObjectList;
};
#if 0
/*
Used for handling selections of special stuff
*/
class PseudoMBObject : public MapBlockObject
{
public:
// The constructor of every MapBlockObject should be like this
PseudoMBObject(MapBlock *block, s16 id, v3f pos):
MapBlockObject(block, id, pos)
{
}
virtual ~PseudoMBObject()
{
if(m_selection_box)
delete m_selection_box;
}
/*
Implementation interface
*/
virtual u16 getTypeId() const
{
return MAPBLOCKOBJECT_TYPE_PSEUDO;
}
virtual void serialize(std::ostream &os, u8 version)
{
assert(0);
}
virtual void update(std::istream &is, u8 version)
{
assert(0);
}
virtual bool serverStep(float dtime)
{
assert(0);
}
/*
Special methods
*/
void setSelectionBox(core::aabbox3d<f32> box)
{
m_selection_box = new core::aabbox3d<f32>(box);
}
protected:
};
#endif
class TestObject : public MapBlockObject
{
public:

205
src/mapnode.h
View File

@ -41,66 +41,68 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Doesn't create faces with anything and is considered being
out-of-map in the game map.
*/
#define MATERIAL_IGNORE 255
#define MATERIAL_IGNORE_DEFAULT_PARAM 0
#define CONTENT_IGNORE 255
#define CONTENT_IGNORE_DEFAULT_PARAM 0
/*
The common material through which the player can walk and which
is transparent to light
*/
#define MATERIAL_AIR 254
#define CONTENT_AIR 254
/*
Materials-todo:
Suggested materials:
GRAVEL
- Dynamics of gravel: if there is a drop of more than two
blocks on any side, it will drop in there. Is this doable?
TODO: These should be named to "content" or something like that
New naming scheme:
- Material = irrlicht's Material class
- Content = (u8) content of a node
- Tile = (u16) Material ID at some side of a node
*/
enum Material
enum Content
{
MATERIAL_STONE=0,
CONTENT_STONE=0,
MATERIAL_GRASS,
CONTENT_GRASS,
MATERIAL_WATER,
CONTENT_WATER,
MATERIAL_LIGHT,
CONTENT_LIGHT,
MATERIAL_TREE,
CONTENT_TREE,
MATERIAL_LEAVES,
CONTENT_LEAVES,
MATERIAL_GRASS_FOOTSTEPS,
CONTENT_GRASS_FOOTSTEPS,
MATERIAL_MESE,
CONTENT_MESE,
MATERIAL_MUD,
CONTENT_MUD,
MATERIAL_OCEAN,
CONTENT_OCEAN,
// This is set to the number of the actual values in this enum
USEFUL_MATERIAL_COUNT
USEFUL_CONTENT_COUNT
};
/*
If true, the material allows light propagation and brightness is stored
in param.
*/
inline bool light_propagates_material(u8 m)
inline bool light_propagates_content(u8 m)
{
return (m == MATERIAL_AIR || m == MATERIAL_LIGHT || m == MATERIAL_WATER || m == MATERIAL_OCEAN);
return (m == CONTENT_AIR || m == CONTENT_LIGHT || m == CONTENT_WATER || m == CONTENT_OCEAN);
}
/*
If true, the material allows lossless sunlight propagation.
*/
inline bool sunlight_propagates_material(u8 m)
inline bool sunlight_propagates_content(u8 m)
{
return (m == MATERIAL_AIR);
return (m == CONTENT_AIR || m == CONTENT_LIGHT);
}
/*
@ -110,98 +112,157 @@ inline bool sunlight_propagates_material(u8 m)
1: Transparent
2: Opaque
*/
inline u8 material_solidness(u8 m)
inline u8 content_solidness(u8 m)
{
if(m == MATERIAL_AIR)
if(m == CONTENT_AIR)
return 0;
if(m == MATERIAL_WATER || m == MATERIAL_OCEAN)
if(m == CONTENT_WATER || m == CONTENT_OCEAN)
return 1;
return 2;
}
// Objects collide with walkable materials
inline bool material_walkable(u8 m)
// Objects collide with walkable contents
inline bool content_walkable(u8 m)
{
return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN && m != MATERIAL_LIGHT);
return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN && m != CONTENT_LIGHT);
}
// A liquid resists fast movement
inline bool material_liquid(u8 m)
inline bool content_liquid(u8 m)
{
return (m == MATERIAL_WATER || m == MATERIAL_OCEAN);
return (m == CONTENT_WATER || m == CONTENT_OCEAN);
}
// Pointable materials can be pointed to in the map
inline bool material_pointable(u8 m)
// Pointable contents can be pointed to in the map
inline bool content_pointable(u8 m)
{
return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN);
return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN);
}
inline bool material_diggable(u8 m)
inline bool content_diggable(u8 m)
{
return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN);
return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN);
}
inline bool material_buildable_to(u8 m)
inline bool content_buildable_to(u8 m)
{
return (m == MATERIAL_AIR || m == MATERIAL_WATER || m == MATERIAL_OCEAN);
return (m == CONTENT_AIR || m == CONTENT_WATER || m == CONTENT_OCEAN);
}
/*
As of now, input is a "material" and the output is a "material"
TODO: Make a mapper class for mapping every side of a content
to some tile.
This dumbily maps all sides of content to the tile of the same id.
*/
inline u8 content_cube_material(u8 c)
inline u8 content_tile(u8 c)
{
if(c == MATERIAL_IGNORE || c == MATERIAL_LIGHT)
return MATERIAL_AIR;
if(c == CONTENT_IGNORE || c == CONTENT_LIGHT)
return CONTENT_AIR;
return c;
}
/*
Returns true for materials that form the base ground that
Returns true for contents that form the base ground that
follows the main heightmap
*/
inline bool is_ground_material(u8 m)
inline bool is_ground_content(u8 m)
{
return(
m == MATERIAL_STONE ||
m == MATERIAL_GRASS ||
m == MATERIAL_GRASS_FOOTSTEPS ||
m == MATERIAL_MESE ||
m == MATERIAL_MUD
m == CONTENT_STONE ||
m == CONTENT_GRASS ||
m == CONTENT_GRASS_FOOTSTEPS ||
m == CONTENT_MESE ||
m == CONTENT_MUD
);
}
/*
Nodes make a face if materials differ and solidness differs.
Nodes make a face if contents differ and solidness differs.
Return value:
0: No face
1: Face uses m1's material
2: Face uses m2's material
1: Face uses m1's content
2: Face uses m2's content
*/
inline u8 face_materials(u8 m1, u8 m2)
inline u8 face_contents(u8 m1, u8 m2)
{
if(m1 == MATERIAL_IGNORE || m2 == MATERIAL_IGNORE)
if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
return 0;
bool materials_differ = (m1 != m2);
bool solidness_differs = (material_solidness(m1) != material_solidness(m2));
bool makes_face = materials_differ && solidness_differs;
bool contents_differ = (m1 != m2);
bool solidness_differs = (content_solidness(m1) != content_solidness(m2));
bool makes_face = contents_differ && solidness_differs;
if(makes_face == false)
return 0;
if(material_solidness(m1) > material_solidness(m2))
if(content_solidness(m1) > content_solidness(m2))
return 1;
else
return 2;
}
inline bool liquid_replaces_content(u8 c)
{
return (c == CONTENT_AIR || c == CONTENT_LIGHT);
}
/*
When placing a node, drection info is added to it if this is true
*/
inline bool content_directional(u8 c)
{
return (c == CONTENT_LIGHT);
}
/*
Packs directions like (1,0,0), (1,-1,0)
*/
inline u8 packDir(v3s16 dir)
{
u8 b = 0;
if(dir.X > 0)
b |= (1<<0);
else if(dir.X < 0)
b |= (1<<1);
if(dir.Y > 0)
b |= (1<<2);
else if(dir.Y < 0)
b |= (1<<3);
if(dir.Z > 0)
b |= (1<<4);
else if(dir.Z < 0)
b |= (1<<5);
return b;
}
inline v3s16 unpackDir(u8 b)
{
v3s16 d(0,0,0);
if(b & (1<<0))
d.X = 1;
else if(b & (1<<1))
d.X = -1;
if(b & (1<<2))
d.Y = 1;
else if(b & (1<<3))
d.Y = -1;
if(b & (1<<4))
d.Z = 1;
else if(b & (1<<5))
d.Z = -1;
return d;
}
struct MapNode
{
//TODO: block type to differ from material
// (e.g. grass edges or something)
// block type
// Content
u8 d;
/*
@ -212,14 +273,26 @@ struct MapNode
*/
s8 param;
union
{
/*
Pressure for liquids
*/
u8 pressure;
/*
Direction for torches and other stuff.
If possible, packed with packDir.
*/
u8 dir;
};
MapNode(const MapNode & n)
{
*this = n;
}
MapNode(u8 data=MATERIAL_AIR, u8 a_param=0, u8 a_pressure=0)
MapNode(u8 data=CONTENT_AIR, u8 a_param=0, u8 a_pressure=0)
{
d = data;
param = a_param;
@ -235,17 +308,17 @@ struct MapNode
bool light_propagates()
{
return light_propagates_material(d);
return light_propagates_content(d);
}
bool sunlight_propagates()
{
return sunlight_propagates_material(d);
return sunlight_propagates_content(d);
}
u8 solidness()
{
return material_solidness(d);
return content_solidness(d);
}
u8 light_source()
@ -253,7 +326,7 @@ struct MapNode
/*
Note that a block that isn't light_propagates() can be a light source.
*/
if(d == MATERIAL_LIGHT)
if(d == CONTENT_LIGHT)
return LIGHT_MAX;
return 0;
@ -261,7 +334,7 @@ struct MapNode
u8 getLight()
{
// Select the brightest of [light_source, transparent_light]
// Select the brightest of [light source, propagated light]
u8 light = 0;
if(light_propagates())
light = param & 0x0f;

6
src/player.cpp
View File

@ -72,12 +72,12 @@ void Player::move(f32 dtime, Map &map)
if(in_water)
{
v3s16 pp = floatToInt(position + v3f(0,0,0));
in_water = material_liquid(map.getNode(pp).d);
in_water = content_liquid(map.getNode(pp).d);
}
else
{
v3s16 pp = floatToInt(position + v3f(0,BS/2,0));
in_water = material_liquid(map.getNode(pp).d);
in_water = content_liquid(map.getNode(pp).d);
}
}
catch(InvalidPositionException &e)
@ -122,7 +122,7 @@ void Player::move(f32 dtime, Map &map)
for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++){
for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++){
try{
if(material_walkable(map.getNode(v3s16(x,y,z)).d) == false){
if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){
continue;
}
}

266
src/server.cpp
View File

@ -95,6 +95,8 @@ void * EmergeThread::Thread()
//derr_server<<"EmergeThread::Thread(): running"<<std::endl;
//TimeTaker timer("block emerge", g_device);
/*
Try to emerge it from somewhere.
@ -185,39 +187,32 @@ void * EmergeThread::Thread()
dout_server<<std::endl;
}
/*
Update water pressure
*/
m_server->UpdateBlockWaterPressure(block, modified_blocks);
for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
m_server->UpdateBlockWaterPressure(block, modified_blocks);
//v3s16 p = i.getNode()->getKey();
//m_server->UpdateBlockWaterPressure(p, modified_blocks);
}
/*
Collect a list of blocks that have been modified in
addition to the fetched one.
*/
// Add all the "changed blocks"
// Add all the "changed blocks" to modified_blocks
for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
modified_blocks.insert(block->getPos(), block);
/*
Update water pressure.
This also adds suitable nodes to active_nodes.
*/
MapVoxelManipulator v(&map);
VoxelArea area(block->getPosRelative(),
block->getPosRelative() + v3s16(1,1,1)*(MAP_BLOCKSIZE-1));
try
{
v.updateAreaWaterPressure(area, m_server->m_flow_active_nodes);
}
catch(ProcessingLimitException &e)
{
dstream<<"Processing limit reached (1)"<<std::endl;
}
v.blitBack(modified_blocks);
}
/*dstream<<"lighting "<<lighting_invalidated_blocks.size()
@ -1017,9 +1012,11 @@ void Server::AsyncRunStep()
{
JMutexAutoLock lock(m_env_mutex);
JMutexAutoLock envlock(m_env_mutex);
MapVoxelManipulator v(&m_env.getMap());
v.m_disable_water_climb =
g_settings.getBool("disable_water_climb");
v.flowWater(m_flow_active_nodes, 0, false, 50);
@ -1039,7 +1036,7 @@ void Server::AsyncRunStep()
MapBlock *block = i.getNode()->getValue();
modified_blocks.insert(block->getPos(), block);
}
}
} // envlock
/*
Set the modified blocks unsent for all the clients
@ -1492,7 +1489,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// Get material at position
material = m_env.getMap().getNode(p_under).d;
// If it's not diggable, do nothing
if(material_diggable(material) == false)
if(content_diggable(material) == false)
{
return;
}
@ -1539,6 +1536,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// This also adds it to m_flow_active_nodes if appropriate
MapVoxelManipulator v(&m_env.getMap());
v.m_disable_water_climb =
g_settings.getBool("disable_water_climb");
VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1));
@ -1575,15 +1574,10 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
*/
if(std::string("MaterialItem") == item->getName())
{
MaterialItem *mitem = (MaterialItem*)item;
MapNode n;
n.d = mitem->getMaterial();
try{
// Don't add a node if this is not a free space
MapNode n2 = m_env.getMap().getNode(p_over);
if(material_buildable_to(n2.d) == false)
if(content_buildable_to(n2.d) == false)
return;
}
catch(InvalidPositionException &e)
@ -1596,17 +1590,14 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// Reset build time counter
getClient(peer->id)->m_time_from_building.set(0.0);
if(g_settings.getBool("creative_mode") == false)
{
// Remove from inventory and send inventory
if(mitem->getCount() == 1)
player->inventory.deleteItem(item_i);
else
mitem->remove(1);
// Send inventory
SendInventory(peer_id);
}
// Create node data
MaterialItem *mitem = (MaterialItem*)item;
MapNode n;
n.d = mitem->getMaterial();
if(content_directional(n.d))
n.dir = packDir(p_under - p_over);
#if 1
// Create packet
u32 replysize = 8 + MapNode::serializedLength(peer_ser_ver);
SharedBuffer<u8> reply(replysize);
@ -1618,6 +1609,20 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// Send as reliable
m_con.SendToAll(0, reply, true);
/*
Handle inventory
*/
if(g_settings.getBool("creative_mode") == false)
{
// Remove from inventory and send inventory
if(mitem->getCount() == 1)
player->inventory.deleteItem(item_i);
else
mitem->remove(1);
// Send inventory
SendInventory(peer_id);
}
/*
Add node.
@ -1625,6 +1630,49 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
*/
core::map<v3s16, MapBlock*> modified_blocks;
m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks);
#endif
#if 0
/*
Handle inventory
*/
if(g_settings.getBool("creative_mode") == false)
{
// Remove from inventory and send inventory
if(mitem->getCount() == 1)
player->inventory.deleteItem(item_i);
else
mitem->remove(1);
// Send inventory
SendInventory(peer_id);
}
/*
Add node.
This takes some time so it is done after the quick stuff
*/
core::map<v3s16, MapBlock*> modified_blocks;
m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks);
/*
Set the modified blocks unsent for all the clients
*/
//JMutexAutoLock lock2(m_con_mutex);
for(core::map<u16, RemoteClient*>::Iterator
i = m_clients.getIterator();
i.atEnd() == false; i++)
{
RemoteClient *client = i.getNode()->getValue();
if(modified_blocks.size() > 0)
{
// Remove block from sent history
client->SetBlocksNotSent(modified_blocks);
}
}
#endif
/*
Update water
@ -1634,6 +1682,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// This also adds it to m_flow_active_nodes if appropriate
MapVoxelManipulator v(&m_env.getMap());
v.m_disable_water_climb =
g_settings.getBool("disable_water_climb");
VoxelArea area(p_over-v3s16(1,1,1), p_over+v3s16(1,1,1));
@ -1826,113 +1876,14 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver)
writeS16(&reply[6], p.Z);
memcpy(&reply[8], *blockdata, blockdata.getSize());
//dstream<<"Sending block: packet size: "<<replysize<<std::endl;
/*
Send packet
*/
m_con.Send(peer_id, 1, reply, true);
}
/*void Server::SendBlock(u16 peer_id, MapBlock *block, u8 ver)
{
JMutexAutoLock conlock(m_con_mutex);
SendBlockNoLock(peer_id, block, ver);
}*/
#if 0
void Server::SendSectorMeta(u16 peer_id, core::list<v2s16> ps, u8 ver)
{
DSTACK(__FUNCTION_NAME);
dstream<<"Server sending sector meta of "
<<ps.getSize()<<" sectors"<<std::endl;
core::list<v2s16>::Iterator i = ps.begin();
core::list<v2s16> sendlist;
for(;;)
{
if(sendlist.size() == 255 || i == ps.end())
{
if(sendlist.size() == 0)
break;
/*
[0] u16 command
[2] u8 sector count
[3...] v2s16 pos + sector metadata
*/
std::ostringstream os(std::ios_base::binary);
u8 buf[4];
writeU16(buf, TOCLIENT_SECTORMETA);
os.write((char*)buf, 2);
writeU8(buf, sendlist.size());
os.write((char*)buf, 1);
for(core::list<v2s16>::Iterator
j = sendlist.begin();
j != sendlist.end(); j++)
{
// Write position
writeV2S16(buf, *j);
os.write((char*)buf, 4);
/*
Write ClientMapSector metadata
*/
/*
[0] u8 serialization version
[1] s16 corners[0]
[3] s16 corners[1]
[5] s16 corners[2]
[7] s16 corners[3]
size = 9
In which corners are in these positions
v2s16(0,0),
v2s16(1,0),
v2s16(1,1),
v2s16(0,1),
*/
// Write version
writeU8(buf, ver);
os.write((char*)buf, 1);
// Write corners
// TODO: Get real values
s16 corners[4];
((ServerMap&)m_env.getMap()).getSectorCorners(*j, corners);
writeS16(buf, corners[0]);
os.write((char*)buf, 2);
writeS16(buf, corners[1]);
os.write((char*)buf, 2);
writeS16(buf, corners[2]);
os.write((char*)buf, 2);
writeS16(buf, corners[3]);
os.write((char*)buf, 2);
}
SharedBuffer<u8> data((u8*)os.str().c_str(), os.str().size());
/*dstream<<"Server::SendSectorMeta(): sending packet"
" with "<<sendlist.size()<<" sectors"<<std::endl;*/
m_con.Send(peer_id, 1, data, true);
if(i == ps.end())
break;
sendlist.clear();
}
sendlist.push_back(*i);
i++;
}
}
#endif
core::list<PlayerInfo> Server::getPlayerInfo()
{
DSTACK(__FUNCTION_NAME);
@ -2039,11 +1990,11 @@ void Server::peerAdded(con::Peer *peer)
if(g_settings.getBool("creative_mode"))
{
// Give all materials
assert(USEFUL_MATERIAL_COUNT <= PLAYER_INVENTORY_SIZE);
for(u16 i=0; i<USEFUL_MATERIAL_COUNT; i++)
assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE);
for(u16 i=0; i<USEFUL_CONTENT_COUNT; i++)
{
// Skip some materials
if(i == MATERIAL_OCEAN)
if(i == CONTENT_OCEAN)
continue;
InventoryItem *item = new MaterialItem(i, 1);
@ -2272,4 +2223,27 @@ RemoteClient* Server::getClient(u16 peer_id)
return n->getValue();
}
void Server::UpdateBlockWaterPressure(MapBlock *block,
core::map<v3s16, MapBlock*> &modified_blocks)
{
MapVoxelManipulator v(&m_env.getMap());
v.m_disable_water_climb =
g_settings.getBool("disable_water_climb");
VoxelArea area(block->getPosRelative(),
block->getPosRelative() + v3s16(1,1,1)*(MAP_BLOCKSIZE-1));
try
{
v.updateAreaWaterPressure(area, m_flow_active_nodes);
}
catch(ProcessingLimitException &e)
{
dstream<<"Processing limit reached (1)"<<std::endl;
}
v.blitBack(modified_blocks);
}

12
src/server.h
View File

@ -275,7 +275,7 @@ public:
u8 pending_serialization_version;
RemoteClient():
m_time_from_building(0.0)
m_time_from_building(9999)
//m_num_blocks_in_emerge_queue(0)
{
peer_id = 0;
@ -451,9 +451,17 @@ private:
// When called, connection mutex should be locked
RemoteClient* getClient(u16 peer_id);
/*
Update water pressure.
This also adds suitable nodes to active_nodes.
environment has to be locked when calling.
*/
void UpdateBlockWaterPressure(MapBlock *block,
core::map<v3s16, MapBlock*> &modified_blocks);
// NOTE: If connection and environment are both to be locked,
// environment shall be locked first.
JMutex m_env_mutex;
Environment m_env;

32
src/test.cpp
View File

@ -133,11 +133,11 @@ struct TestMapNode
MapNode n;
// Default values
assert(n.d == MATERIAL_AIR);
assert(n.d == CONTENT_AIR);
assert(n.getLight() == 0);
// Transparency
n.d = MATERIAL_AIR;
n.d = CONTENT_AIR;
assert(n.light_propagates() == true);
n.d = 0;
assert(n.light_propagates() == false);
@ -243,11 +243,11 @@ struct TestVoxelManipulator
MapNode n;
//n.pressure = size.Y - y;
if(*p == '#')
n.d = MATERIAL_STONE;
n.d = CONTENT_STONE;
else if(*p == '.')
n.d = MATERIAL_WATER;
n.d = CONTENT_WATER;
else if(*p == ' ')
n.d = MATERIAL_AIR;
n.d = CONTENT_AIR;
else
assert(0);
v.setNode(v3s16(x,y,z), n);
@ -262,8 +262,12 @@ struct TestVoxelManipulator
v.print(dstream, VOXELPRINT_WATERPRESSURE);
s16 highest_y = -32768;
assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1);
assert(highest_y == 3);
/*
NOTE: These are commented out because this behaviour is changed
all the time
*/
//assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1);
//assert(highest_y == 3);
/*assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == 3);
//assert(highest_y == 3);*/
@ -365,11 +369,11 @@ struct TestMapBlock
assert(b.getChangedFlag() == false);
// All nodes should have been set to
// .d=MATERIAL_AIR and .getLight() = 0
// .d=CONTENT_AIR and .getLight() = 0
for(u16 z=0; z<MAP_BLOCKSIZE; z++)
for(u16 y=0; y<MAP_BLOCKSIZE; y++)
for(u16 x=0; x<MAP_BLOCKSIZE; x++){
assert(b.getNode(v3s16(x,y,z)).d == MATERIAL_AIR);
assert(b.getNode(v3s16(x,y,z)).d == CONTENT_AIR);
assert(b.getNode(v3s16(x,y,z)).getLight() == 0);
}
@ -385,7 +389,7 @@ struct TestMapBlock
assert(b.isValidPositionParent(v3s16(0,0,0)) == true);
assert(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true);
n = b.getNodeParent(v3s16(0,MAP_BLOCKSIZE-1,0));
assert(n.d == MATERIAL_AIR);
assert(n.d == CONTENT_AIR);
// ...but outside the block they should be invalid
assert(b.isValidPositionParent(v3s16(-121,2341,0)) == false);
@ -420,8 +424,8 @@ struct TestMapBlock
n.d = 4;
b.setNode(p, n);
assert(b.getNode(p).d == 4);
assert(b.getNodeMaterial(p) == 4);
assert(b.getNodeMaterial(v3s16(-1,-1,0)) == 5);
assert(b.getNodeTile(p) == 4);
assert(b.getNodeTile(v3s16(-1,-1,0)) == 5);
/*
propagateSunlight()
@ -442,7 +446,7 @@ struct TestMapBlock
*/
parent.position_valid = true;
b.setIsUnderground(false);
parent.node.d = MATERIAL_AIR;
parent.node.d = CONTENT_AIR;
parent.node.setLight(LIGHT_SUN);
core::map<v3s16, bool> light_sources;
// The bottom block is invalid, because we have a shadowing node
@ -493,7 +497,7 @@ struct TestMapBlock
for(u16 y=0; y<MAP_BLOCKSIZE; y++){
for(u16 x=0; x<MAP_BLOCKSIZE; x++){
MapNode n;
n.d = MATERIAL_AIR;
n.d = CONTENT_AIR;
n.setLight(0);
b.setNode(v3s16(x,y,z), n);
}

42
src/utility.h
View File

@ -32,6 +32,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <fstream>
#include <string>
#include <sstream>
#include <jmutex.h>
#include <jmutexautolock.h>
extern const v3s16 g_26dirs[26];
@ -808,5 +810,45 @@ private:
core::map<std::string, std::string> m_settings;
};
/*
A thread-safe texture cache.
This is used so that irrlicht doesn't get called from many threads
*/
class TextureCache
{
public:
TextureCache()
{
m_mutex.Init();
assert(m_mutex.IsInitialized());
}
void set(std::string name, video::ITexture *texture)
{
JMutexAutoLock lock(m_mutex);
m_textures[name] = texture;
}
video::ITexture* get(std::string name)
{
JMutexAutoLock lock(m_mutex);
core::map<std::string, video::ITexture*>::Node *n;
n = m_textures.find(name);
if(n != NULL)
return n->getValue();
return NULL;
}
private:
core::map<std::string, video::ITexture*> m_textures;
JMutex m_mutex;
};
#endif

73
src/voxel.cpp
View File

@ -41,6 +41,7 @@ VoxelManipulator::VoxelManipulator():
m_data(NULL),
m_flags(NULL)
{
m_disable_water_climb = false;
}
VoxelManipulator::~VoxelManipulator()
@ -103,13 +104,13 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
}
else if(mode == VOXELPRINT_WATERPRESSURE)
{
if(m == MATERIAL_WATER)
if(m == CONTENT_WATER)
{
c = 'w';
if(pr <= 9)
c = pr + '0';
}
else if(m == MATERIAL_AIR)
else if(liquid_replaces_content(m))
{
c = ' ';
}
@ -249,7 +250,7 @@ void VoxelManipulator::interpolate(VoxelArea area)
s16 total = 0;
s16 airness = 0;
u8 m = MATERIAL_IGNORE;
u8 m = CONTENT_IGNORE;
for(s16 i=0; i<8; i++)
//for(s16 i=0; i<26; i++)
@ -263,17 +264,17 @@ void VoxelManipulator::interpolate(VoxelArea area)
MapNode &n = m_data[m_area.index(p2)];
airness += (n.d == MATERIAL_AIR) ? 1 : -1;
airness += (n.d == CONTENT_AIR) ? 1 : -1;
total++;
if(m == MATERIAL_IGNORE && n.d != MATERIAL_AIR)
if(m == CONTENT_IGNORE && n.d != CONTENT_AIR)
m = n.d;
}
// 1 if air, 0 if not
buf[area.index(p)] = airness > -total/2 ? MATERIAL_AIR : m;
//buf[area.index(p)] = airness > -total ? MATERIAL_AIR : m;
//buf[area.index(p)] = airness >= -7 ? MATERIAL_AIR : m;
buf[area.index(p)] = airness > -total/2 ? CONTENT_AIR : m;
//buf[area.index(p)] = airness > -total ? CONTENT_AIR : m;
//buf[area.index(p)] = airness >= -7 ? CONTENT_AIR : m;
}
for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++)
@ -366,13 +367,14 @@ int VoxelManipulator::getWaterPressure(v3s16 p, s16 &highest_y, int recur_count)
continue;
MapNode &n = m_data[m_area.index(p2)];
// Ignore non-liquid nodes
if(material_liquid(n.d) == false)
if(content_liquid(n.d) == false)
continue;
int pr;
// If at ocean surface
if(n.pressure == 1 && n.d == MATERIAL_OCEAN)
if(n.pressure == 1 && n.d == CONTENT_OCEAN)
//if(n.pressure == 1) // Causes glitches but is fast
{
pr = 1;
}
@ -463,12 +465,15 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
NOTE: Do not remove anything from there. We cannot know
here if some other neighbor of it causes flow.
*/
if(n.d == MATERIAL_AIR)
if(liquid_replaces_content(n.d))
{
bool pressure_causes_flow = false;
// If block is at top
// If empty block is at top
if(i == 0)
{
if(m_disable_water_climb)
continue;
//if(pr >= PRESERVE_WATER_VOLUME ? 3 : 2)
if(pr >= 3)
pressure_causes_flow = true;
@ -495,7 +500,7 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
}
// Ignore non-liquid nodes
if(material_liquid(n.d) == false)
if(content_liquid(n.d) == false)
continue;
int pr2 = pr;
@ -512,6 +517,12 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
pr2++;
}
/*if(m_disable_water_climb)
{
if(pr2 > 3)
pr2 = 3;
}*/
// Ignore if correct pressure is already set and is not on
// request_area.
// Thus, request_area can be used for updating as much
@ -556,7 +567,7 @@ void VoxelManipulator::updateAreaWaterPressure(VoxelArea a,
continue;
MapNode &n = m_data[m_area.index(p)];
// Ignore non-liquid nodes
if(material_liquid(n.d) == false)
if(content_liquid(n.d) == false)
continue;
if(checked2_clear == false)
@ -654,14 +665,18 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos,
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
return false;
MapNode &n = m_data[m_area.index(removed_pos)];
// Water can move only to air
if(n.d != MATERIAL_AIR)
// Ignore nodes to which the water can't go
if(liquid_replaces_content(n.d) == false)
return false;
}
s32 i;
for(i=0; i<6; i++)
{
// Don't raise water from bottom
if(m_disable_water_climb && i == 5)
continue;
p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
u8 f = m_flags[m_area.index(p)];
@ -670,7 +685,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos,
continue;
MapNode &n = m_data[m_area.index(p)];
// Only liquid nodes can move
if(material_liquid(n.d) == false)
if(content_liquid(n.d) == false)
continue;
// If block is at top, select it always
if(i == 0)
@ -704,7 +719,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos,
u8 m = m_data[m_area.index(p)].d;
u8 f = m_flags[m_area.index(p)];
if(m == MATERIAL_OCEAN)
if(m == CONTENT_OCEAN)
from_ocean = true;
// Move air bubble if not taking water from ocean
@ -714,9 +729,23 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos,
m_flags[m_area.index(p)] = m_flags[m_area.index(removed_pos)];
}
/*
This has to be done to copy the brightness of a light source
correctly. Otherwise unspreadLight will fuck up when water
has replaced a light source.
*/
u8 light = m_data[m_area.index(removed_pos)].getLight();
m_data[m_area.index(removed_pos)].d = m;
m_flags[m_area.index(removed_pos)] = f;
m_data[m_area.index(removed_pos)].setLight(light);
/*// NOTE: HACK: This has to be set to LIGHT_MAX so that
// unspreadLight will clear all light that came from this node.
// Otherwise there will be weird bugs
m_data[m_area.index(removed_pos)].setLight(LIGHT_MAX);*/
// Mark removed_pos checked
m_flags[m_area.index(removed_pos)] |= VOXELFLAG_CHECKED;
@ -728,7 +757,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos,
/*
NOTE: This does not work as-is
if(m == MATERIAL_OCEAN)
if(m == CONTENT_OCEAN)
{
// If block was raised to surface, increase pressure of
// source node
@ -795,6 +824,10 @@ find_again:
// They are checked in reverse order compared to the previous loop.
for(s32 i=5; i>=0; i--)
{
// Don't try to flow to top
if(m_disable_water_climb && i == 0)
continue;
//v3s16 p = removed_pos + dirs[i];
p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
@ -804,7 +837,7 @@ find_again:
continue;
MapNode &n = m_data[m_area.index(p)];
// Water can only move to air
if(n.d != MATERIAL_AIR)
if(liquid_replaces_content(n.d) == false)
continue;
// Flow water to node

6
src/voxel.h
View File

@ -502,6 +502,12 @@ public:
//TODO: Would these make any speed improvement?
//bool m_pressure_route_valid;
//v3s16 m_pressure_route_surface;
/*
Some settings
*/
bool m_disable_water_climb;
private:
};