Fix key change menu a bit

[dragonfireclient.git] / src / materials.h

diff --git a/src/materials.h b/src/materials.h
index f061ecbfa5eb7075c5fe0e4463fad10ff6279301..b25d047beb9831060268d46a7e6a78d7d9a34d70 100644 (file)
--- a/src/materials.h
+++ b/src/materials.h
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-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
@@ -26,78 +26,92 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "common_irrlicht.h"
 #include <string>
+#include <iostream>
+
+enum Diggability
+{
+       DIGGABLE_NOT,
+       DIGGABLE_NORMAL,
+       DIGGABLE_CONSTANT
+};
+
+struct MaterialProperties
+{
+       // Values can be anything. 0 is normal.
+       
+       enum Diggability diggability;
+
+       // Constant time for DIGGABLE_CONSTANT
+       float constant_time;
+
+       // Weight; the amount of stuff in the block. Not realistic.
+       float weight;
+       // Rock; wood a bit.
+       // A Pickaxe manages high crackiness well.
+       float crackiness;
+       // Sand is extremely crumble; dirt is quite crumble.
+       // A shovel is good for crumbly stuff. Pickaxe is horrible.
+       float crumbliness;
+       // An axe is best for cuttable heavy stuff.
+       // Sword is best for cuttable light stuff.
+       float cuttability;
+       // If high, ignites easily
+       float flammability;
+
+       MaterialProperties():
+               diggability(DIGGABLE_NOT),
+               constant_time(0.5),
+               weight(0),
+               crackiness(0),
+               crumbliness(0),
+               cuttability(0),
+               flammability(0)
+       {}
+
+       void serialize(std::ostream &os);
+       void deSerialize(std::istream &is);
+};
 
 struct DiggingProperties
 {
-       DiggingProperties():
-               diggable(false),
-               time(0.0),
-               wear(0)
-       {
-       }
-       DiggingProperties(bool a_diggable, float a_time, u16 a_wear):
-               diggable(a_diggable),
-               time(a_time),
-               wear(a_wear)
-       {
-       }
        bool diggable;
        // Digging time in seconds
        float time;
        // Caused wear
        u16 wear;
+
+       DiggingProperties(bool a_diggable=false, float a_time=0, u16 a_wear=0):
+               diggable(a_diggable),
+               time(a_time),
+               wear(a_wear)
+       {}
 };
 
-/*
-       This is a bad way of determining mining characteristics.
-       TODO: Get rid of this and set up some attributes like toughness,
-             fluffyness, and a funciton to calculate time and durability loss
-             (and sound? and whatever else) from them
-*/
-class DiggingPropertiesList
+struct ToolDiggingProperties;
+class INodeDefManager;
+
+DiggingProperties getDiggingProperties(const MaterialProperties *mp,
+               const ToolDiggingProperties *tp, float time_from_last_punch);
+
+DiggingProperties getDiggingProperties(const MaterialProperties *mp,
+               const ToolDiggingProperties *tp);
+
+DiggingProperties getDiggingProperties(u16 content,
+               const ToolDiggingProperties *tp, INodeDefManager *nodemgr);
+
+struct HittingProperties
 {
-public:
-       DiggingPropertiesList()
-       {
-       }
-
-       void set(const std::string toolname,
-                       const DiggingProperties &prop)
-       {
-               m_digging_properties[toolname] = prop;
-       }
-
-       DiggingProperties get(const std::string toolname)
-       {
-               core::map<std::string, DiggingProperties>::Node *n;
-               n = m_digging_properties.find(toolname);
-               if(n == NULL)
-               {
-                       // Not diggable by this tool, try to get defaults
-                       n = m_digging_properties.find("");
-                       if(n == NULL)
-                       {
-                               // Not diggable at all
-                               return DiggingProperties();
-                       }
-               }
-               // Return found properties
-               return n->getValue();
-       }
-
-       void clear()
-       {
-               m_digging_properties.clear();
-       }
-
-private:
-       // toolname="": default properties (digging by hand)
-       // Key is toolname
-       core::map<std::string, DiggingProperties> m_digging_properties;
+       s16 hp;
+       s16 wear;
+
+       HittingProperties(s16 hp_=0, s16 wear_=0):
+               hp(hp_),
+               wear(wear_)
+       {}
 };
 
-// For getting the default properties, set tool=""
-DiggingProperties getDiggingProperties(u8 material, const std::string &tool);
+HittingProperties getHittingProperties(const MaterialProperties *mp,
+               const ToolDiggingProperties *tp, float time_from_last_punch);
 
 #endif