src/tooldef.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "tooldef.h"
  21 #include "irrlichttypes.h"
  22 #include "log.h"
  23 #include <sstream>
  24 #include "utility.h"
  25
  26 ToolDiggingProperties::ToolDiggingProperties(float full_punch_interval_,
  27                 float a, float b, float c, float d, float e,
  28                 float f, float g, float h, float i, float j):
  29         full_punch_interval(full_punch_interval_),
  30         basetime(a),
  31         dt_weight(b),
  32         dt_crackiness(c),
  33         dt_crumbliness(d),
  34         dt_cuttability(e),
  35         basedurability(f),
  36         dd_weight(g),
  37         dd_crackiness(h),
  38         dd_crumbliness(i),
  39         dd_cuttability(j)
  40 {}
  41
  42 std::string ToolDefinition::dump()
  43 {
  44         std::ostringstream os(std::ios::binary);
  45         os<<"[ToolDefinition::dump() not implemented due to lazyness]"
  46                         <<std::endl;
  47         return os.str();
  48 }
  49
  50 void ToolDefinition::serialize(std::ostream &os)
  51 {
  52         writeU8(os, 0); // version
  53         os<<serializeString(imagename);
  54         writeF1000(os, properties.basetime);
  55         writeF1000(os, properties.dt_weight);
  56         writeF1000(os, properties.dt_crackiness);
  57         writeF1000(os, properties.dt_crumbliness);
  58         writeF1000(os, properties.dt_cuttability);
  59         writeF1000(os, properties.basedurability);
  60         writeF1000(os, properties.dd_weight);
  61         writeF1000(os, properties.dd_crackiness);
  62         writeF1000(os, properties.dd_crumbliness);
  63         writeF1000(os, properties.dd_cuttability);
  64         writeF1000(os, properties.full_punch_interval);
  65 }
  66
  67 void ToolDefinition::deSerialize(std::istream &is)
  68 {
  69         int version = readU8(is);
  70         if(version != 0) throw SerializationError(
  71                         "unsupported ToolDefinition version");
  72         imagename = deSerializeString(is);
  73         properties.basetime = readF1000(is);
  74         properties.dt_weight = readF1000(is);
  75         properties.dt_crackiness = readF1000(is);
  76         properties.dt_crumbliness = readF1000(is);
  77         properties.dt_cuttability = readF1000(is);
  78         properties.basedurability = readF1000(is);
  79         properties.dd_weight = readF1000(is);
  80         properties.dd_crackiness = readF1000(is);
  81         properties.dd_crumbliness = readF1000(is);
  82         properties.dd_cuttability = readF1000(is);
  83         try{
  84                 properties.full_punch_interval = readF1000(is);
  85         }catch(SerializationError &e){} // Temporary for 0.4.dev
  86 }
  87
  88 class CToolDefManager: public IWritableToolDefManager
  89 {
  90 public:
  91         virtual ~CToolDefManager()
  92         {
  93                 clear();
  94         }
  95         virtual const ToolDefinition* getToolDefinition(const std::string &toolname) const
  96         {
  97                 core::map<std::string, ToolDefinition*>::Node *n;
  98                 n = m_tool_definitions.find(toolname);
  99                 if(n == NULL)
 100                         return NULL;
 101                 return n->getValue();
 102         }
 103         virtual std::string getImagename(const std::string &toolname) const
 104         {
 105                 const ToolDefinition *def = getToolDefinition(toolname);
 106                 if(def == NULL)
 107                         return "";
 108                 return def->imagename;
 109         }
 110         virtual ToolDiggingProperties getDiggingProperties(
 111                         const std::string &toolname) const
 112         {
 113                 const ToolDefinition *def = getToolDefinition(toolname);
 114                 // If tool does not exist, just return an impossible
 115                 if(def == NULL){
 116                         // If tool does not exist, try empty name
 117                         const ToolDefinition *def = getToolDefinition("");
 118                         if(def == NULL) // If that doesn't exist either, return default
 119                                 return ToolDiggingProperties();
 120                         return def->properties;
 121                 }
 122                 return def->properties;
 123         }
 124         virtual bool registerTool(std::string toolname, const ToolDefinition &def)
 125         {
 126                 infostream<<"registerTool: registering tool \""<<toolname<<"\""<<std::endl;
 127                 /*core::map<std::string, ToolDefinition*>::Node *n;
 128                 n = m_tool_definitions.find(toolname);
 129                 if(n != NULL){
 130                         errorstream<<"registerTool: registering tool \""<<toolname
 131                                         <<"\" failed: name is already registered"<<std::endl;
 132                         return false;
 133                 }*/
 134                 m_tool_definitions[toolname] = new ToolDefinition(def);
 135                 return true;
 136         }
 137         virtual void clear()
 138         {
 139                 for(core::map<std::string, ToolDefinition*>::Iterator
 140                                 i = m_tool_definitions.getIterator();
 141                                 i.atEnd() == false; i++){
 142                         delete i.getNode()->getValue();
 143                 }
 144                 m_tool_definitions.clear();
 145         }
 146         virtual void serialize(std::ostream &os)
 147         {
 148                 writeU8(os, 0); // version
 149                 u16 count = m_tool_definitions.size();
 150                 writeU16(os, count);
 151                 for(core::map<std::string, ToolDefinition*>::Iterator
 152                                 i = m_tool_definitions.getIterator();
 153                                 i.atEnd() == false; i++){
 154                         std::string name = i.getNode()->getKey();
 155                         ToolDefinition *def = i.getNode()->getValue();
 156                         // Serialize name
 157                         os<<serializeString(name);
 158                         // Serialize ToolDefinition and write wrapped in a string
 159                         std::ostringstream tmp_os(std::ios::binary);
 160                         def->serialize(tmp_os);
 161                         os<<serializeString(tmp_os.str());
 162                 }
 163         }
 164         virtual void deSerialize(std::istream &is)
 165         {
 166                 // Clear everything
 167                 clear();
 168                 // Deserialize
 169                 int version = readU8(is);
 170                 if(version != 0) throw SerializationError(
 171                                 "unsupported ToolDefManager version");
 172                 u16 count = readU16(is);
 173                 for(u16 i=0; i<count; i++){
 174                         // Deserialize name
 175                         std::string name = deSerializeString(is);
 176                         // Deserialize a string and grab a ToolDefinition from it
 177                         std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
 178                         ToolDefinition def;
 179                         def.deSerialize(tmp_is);
 180                         // Register
 181                         registerTool(name, def);
 182                 }
 183         }
 184 private:
 185         // Key is name
 186         core::map<std::string, ToolDefinition*> m_tool_definitions;
 187 };
 188
 189 IWritableToolDefManager* createToolDefManager()
 190 {
 191         return new CToolDefManager();
 192 }
 193