Wuzzy
/
BlockColor-Engine
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial commit of mapgen v.2. Lacks configuration and saving to disk.

This commit is contained in:
Perttu Ahola 2011-01-16 19:32:14 +02:00
parent 69e7cd9b5b
commit 7068bc90af
13 changed files with 1197 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/constants.h
View File

@ -26,6 +26,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Cross-platform compatibility crap should go in porting.h.
*/
#define HAXMODE 0
#define APPNAME "minetest"
#define DEBUGFILE "debug.txt"

8
src/defaultsettings.cpp
View File

@ -48,10 +48,12 @@ void set_default_settings()
g_settings.setDefault("ravines_amount", "1.0");
g_settings.setDefault("coal_amount", "1.0");*/
g_settings.setDefault("heightmap_blocksize", "16");
g_settings.setDefault("height_randmax", "linear 0 0 30");
g_settings.setDefault("height_randfactor", "linear 0.50 -0.10 0");
//g_settings.setDefault("height_randmax", "linear 0 0 30");
g_settings.setDefault("height_randmax", "linear 0.5 0 0");
//g_settings.setDefault("height_randfactor", "linear 0.50 -0.10 0");
g_settings.setDefault("height_randfactor", "linear 0.60 0 0");
g_settings.setDefault("height_base", "linear 5 0 0");
g_settings.setDefault("plants_amount", "0.2");
g_settings.setDefault("plants_amount", "1.0");
g_settings.setDefault("ravines_amount", "0");
g_settings.setDefault("coal_amount", "1.0");

2
src/environment.cpp
View File

@ -107,7 +107,7 @@ void Environment::step(float dtime)
v3f playerpos = player->getPosition();
// Apply physics to local player
if(player->isLocal())
if(player->isLocal() && HAXMODE == false)
{
// Apply gravity to local player
v3f speed = player->getSpeed();

313
src/heightmap.cpp
View File

@ -23,6 +23,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "heightmap.h"
// For MAP_BLOCKSIZE
#include "mapblock.h"
/*
ValueGenerator
*/
@ -258,59 +261,6 @@ void FixedHeightmap::generateContinued(f32 randmax, f32 randfactor,
}
}
/*
Seed borders from master heightmap
NOTE: Does this actually have any effect on the output?
*/
/*struct SeedSpec
{
v2s16 neighbour_start;
v2s16 heightmap_start;
v2s16 dir;
};
SeedSpec seeds[4] =
{
{ // Z- edge on X-axis
v2s16(0, -1), // neighbour_start
v2s16(0, 0), // heightmap_start
v2s16(1, 0) // dir
},
{ // Z+ edge on X-axis
v2s16(0, m_blocksize),
v2s16(0, m_blocksize),
v2s16(1, 0)
},
{ // X- edge on Z-axis
v2s16(-1, 0),
v2s16(0, 0),
v2s16(0, 1)
},
{ // X+ edge on Z-axis
v2s16(m_blocksize, 0),
v2s16(m_blocksize, 0),
v2s16(0, 1)
},
};
for(s16 i=0; i<4; i++){
v2s16 npos = seeds[i].neighbour_start + m_pos_on_master * m_blocksize;
v2s16 hpos = seeds[i].heightmap_start;
for(s16 s=0; s<m_blocksize+1; s++){
f32 h = m_master->getGroundHeight(npos, false);
//dstream<<"h="<<h<<std::endl;
if(h < GROUNDHEIGHT_VALID_MINVALUE)
continue;
//break;
setGroundHeight(hpos, h);
hpos += seeds[i].dir;
npos += seeds[i].dir;
}
}*/
/*dstream<<"borders seeded:"<<std::endl;
print();*/
/*
Fill with corners[] (if not already set)
*/
@ -550,28 +500,50 @@ FixedHeightmap * UnlimitedHeightmap::getHeightmap(v2s16 p_from, bool generate)
f32 corners[4];
if(m_palist)
s32 div = SECTOR_HEIGHTMAP_SPLIT * MAP_BLOCKSIZE;
{
//TODO: palist must be taken into account in generateContinued.
// It is almost useless in here.
s32 div = 2 * 16;
Settings *attr = m_palist->getNearAttr(p / div);
assert(attr);
corners[0] = attr->getFloat("baseheight");
corners[1] = attr->getFloat("baseheight");
corners[2] = attr->getFloat("baseheight");
corners[3] = attr->getFloat("baseheight");
PointAttributeList *palist = m_padb->getList("hm_baseheight");
if(palist->empty())
{
corners[0] = 0;
corners[1] = 0;
corners[2] = 0;
corners[3] = 0;
}
else
{
#if 0
corners[0] = palist->getNearAttr((p+v2s16(0,0)) * div).getFloat();
corners[1] = palist->getNearAttr((p+v2s16(1,0)) * div).getFloat();
corners[2] = palist->getNearAttr((p+v2s16(1,1)) * div).getFloat();
corners[3] = palist->getNearAttr((p+v2s16(0,1)) * div).getFloat();
#endif
#if 1
corners[0] = palist->getInterpolatedFloat((p+v2s16(0,0))*div);
corners[1] = palist->getInterpolatedFloat((p+v2s16(1,0))*div);
corners[2] = palist->getInterpolatedFloat((p+v2s16(1,1))*div);
corners[3] = palist->getInterpolatedFloat((p+v2s16(0,1))*div);
#endif
}
}
else
/*else
{
corners[0] = m_base_generator->getValue(p+v2s16(0,0));
corners[1] = m_base_generator->getValue(p+v2s16(1,0));
corners[2] = m_base_generator->getValue(p+v2s16(1,1));
corners[3] = m_base_generator->getValue(p+v2s16(0,1));
}
}*/
f32 randmax = m_randmax_generator->getValue(p);
f32 randfactor = m_randfactor_generator->getValue(p);
/*f32 randmax = m_randmax_generator->getValue(p);
f32 randfactor = m_randfactor_generator->getValue(p);*/
f32 randmax = m_padb->getList("hm_randmax")
->getInterpolatedFloat(p*div);
f32 randfactor = m_padb->getList("hm_randfactor")
->getInterpolatedFloat(p*div);
//dstream<<"randmax="<<randmax<<" randfactor="<<randfactor<<std::endl;
heightmap->generateContinued(randmax, randfactor, corners);
}
@ -697,6 +669,148 @@ void UnlimitedHeightmap::serialize(std::ostream &os, u8 version)
throw VersionMismatchException
("ERROR: UnlimitedHeightmap format not supported");
if(version <= 7)
{
/*if(m_base_generator->getId() != VALUE_GENERATOR_ID_CONSTANT
|| m_randmax_generator->getId() != VALUE_GENERATOR_ID_CONSTANT
|| m_randfactor_generator->getId() != VALUE_GENERATOR_ID_CONSTANT)*/
/*if(std::string(m_base_generator->getName()) != "constant"
|| std::string(m_randmax_generator->getName()) != "constant"
|| std::string(m_randfactor_generator->getName()) != "constant")
{
throw SerializationError
("Cannot write UnlimitedHeightmap in old version: "
"Generators are not ConstantGenerators.");
}*/
// Dummy values
f32 basevalue = 0.0;
f32 randmax = 0.0;
f32 randfactor = 0.0;
// Write version
os.write((char*)&version, 1);
/*
[0] u16 blocksize
[2] s32 randmax*1000
[6] s32 randfactor*1000
[10] s32 basevalue*1000
[14] u32 heightmap_count
[18] X * (v2s16 pos + heightmap)
*/
u32 heightmap_size =
FixedHeightmap::serializedLength(version, m_blocksize);
u32 heightmap_count = m_heightmaps.size();
//dstream<<"heightmap_size="<<heightmap_size<<std::endl;
u32 datasize = 2+4+4+4+4+heightmap_count*(4+heightmap_size);
SharedBuffer<u8> data(datasize);
writeU16(&data[0], m_blocksize);
writeU32(&data[2], (s32)(randmax*1000.0));
writeU32(&data[6], (s32)(randfactor*1000.0));
writeU32(&data[10], (s32)(basevalue*1000.0));
writeU32(&data[14], heightmap_count);
core::map<v2s16, FixedHeightmap*>::Iterator j;
j = m_heightmaps.getIterator();
u32 i=0;
for(; j.atEnd() == false; j++)
{
FixedHeightmap *hm = j.getNode()->getValue();
v2s16 pos = j.getNode()->getKey();
writeV2S16(&data[18+i*(4+heightmap_size)], pos);
hm->serialize(&data[18+i*(4+heightmap_size)+4], version);
i++;
}
os.write((char*)*data, data.getSize());
}
else if(version <= 11)
{
// Write version
os.write((char*)&version, 1);
u8 buf[4];
writeU16(buf, m_blocksize);
os.write((char*)buf, 2);
/*m_randmax_generator->serialize(os);
m_randfactor_generator->serialize(os);
m_base_generator->serialize(os);*/
os<<"constant 0.0\n";
os<<"constant 0.0\n";
os<<"constant 0.0\n";
u32 heightmap_count = m_heightmaps.size();
writeU32(buf, heightmap_count);
os.write((char*)buf, 4);
u32 heightmap_size =
FixedHeightmap::serializedLength(version, m_blocksize);
SharedBuffer<u8> hmdata(heightmap_size);
core::map<v2s16, FixedHeightmap*>::Iterator j;
j = m_heightmaps.getIterator();
u32 i=0;
for(; j.atEnd() == false; j++)
{
v2s16 pos = j.getNode()->getKey();
writeV2S16(buf, pos);
os.write((char*)buf, 4);
FixedHeightmap *hm = j.getNode()->getValue();
hm->serialize(*hmdata, version);
os.write((char*)*hmdata, hmdata.getSize());
i++;
}
}
else
{
// Write version
os.write((char*)&version, 1);
u8 buf[4];
writeU16(buf, m_blocksize);
os.write((char*)buf, 2);
/*m_randmax_generator->serialize(os);
m_randfactor_generator->serialize(os);
m_base_generator->serialize(os);*/
u32 heightmap_count = m_heightmaps.size();
writeU32(buf, heightmap_count);
os.write((char*)buf, 4);
u32 heightmap_size =
FixedHeightmap::serializedLength(version, m_blocksize);
SharedBuffer<u8> hmdata(heightmap_size);
core::map<v2s16, FixedHeightmap*>::Iterator j;
j = m_heightmaps.getIterator();
u32 i=0;
for(; j.atEnd() == false; j++)
{
v2s16 pos = j.getNode()->getKey();
writeV2S16(buf, pos);
os.write((char*)buf, 4);
FixedHeightmap *hm = j.getNode()->getValue();
hm->serialize(*hmdata, version);
os.write((char*)*hmdata, hmdata.getSize());
i++;
}
}
#if 0
if(version <= 7)
{
/*if(m_base_generator->getId() != VALUE_GENERATOR_ID_CONSTANT
@ -797,9 +911,11 @@ void UnlimitedHeightmap::serialize(std::ostream &os, u8 version)
i++;
}
}
#endif
}
UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is)
UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is,
PointAttributeDatabase *padb)
{
u8 version;
is.read((char*)&version, 1);
@ -823,9 +939,10 @@ UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is)
throw SerializationError
("UnlimitedHeightmap::deSerialize: no enough input data");
s16 blocksize = readU16(&data[0]);
f32 randmax = (f32)readU32(&data[2]) / 1000.0;
f32 randfactor = (f32)readU32(&data[6]) / 1000.0;
f32 basevalue = (f32)readU32(&data[10]) / 1000.0;
// Dummy read randmax, randfactor, basevalue
/*f32 randmax = (f32)*/readU32(&data[2]) /*/ 1000.0*/;
/*f32 randfactor = (f32)*/readU32(&data[6]) /*/ 1000.0*/;
/*f32 basevalue = (f32)*/readU32(&data[10]) /*/ 1000.0*/;
u32 heightmap_count = readU32(&data[14]);
/*dstream<<"UnlimitedHeightmap::deSerialize():"
@ -838,12 +955,12 @@ UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is)
//dstream<<"heightmap_size="<<heightmap_size<<std::endl;
ValueGenerator *maxgen = new ConstantGenerator(randmax);
/*ValueGenerator *maxgen = new ConstantGenerator(randmax);
ValueGenerator *factorgen = new ConstantGenerator(randfactor);
ValueGenerator *basegen = new ConstantGenerator(basevalue);
ValueGenerator *basegen = new ConstantGenerator(basevalue);*/
UnlimitedHeightmap *hm = new UnlimitedHeightmap
(blocksize, maxgen, factorgen, basegen, NULL);
(blocksize, padb);
for(u32 i=0; i<heightmap_count; i++)
{
@ -862,16 +979,16 @@ UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is)
}
return hm;
}
else
else if(version <= 11)
{
u8 buf[4];
is.read((char*)buf, 2);
s16 blocksize = readU16(buf);
ValueGenerator *maxgen = ValueGenerator::deSerialize(is);
ValueGenerator *factorgen = ValueGenerator::deSerialize(is);
ValueGenerator *basegen = ValueGenerator::deSerialize(is);
// Dummy-read three lines (generators)
std::string templine;
std::getline(is, templine, '\n');
is.read((char*)buf, 4);
u32 heightmap_count = readU32(buf);
@ -880,7 +997,45 @@ UnlimitedHeightmap * UnlimitedHeightmap::deSerialize(std::istream &is)
FixedHeightmap::serializedLength(version, blocksize);
UnlimitedHeightmap *hm = new UnlimitedHeightmap
(blocksize, maxgen, factorgen, basegen, NULL);
(blocksize, padb);
for(u32 i=0; i<heightmap_count; i++)
{
is.read((char*)buf, 4);
v2s16 pos = readV2S16(buf);
SharedBuffer<u8> data(heightmap_size);
is.read((char*)*data, heightmap_size);
if(is.gcount() != (s32)(heightmap_size)){
delete hm;
throw SerializationError
("UnlimitedHeightmap::deSerialize: no enough input data");
}
FixedHeightmap *f = new FixedHeightmap(hm, pos, blocksize);
f->deSerialize(*data, version);
hm->m_heightmaps.insert(pos, f);
}
return hm;
}
else
{
u8 buf[4];
is.read((char*)buf, 2);
s16 blocksize = readU16(buf);
/*ValueGenerator *maxgen = ValueGenerator::deSerialize(is);
ValueGenerator *factorgen = ValueGenerator::deSerialize(is);
ValueGenerator *basegen = ValueGenerator::deSerialize(is);*/
is.read((char*)buf, 4);
u32 heightmap_count = readU32(buf);
u32 heightmap_size =
FixedHeightmap::serializedLength(version, blocksize);
UnlimitedHeightmap *hm = new UnlimitedHeightmap
(blocksize, padb);
for(u32 i=0; i<heightmap_count; i++)
{

30
src/heightmap.h
View File

@ -503,30 +503,31 @@ private:
s16 m_blocksize;
// TODO: Remove ValueGenerators
ValueGenerator *m_randmax_generator;
/*ValueGenerator *m_randmax_generator;
ValueGenerator *m_randfactor_generator;
ValueGenerator *m_base_generator;
ValueGenerator *m_base_generator;*/
PointAttributeList *m_palist;
PointAttributeDatabase *m_padb;
public:
UnlimitedHeightmap(
s16 blocksize,
ValueGenerator *randmax_generator,
/*ValueGenerator *randmax_generator,
ValueGenerator *randfactor_generator,
ValueGenerator *base_generator,
PointAttributeList *palist=NULL
ValueGenerator *base_generator,*/
PointAttributeDatabase *padb
):
m_blocksize(blocksize),
m_randmax_generator(randmax_generator),
/*m_randmax_generator(randmax_generator),
m_randfactor_generator(randfactor_generator),
m_base_generator(base_generator),
m_palist(palist)
m_base_generator(base_generator),*/
m_padb(padb)
{
assert(m_randmax_generator != NULL);
/*assert(m_randmax_generator != NULL);
assert(m_randfactor_generator != NULL);
assert(m_base_generator != NULL);
assert(m_base_generator != NULL);*/
assert(m_padb);
}
~UnlimitedHeightmap()
@ -538,9 +539,9 @@ public:
delete i.getNode()->getValue();
}
delete m_randmax_generator;
/*delete m_randmax_generator;
delete m_randfactor_generator;
delete m_base_generator;
delete m_base_generator;*/
}
void print();
@ -563,7 +564,8 @@ public:
//SharedBuffer<u8> serialize(u8 version);
void serialize(std::ostream &os, u8 version);
static UnlimitedHeightmap * deSerialize(std::istream &istr);
static UnlimitedHeightmap * deSerialize(std::istream &istr,
PointAttributeDatabase *padb);
};
#endif

375
src/map.cpp
View File

@ -1312,6 +1312,197 @@ ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
Map(dout_server),
m_heightmap(NULL)
{
/*
Experimental and debug stuff
*/
{
PointAttributeList *list_baseheight = m_padb.getList("hm_baseheight");
PointAttributeList *list_randmax = m_padb.getList("hm_randmax");
PointAttributeList *list_randfactor = m_padb.getList("hm_randfactor");
PointAttributeList *list_plants_amount = m_padb.getList("plants_amount");
PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
for(u32 i=0; i<3000; i++)
{
u32 lim = MAP_GENERATION_LIMIT;
if(i < 200)
lim = 1000;
v3s16 p(
-lim + myrand()%(lim*2),
0,
-lim + myrand()%(lim*2)
);
/*float plants_amount = (float)(myrand()%1050) / 1000.0;
plants_amount = pow(plants_amount, 5);
list_plants_amount->addPoint(p, Attribute(plants_amount));*/
float plants_amount = 0;
if(myrand()%5 == 0)
{
plants_amount = 1.5;
}
else if(myrand()%4 == 0)
{
plants_amount = 0.5;
}
else if(myrand()%2 == 0)
{
plants_amount = 0.03;
}
else
{
plants_amount = 0.0;
}
float caves_amount = 0;
if(myrand()%5 == 0)
{
caves_amount = 1.0;
}
else if(myrand()%3 == 0)
{
caves_amount = 0.3;
}
else
{
caves_amount = 0.05;
}
list_plants_amount->addPoint(p, Attribute(plants_amount));
list_caves_amount->addPoint(p, Attribute(caves_amount));
}
#if 1
for(u32 i=0; i<3000; i++)
{
u32 lim = MAP_GENERATION_LIMIT;
if(i < 100)
lim = 1000;
v3s16 p(
-lim + myrand()%(lim*2),
0,
-lim + myrand()%(lim*2)
);
/*s32 bh_i = (myrand()%200) - 50;
float baseheight = (float)bh_i;
float m = 100.;
float e = 3.;
float randmax = (float)(myrand()%(int)(10.*pow(m, 1./e)))/10.;
randmax = pow(randmax, e);
//float randmax = (float)(myrand()%60);
float randfactor = (float)(myrand()%450) / 1000.0 + 0.4;*/
float baseheight = 0;
float randmax = 0;
float randfactor = 0;
if(myrand()%4 == 0)
{
baseheight = 100;
randmax = 100;
randfactor = 0.63;
}
else if(myrand()%5 == 0)
{
baseheight = 200;
randmax = 200;
randfactor = 0.66;
}
else if(myrand()%4 == 0)
{
baseheight = -3;
randmax = 30;
randfactor = 0.7;
}
else if(myrand()%3 == 0)
{
baseheight = 0;
randmax = 30;
randfactor = 0.60;
}
else
{
baseheight = -3;
randmax = 20;
randfactor = 0.5;
}
list_baseheight->addPoint(p, Attribute(baseheight));
list_randmax->addPoint(p, Attribute(randmax));
list_randfactor->addPoint(p, Attribute(randfactor));
}
#endif
/*list_baseheight->addPoint(v3s16(0,0,0), Attribute(5));
list_randmax->addPoint(v3s16(0,0,0), Attribute(20));
list_randfactor->addPoint(v3s16(0,0,0), Attribute(0.6));*/
}
#if 0
{
PointAttributeList *palist = m_padb.getList("hm_baseheight");
{
v3s16 p(0,0,0);
Attribute attr;
attr.set("5");
palist->addPoint(p, attr);
}
/*{
v3s16 p(-50,-50,0);
Attribute attr;
attr.set("-10");
palist->addPoint(p, attr);
}
{
v3s16 p(50,0,50);
Attribute attr;
attr.set("200");
palist->addPoint(p, attr);
}*/
}
#endif
#if 0
{
PointAttributeList *palist = m_padb.getList("plants_amount");
// Back
{
v3s16 p(0,0,-100);
Attribute attr;
attr.set("0");
palist->addPoint(p, attr);
}
// Front right
{
v3s16 p(100,0,100);
Attribute attr;
attr.set("2.0");
palist->addPoint(p, attr);
}
// Front left
{
v3s16 p(-100,0,100);
Attribute attr;
attr.set("0.2");
palist->addPoint(p, attr);
}
}
#endif
/*
Try to load map; if not found, create a new one.
*/
m_savedir = savedir;
m_map_saving_enabled = false;
@ -1362,14 +1553,20 @@ ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
dstream<<DTIME<<"Initializing new map."<<std::endl;
// Create master heightmap
ValueGenerator *maxgen =
/*ValueGenerator *maxgen =
ValueGenerator::deSerialize(hmp.randmax);
ValueGenerator *factorgen =
ValueGenerator::deSerialize(hmp.randfactor);
ValueGenerator *basegen =
ValueGenerator::deSerialize(hmp.base);
m_heightmap = new UnlimitedHeightmap
(hmp.blocksize, maxgen, factorgen, basegen);
(hmp.blocksize, maxgen, factorgen, basegen, &m_padb);*/
/*m_heightmap = new UnlimitedHeightmap
(hmp.blocksize, &m_padb);*/
m_heightmap = new UnlimitedHeightmap
(32, &m_padb);
// Set map parameters
m_params = mp;
@ -1457,49 +1654,16 @@ MapSector * ServerMap::emergeSector(v2s16 p2d)
ServerMapSector *sector = new ServerMapSector(this, p2d, hm_split);
// Sector position on map in nodes
v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
/*dstream<<"Generating sector ("<<p2d.X<<","<<p2d.Y<<")"
" heightmaps and objects"<<std::endl;*/
// Loop through sub-heightmaps
for(s16 y=0; y<hm_split; y++)
for(s16 x=0; x<hm_split; x++)
{
v2s16 p_in_sector = v2s16(x,y);
v2s16 mhm_p = p2d * hm_split + p_in_sector;
f32 corners[4] = {
m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)),
m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)),
m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)),
m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)),
};
/*dstream<<"p_in_sector=("<<p_in_sector.X<<","<<p_in_sector.Y<<")"
<<" mhm_p=("<<mhm_p.X<<","<<mhm_p.Y<<")"
<<std::endl;*/
FixedHeightmap *hm = new FixedHeightmap(&m_hwrapper,
mhm_p, hm_d);
sector->setHeightmap(p_in_sector, hm);
//TODO: Make these values configurable
//hm->generateContinued(0.0, 0.0, corners);
hm->generateContinued(0.25, 0.2, corners);
//hm->generateContinued(0.5, 0.2, corners);
//hm->generateContinued(1.0, 0.2, corners);
//hm->generateContinued(2.0, 0.2, corners);
//hm->print();
}
/*
Generate objects
Calculate some information about local properties
*/
core::map<v3s16, u8> *objects = new core::map<v3s16, u8>;
sector->setObjects(objects);
v2s16 mhm_p = p2d * hm_split;
f32 corners[4] = {
m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)*hm_split),
@ -1536,18 +1700,77 @@ MapSector * ServerMap::emergeSector(v2s16 p2d)
pitness /= MAP_BLOCKSIZE;
//dstream<<"pitness="<<pitness<<std::endl;
/*
Get local attributes
*/
// Get plant amount from attributes
PointAttributeList *palist = m_padb.getList("plants_amount");
assert(palist);
/*float local_plants_amount =
palist->getNearAttr(nodepos2d).getFloat();*/
float local_plants_amount =
palist->getInterpolatedFloat(nodepos2d);
/*
Generate sector heightmap
*/
// Loop through sub-heightmaps
for(s16 y=0; y<hm_split; y++)
for(s16 x=0; x<hm_split; x++)
{
v2s16 p_in_sector = v2s16(x,y);
v2s16 mhm_p = p2d * hm_split + p_in_sector;
f32 corners[4] = {
m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)),
m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)),
m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)),
m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)),
};
/*dstream<<"p_in_sector=("<<p_in_sector.X<<","<<p_in_sector.Y<<")"
<<" mhm_p=("<<mhm_p.X<<","<<mhm_p.Y<<")"
<<std::endl;*/
FixedHeightmap *hm = new FixedHeightmap(&m_hwrapper,
mhm_p, hm_d);
sector->setHeightmap(p_in_sector, hm);
//TODO: Make these values configurable
//hm->generateContinued(0.0, 0.0, corners);
//hm->generateContinued(0.25, 0.2, corners);
//hm->generateContinued(0.5, 0.2, corners);
//hm->generateContinued(1.0, 0.2, corners);
//hm->generateContinued(2.0, 0.2, corners);
hm->generateContinued(2.0 * avgslope, 0.5, corners);
//hm->print();
}
/*
Generate objects
*/
core::map<v3s16, u8> *objects = new core::map<v3s16, u8>;
sector->setObjects(objects);
/*
Plant some trees if there is not much slope
*/
{
// Avgslope is the derivative of a hill
float t = avgslope * avgslope;
float a = MAP_BLOCKSIZE * m_params.plants_amount;
//float t = avgslope * avgslope;
float t = avgslope;
float a = MAP_BLOCKSIZE * m_params.plants_amount * local_plants_amount;
u32 tree_max;
if(t > 0.03)
tree_max = a / (t/0.03);
//float something = 0.17*0.17;
float something = 0.3;
if(t > something)
tree_max = a / (t/something);
else
tree_max = a;
u32 count = (myrand()%(tree_max+1));
//u32 count = tree_max;
for(u32 i=0; i<count; i++)
@ -1567,7 +1790,7 @@ MapSector * ServerMap::emergeSector(v2s16 p2d)
{
// Pitness usually goes at around -0.5...0.5
u32 bush_max = 0;
u32 a = MAP_BLOCKSIZE * 3.0 * m_params.plants_amount;
u32 a = MAP_BLOCKSIZE * 3.0 * m_params.plants_amount * local_plants_amount;
if(pitness > 0)
bush_max = (pitness*a*4);
if(bush_max > a)
@ -1589,7 +1812,7 @@ MapSector * ServerMap::emergeSector(v2s16 p2d)
*/
if(m_params.ravines_amount != 0)
{
if(myrand()%(s32)(20.0 / m_params.ravines_amount) == 0)
if(myrand()%(s32)(200.0 / m_params.ravines_amount) == 0)
{
s16 s = 6;
s16 x = myrand()%(MAP_BLOCKSIZE-s*2-1)+s;
@ -1838,6 +2061,14 @@ MapBlock * ServerMap::emergeBlock(
bool some_part_underground = block_y * MAP_BLOCKSIZE <= highest_ground_y;
/*
Get local attributes
*/
v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
float caves_amount = list_caves_amount->getInterpolatedFloat(nodepos2d);
/*
Generate dungeons
*/
@ -1937,20 +2168,60 @@ MapBlock * ServerMap::emergeBlock(
}
catch(InvalidPositionException &e){}
// Check y-
try
{
s16 y = -1;
for(s16 x=0; x<ued; x++)
for(s16 z=0; z<ued; z++)
{
v3s16 ap = v3s16(x,y,z) + block->getPosRelative();
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(x+1,0,z+1);
found_existing = true;
goto continue_generating;
}
}
}
catch(InvalidPositionException &e){}
// Check y+
try
{
s16 y = ued;
for(s16 x=0; x<ued; x++)
for(s16 z=0; z<ued; z++)
{
v3s16 ap = v3s16(x,y,z) + block->getPosRelative();
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(x+1,ued-1,z+1);
found_existing = true;
goto continue_generating;
}
}
}
catch(InvalidPositionException &e){}
continue_generating:
/*
Don't always generate dungeon
*/
bool do_generate_dungeons = true;
// Don't generate if no part is underground
if(!some_part_underground)
do_generate_dungeons = false;
// If block is partly underground, caves are generated.
else if(!completely_underground)
do_generate_dungeons = rand() % 5;
else if(found_existing)
do_generate_dungeons = (rand() % 100 <= (u32)(caves_amount*100));
// Always continue if found existing dungeons underground
else if(found_existing && completely_underground)
do_generate_dungeons = true;
// If underground and no dungeons found
else
do_generate_dungeons = rand() % 2;
do_generate_dungeons = (rand() % 2 == 0);
if(do_generate_dungeons)
{
@ -2427,6 +2698,12 @@ continue_generating:
changed_blocks.insert(block->getPos(), block);
}
if(HAXMODE)
{
// Don't calculate lighting at all
lighting_invalidated_blocks.clear();
}
return block;
}
@ -2659,7 +2936,7 @@ void ServerMap::loadMasterHeightmap()
if(m_heightmap != NULL)
delete m_heightmap;
m_heightmap = UnlimitedHeightmap::deSerialize(is);
m_heightmap = UnlimitedHeightmap::deSerialize(is, &m_padb);
}
void ServerMap::saveSectorMeta(ServerMapSector *sector)

14
src/map.h
View File

@ -381,6 +381,12 @@ struct MapParams
//u16 max_objects_in_block;
};
/*
ServerMap
This is the only map class that is able to generate map.
*/
class ServerMap : public Map
{
public:
@ -467,8 +473,10 @@ public:
virtual void PrintInfo(std::ostream &out);
private:
// Generator parameters
UnlimitedHeightmap *m_heightmap;
MapParams m_params;
PointAttributeDatabase m_padb;
std::string m_savedir;
bool m_map_saving_enabled;
@ -503,6 +511,12 @@ struct MapDrawControl
class Client;
/*
ClientMap
This is the only map class that is able to render itself on screen.
*/
class ClientMap : public Map, public scene::ISceneNode
{
public:

41
src/player.cpp
View File

@ -286,6 +286,10 @@ void LocalPlayer::move(f32 dtime, Map &map)
{
// Doing nothing here will block the player from
// walking over map borders
// Go over borders in debug mode
if(HAXMODE)
continue;
}
core::aabbox3d<f32> nodebox = Map::getNodeBox(
@ -374,14 +378,33 @@ void LocalPlayer::applyControl(float dtime)
v3f speed = v3f(0,0,0);
if(HAXMODE)
{
v3f speed = getSpeed();
speed.Y = 0;
setSpeed(speed);
}
// Superspeed mode
bool superspeed = false;
if(control.superspeed)
{
speed += move_direction;
superspeed = true;
if(HAXMODE)
{
v3f speed = getSpeed();
speed.Y = -20*BS;
setSpeed(speed);
}
else
{
speed += move_direction;
superspeed = true;
}
}
if(HAXMODE)
superspeed = true;
if(control.up)
{
speed += move_direction;
@ -400,7 +423,16 @@ void LocalPlayer::applyControl(float dtime)
}
if(control.jump)
{
if(touching_ground)
if(HAXMODE)
{
v3f speed = getSpeed();
/*speed.Y += 20.*BS * dtime * 2;
if(speed.Y < 0)
speed.Y = 0;*/
speed.Y = 20*BS;
setSpeed(speed);
}
else if(touching_ground)
{
v3f speed = getSpeed();
speed.Y = 6.5*BS;
@ -422,6 +454,9 @@ void LocalPlayer::applyControl(float dtime)
f32 inc = walk_acceleration * BS * dtime;
if(HAXMODE)
inc = walk_acceleration * BS * dtime * 10;
// Accelerate to target speed with maximum increment
accelerate(speed, inc);
}

3
src/serialization.h
View File

@ -44,11 +44,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
9: (dev) block objects
10: (dev) water pressure
11: (dev) zlib'd blocks, block flags
12: (dev) UnlimitedHeightmap now uses interpolated areas
*/
// This represents an uninitialized or invalid format
#define SER_FMT_VER_INVALID 255
// Highest supported serialization version
#define SER_FMT_VER_HIGHEST 11
#define SER_FMT_VER_HIGHEST 12
// Lowest supported serialization version
#define SER_FMT_VER_LOWEST 2

89
src/server.cpp
View File

@ -150,11 +150,37 @@ void * EmergeThread::Thread()
if(optional)
only_from_disk = true;
block = map.emergeBlock(
p,
only_from_disk,
changed_blocks,
lighting_invalidated_blocks);
// First check if the block already exists
if(only_from_disk)
{
block = map.getBlockNoCreate(p);
}
if(block == NULL)
{
block = map.emergeBlock(
p,
only_from_disk,
changed_blocks,
lighting_invalidated_blocks);
/*
EXPERIMENTAL: Create a few other blocks too
*/
map.emergeBlock(
p + v3s16(0,1,0),
only_from_disk,
changed_blocks,
lighting_invalidated_blocks);
map.emergeBlock(
p + v3s16(0,-1,0),
only_from_disk,
changed_blocks,
lighting_invalidated_blocks);
}
// If it is a dummy, block was not found on disk
if(block->isDummy())
@ -458,9 +484,18 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
bool generate = d <= d_max_gen;
// Limit the generating area vertically to 2/3
if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
generate = false;
if(HAXMODE)
{
// Don't generate above player
if(p.Y > center.Y)
generate = false;
}
else
{
// Limit the generating area vertically to 2/3
if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
generate = false;
}
/*
Don't send already sent blocks
@ -472,6 +507,23 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
continue;
}
if(HAXMODE)
{
/*
Ignore block if it is not at ground surface
*/
v2s16 p2d(p.X*MAP_BLOCKSIZE + MAP_BLOCKSIZE/2,
p.Z*MAP_BLOCKSIZE + MAP_BLOCKSIZE/2);
f32 y = server->m_env.getMap().getGroundHeight(p2d);
// The sector might not exist yet, thus no heightmap
if(y > GROUNDHEIGHT_VALID_MINVALUE)
{
f32 by = p.Y*MAP_BLOCKSIZE + MAP_BLOCKSIZE/2;
if(fabs(by - y) > MAP_BLOCKSIZE + MAP_BLOCKSIZE/3)
continue;
}
}
/*
Check if map has this block
*/
@ -2980,22 +3032,9 @@ Player *Server::emergePlayer(const char *name, const char *password)
/*
Set player position
*/
#if 0
// We're going to throw the player to this position
//v2s16 nodepos(29990,29990);
//v2s16 nodepos(9990,9990);
v2s16 nodepos(0,0);
v2s16 sectorpos = getNodeSectorPos(nodepos);
// Get sector
m_env.getMap().emergeSector(sectorpos);
// Get ground height at point
f32 groundheight = m_env.getMap().getGroundHeight(nodepos, true);
// The sector should have been generated -> groundheight exists
assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE);
// Don't go underwater
if(groundheight < WATER_LEVEL)
groundheight = WATER_LEVEL;
#endif
dstream<<"Server: Finding spawn place for player \""
<<player->getName()<<"\""<<std::endl;
#if 1
v2s16 nodepos;
@ -3003,7 +3042,7 @@ Player *Server::emergePlayer(const char *name, const char *password)
// Try to find a good place a few times
for(s32 i=0; i<100; i++)
{
s32 range = 1 + i*2;
s32 range = 1 + i*4;
// We're going to try to throw the player to this position
nodepos = v2s16(-range/2 + (myrand()%range),
-range/2 + (myrand()%range));

26
src/test.cpp
View File

@ -695,10 +695,12 @@ struct TestHeightmap
{
//g_heightmap_debugprint = true;
const s16 BS1 = 4;
UnlimitedHeightmap hm1(BS1,
/*UnlimitedHeightmap hm1(BS1,
new ConstantGenerator(0.0),
new ConstantGenerator(0.0),
new ConstantGenerator(5.0));
new ConstantGenerator(5.0));*/
PointAttributeDatabase padb;
UnlimitedHeightmap hm1(BS1, &padb);
// Go through it so it generates itself
for(s16 y=0; y<=BS1; y++){
for(s16 x=0; x<=BS1; x++){
@ -729,10 +731,26 @@ struct TestHeightmap
dstream<<std::endl;
const s16 BS1 = 8;
UnlimitedHeightmap hm1(BS1,
/*UnlimitedHeightmap hm1(BS1,
new ConstantGenerator(10.0),
new ConstantGenerator(0.3),
new ConstantGenerator(0.0));
new ConstantGenerator(0.0));*/
PointAttributeDatabase padb;
padb.getList("hm_baseheight")->addPoint(v2s16(-BS1,0), Attribute(0));
padb.getList("hm_randmax")->addPoint(v2s16(-BS1,0), Attribute(0));
padb.getList("hm_randfactor")->addPoint(v2s16(-BS1,0), Attribute(0.0));
padb.getList("hm_baseheight")->addPoint(v2s16(0,0), Attribute(-20));
padb.getList("hm_randmax")->addPoint(v2s16(0,0), Attribute(0));
padb.getList("hm_randfactor")->addPoint(v2s16(0,0), Attribute(0.5));
padb.getList("hm_baseheight")->addPoint(v2s16(BS1*2,BS1), Attribute(0));
padb.getList("hm_randmax")->addPoint(v2s16(BS1*2,BS1), Attribute(30));
padb.getList("hm_randfactor")->addPoint(v2s16(BS1*2,BS1), Attribute(0.9));
UnlimitedHeightmap hm1(BS1, &padb);
// Force hm1 to generate a some heightmap
hm1.getGroundHeight(v2s16(0,0));

226
src/utility.cpp
View File

@ -102,4 +102,230 @@ void mysrand(unsigned seed)
next = seed;
}
// Float with distance
struct DFloat
{
float v;
u32 d;
};
float PointAttributeList::getInterpolatedFloat(v3s16 p)
{
const u32 near_wanted_count = 5;
// Last is nearest, first is farthest
core::list<DFloat> near;
for(core::list<PointWithAttr>::Iterator
i = m_points.begin();
i != m_points.end(); i++)
{
PointWithAttr &pwa = *i;
u32 d = pwa.p.getDistanceFrom(p);
DFloat df;
df.v = pwa.attr.getFloat();
df.d = d;
// If near list is empty, add directly and continue
if(near.size() == 0)
{
near.push_back(df);
continue;
}
// Get distance of farthest in near list
u32 near_d = 100000;
if(near.size() > 0)
{
core::list<DFloat>::Iterator i = near.begin();
near_d = i->d;
}
/*
If point is closer than the farthest in the near list or
there are not yet enough points on the list
*/
if(d < near_d || near.size() < near_wanted_count)
{
// Find the right place in the near list and put it there
// Go from farthest to near in the near list
core::list<DFloat>::Iterator i = near.begin();
for(; i != near.end(); i++)
{
// Stop when i is at the first nearer node
if(i->d < d)
break;
}
// Add df to before i
if(i == near.end())
near.push_back(df);
else
near.insert_before(i, df);
// Keep near list at right size
if(near.size() > near_wanted_count)
{
core::list<DFloat>::Iterator j = near.begin();
near.erase(j);
}
}
}
// Return if no values found
if(near.size() == 0)
return 0.0;
/*
20:58:29 < tejeez> joka pisteelle a += arvo / etäisyys^6; b += 1 / etäisyys^6; ja
lopuks sit otetaan a/b
*/
float a = 0;
float b = 0;
for(core::list<DFloat>::Iterator i = near.begin();
i != near.end(); i++)
{
if(i->d == 0)
return i->v;
//float dd = pow((float)i->d, 6);
float dd = pow((float)i->d, 5);
float v = i->v;
//dstream<<"dd="<<dd<<", v="<<v<<std::endl;
a += v / dd;
b += 1 / dd;
}
return a / b;
}
#if 0
float PointAttributeList::getInterpolatedFloat(v3s16 p)
{
const u32 near_wanted_count = 2;
const u32 nearest_wanted_count = 2;
// Last is near
core::list<DFloat> near;
for(core::list<PointWithAttr>::Iterator
i = m_points.begin();
i != m_points.end(); i++)
{
PointWithAttr &pwa = *i;
u32 d = pwa.p.getDistanceFrom(p);
DFloat df;
df.v = pwa.attr.getFloat();
df.d = d;
// If near list is empty, add directly and continue
if(near.size() == 0)
{
near.push_back(df);
continue;
}
// Get distance of farthest in near list
u32 near_d = 100000;
if(near.size() > 0)
{
core::list<DFloat>::Iterator i = near.begin();
near_d = i->d;
}
/*
If point is closer than the farthest in the near list or
there are not yet enough points on the list
*/
if(d < near_d || near.size() < near_wanted_count)
{
// Find the right place in the near list and put it there
// Go from farthest to near in the near list
core::list<DFloat>::Iterator i = near.begin();
for(; i != near.end(); i++)
{
// Stop when i is at the first nearer node
if(i->d < d)
break;
}
// Add df to before i
if(i == near.end())
near.push_back(df);
else
near.insert_before(i, df);
// Keep near list at right size
if(near.size() > near_wanted_count)
{
core::list<DFloat>::Iterator j = near.begin();
near.erase(j);
}
}
}
// Return if no values found
if(near.size() == 0)
return 0.0;
/*
Get nearest ones
*/
u32 nearest_count = nearest_wanted_count;
if(nearest_count > near.size())
nearest_count = near.size();
core::list<DFloat> nearest;
{
core::list<DFloat>::Iterator i = near.getLast();
for(u32 j=0; j<nearest_count; j++)
{
nearest.push_front(*i);
i--;
}
}
/*
TODO: Try this:
20:58:29 < tejeez> joka pisteelle a += arvo / etäisyys^6; b += 1 / etäisyys^6; ja
lopuks sit otetaan a/b
*/
/*
Get total distance to nearest points
*/
float nearest_d_sum = 0;
for(core::list<DFloat>::Iterator i = nearest.begin();
i != nearest.end(); i++)
{
nearest_d_sum += (float)i->d;
}
/*
Interpolate a value between the first ones
*/
dstream<<"nearest.size()="<<nearest.size()<<std::endl;
float interpolated = 0;
for(core::list<DFloat>::Iterator i = nearest.begin();
i != nearest.end(); i++)
{
float weight;
if(nearest_d_sum > 0.001)
weight = (float)i->d / nearest_d_sum;
else
weight = 1. / nearest.size();
/*dstream<<"i->d="<<i->d<<" nearest_d_sum="<<nearest_d_sum
<<" weight="<<weight<<std::endl;*/
interpolated += weight * i->v;
}
return interpolated;
}
#endif

243
src/utility.h
View File

@ -666,6 +666,20 @@ inline s32 stoi(std::string s)
return atoi(s.c_str());
}
inline std::string itos(s32 i)
{
std::ostringstream o;
o<<i;
return o.str();
}
inline std::string ftos(float f)
{
std::ostringstream o;
o<<f;
return o.str();
}
/*
A base class for simple background thread implementation
*/
@ -1101,6 +1115,46 @@ public:
return stoi(get(name));
}
void clear()
{
m_settings.clear();
m_defaults.clear();
}
Settings & operator+=(Settings &other)
{
if(&other == this)
return *this;
for(core::map<std::string, std::string>::Iterator
i = other.m_settings.getIterator();
i.atEnd() == false; i++)
{
m_settings.insert(i.getNode()->getKey(),
i.getNode()->getValue());
}
for(core::map<std::string, std::string>::Iterator
i = other.m_defaults.getIterator();
i.atEnd() == false; i++)
{
m_defaults.insert(i.getNode()->getKey(),
i.getNode()->getValue());
}
}
Settings & operator=(Settings &other)
{
if(&other == this)
return *this;
clear();
(*this) += other;
return *this;
}
private:
core::map<std::string, std::string> m_settings;
core::map<std::string, std::string> m_defaults;
@ -1331,9 +1385,194 @@ void mysrand(unsigned seed);
#define MYRAND_MAX 32767
/*
TODO: Some kind of a thing that stores arbitary data related to
2D coordinate points
Some kind of a thing that stores attributes related to
coordinate points
*/
struct Attribute
{
Attribute()
{
}
Attribute(const std::string &value):
m_value(value)
{
}
Attribute(float value)
{
m_value = ftos(value);
}
void set(const std::string &value)
{
m_value = value;
}
std::string get()
{
return m_value;
}
bool getBool()
{
return is_yes(get());
}
float getFloat()
{
float f;
std::istringstream vis(get());
vis>>f;
return f;
}
u16 getU16()
{
return stoi(get(), 0, 65535);
}
s16 getS16()
{
return stoi(get(), -32768, 32767);
}
s32 getS32()
{
return stoi(get());
}
std::string m_value;
};
class PointAttributeList
{
struct PointWithAttr
{
v3s16 p;
Attribute attr;
};
public:
~PointAttributeList()
{
/*for(core::list<PointWithAttr>::Iterator
i = m_points.begin();
i != m_points.end(); i++)
{
PointWithAttr &pwa = *i;
//delete pwa.attr;
}*/
}
Attribute getNearAttr(v3s16 p)
{
core::list<PointWithAttr>::Iterator
nearest_i = m_points.end();
s16 nearest_d = 32767;
for(core::list<PointWithAttr>::Iterator
i = m_points.begin();
i != m_points.end(); i++)
{
PointWithAttr &pwa = *i;
s16 d = pwa.p.getDistanceFrom(p);
if(d < nearest_d)
{
nearest_i = i;
nearest_d = d;
}
}
if(nearest_i == m_points.end())
Attribute();
return nearest_i->attr;
}
Attribute getNearAttr(v2s16 p)
{
return getNearAttr(v3s16(p.X, 0, p.Y));
}
bool empty()
{
return (m_points.size() == 0);
}
/*
Take all points in range, or at least the nearest point,
and interpolate the values as floats
*/
float getInterpolatedFloat(v3s16 p);
float getInterpolatedFloat(v2s16 p)
{
return getInterpolatedFloat(v3s16(p.X, 0, p.Y));
}
//float getInterpolatedFloat(v3s16 p, s32 range);
/*float getInterpolatedFloat(v2s16 p, s32 range)
{
return getInterpolatedFloat(v3s16(p.X, 0, p.Y), range);
}*/
void addPoint(v3s16 p, const Attribute &attr)
{
PointWithAttr pattr;
pattr.p = p;
pattr.attr = attr;
m_points.push_back(pattr);
}
void addPoint(v2s16 p, const Attribute &attr)
{
addPoint(v3s16(p.X, 0, p.Y), attr);
}
private:
core::list<PointWithAttr> m_points;
};
/*
Basically just a wrapper to core::map<PointAttributeList*>
*/
class PointAttributeDatabase
{
public:
~PointAttributeDatabase()
{
for(core::map<std::string, PointAttributeList*>::Iterator
i = m_lists.getIterator();
i.atEnd() == false; i++)
{
delete i.getNode()->getValue();
}
}
PointAttributeList *getList(const std::string &name)
{
PointAttributeList *list = NULL;
core::map<std::string, PointAttributeList*>::Node *n;
n = m_lists.find(name);
if(n == NULL)
{
list = new PointAttributeList();
m_lists.insert(name, list);
}
else
{
list = n->getValue();
}
return list;
}
private:
core::map<std::string, PointAttributeList*> m_lists;
};
#endif