src/materials.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   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.
   9
  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.
  14
  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.
  18 */
  19
  20 #include "materials.h"
  21 #include "utility.h"
  22
  23 void MaterialProperties::serialize(std::ostream &os)
  24 {
  25         writeU8(os, 0); // version
  26         writeU8(os, diggability);
  27         writeF1000(os, constant_time);
  28         writeF1000(os, weight);
  29         writeF1000(os, crackiness);
  30         writeF1000(os, crumbliness);
  31         writeF1000(os, cuttability);
  32         writeF1000(os, flammability);
  33 }
  34
  35 void MaterialProperties::deSerialize(std::istream &is)
  36 {
  37         int version = readU8(is);
  38         if(version != 0)
  39                 throw SerializationError("unsupported MaterialProperties version");
  40         diggability = (enum Diggability)readU8(is);
  41         constant_time = readF1000(is);
  42         weight = readF1000(is);
  43         crackiness = readF1000(is);
  44         crumbliness = readF1000(is);
  45         cuttability = readF1000(is);
  46         flammability = readF1000(is);
  47 }
  48
  49 ToolDiggingProperties::ToolDiggingProperties(float full_punch_interval_,
  50                 float a, float b, float c, float d, float e,
  51                 float f, float g, float h, float i, float j):
  52         full_punch_interval(full_punch_interval_),
  53         basetime(a),
  54         dt_weight(b),
  55         dt_crackiness(c),
  56         dt_crumbliness(d),
  57         dt_cuttability(e),
  58         basedurability(f),
  59         dd_weight(g),
  60         dd_crackiness(h),
  61         dd_crumbliness(i),
  62         dd_cuttability(j)
  63 {}
  64
  65 void ToolDiggingProperties::serialize(std::ostream &os)
  66 {
  67         writeU8(os, 0); // version
  68         writeF1000(os, full_punch_interval);
  69         writeF1000(os, basetime);
  70         writeF1000(os, dt_weight);
  71         writeF1000(os, dt_crackiness);
  72         writeF1000(os, dt_crumbliness);
  73         writeF1000(os, dt_cuttability);
  74         writeF1000(os, basedurability);
  75         writeF1000(os, dd_weight);
  76         writeF1000(os, dd_crackiness);
  77         writeF1000(os, dd_crumbliness);
  78         writeF1000(os, dd_cuttability);
  79 }
  80
  81 void ToolDiggingProperties::deSerialize(std::istream &is)
  82 {
  83         int version = readU8(is);
  84         if(version != 0) throw SerializationError(
  85                         "unsupported ToolDiggingProperties version");
  86         full_punch_interval = readF1000(is);
  87         basetime = readF1000(is);
  88         dt_weight = readF1000(is);
  89         dt_crackiness = readF1000(is);
  90         dt_crumbliness = readF1000(is);
  91         dt_cuttability = readF1000(is);
  92         basedurability = readF1000(is);
  93         dd_weight = readF1000(is);
  94         dd_crackiness = readF1000(is);
  95         dd_crumbliness = readF1000(is);
  96         dd_cuttability = readF1000(is);
  97 }
  98
  99 DiggingProperties getDiggingProperties(const MaterialProperties *mp,
 100                 const ToolDiggingProperties *tp, float time_from_last_punch)
 101 {
 102         if(mp->diggability == DIGGABLE_NOT)
 103                 return DiggingProperties(false, 0, 0);
 104         if(mp->diggability == DIGGABLE_CONSTANT)
 105                 return DiggingProperties(true, mp->constant_time, 0);
 106
 107         float time = tp->basetime;
 108         time += tp->dt_weight * mp->weight;
 109         time += tp->dt_crackiness * mp->crackiness;
 110         time += tp->dt_crumbliness * mp->crumbliness;
 111         time += tp->dt_cuttability * mp->cuttability;
 112         if(time < 0.2)
 113                 time = 0.2;
 114
 115         float durability = tp->basedurability;
 116         durability += tp->dd_weight * mp->weight;
 117         durability += tp->dd_crackiness * mp->crackiness;
 118         durability += tp->dd_crumbliness * mp->crumbliness;
 119         durability += tp->dd_cuttability * mp->cuttability;
 120         if(durability < 1)
 121                 durability = 1;
 122
 123         if(time_from_last_punch < tp->full_punch_interval){
 124                 float f = time_from_last_punch / tp->full_punch_interval;
 125                 time /= f;
 126                 durability /= f;
 127         }
 128
 129         float wear = 1.0 / durability;
 130         u16 wear_i = 65535.*wear;
 131         return DiggingProperties(true, time, wear_i);
 132 }
 133
 134 DiggingProperties getDiggingProperties(const MaterialProperties *mp,
 135                 const ToolDiggingProperties *tp)
 136 {
 137         return getDiggingProperties(mp, tp, 1000000);
 138 }
 139
 140 HittingProperties getHittingProperties(const MaterialProperties *mp,
 141                 const ToolDiggingProperties *tp, float time_from_last_punch)
 142 {
 143         DiggingProperties digprop = getDiggingProperties(mp, tp,
 144                         time_from_last_punch);
 145
 146         // If digging time would be 1 second, 2 hearts go in 1 second.
 147         s16 hp = 2.0 * 2.0 / digprop.time;
 148         // Wear is the same as for digging a single node
 149         s16 wear = (float)digprop.wear;
 150
 151         return HittingProperties(hp, wear);
 152 }
 153
 154 HittingProperties getHittingProperties(const MaterialProperties *mp,
 155                 const ToolDiggingProperties *tp)
 156 {
 157         return getHittingProperties(mp, tp, 1000000);
 158 }
 159