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                 clear();
  89         }
  90         virtual const ToolDefinition* getToolDefinition(const std::string &toolname) const
  91         {
  92                 core::map<std::string, ToolDefinition*>::Node *n;
  93                 n = m_tool_definitions.find(toolname);
  94                 if(n == NULL)
  95                         return NULL;
  96                 return n->getValue();
  97         }
  98         virtual std::string getImagename(const std::string &toolname) const
  99         {
 100                 const ToolDefinition *def = getToolDefinition(toolname);
 101                 if(def == NULL)
 102                         return "";
 103                 return def->imagename;
 104         }
 105         virtual ToolDiggingProperties getDiggingProperties(
 106                         const std::string &toolname) const
 107         {
 108                 const ToolDefinition *def = getToolDefinition(toolname);
 109                 // If tool does not exist, just return an impossible
 110                 if(def == NULL){
 111                         // If tool does not exist, try empty name
 112                         const ToolDefinition *def = getToolDefinition("");
 113                         if(def == NULL) // If that doesn't exist either, return default
 114                                 return ToolDiggingProperties();
 115                         return def->properties;
 116                 }
 117                 return def->properties;
 118         }
 119         virtual bool registerTool(std::string toolname, const ToolDefinition &def)
 120         {
 121                 infostream<<"registerTool: registering tool \""<<toolname<<"\""<<std::endl;
 122                 /*core::map<std::string, ToolDefinition*>::Node *n;
 123                 n = m_tool_definitions.find(toolname);
 124                 if(n != NULL){
 125                         errorstream<<"registerTool: registering tool \""<<toolname
 126                                         <<"\" failed: name is already registered"<<std::endl;
 127                         return false;
 128                 }*/
 129                 m_tool_definitions[toolname] = new ToolDefinition(def);
 130                 return true;
 131         }
 132         virtual void clear()
 133         {
 134                 for(core::map<std::string, ToolDefinition*>::Iterator
 135                                 i = m_tool_definitions.getIterator();
 136                                 i.atEnd() == false; i++){
 137                         delete i.getNode()->getValue();
 138                 }
 139                 m_tool_definitions.clear();
 140         }
 141         virtual void serialize(std::ostream &os)
 142         {
 143                 writeU8(os, 0); // version
 144                 u16 count = m_tool_definitions.size();
 145                 writeU16(os, count);
 146                 for(core::map<std::string, ToolDefinition*>::Iterator
 147                                 i = m_tool_definitions.getIterator();
 148                                 i.atEnd() == false; i++){
 149                         std::string name = i.getNode()->getKey();
 150                         ToolDefinition *def = i.getNode()->getValue();
 151                         // Serialize name
 152                         os<<serializeString(name);
 153                         // Serialize ToolDefinition and write wrapped in a string
 154                         std::ostringstream tmp_os(std::ios::binary);
 155                         def->serialize(tmp_os);
 156                         os<<serializeString(tmp_os.str());
 157                 }
 158         }
 159         virtual void deSerialize(std::istream &is)
 160         {
 161                 // Clear everything
 162                 clear();
 163                 // Deserialize
 164                 int version = readU8(is);
 165                 if(version != 0) throw SerializationError(
 166                                 "unsupported ToolDefManager version");
 167                 u16 count = readU16(is);
 168                 for(u16 i=0; i<count; i++){
 169                         // Deserialize name
 170                         std::string name = deSerializeString(is);
 171                         // Deserialize a string and grab a ToolDefinition from it
 172                         std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
 173                         ToolDefinition def;
 174                         def.deSerialize(tmp_is);
 175                         // Register
 176                         registerTool(name, def);
 177                 }
 178         }
 179 private:
 180         // Key is name
 181         core::map<std::string, ToolDefinition*> m_tool_definitions;
 182 };
 183
 184 IWritableToolDefManager* createToolDefManager()
 185 {
 186         return new CToolDefManager();
 187 }
 188