239 lines
6.9 KiB
C++
239 lines
6.9 KiB
C++
/*
|
|
Minetest-c55
|
|
Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "tooldef.h"
|
|
#include "irrlichttypes.h"
|
|
#include "log.h"
|
|
#include <sstream>
|
|
#include "utility.h"
|
|
#include <map>
|
|
|
|
ToolDiggingProperties::ToolDiggingProperties(float full_punch_interval_,
|
|
float a, float b, float c, float d, float e,
|
|
float f, float g, float h, float i, float j):
|
|
full_punch_interval(full_punch_interval_),
|
|
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);
|
|
writeF1000(os, properties.full_punch_interval);
|
|
}
|
|
|
|
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);
|
|
try{
|
|
properties.full_punch_interval = readF1000(is);
|
|
}catch(SerializationError &e){} // Temporary for 0.4.dev
|
|
}
|
|
|
|
class CToolDefManager: public IWritableToolDefManager
|
|
{
|
|
public:
|
|
virtual ~CToolDefManager()
|
|
{
|
|
clear();
|
|
}
|
|
virtual const ToolDefinition* getToolDefinition(const std::string &toolname_) const
|
|
{
|
|
// Convert name according to possible alias
|
|
std::string toolname = getAlias(toolname_);
|
|
// Get the definition
|
|
core::map<std::string, ToolDefinition*>::Node *n;
|
|
n = m_tool_definitions.find(toolname);
|
|
if(n == NULL)
|
|
return NULL;
|
|
return n->getValue();
|
|
}
|
|
virtual std::string getImagename(const std::string &toolname) const
|
|
{
|
|
const ToolDefinition *def = getToolDefinition(toolname);
|
|
if(def == NULL)
|
|
return "";
|
|
return def->imagename;
|
|
}
|
|
virtual ToolDiggingProperties getDiggingProperties(
|
|
const std::string &toolname) const
|
|
{
|
|
const ToolDefinition *def = getToolDefinition(toolname);
|
|
// If tool does not exist, just return an impossible
|
|
if(def == NULL){
|
|
// If tool does not exist, try empty name
|
|
const ToolDefinition *def = getToolDefinition("");
|
|
if(def == NULL) // If that doesn't exist either, return default
|
|
return ToolDiggingProperties();
|
|
return def->properties;
|
|
}
|
|
return def->properties;
|
|
}
|
|
virtual std::string getAlias(const std::string &name) const
|
|
{
|
|
std::map<std::string, std::string>::const_iterator i;
|
|
i = m_aliases.find(name);
|
|
if(i != m_aliases.end())
|
|
return i->second;
|
|
return name;
|
|
}
|
|
// IWritableToolDefManager
|
|
virtual bool registerTool(std::string toolname, const ToolDefinition &def)
|
|
{
|
|
infostream<<"registerTool: registering tool \""<<toolname<<"\""<<std::endl;
|
|
m_tool_definitions[toolname] = new ToolDefinition(def);
|
|
|
|
// Remove conflicting alias if it exists
|
|
bool alias_removed = (m_aliases.erase(toolname) != 0);
|
|
if(alias_removed)
|
|
infostream<<"tdef: erased alias "<<toolname
|
|
<<" because tool was defined"<<std::endl;
|
|
|
|
return true;
|
|
}
|
|
virtual void clear()
|
|
{
|
|
for(core::map<std::string, ToolDefinition*>::Iterator
|
|
i = m_tool_definitions.getIterator();
|
|
i.atEnd() == false; i++){
|
|
delete i.getNode()->getValue();
|
|
}
|
|
m_tool_definitions.clear();
|
|
m_aliases.clear();
|
|
}
|
|
virtual void setAlias(const std::string &name,
|
|
const std::string &convert_to)
|
|
{
|
|
if(getToolDefinition(name) != NULL){
|
|
infostream<<"tdef: not setting alias "<<name<<" -> "<<convert_to
|
|
<<": "<<name<<" is already defined"<<std::endl;
|
|
return;
|
|
}
|
|
infostream<<"tdef: setting alias "<<name<<" -> "<<convert_to
|
|
<<std::endl;
|
|
m_aliases[name] = convert_to;
|
|
}
|
|
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());
|
|
}
|
|
|
|
writeU16(os, m_aliases.size());
|
|
for(std::map<std::string, std::string>::const_iterator
|
|
i = m_aliases.begin(); i != m_aliases.end(); i++)
|
|
{
|
|
os<<serializeString(i->first);
|
|
os<<serializeString(i->second);
|
|
}
|
|
}
|
|
virtual void deSerialize(std::istream &is)
|
|
{
|
|
// Clear everything
|
|
clear();
|
|
// Deserialize
|
|
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);
|
|
}
|
|
|
|
u16 num_aliases = readU16(is);
|
|
if(!is.eof()){
|
|
for(u16 i=0; i<num_aliases; i++){
|
|
std::string name = deSerializeString(is);
|
|
std::string convert_to = deSerializeString(is);
|
|
m_aliases[name] = convert_to;
|
|
}
|
|
}
|
|
}
|
|
private:
|
|
// Key is name
|
|
core::map<std::string, ToolDefinition*> m_tool_definitions;
|
|
// Aliases
|
|
std::map<std::string, std::string> m_aliases;
|
|
};
|
|
|
|
IWritableToolDefManager* createToolDefManager()
|
|
{
|
|
return new CToolDefManager();
|
|
}
|
|
|