X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftool.cpp;h=568f0af542df70b6fb957fee581d7142ef9b3448;hb=a1c5a011421840f4b2f9d8b6cc9b9724cf333168;hp=bb884938c8eb6a66642f0b0e6c7a6c129f18b09c;hpb=7f4cdbcbe9b5b4655c2c5eba2043628487668e24;p=oweals%2Fminetest.git

diff --git a/src/tool.cpp b/src/tool.cpp
index bb884938c..568f0af54 100644
--- a/src/tool.cpp
+++ b/src/tool.cpp
@@ -25,79 +25,158 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "util/serialize.h"
 #include "util/numeric.h"
 
+void ToolGroupCap::toJson(Json::Value &object) const
+{
+	object["maxlevel"] = maxlevel;
+	object["uses"] = uses;
+
+	Json::Value times_object;
+	for (auto time : times)
+		times_object[time.first] = time.second;
+	object["times"] = times_object;
+}
+
+void ToolGroupCap::fromJson(const Json::Value &json)
+{
+	if (json.isObject()) {
+		if (json["maxlevel"].isInt())
+			maxlevel = json["maxlevel"].asInt();
+		if (json["uses"].isInt())
+			uses = json["uses"].asInt();
+		const Json::Value &times_object = json["times"];
+		if (times_object.isArray()) {
+			Json::ArrayIndex size = times_object.size();
+			for (Json::ArrayIndex i = 0; i < size; ++i)
+				if (times_object[i].isDouble())
+					times[i] = times_object[i].asFloat();
+		}
+	}
+}
+
 void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
 {
-	writeU8(os, 2); // version (protocol >= 18)
+	writeU8(os, 3); // protocol_version >= 36
 	writeF1000(os, full_punch_interval);
 	writeS16(os, max_drop_level);
 	writeU32(os, groupcaps.size());
-	for (ToolGCMap::const_iterator i = groupcaps.begin(); i != groupcaps.end(); ++i) {
-		const std::string *name = &i->first;
-		const ToolGroupCap *cap = &i->second;
+	for (const auto &groupcap : groupcaps) {
+		const std::string *name = &groupcap.first;
+		const ToolGroupCap *cap = &groupcap.second;
 		os << serializeString(*name);
 		writeS16(os, cap->uses);
 		writeS16(os, cap->maxlevel);
 		writeU32(os, cap->times.size());
-		for (UNORDERED_MAP<int, float>::const_iterator
-				j = cap->times.begin(); j != cap->times.end(); ++j) {
-			writeS16(os, j->first);
-			writeF1000(os, j->second);
+		for (const auto &time : cap->times) {
+			writeS16(os, time.first);
+			writeF1000(os, time.second);
 		}
 	}
 
 	writeU32(os, damageGroups.size());
 
-	for (DamageGroup::const_iterator i = damageGroups.begin();
-			i != damageGroups.end(); ++i) {
-		os << serializeString(i->first);
-		writeS16(os, i->second);
+	for (const auto &damageGroup : damageGroups) {
+		os << serializeString(damageGroup.first);
+		writeS16(os, damageGroup.second);
 	}
 }
 
 void ToolCapabilities::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 1 && version != 2) throw SerializationError(
-			"unsupported ToolCapabilities version");
+	if (version < 3)
+		throw SerializationError("unsupported ToolCapabilities version");
+
 	full_punch_interval = readF1000(is);
 	max_drop_level = readS16(is);
 	groupcaps.clear();
 	u32 groupcaps_size = readU32(is);
-	for(u32 i=0; i<groupcaps_size; i++){
+	for (u32 i = 0; i < groupcaps_size; i++) {
 		std::string name = deSerializeString(is);
 		ToolGroupCap cap;
 		cap.uses = readS16(is);
 		cap.maxlevel = readS16(is);
 		u32 times_size = readU32(is);
-		for(u32 i=0; i<times_size; i++){
+		for(u32 i = 0; i < times_size; i++) {
 			int level = readS16(is);
 			float time = readF1000(is);
 			cap.times[level] = time;
 		}
 		groupcaps[name] = cap;
 	}
-	if(version == 2)
-	{
-		u32 damage_groups_size = readU32(is);
-		for(u32 i=0; i<damage_groups_size; i++){
-			std::string name = deSerializeString(is);
-			s16 rating = readS16(is);
-			damageGroups[name] = rating;
+
+	u32 damage_groups_size = readU32(is);
+	for (u32 i = 0; i < damage_groups_size; i++) {
+		std::string name = deSerializeString(is);
+		s16 rating = readS16(is);
+		damageGroups[name] = rating;
+	}
+}
+
+void ToolCapabilities::serializeJson(std::ostream &os) const
+{
+	Json::Value root;
+	root["full_punch_interval"] = full_punch_interval;
+	root["max_drop_level"] = max_drop_level;
+
+	Json::Value groupcaps_object;
+	for (auto groupcap : groupcaps) {
+		groupcap.second.toJson(groupcaps_object[groupcap.first]);
+	}
+	root["groupcaps"] = groupcaps_object;
+
+	Json::Value damage_groups_object;
+	DamageGroup::const_iterator dgiter;
+	for (dgiter = damageGroups.begin(); dgiter != damageGroups.end(); ++dgiter) {
+		damage_groups_object[dgiter->first] = dgiter->second;
+	}
+	root["damage_groups"] = damage_groups_object;
+
+	os << root;
+}
+
+void ToolCapabilities::deserializeJson(std::istream &is)
+{
+	Json::Value root;
+	is >> root;
+	if (root.isObject()) {
+		if (root["full_punch_interval"].isDouble())
+			full_punch_interval = root["full_punch_interval"].asFloat();
+		if (root["max_drop_level"].isInt())
+			max_drop_level = root["max_drop_level"].asInt();
+
+		Json::Value &groupcaps_object = root["groupcaps"];
+		if (groupcaps_object.isObject()) {
+			Json::ValueIterator gciter;
+			for (gciter = groupcaps_object.begin();
+					gciter != groupcaps_object.end(); ++gciter) {
+				ToolGroupCap groupcap;
+				groupcap.fromJson(*gciter);
+				groupcaps[gciter.key().asString()] = groupcap;
+			}
+		}
+
+		Json::Value &damage_groups_object = root["damage_groups"];
+		if (damage_groups_object.isObject()) {
+			Json::ValueIterator dgiter;
+			for (dgiter = damage_groups_object.begin();
+					dgiter != damage_groups_object.end(); ++dgiter) {
+				Json::Value &value = *dgiter;
+				if (value.isInt())
+					damageGroups[dgiter.key().asString()] =
+						value.asInt();
+			}
 		}
 	}
 }
 
 DigParams getDigParams(const ItemGroupList &groups,
-		const ToolCapabilities *tp, float time_from_last_punch)
+		const ToolCapabilities *tp)
 {
-	//infostream<<"getDigParams"<<std::endl;
-	/* Check group dig_immediate */
-	switch(itemgroup_get(groups, "dig_immediate")){
+	// Group dig_immediate has fixed time and no wear
+	switch (itemgroup_get(groups, "dig_immediate")) {
 	case 2:
-		//infostream<<"dig_immediate=2"<<std::endl;
 		return DigParams(true, 0.5, 0, "dig_immediate");
 	case 3:
-		//infostream<<"dig_immediate=3"<<std::endl;
 		return DigParams(true, 0, 0, "dig_immediate");
 	default:
 		break;
@@ -107,66 +186,54 @@ DigParams getDigParams(const ItemGroupList &groups,
 	bool result_diggable = false;
 	float result_time = 0.0;
 	float result_wear = 0.0;
-	std::string result_main_group = "";
+	std::string result_main_group;
 
 	int level = itemgroup_get(groups, "level");
-	//infostream<<"level="<<level<<std::endl;
-	for (ToolGCMap::const_iterator i = tp->groupcaps.begin();
-		 	i != tp->groupcaps.end(); ++i) {
-		const std::string &name = i->first;
-		//infostream<<"group="<<name<<std::endl;
-		const ToolGroupCap &cap = i->second;
-		int rating = itemgroup_get(groups, name);
+	for (const auto &groupcap : tp->groupcaps) {
+		const ToolGroupCap &cap = groupcap.second;
+
+		int leveldiff = cap.maxlevel - level;
+		if (leveldiff < 0)
+			continue;
+
+		const std::string &groupname = groupcap.first;
 		float time = 0;
+		int rating = itemgroup_get(groups, groupname);
 		bool time_exists = cap.getTime(rating, &time);
-		if(!result_diggable || time < result_time){
-			if(cap.maxlevel >= level && time_exists){
-				result_diggable = true;
-				int leveldiff = cap.maxlevel - level;
-				result_time = time / MYMAX(1, leveldiff);
-				if(cap.uses != 0)
-					result_wear = 1.0 / cap.uses / pow(3.0, (double)leveldiff);
-				else
-					result_wear = 0;
-				result_main_group = name;
-			}
+		if (!time_exists)
+			continue;
+
+		if (leveldiff > 1)
+			time /= leveldiff;
+		if (!result_diggable || time < result_time) {
+			result_time = time;
+			result_diggable = true;
+			if (cap.uses != 0)
+				result_wear = 1.0 / cap.uses / pow(3.0, leveldiff);
+			else
+				result_wear = 0;
+			result_main_group = groupname;
 		}
 	}
-	//infostream<<"result_diggable="<<result_diggable<<std::endl;
-	//infostream<<"result_time="<<result_time<<std::endl;
-	//infostream<<"result_wear="<<result_wear<<std::endl;
-
-	if(time_from_last_punch < tp->full_punch_interval){
-		float f = time_from_last_punch / tp->full_punch_interval;
-		//infostream<<"f="<<f<<std::endl;
-		result_time /= f;
-		result_wear /= f;
-	}
 
-	u16 wear_i = 65535.*result_wear;
+	u16 wear_i = U16_MAX * result_wear;
 	return DigParams(result_diggable, result_time, wear_i, result_main_group);
 }
 
-DigParams getDigParams(const ItemGroupList &groups,
-		const ToolCapabilities *tp)
-{
-	return getDigParams(groups, tp, 1000000);
-}
-
 HitParams getHitParams(const ItemGroupList &armor_groups,
 		const ToolCapabilities *tp, float time_from_last_punch)
 {
 	s16 damage = 0;
 	float full_punch_interval = tp->full_punch_interval;
 
-	for (DamageGroup::const_iterator i = tp->damageGroups.begin();
-			i != tp->damageGroups.end(); ++i) {
-		s16 armor = itemgroup_get(armor_groups, i->first);
-		damage += i->second * rangelim(time_from_last_punch / full_punch_interval, 0.0, 1.0)
+	for (const auto &damageGroup : tp->damageGroups) {
+		s16 armor = itemgroup_get(armor_groups, damageGroup.first);
+		damage += damageGroup.second
+				* rangelim(time_from_last_punch / full_punch_interval, 0.0, 1.0)
 				* armor / 100.0;
 	}
 
-	return HitParams(damage, 0);
+	return {damage, 0};
 }
 
 HitParams getHitParams(const ItemGroupList &armor_groups,
@@ -183,12 +250,13 @@ PunchDamageResult getPunchDamage(
 ){
 	bool do_hit = true;
 	{
-		if(do_hit && punchitem){
-			if(itemgroup_get(armor_groups, "punch_operable") &&
-					(toolcap == NULL || punchitem->name == ""))
+		if (do_hit && punchitem) {
+			if (itemgroup_get(armor_groups, "punch_operable") &&
+					(toolcap == NULL || punchitem->name.empty()))
 				do_hit = false;
 		}
-		if(do_hit){
+
+		if (do_hit) {
 			if(itemgroup_get(armor_groups, "immortal"))
 				do_hit = false;
 		}