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(
  27                 float a, float b, float c, float d, float e,
  28                 float f, float g, float h, float i, float j):
  29         basetime(a),
  30         dt_weight(b),
  31         dt_crackiness(c),
  32         dt_crumbliness(d),
  33         dt_cuttability(e),
  34         basedurability(f),
  35         dd_weight(g),
  36         dd_crackiness(h),
  37         dd_crumbliness(i),
  38         dd_cuttability(j)
  39 {}
  40
  41 std::string ToolDefinition::dump()
  42 {
  43         std::ostringstream os(std::ios::binary);
  44         os<<"[ToolDefinition::dump() not implemented due to lazyness]"
  45                         <<std::endl;
  46         return os.str();
  47 }
  48
  49 void ToolDefinition::serialize(std::ostream &os)
  50 {
  51         writeU8(os, 0); // version
  52         os<<serializeString(imagename);
  53         writeF1000(os, properties.basetime);
  54         writeF1000(os, properties.dt_weight);
  55         writeF1000(os, properties.dt_crackiness);
  56         writeF1000(os, properties.dt_crumbliness);
  57         writeF1000(os, properties.dt_cuttability);
  58         writeF1000(os, properties.basedurability);
  59         writeF1000(os, properties.dd_weight);
  60         writeF1000(os, properties.dd_crackiness);
  61         writeF1000(os, properties.dd_crumbliness);
  62         writeF1000(os, properties.dd_cuttability);
  63 }
  64
  65 void ToolDefinition::deSerialize(std::istream &is)
  66 {
  67         int version = readU8(is);
  68         if(version != 0) throw SerializationError(
  69                         "unsupported ToolDefinition version");
  70         imagename = deSerializeString(is);
  71         properties.basetime = readF1000(is);
  72         properties.dt_weight = readF1000(is);
  73         properties.dt_crackiness = readF1000(is);
  74         properties.dt_crumbliness = readF1000(is);
  75         properties.dt_cuttability = readF1000(is);
  76         properties.basedurability = readF1000(is);
  77         properties.dd_weight = readF1000(is);
  78         properties.dd_crackiness = readF1000(is);
  79         properties.dd_crumbliness = readF1000(is);
  80         properties.dd_cuttability = readF1000(is);
  81 }
  82
  83 class CToolDefManager: public IWritableToolDefManager
  84 {
  85 public:
  86         virtual ~CToolDefManager()
  87         {
  88                 for(core::map<std::string, ToolDefinition*>::Iterator
  89                                 i = m_tool_definitions.getIterator();
  90                                 i.atEnd() == false; i++){
  91                         delete i.getNode()->getValue();
  92                 }
  93         }
  94         virtual const ToolDefinition* getToolDefinition(const std::string &toolname) const
  95         {
  96                 core::map<std::string, ToolDefinition*>::Node *n;
  97                 n = m_tool_definitions.find(toolname);
  98                 if(n == NULL)
  99                         return NULL;
 100                 return n->getValue();
 101         }
 102         virtual std::string getImagename(const std::string &toolname) const
 103         {
 104                 const ToolDefinition *def = getToolDefinition(toolname);
 105                 if(def == NULL)
 106                         return "";
 107                 return def->imagename;
 108         }
 109         virtual ToolDiggingProperties getDiggingProperties(
 110                         const std::string &toolname) const
 111         {
 112                 const ToolDefinition *def = getToolDefinition(toolname);
 113                 // If tool does not exist, just return an impossible
 114                 if(def == NULL){
 115                         // If tool does not exist, try empty name
 116                         const ToolDefinition *def = getToolDefinition("");
 117                         if(def == NULL) // If that doesn't exist either, return default
 118                                 return ToolDiggingProperties();
 119                         return def->properties;
 120                 }
 121                 return def->properties;
 122         }
 123         virtual bool registerTool(std::string toolname, const ToolDefinition &def)
 124         {
 125                 infostream<<"registerTool: registering tool \""<<toolname<<"\""<<std::endl;
 126                 core::map<std::string, ToolDefinition*>::Node *n;
 127                 n = m_tool_definitions.find(toolname);
 128                 if(n != NULL){
 129                         errorstream<<"registerTool: registering tool \""<<toolname
 130                                         <<"\" failed: name is already registered"<<std::endl;
 131                         return false;
 132                 }
 133                 m_tool_definitions[toolname] = new ToolDefinition(def);
 134                 return true;
 135         }
 136         virtual void serialize(std::ostream &os)
 137         {
 138                 writeU8(os, 0); // version
 139                 u16 count = m_tool_definitions.size();
 140                 writeU16(os, count);
 141                 for(core::map<std::string, ToolDefinition*>::Iterator
 142                                 i = m_tool_definitions.getIterator();
 143                                 i.atEnd() == false; i++){
 144                         std::string name = i.getNode()->getKey();
 145                         ToolDefinition *def = i.getNode()->getValue();
 146                         // Serialize name
 147                         os<<serializeString(name);
 148                         // Serialize ToolDefinition and write wrapped in a string
 149                         std::ostringstream tmp_os(std::ios::binary);
 150                         def->serialize(tmp_os);
 151                         os<<serializeString(tmp_os.str());
 152                 }
 153         }
 154         virtual void deSerialize(std::istream &is)
 155         {
 156                 int version = readU8(is);
 157                 if(version != 0) throw SerializationError(
 158                                 "unsupported ToolDefManager version");
 159                 u16 count = readU16(is);
 160                 for(u16 i=0; i<count; i++){
 161                         // Deserialize name
 162                         std::string name = deSerializeString(is);
 163                         // Deserialize a string and grab a ToolDefinition from it
 164                         std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
 165                         ToolDefinition def;
 166                         def.deSerialize(tmp_is);
 167                         // Register
 168                         registerTool(name, def);
 169                 }
 170         }
 171 private:
 172         // Key is name
 173         core::map<std::string, ToolDefinition*> m_tool_definitions;
 174 };
 175
 176 IWritableToolDefManager* createToolDefManager()
 177 {
 178         return new CToolDefManager();
 179 }
 180