Mgvalleys: use standard caves

[minetest.git] / src / itemdef.cpp

diff --git a/src/itemdef.cpp b/src/itemdef.cpp
index d356b96c5379d4b2f68cb7becf2416853c40e060..60a7dc64e33316f109eb3c20b81f6fb953792cea 100644 (file)
--- a/src/itemdef.cpp
+++ b/src/itemdef.cpp
@@ -28,10 +28,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "mapblock_mesh.h"
 #include "mesh.h"
 #include "wieldmesh.h"
-#include "tile.h"
+#include "client/tile.h"
 #endif
 #include "log.h"
-#include "main.h" // g_settings
 #include "settings.h"
 #include "util/serialize.h"
 #include "util/container.h"
@@ -81,6 +80,7 @@ ItemDefinition& ItemDefinition::operator=(const ItemDefinition &def)
        groups = def.groups;
        node_placement_prediction = def.node_placement_prediction;
        sound_place = def.sound_place;
+       sound_place_failed = def.sound_place_failed;
        range = def.range;
        return *this;
 }
@@ -115,6 +115,7 @@ void ItemDefinition::reset()
        }
        groups.clear();
        sound_place = SimpleSoundSpec();
+       sound_place_failed = SimpleSoundSpec();
        range = -1;
 
        node_placement_prediction = "";
@@ -146,7 +147,7 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
        os<<serializeString(tool_capabilities_s);
        writeU16(os, groups.size());
        for(std::map<std::string, int>::const_iterator
-                       i = groups.begin(); i != groups.end(); i++){
+                       i = groups.begin(); i != groups.end(); ++i){
                os<<serializeString(i->first);
                writeS16(os, i->second);
        }
@@ -156,8 +157,10 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
                os<<serializeString(sound_place.name);
                writeF1000(os, sound_place.gain);
        }
-       if(protocol_version > 20){
+       if (protocol_version > 20) {
                writeF1000(os, range);
+               os << serializeString(sound_place_failed.name);
+               writeF1000(os, sound_place_failed.gain);
        }
 }
 
@@ -212,8 +215,10 @@ void ItemDefinition::deSerialize(std::istream &is)
        }
        // If you add anything here, insert it primarily inside the try-catch
        // block to not need to increase the version.
-       try{
-       }catch(SerializationError &e) {};
+       try {
+               sound_place_failed.name = deSerializeString(is);
+               sound_place_failed.gain = readF1000(is);
+       } catch(SerializationError &e) {};
 }
 
 /*
@@ -242,15 +247,15 @@ class CItemDefManager: public IWritableItemDefManager
        {
 
 #ifndef SERVER
-               m_main_thread = get_current_thread_id();
+               m_main_thread = thr_get_current_thread_id();
 #endif
                clear();
        }
        virtual ~CItemDefManager()
        {
 #ifndef SERVER
-               const std::list<ClientCached*> &values = m_clientcached.getValues();
-               for(std::list<ClientCached*>::const_iterator
+               const std::vector<ClientCached*> &values = m_clientcached.getValues();
+               for(std::vector<ClientCached*>::const_iterator
                                i = values.begin(); i != values.end(); ++i)
                {
                        ClientCached *cc = *i;
@@ -262,7 +267,7 @@ class CItemDefManager: public IWritableItemDefManager
 #endif
                for (std::map<std::string, ItemDefinition*>::iterator iter =
                                m_item_definitions.begin(); iter != m_item_definitions.end();
-                               iter ++) {
+                               ++iter) {
                        delete iter->second;
                }
                m_item_definitions.clear();
@@ -281,26 +286,23 @@ class CItemDefManager: public IWritableItemDefManager
        }
        virtual std::string getAlias(const std::string &name) const
        {
-               std::map<std::string, std::string>::const_iterator i;
-               i = m_aliases.find(name);
-               if(i != m_aliases.end())
-                       return i->second;
+               StringMap::const_iterator it = m_aliases.find(name);
+               if (it != m_aliases.end())
+                       return it->second;
                return name;
        }
        virtual std::set<std::string> getAll() const
        {
                std::set<std::string> result;
-               for(std::map<std::string, ItemDefinition*>::const_iterator
-                               i = m_item_definitions.begin();
-                               i != m_item_definitions.end(); i++)
-               {
-                       result.insert(i->first);
+               for(std::map<std::string, ItemDefinition *>::const_iterator
+                               it = m_item_definitions.begin();
+                               it != m_item_definitions.end(); ++it) {
+                       result.insert(it->first);
                }
-               for(std::map<std::string, std::string>::const_iterator
-                               i = m_aliases.begin();
-                               i != m_aliases.end(); i++)
-               {
-                       result.insert(i->first);
+               for (StringMap::const_iterator
+                               it = m_aliases.begin();
+                               it != m_aliases.end(); ++it) {
+                       result.insert(it->first);
                }
                return result;
        }
@@ -321,7 +323,7 @@ class CItemDefManager: public IWritableItemDefManager
                                <<name<<"\""<<std::endl;
 
                // This is not thread-safe
-               assert(get_current_thread_id() == m_main_thread);
+               sanity_check(thr_is_current_thread(m_main_thread));
 
                // Skip if already in cache
                ClientCached *cc = NULL;
@@ -452,7 +454,7 @@ class CItemDefManager: public IWritableItemDefManager
                if(cc)
                        return cc;
 
-               if(get_current_thread_id() == m_main_thread)
+               if(thr_is_current_thread(m_main_thread))
                {
                        return createClientCachedDirect(name, gamedef);
                }
@@ -504,7 +506,7 @@ class CItemDefManager: public IWritableItemDefManager
        {
                for(std::map<std::string, ItemDefinition*>::const_iterator
                                i = m_item_definitions.begin();
-                               i != m_item_definitions.end(); i++)
+                               i != m_item_definitions.end(); ++i)
                {
                        delete i->second;
                }
@@ -544,7 +546,7 @@ class CItemDefManager: public IWritableItemDefManager
                verbosestream<<"ItemDefManager: registering \""<<def.name<<"\""<<std::endl;
                // Ensure that the "" item (the hand) always has ToolCapabilities
                if(def.name == "")
-                       assert(def.tool_capabilities != NULL);
+                       FATAL_ERROR_IF(!def.tool_capabilities, "Hand does not have ToolCapabilities");
 
                if(m_item_definitions.count(def.name) == 0)
                        m_item_definitions[def.name] = new ItemDefinition(def);
@@ -572,22 +574,24 @@ class CItemDefManager: public IWritableItemDefManager
                writeU8(os, 0); // version
                u16 count = m_item_definitions.size();
                writeU16(os, count);
-               for(std::map<std::string, ItemDefinition*>::const_iterator
-                               i = m_item_definitions.begin();
-                               i != m_item_definitions.end(); i++)
-               {
-                       ItemDefinition *def = i->second;
+
+               for (std::map<std::string, ItemDefinition *>::const_iterator
+                               it = m_item_definitions.begin();
+                               it != m_item_definitions.end(); ++it) {
+                       ItemDefinition *def = it->second;
                        // Serialize ItemDefinition and write wrapped in a string
                        std::ostringstream tmp_os(std::ios::binary);
                        def->serialize(tmp_os, protocol_version);
-                       os<<serializeString(tmp_os.str());
+                       os << serializeString(tmp_os.str());
                }
+
                writeU16(os, m_aliases.size());
-               for(std::map<std::string, std::string>::const_iterator
-                       i = m_aliases.begin(); i != m_aliases.end(); i++)
-               {
-                       os<<serializeString(i->first);
-                       os<<serializeString(i->second);
+
+               for (StringMap::const_iterator
+                               it = m_aliases.begin();
+                               it != m_aliases.end(); ++it) {
+                       os << serializeString(it->first);
+                       os << serializeString(it->second);
                }
        }
        void deSerialize(std::istream &is)
@@ -634,7 +638,7 @@ class CItemDefManager: public IWritableItemDefManager
        // Key is name
        std::map<std::string, ItemDefinition*> m_item_definitions;
        // Aliases
-       std::map<std::string, std::string> m_aliases;
+       StringMap m_aliases;
 #ifndef SERVER
        // The id of the thread that is allowed to use irrlicht directly
        threadid_t m_main_thread;