#include "tooldef.h"
#include "irrlichttypes.h"
#include "log.h"
-#include <ostream>
+#include <sstream>
+#include "utility.h"
+
+ToolDiggingProperties::ToolDiggingProperties(
+ float a, float b, float c, float d, float e,
+ float f, float g, float h, float i, float j):
+ basetime(a),
+ dt_weight(b),
+ dt_crackiness(c),
+ dt_crumbliness(d),
+ dt_cuttability(e),
+ basedurability(f),
+ dd_weight(g),
+ dd_crackiness(h),
+ dd_crumbliness(i),
+ dd_cuttability(j)
+{}
+
+std::string ToolDefinition::dump()
+{
+ std::ostringstream os(std::ios::binary);
+ os<<"[ToolDefinition::dump() not implemented due to lazyness]"
+ <<std::endl;
+ return os.str();
+}
+
+void ToolDefinition::serialize(std::ostream &os)
+{
+ writeU8(os, 0); // version
+ os<<serializeString(imagename);
+ writeF1000(os, properties.basetime);
+ writeF1000(os, properties.dt_weight);
+ writeF1000(os, properties.dt_crackiness);
+ writeF1000(os, properties.dt_crumbliness);
+ writeF1000(os, properties.dt_cuttability);
+ writeF1000(os, properties.basedurability);
+ writeF1000(os, properties.dd_weight);
+ writeF1000(os, properties.dd_crackiness);
+ writeF1000(os, properties.dd_crumbliness);
+ writeF1000(os, properties.dd_cuttability);
+}
+
+void ToolDefinition::deSerialize(std::istream &is)
+{
+ int version = readU8(is);
+ if(version != 0) throw SerializationError(
+ "unsupported ToolDefinition version");
+ imagename = deSerializeString(is);
+ properties.basetime = readF1000(is);
+ properties.dt_weight = readF1000(is);
+ properties.dt_crackiness = readF1000(is);
+ properties.dt_crumbliness = readF1000(is);
+ properties.dt_cuttability = readF1000(is);
+ properties.basedurability = readF1000(is);
+ properties.dd_weight = readF1000(is);
+ properties.dd_crackiness = readF1000(is);
+ properties.dd_crumbliness = readF1000(is);
+ properties.dd_cuttability = readF1000(is);
+}
class CToolDefManager: public IWritableToolDefManager
{
m_tool_definitions[toolname] = new ToolDefinition(def);
return true;
}
+ virtual void serialize(std::ostream &os)
+ {
+ writeU8(os, 0); // version
+ u16 count = m_tool_definitions.size();
+ writeU16(os, count);
+ for(core::map<std::string, ToolDefinition*>::Iterator
+ i = m_tool_definitions.getIterator();
+ i.atEnd() == false; i++){
+ std::string name = i.getNode()->getKey();
+ ToolDefinition *def = i.getNode()->getValue();
+ // Serialize name
+ os<<serializeString(name);
+ // Serialize ToolDefinition and write wrapped in a string
+ std::ostringstream tmp_os(std::ios::binary);
+ def->serialize(tmp_os);
+ os<<serializeString(tmp_os.str());
+ }
+ }
+ virtual void deSerialize(std::istream &is)
+ {
+ int version = readU8(is);
+ if(version != 0) throw SerializationError(
+ "unsupported ToolDefManager version");
+ u16 count = readU16(is);
+ for(u16 i=0; i<count; i++){
+ // Deserialize name
+ std::string name = deSerializeString(is);
+ // Deserialize a string and grab a ToolDefinition from it
+ std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
+ ToolDefinition def;
+ def.deSerialize(tmp_is);
+ // Register
+ registerTool(name, def);
+ }
+ }
private:
// Key is name
core::map<std::string, ToolDefinition*> m_tool_definitions;