3 Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
21 #include "irrlichttypes.h"
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):
41 std::string ToolDefinition::dump()
43 std::ostringstream os(std::ios::binary);
44 os<<"[ToolDefinition::dump() not implemented due to lazyness]"
49 void ToolDefinition::serialize(std::ostream &os)
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);
65 void ToolDefinition::deSerialize(std::istream &is)
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);
83 class CToolDefManager: public IWritableToolDefManager
86 virtual ~CToolDefManager()
90 virtual const ToolDefinition* getToolDefinition(const std::string &toolname) const
92 core::map<std::string, ToolDefinition*>::Node *n;
93 n = m_tool_definitions.find(toolname);
98 virtual std::string getImagename(const std::string &toolname) const
100 const ToolDefinition *def = getToolDefinition(toolname);
103 return def->imagename;
105 virtual ToolDiggingProperties getDiggingProperties(
106 const std::string &toolname) const
108 const ToolDefinition *def = getToolDefinition(toolname);
109 // If tool does not exist, just return an impossible
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;
117 return def->properties;
119 virtual bool registerTool(std::string toolname, const ToolDefinition &def)
121 infostream<<"registerTool: registering tool \""<<toolname<<"\""<<std::endl;
122 /*core::map<std::string, ToolDefinition*>::Node *n;
123 n = m_tool_definitions.find(toolname);
125 errorstream<<"registerTool: registering tool \""<<toolname
126 <<"\" failed: name is already registered"<<std::endl;
129 m_tool_definitions[toolname] = new ToolDefinition(def);
134 for(core::map<std::string, ToolDefinition*>::Iterator
135 i = m_tool_definitions.getIterator();
136 i.atEnd() == false; i++){
137 delete i.getNode()->getValue();
139 m_tool_definitions.clear();
141 virtual void serialize(std::ostream &os)
143 writeU8(os, 0); // version
144 u16 count = m_tool_definitions.size();
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();
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());
159 virtual void deSerialize(std::istream &is)
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++){
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);
174 def.deSerialize(tmp_is);
176 registerTool(name, def);
181 core::map<std::string, ToolDefinition*> m_tool_definitions;
184 IWritableToolDefManager* createToolDefManager()
186 return new CToolDefManager();