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

Redefine NodeResolver interface and replace with callback mechanism

Browse Source
This commit is contained in:
kwolekr 2014-12-17 03:20:17 -05:00
parent 3ea5ed4ffe
commit b67f37f27e
16 changed files with 278 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mapgen.cpp
View File

@ -384,7 +384,7 @@ void GenerateNotifier::getEvents(
GenElementManager::GenElementManager(IGameDef *gamedef)
{
m_resolver = gamedef->getNodeDefManager()->getResolver();
m_ndef = gamedef->getNodeDefManager();
}

2
src/mapgen.h
View File

@ -192,7 +192,7 @@ public:
virtual GenElement *getByName(const std::string &name);
protected:
NodeResolver *m_resolver;
INodeDefManager *m_ndef;
std::vector<GenElement *> m_elements;
};

40
src/mg_biome.cpp
View File

@ -48,12 +48,14 @@ BiomeManager::BiomeManager(IGameDef *gamedef) :
b->heat_point = 0.0;
b->humidity_point = 0.0;
m_resolver->addNode("air", "", CONTENT_AIR, &b->c_top);
m_resolver->addNode("air", "", CONTENT_AIR, &b->c_filler);
m_resolver->addNode("mapgen_stone", "", CONTENT_AIR, &b->c_stone);
m_resolver->addNode("mapgen_water_source", "", CONTENT_AIR, &b->c_water);
m_resolver->addNode("air", "", CONTENT_AIR, &b->c_dust);
m_resolver->addNode("mapgen_water_source", "", CONTENT_AIR, &b->c_dust_water);
NodeResolveInfo *nri = new NodeResolveInfo(b);
nri->nodenames.push_back("air");
nri->nodenames.push_back("air");
nri->nodenames.push_back("mapgen_stone");
nri->nodenames.push_back("mapgen_water_source");
nri->nodenames.push_back("air");
nri->nodenames.push_back("mapgen_water_source");
m_ndef->pendNodeResolve(nri);
add(b);
}
@ -102,18 +104,26 @@ Biome *BiomeManager::getBiome(float heat, float humidity, s16 y)
void BiomeManager::clear()
{
for (size_t i = 1; i < m_elements.size(); i++) {
Biome *b = (Biome *)m_elements[i];
if (!b)
continue;
m_resolver->cancelNode(&b->c_top);
m_resolver->cancelNode(&b->c_filler);
m_resolver->cancelNode(&b->c_stone);
m_resolver->cancelNode(&b->c_water);
m_resolver->cancelNode(&b->c_dust);
m_resolver->cancelNode(&b->c_dust_water);
delete b;
}
m_elements.resize(1);
}
///////////////////////////////////////////////////////////////////////////////
void Biome::resolveNodeNames(NodeResolveInfo *nri)
{
m_ndef->getIdFromResolveInfo(nri, "mapgen_dirt_with_grass", CONTENT_AIR, c_top);
m_ndef->getIdFromResolveInfo(nri, "mapgen_dirt", CONTENT_AIR, c_filler);
m_ndef->getIdFromResolveInfo(nri, "mapgen_stone", CONTENT_AIR, c_stone);
m_ndef->getIdFromResolveInfo(nri, "mapgen_water_source", CONTENT_AIR, c_water);
m_ndef->getIdFromResolveInfo(nri, "air", CONTENT_IGNORE, c_dust);
m_ndef->getIdFromResolveInfo(nri, "mapgen_water_source", CONTENT_IGNORE, c_dust_water);
}

4
src/mg_biome.h
View File

@ -33,7 +33,7 @@ enum BiomeType
BIOME_TYPE_FLAT
};
class Biome : public GenElement {
class Biome : public GenElement, public NodeResolver {
public:
u32 flags;
@ -51,6 +51,8 @@ public:
s16 height_max;
float heat_point;
float humidity_point;
virtual void resolveNodeNames(NodeResolveInfo *nri);
};
class BiomeManager : public GenElementManager {

26
src/mg_decoration.cpp
View File

@ -65,10 +65,7 @@ void DecorationManager::clear()
{
for (size_t i = 0; i < m_elements.size(); i++) {
Decoration *deco = (Decoration *)m_elements[i];
if (!deco)
continue;
deco->dropResolverEntries(m_resolver);
delete deco;
}
m_elements.clear();
}
@ -91,6 +88,12 @@ Decoration::~Decoration()
}
void Decoration::resolveNodeNames(NodeResolveInfo *nri)
{
m_ndef->getIdsFromResolveInfo(nri, c_place_on);
}
size_t Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
PseudoRandom ps(blockseed + 53);
@ -229,6 +232,14 @@ void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
///////////////////////////////////////////////////////////////////////////////
void DecoSimple::resolveNodeNames(NodeResolveInfo *nri)
{
Decoration::resolveNodeNames(nri);
m_ndef->getIdsFromResolveInfo(nri, c_decos);
m_ndef->getIdsFromResolveInfo(nri, c_spawnby);
}
bool DecoSimple::canPlaceDecoration(ManualMapVoxelManipulator *vm, v3s16 p)
{
// Don't bother if there aren't any decorations to place
@ -310,13 +321,6 @@ int DecoSimple::getHeight()
}
void DecoSimple::dropResolverEntries(NodeResolver *resolver)
{
resolver->cancelNodeList(&c_decos);
resolver->cancelNodeList(&c_spawnby);
}
///////////////////////////////////////////////////////////////////////////////

10
src/mg_decoration.h
View File

@ -58,7 +58,7 @@ struct CutoffData {
};
#endif
class Decoration : public GenElement {
class Decoration : public GenElement, public NodeResolver {
public:
INodeDefManager *ndef;
@ -76,12 +76,13 @@ public:
Decoration();
virtual ~Decoration();
virtual void resolveNodeNames(NodeResolveInfo *nri);
size_t placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
size_t placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
virtual size_t generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p) = 0;
virtual int getHeight() = 0;
virtual void dropResolverEntries(NodeResolver *resolver) {}
};
class DecoSimple : public Decoration {
@ -92,12 +93,11 @@ public:
s16 deco_height_max;
s16 nspawnby;
~DecoSimple() {}
virtual void resolveNodeNames(NodeResolveInfo *nri);
bool canPlaceDecoration(ManualMapVoxelManipulator *vm, v3s16 p);
virtual size_t generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p);
virtual int getHeight();
virtual void dropResolverEntries(NodeResolver *resolver);
};
class DecoSchematic : public Decoration {
@ -106,8 +106,6 @@ public:
Schematic *schematic;
std::string filename;
~DecoSchematic() {}
virtual size_t generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p);
virtual int getHeight();
};

25
src/mg_ore.cpp
View File

@ -64,11 +64,7 @@ void OreManager::clear()
{
for (size_t i = 0; i < m_elements.size(); i++) {
Ore *ore = (Ore *)m_elements[i];
if (!ore)
continue;
m_resolver->cancelNodeList(&ore->c_wherein);
m_resolver->cancelNode(&ore->c_ore);
delete ore;
}
m_elements.clear();
}
@ -84,6 +80,19 @@ Ore::Ore()
}
Ore::~Ore()
{
delete noise;
}
void Ore::resolveNodeNames(NodeResolveInfo *nri)
{
m_ndef->getIdFromResolveInfo(nri, "", CONTENT_AIR, c_ore);
m_ndef->getIdsFromResolveInfo(nri, c_wherein);
}
size_t Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
int in_range = 0;
@ -113,6 +122,9 @@ size_t Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
}
///////////////////////////////////////////////////////////////////////////////
void OreScatter::generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax)
{
@ -151,6 +163,9 @@ void OreScatter::generate(ManualMapVoxelManipulator *vm, int seed,
}
///////////////////////////////////////////////////////////////////////////////
void OreSheet::generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax)
{

5
src/mg_ore.h
View File

@ -54,7 +54,7 @@ enum OreType {
extern FlagDesc flagdesc_ore[];
class Ore : public GenElement {
class Ore : public GenElement, public NodeResolver {
public:
static const bool NEEDS_NOISE = false;
@ -72,6 +72,9 @@ public:
Noise *noise;
Ore();
virtual ~Ore();
virtual void resolveNodeNames(NodeResolveInfo *nri);
size_t placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
virtual void generate(ManualMapVoxelManipulator *vm, int seed,

22
src/mg_schematic.cpp
View File

@ -58,6 +58,12 @@ Schematic::~Schematic()
}
void Schematic::resolveNodeNames(NodeResolveInfo *nri)
{
m_ndef->getIdsFromResolveInfo(nri, c_nodes);
}
void Schematic::updateContentIds()
{
if (flags & SCHEM_CIDS_UPDATED)
@ -195,8 +201,7 @@ void Schematic::placeStructure(Map *map, v3s16 p, u32 flags,
bool Schematic::loadSchematicFromFile(const char *filename,
NodeResolver *resolver,
std::map<std::string, std::string> &replace_names)
INodeDefManager *ndef, std::map<std::string, std::string> &replace_names)
{
content_t cignore = CONTENT_IGNORE;
bool have_cignore = false;
@ -224,10 +229,9 @@ bool Schematic::loadSchematicFromFile(const char *filename,
for (int y = 0; y != size.Y; y++)
slice_probs[y] = (version >= 3) ? readU8(is) : MTSCHEM_PROB_ALWAYS;
int nodecount = size.X * size.Y * size.Z;
NodeResolveInfo *nri = new NodeResolveInfo(this);
u16 nidmapcount = readU16(is);
for (int i = 0; i != nidmapcount; i++) {
std::string name = deSerializeString(is);
if (name == "ignore") {
@ -241,16 +245,22 @@ bool Schematic::loadSchematicFromFile(const char *filename,
if (it != replace_names.end())
name = it->second;
resolver->addNodeList(name.c_str(), &c_nodes);
nri->nodenames.push_back(name);
}
nri->nodename_sizes.push_back(nidmapcount);
ndef->pendNodeResolve(nri);
size_t nodecount = size.X * size.Y * size.Z;
delete []schemdata;
schemdata = new MapNode[nodecount];
MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST_READ, schemdata,
nodecount, 2, 2, true);
if (version == 1) { // fix up the probability values
for (int i = 0; i != nodecount; i++) {
for (size_t i = 0; i != nodecount; i++) {
if (schemdata[i].param1 == 0)
schemdata[i].param1 = MTSCHEM_PROB_ALWAYS;
if (have_cignore && schemdata[i].getContent() == cignore)

8
src/mg_schematic.h
View File

@ -42,7 +42,7 @@ class NodeResolver;
#define MTSCHEM_PROB_ALWAYS 0xFF
class Schematic : public GenElement {
class Schematic : public GenElement, public NodeResolver {
public:
std::vector<content_t> c_nodes;
@ -52,14 +52,16 @@ public:
u8 *slice_probs;
Schematic();
~Schematic();
virtual ~Schematic();
virtual void resolveNodeNames(NodeResolveInfo *nri);
void updateContentIds();
void blitToVManip(v3s16 p, ManualMapVoxelManipulator *vm,
Rotation rot, bool force_placement, INodeDefManager *ndef);
bool loadSchematicFromFile(const char *filename, NodeResolver *resolver,
bool loadSchematicFromFile(const char *filename, INodeDefManager *ndef,
std::map<std::string, std::string> &replace_names);
void saveSchematicToFile(const char *filename, INodeDefManager *ndef);
bool getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2);

229
src/nodedef.cpp
View File

@ -402,7 +402,15 @@ public:
virtual void updateTextures(IGameDef *gamedef);
void serialize(std::ostream &os, u16 protocol_version);
void deSerialize(std::istream &is);
virtual NodeResolver *getResolver();
virtual void pendNodeResolve(NodeResolveInfo *nri);
virtual void cancelNodeResolve(NodeResolver *resolver);
virtual void runNodeResolverCallbacks();
virtual bool getIdFromResolveInfo(NodeResolveInfo *nri,
const std::string &node_alt, content_t c_fallback, content_t &result);
virtual bool getIdsFromResolveInfo(NodeResolveInfo *nri,
std::vector<content_t> &result);
private:
void addNameIdMapping(content_t i, std::string name);
@ -432,13 +440,12 @@ private:
// Next possibly free id
content_t m_next_id;
// NodeResolver to queue pending node resolutions
NodeResolver m_resolver;
// List of node strings and node resolver callbacks to perform
std::list<NodeResolveInfo *> m_pending_node_lookups;
};
CNodeDefManager::CNodeDefManager() :
m_resolver(this)
CNodeDefManager::CNodeDefManager()
{
clear();
}
@ -1035,12 +1042,6 @@ void CNodeDefManager::addNameIdMapping(content_t i, std::string name)
}
NodeResolver *CNodeDefManager::getResolver()
{
return &m_resolver;
}
IWritableNodeDefManager *createNodeDefManager()
{
return new CNodeDefManager();
@ -1267,166 +1268,100 @@ void ContentFeatures::deSerializeOld(std::istream &is, int version)
}
}
/*
NodeResolver
*/
NodeResolver::NodeResolver(INodeDefManager *ndef)
void CNodeDefManager::pendNodeResolve(NodeResolveInfo *nri)
{
m_ndef = ndef;
m_is_node_registration_complete = false;
nri->resolver->m_ndef = this;
m_pending_node_lookups.push_back(nri);
}
NodeResolver::~NodeResolver()
void CNodeDefManager::cancelNodeResolve(NodeResolver *resolver)
{
while (!m_pending_contents.empty()) {
NodeResolveInfo *nri = m_pending_contents.front();
m_pending_contents.pop_front();
for (std::list<NodeResolveInfo *>::iterator
it = m_pending_node_lookups.begin();
it != m_pending_node_lookups.end();
++it) {
NodeResolveInfo *nri = *it;
if (resolver == nri->resolver) {
it = m_pending_node_lookups.erase(it);
delete nri;
}
}
}
void CNodeDefManager::runNodeResolverCallbacks()
{
while (!m_pending_node_lookups.empty()) {
NodeResolveInfo *nri = m_pending_node_lookups.front();
m_pending_node_lookups.pop_front();
nri->resolver->resolveNodeNames(nri);
nri->resolver->m_lookup_done = true;
delete nri;
}
}
int NodeResolver::addNode(const std::string &n_wanted, const std::string &n_alt,
content_t c_fallback, content_t *content)
bool CNodeDefManager::getIdFromResolveInfo(NodeResolveInfo *nri,
const std::string &node_alt, content_t c_fallback, content_t &result)
{
if (m_is_node_registration_complete) {
if (m_ndef->getId(n_wanted, *content))
return NR_STATUS_SUCCESS;
if (n_alt == "" || !m_ndef->getId(n_alt, *content)) {
*content = c_fallback;
return NR_STATUS_FAILURE;
if (nri->nodenames.empty()) {
result = c_fallback;
errorstream << "CNodeDefManager::getIdFromResolveInfo: empty "
"nodenames list" << std::endl;
return false;
}
return NR_STATUS_SUCCESS;
} else {
NodeResolveInfo *nfi = new NodeResolveInfo;
nfi->n_wanted = n_wanted;
nfi->n_alt = n_alt;
nfi->c_fallback = c_fallback;
nfi->output = content;
content_t c;
std::string name = nri->nodenames.front();
nri->nodenames.pop_front();
m_pending_contents.push_back(nfi);
return NR_STATUS_PENDING;
}
}
int NodeResolver::addNodeList(const std::string &nodename,
std::vector<content_t> *content_vec)
{
if (m_is_node_registration_complete) {
std::set<content_t> idset;
std::set<content_t>::iterator it;
m_ndef->getIds(nodename, idset);
for (it = idset.begin(); it != idset.end(); ++it)
content_vec->push_back(*it);
return idset.size() ? NR_STATUS_SUCCESS : NR_STATUS_FAILURE;
} else {
m_pending_content_vecs.push_back(
std::make_pair(nodename, content_vec));
return NR_STATUS_PENDING;
}
}
bool NodeResolver::cancelNode(content_t *content)
{
bool found = false;
for (std::list<NodeResolveInfo *>::iterator
it = m_pending_contents.begin();
it != m_pending_contents.end();
++it) {
NodeResolveInfo *nfi = *it;
if (nfi->output == content) {
it = m_pending_contents.erase(it);
delete nfi;
found = true;
}
}
return found;
}
int NodeResolver::cancelNodeList(std::vector<content_t> *content_vec)
{
int num_canceled = 0;
for (ContentVectorResolveList::iterator
it = m_pending_content_vecs.begin();
it != m_pending_content_vecs.end();
++it) {
if (it->second == content_vec) {
it = m_pending_content_vecs.erase(it);
num_canceled++;
}
}
return num_canceled;
}
int NodeResolver::resolveNodes()
{
int num_failed = 0;
//// Resolve pending single node name -> content ID mappings
while (!m_pending_contents.empty()) {
NodeResolveInfo *nri = m_pending_contents.front();
m_pending_contents.pop_front();
bool success = true;
if (!m_ndef->getId(nri->n_wanted, *nri->output)) {
success = (nri->n_alt != "") ?
m_ndef->getId(nri->n_alt, *nri->output) : false;
bool success = getId(name, c);
if (!success && node_alt != "") {
name = node_alt;
success = getId(name, c);
}
if (!success) {
*nri->output = nri->c_fallback;
num_failed++;
errorstream << "NodeResolver::resolveNodes(): Failed to "
"resolve '" << nri->n_wanted;
if (nri->n_alt != "")
errorstream << "' and '" << nri->n_alt;
errorstream << "'" << std::endl;
errorstream << "CNodeDefManager::getIdFromResolveInfo: Failed to "
"resolve node name '" << name << "'." << std::endl;
c = c_fallback;
}
delete nri;
result = c;
return success;
}
//// Resolve pending node names and add to content_t vector
while (!m_pending_content_vecs.empty()) {
std::pair<std::string, std::vector<content_t> *> item =
m_pending_content_vecs.front();
m_pending_content_vecs.pop_front();
std::string &name = item.first;
std::vector<content_t> *output = item.second;
std::set<content_t> idset;
std::set<content_t>::iterator it;
m_ndef->getIds(name, idset);
for (it = idset.begin(); it != idset.end(); ++it)
output->push_back(*it);
if (idset.empty()) {
num_failed++;
errorstream << "NodeResolver::resolveNodes(): Failed to "
"resolve '" << name << "'" << std::endl;
}
bool CNodeDefManager::getIdsFromResolveInfo(NodeResolveInfo *nri,
std::vector<content_t> &result)
{
if (nri->nodename_sizes.empty()) {
errorstream << "CNodeDefManager::getIdsFromResolveInfo: empty "
"nodename_sizes list" << std::endl;
return false;
}
//// Mark node registration as complete so future resolve
//// requests are satisfied immediately
m_is_node_registration_complete = true;
size_t nitems = nri->nodename_sizes.front();
nri->nodename_sizes.pop_front();
return num_failed;
while (nitems--) {
if (nri->nodenames.empty()) {
errorstream << "" << std::endl;
return false;
}
content_t c;
if (getId(nri->nodenames.front(), c)) {
result.push_back(c);
} else {
errorstream << "CNodeDefManager::getIdsFromResolveInfo: empty "
"nodenames list" << std::endl;
}
nri->nodenames.pop_front();
}
return true;
}

168
src/nodedef.h
View File

@ -40,8 +40,6 @@ class IShaderSource;
class IGameDef;
typedef std::list<std::pair<content_t, int> > GroupItems;
typedef std::list<std::pair<std::string, std::vector<content_t> *> >
ContentVectorResolveList;
enum ContentParamType
{
@ -284,125 +282,18 @@ struct ContentFeatures
}
};
class NodeResolver;
class INodeDefManager;
struct NodeResolveInfo {
std::string n_wanted;
std::string n_alt;
content_t c_fallback;
content_t *output;
};
NodeResolveInfo(NodeResolver *nr)
{
resolver = nr;
}
#define NR_STATUS_FAILURE 0
#define NR_STATUS_PENDING 1
#define NR_STATUS_SUCCESS 2
/**
NodeResolver
NodeResolver attempts to resolve node names to content ID integers. If the
node registration phase has not yet finished at the time the resolution
request is placed, the request is marked as pending and added to an internal
queue. The name resolution request is later satisfied by writing directly
to the output location when the node registration phase has been completed.
This is primarily intended to be used for objects registered during script
initialization (i.e. while nodes are being registered) that reference
particular nodes.
*/
class NodeResolver {
public:
NodeResolver(INodeDefManager *ndef);
~NodeResolver();
/**
Add a request to resolve the node n_wanted and set *content to the
result, or alternatively, n_alt if n_wanted is not found. If n_alt
cannot be found either, or has not been specified, *content is set
to c_fallback.
If node registration is complete, the request is finished immediately
and NR_STATUS_SUCCESS is returned (or NR_STATUS_FAILURE if no node can
be found). Otherwise, NR_STATUS_PENDING is returned and the resolution
request is queued.
N.B. If the memory in which content is located has been deallocated
before the pending request had been satisfied, cancelNode() must be
called.
@param n_wanted Name of node that is wanted.
@param n_alt Name of node in case n_wanted could not be found. Blank
if no alternative node is desired.
@param c_fallback Content ID that content is set to in case of node
resolution failure (should be CONTENT_AIR, CONTENT_IGNORE, etc.)
@param content Pointer to content_t that receives the result of the
node name resolution.
@return Status of node resolution request.
*/
int addNode(const std::string &n_wanted, const std::string &n_alt,
content_t c_fallback, content_t *content);
/**
Add a request to resolve the node(s) specified by nodename.
If node registration is complete, the request is finished immediately
and NR_STATUS_SUCCESS is returned if at least one node is resolved; if
zero were resolved, NR_STATUS_FAILURE. Otherwise, NR_STATUS_PENDING is
returned and the resolution request is queued.
N.B. If the memory in which content_vec is located has been deallocated
before the pending request had been satisfied, cancelNodeList() must be
called.
@param nodename Name of node (or node group) to be resolved.
@param content_vec Pointer to content_t vector onto which the results
are added.
@return Status of node resolution request.
*/
int addNodeList(const std::string &nodename,
std::vector<content_t> *content_vec);
/**
Removes all pending requests from the resolution queue with the output
address of 'content'.
@param content Location of the content ID for the request being
cancelled.
@return Number of pending requests cancelled.
*/
bool cancelNode(content_t *content);
/**
Removes all pending requests from the resolution queue with the output
address of 'content_vec'.
@param content_vec Location of the content ID vector for requests being
cancelled.
@return Number of pending requests cancelled.
*/
int cancelNodeList(std::vector<content_t> *content_vec);
/**
Carries out all pending node resolution requests. Call this when the
node registration phase has completed.
Internally marks node registration as complete.
@return Number of failed pending requests.
*/
int resolveNodes();
/**
Returns the status of the node registration phase.
@return Boolean of whether the registration phase is complete.
*/
bool isNodeRegFinished() { return m_is_node_registration_complete; }
private:
INodeDefManager *m_ndef;
bool m_is_node_registration_complete;
std::list<NodeResolveInfo *> m_pending_contents;
ContentVectorResolveList m_pending_content_vecs;
std::list<std::string> nodenames;
std::list<size_t> nodename_sizes;
NodeResolver *resolver;
};
class INodeDefManager
@ -422,7 +313,14 @@ public:
virtual void serialize(std::ostream &os, u16 protocol_version)=0;
virtual NodeResolver *getResolver()=0;
virtual void pendNodeResolve(NodeResolveInfo *nri)=0;
virtual void cancelNodeResolve(NodeResolver *resolver)=0;
virtual void runNodeResolverCallbacks()=0;
virtual bool getIdFromResolveInfo(NodeResolveInfo *nri,
const std::string &node_alt, content_t c_fallback, content_t &result)=0;
virtual bool getIdsFromResolveInfo(NodeResolveInfo *nri,
std::vector<content_t> &result)=0;
};
class IWritableNodeDefManager : public INodeDefManager
@ -464,10 +362,38 @@ public:
virtual void serialize(std::ostream &os, u16 protocol_version)=0;
virtual void deSerialize(std::istream &is)=0;
virtual NodeResolver *getResolver()=0;
virtual void pendNodeResolve(NodeResolveInfo *nri)=0;
virtual void cancelNodeResolve(NodeResolver *resolver)=0;
virtual void runNodeResolverCallbacks()=0;
virtual bool getIdFromResolveInfo(NodeResolveInfo *nri,
const std::string &node_alt, content_t c_fallback, content_t &result)=0;
virtual bool getIdsFromResolveInfo(NodeResolveInfo *nri,
std::vector<content_t> &result)=0;
};
IWritableNodeDefManager *createNodeDefManager();
class NodeResolver {
public:
NodeResolver()
{
m_lookup_done = false;
m_ndef = NULL;
}
~NodeResolver()
{
if (!m_lookup_done)
m_ndef->cancelNodeResolve(this);
}
virtual void resolveNodeNames(NodeResolveInfo *nri) = 0;
bool m_lookup_done;
INodeDefManager *m_ndef;
};
#endif

1
src/script/common/c_converter.cpp
View File

@ -235,6 +235,7 @@ bool read_stringlist(lua_State *L, int index, std::vector<const char *> &result)
if (lua_istable(L, index)) {
lua_pushnil(L);
while (lua_next(L, index)) {
if (lua_isstring(L, -1))
result.push_back(lua_tostring(L, -1));
lua_pop(L, 1);
}

64
src/script/lua_api/l_mapgen.cpp
View File

@ -183,9 +183,8 @@ bool get_schematic(lua_State *L, int index, Schematic *schem,
if (lua_istable(L, index)) {
return read_schematic(L, index, schem, ndef, replace_names);
} else if (lua_isstring(L, index)) {
NodeResolver *resolver = ndef->getResolver();
const char *filename = lua_tostring(L, index);
return schem->loadSchematicFromFile(filename, resolver, replace_names);
return schem->loadSchematicFromFile(filename, ndef, replace_names);
} else {
return false;
}
@ -415,7 +414,7 @@ int ModApiMapgen::l_register_biome(lua_State *L)
int index = 1;
luaL_checktype(L, index, LUA_TTABLE);
NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
INodeDefManager *ndef = getServer(L)->getNodeDefManager();
BiomeManager *bmgr = getServer(L)->getEmergeManager()->biomemgr;
enum BiomeType biometype = (BiomeType)getenumfield(L, index, "type",
@ -437,19 +436,15 @@ int ModApiMapgen::l_register_biome(lua_State *L)
return 0;
}
// Pend node resolutions only if insertion succeeded
resolver->addNode(getstringfield_default(L, index, "node_top", ""),
"mapgen_dirt_with_grass", CONTENT_AIR, &b->c_top);
resolver->addNode(getstringfield_default(L, index, "node_filler", ""),
"mapgen_dirt", CONTENT_AIR, &b->c_filler);
resolver->addNode(getstringfield_default(L, index, "node_stone", ""),
"mapgen_stone", CONTENT_AIR, &b->c_stone);
resolver->addNode(getstringfield_default(L, index, "node_water", ""),
"mapgen_water_source", CONTENT_AIR, &b->c_water);
resolver->addNode(getstringfield_default(L, index, "node_dust", ""),
"air", CONTENT_IGNORE, &b->c_dust);
resolver->addNode(getstringfield_default(L, index, "node_dust_water", ""),
"mapgen_water_source", CONTENT_IGNORE, &b->c_dust_water);
NodeResolveInfo *nri = new NodeResolveInfo(b);
std::list<std::string> &nnames = nri->nodenames;
nnames.push_back(getstringfield_default(L, index, "node_top", ""));
nnames.push_back(getstringfield_default(L, index, "node_filler", ""));
nnames.push_back(getstringfield_default(L, index, "node_stone", ""));
nnames.push_back(getstringfield_default(L, index, "node_water", ""));
nnames.push_back(getstringfield_default(L, index, "node_dust", ""));
nnames.push_back(getstringfield_default(L, index, "node_dust_water", ""));
ndef->pendNodeResolve(nri);
verbosestream << "register_biome: " << b->name << std::endl;
@ -485,7 +480,6 @@ int ModApiMapgen::l_register_decoration(lua_State *L)
luaL_checktype(L, index, LUA_TTABLE);
INodeDefManager *ndef = getServer(L)->getNodeDefManager();
NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
DecorationManager *decomgr = getServer(L)->getEmergeManager()->decomgr;
BiomeManager *biomemgr = getServer(L)->getEmergeManager()->biomemgr;
@ -509,11 +503,14 @@ int ModApiMapgen::l_register_decoration(lua_State *L)
return 0;
}
NodeResolveInfo *nri = new NodeResolveInfo(deco);
//// Get node name(s) to place decoration on
std::vector<const char *> place_on_names;
getstringlistfield(L, index, "place_on", place_on_names);
nri->nodename_sizes.push_back(place_on_names.size());
for (size_t i = 0; i != place_on_names.size(); i++)
resolver->addNodeList(place_on_names[i], &deco->c_place_on);
nri->nodenames.push_back(place_on_names[i]);
getflagsfield(L, index, "flags", flagdesc_deco, &deco->flags, NULL);
@ -538,7 +535,7 @@ int ModApiMapgen::l_register_decoration(lua_State *L)
bool success = false;
switch (decotype) {
case DECO_SIMPLE:
success = regDecoSimple(L, resolver, (DecoSimple *)deco);
success = regDecoSimple(L, nri, (DecoSimple *)deco);
break;
case DECO_SCHEMATIC:
success = regDecoSchematic(L, ndef, (DecoSchematic *)deco);
@ -547,6 +544,8 @@ int ModApiMapgen::l_register_decoration(lua_State *L)
break;
}
ndef->pendNodeResolve(nri);
if (!success) {
delete deco;
return 0;
@ -558,12 +557,14 @@ int ModApiMapgen::l_register_decoration(lua_State *L)
return 0;
}
verbosestream << "register_decoration: " << deco->name << std::endl;
lua_pushinteger(L, id);
return 1;
}
bool ModApiMapgen::regDecoSimple(lua_State *L,
NodeResolver *resolver, DecoSimple *deco)
NodeResolveInfo *nri, DecoSimple *deco)
{
int index = 1;
@ -584,6 +585,9 @@ bool ModApiMapgen::regDecoSimple(lua_State *L,
"defined" << std::endl;
return false;
}
nri->nodename_sizes.push_back(deco_names.size());
for (size_t i = 0; i != deco_names.size(); i++)
nri->nodenames.push_back(deco_names[i]);
std::vector<const char *> spawnby_names;
getstringlistfield(L, index, "spawn_by", spawnby_names);
@ -592,11 +596,9 @@ bool ModApiMapgen::regDecoSimple(lua_State *L,
" but num_spawn_by specified" << std::endl;
return false;
}
for (size_t i = 0; i != deco_names.size(); i++)
resolver->addNodeList(deco_names[i], &deco->c_decos);
nri->nodename_sizes.push_back(spawnby_names.size());
for (size_t i = 0; i != spawnby_names.size(); i++)
resolver->addNodeList(spawnby_names[i], &deco->c_spawnby);
nri->nodenames.push_back(spawnby_names[i]);
return true;
}
@ -615,6 +617,7 @@ bool ModApiMapgen::regDecoSchematic(lua_State *L, INodeDefManager *ndef,
read_schematic_replacements(L, replace_names, lua_gettop(L));
lua_pop(L, 1);
// TODO(hmmmm): get a ref from registered schematics
Schematic *schem = new Schematic;
lua_getfield(L, index, "schematic");
if (!get_schematic(L, -1, schem, ndef, replace_names)) {
@ -635,7 +638,7 @@ int ModApiMapgen::l_register_ore(lua_State *L)
int index = 1;
luaL_checktype(L, index, LUA_TTABLE);
NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
INodeDefManager *ndef = getServer(L)->getNodeDefManager();
OreManager *oremgr = getServer(L)->getEmergeManager()->oremgr;
enum OreType oretype = (OreType)getenumfield(L, index,
@ -683,13 +686,18 @@ int ModApiMapgen::l_register_ore(lua_State *L)
return 0;
}
NodeResolveInfo *nri = new NodeResolveInfo(ore);
nri->nodenames.push_back(getstringfield_default(L, index, "ore", ""));
std::vector<const char *> wherein_names;
getstringlistfield(L, index, "wherein", wherein_names);
nri->nodename_sizes.push_back(wherein_names.size());
for (size_t i = 0; i != wherein_names.size(); i++)
resolver->addNodeList(wherein_names[i], &ore->c_wherein);
nri->nodenames.push_back(wherein_names[i]);
resolver->addNode(getstringfield_default(L, index, "ore", ""),
"", CONTENT_AIR, &ore->c_ore);
ndef->pendNodeResolve(nri);
verbosestream << "register_ore: " << ore->name << std::endl;
lua_pushinteger(L, id);
return 1;

4
src/script/lua_api/l_mapgen.h
View File

@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "lua_api/l_base.h"
class INodeDefManager;
class NodeResolver;
class NodeResolveInfo;
class DecoSimple;
class DecoSchematic;
@ -68,7 +68,7 @@ private:
static int l_place_schematic(lua_State *L);
static bool regDecoSimple(lua_State *L,
NodeResolver *resolver, DecoSimple *deco);
NodeResolveInfo *nri, DecoSimple *deco);
static bool regDecoSchematic(lua_State *L,
INodeDefManager *ndef, DecoSchematic *deco);

2
src/server.cpp
View File

@ -337,7 +337,7 @@ Server::Server(
m_nodedef->updateAliases(m_itemdef);
// Perform pending node name resolutions
m_nodedef->getResolver()->resolveNodes();
m_nodedef->runNodeResolverCallbacks();
// Load the mapgen params from global settings now after any
// initial overrides have been set by the mods