src/nodedef.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-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 #ifndef NODEDEF_HEADER
  21 #define NODEDEF_HEADER
  22
  23 #include "irrlichttypes.h"
  24 #include <string>
  25 #include <iostream>
  26 #include <map>
  27 #include "mapnode.h"
  28 #ifndef SERVER
  29 #include "tile.h"
  30 #endif
  31 #include "itemgroup.h"
  32 #include "sound.h" // SimpleSoundSpec
  33 class IItemDefManager;
  34 class ITextureSource;
  35 class IGameDef;
  36
  37 enum ContentParamType
  38 {
  39         CPT_NONE,
  40         CPT_LIGHT,
  41 };
  42
  43 enum ContentParamType2
  44 {
  45         CPT2_NONE,
  46         // Need 8-bit param2
  47         CPT2_FULL,
  48         // Flowing liquid properties
  49         CPT2_FLOWINGLIQUID,
  50         // Direction for chests and furnaces and such
  51         CPT2_FACEDIR,
  52         // Direction for signs, torches and such
  53         CPT2_WALLMOUNTED,
  54 };
  55
  56 enum LiquidType
  57 {
  58         LIQUID_NONE,
  59         LIQUID_FLOWING,
  60         LIQUID_SOURCE
  61 };
  62
  63 enum NodeBoxType
  64 {
  65         NODEBOX_REGULAR, // Regular block; allows buildable_to
  66         NODEBOX_FIXED, // Static separately defined box
  67         NODEBOX_WALLMOUNTED, // Box for wall mounted nodes; (top, bottom, side)
  68 };
  69
  70 struct NodeBox
  71 {
  72         enum NodeBoxType type;
  73         // NODEBOX_REGULAR (no parameters)
  74         // NODEBOX_FIXED
  75         core::aabbox3d<f32> fixed;
  76         // NODEBOX_WALLMOUNTED
  77         core::aabbox3d<f32> wall_top;
  78         core::aabbox3d<f32> wall_bottom;
  79         core::aabbox3d<f32> wall_side; // being at the -X side
  80
  81         NodeBox():
  82                 type(NODEBOX_REGULAR),
  83                 // default is rail-like
  84                 fixed(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2),
  85                 // default is sign/ladder-like
  86                 wall_top(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2),
  87                 wall_bottom(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2),
  88                 wall_side(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2)
  89         {}
  90
  91         void serialize(std::ostream &os) const;
  92         void deSerialize(std::istream &is);
  93 };
  94
  95 struct MapNode;
  96 class NodeMetadata;
  97
  98 struct MaterialSpec
  99 {
 100         std::string tname;
 101         bool backface_culling;
 102
 103         MaterialSpec(const std::string &tname_="", bool backface_culling_=true):
 104                 tname(tname_),
 105                 backface_culling(backface_culling_)
 106         {}
 107
 108         void serialize(std::ostream &os) const;
 109         void deSerialize(std::istream &is);
 110 };
 111
 112 enum NodeDrawType
 113 {
 114         NDT_NORMAL, // A basic solid block
 115         NDT_AIRLIKE, // Nothing is drawn
 116         NDT_LIQUID, // Do not draw face towards same kind of flowing/source liquid
 117         NDT_FLOWINGLIQUID, // A very special kind of thing
 118         NDT_GLASSLIKE, // Glass-like, don't draw faces towards other glass
 119         NDT_ALLFACES, // Leaves-like, draw all faces no matter what
 120         NDT_ALLFACES_OPTIONAL, // Fancy -> allfaces, fast -> normal
 121         NDT_TORCHLIKE,
 122         NDT_SIGNLIKE,
 123         NDT_PLANTLIKE,
 124         NDT_FENCELIKE,
 125         NDT_RAILLIKE,
 126 };
 127
 128 #define CF_SPECIAL_COUNT 2
 129
 130 struct ContentFeatures
 131 {
 132         /*
 133                 Cached stuff
 134         */
 135 #ifndef SERVER
 136         // 0     1     2     3     4     5
 137         // up    down  right left  back  front
 138         TileSpec tiles[6];
 139         // Special tiles
 140         // - Currently used for flowing liquids
 141         TileSpec special_tiles[CF_SPECIAL_COUNT];
 142         u8 solidness; // Used when choosing which face is drawn
 143         u8 visual_solidness; // When solidness=0, this tells how it looks like
 144         bool backface_culling;
 145 #endif
 146
 147         /*
 148                 Actual data
 149         */
 150
 151         std::string name; // "" = undefined node
 152         ItemGroupList groups; // Same as in itemdef
 153
 154         // Visual definition
 155         enum NodeDrawType drawtype;
 156         float visual_scale; // Misc. scale parameter
 157         std::string tname_tiles[6];
 158         MaterialSpec mspec_special[CF_SPECIAL_COUNT]; // Use setter methods
 159         u8 alpha;
 160
 161         // Post effect color, drawn when the camera is inside the node.
 162         video::SColor post_effect_color;
 163         // Type of MapNode::param1
 164         ContentParamType param_type;
 165         // Type of MapNode::param2
 166         ContentParamType2 param_type_2;
 167         // True for all ground-like things like stone and mud, false for eg. trees
 168         bool is_ground_content;
 169         bool light_propagates;
 170         bool sunlight_propagates;
 171         // This is used for collision detection.
 172         // Also for general solidness queries.
 173         bool walkable;
 174         // Player can point to these
 175         bool pointable;
 176         // Player can dig these
 177         bool diggable;
 178         // Player can climb these
 179         bool climbable;
 180         // Player can build on these
 181         bool buildable_to;
 182         // Whether the node is non-liquid, source liquid or flowing liquid
 183         enum LiquidType liquid_type;
 184         // If the content is liquid, this is the flowing version of the liquid.
 185         std::string liquid_alternative_flowing;
 186         // If the content is liquid, this is the source version of the liquid.
 187         std::string liquid_alternative_source;
 188         // Viscosity for fluid flow, ranging from 1 to 7, with
 189         // 1 giving almost instantaneous propagation and 7 being
 190         // the slowest possible
 191         u8 liquid_viscosity;
 192         // Amount of light the node emits
 193         u8 light_source;
 194         u32 damage_per_second;
 195         NodeBox selection_box;
 196         // Compatibility with old maps
 197         // Set to true if paramtype used to be 'facedir_simple'
 198         bool legacy_facedir_simple;
 199         // Set to true if wall_mounted used to be set to true
 200         bool legacy_wallmounted;
 201
 202         // Sound properties
 203         SimpleSoundSpec sound_footstep;
 204         SimpleSoundSpec sound_dig;
 205         SimpleSoundSpec sound_dug;
 206
 207         /*
 208                 Methods
 209         */
 210
 211         ContentFeatures();
 212         ~ContentFeatures();
 213         void reset();
 214         void serialize(std::ostream &os);
 215         void deSerialize(std::istream &is);
 216
 217         /*
 218                 Some handy methods
 219         */
 220         bool isLiquid() const{
 221                 return (liquid_type != LIQUID_NONE);
 222         }
 223         bool sameLiquid(const ContentFeatures &f) const{
 224                 if(!isLiquid() || !f.isLiquid()) return false;
 225                 return (liquid_alternative_flowing == f.liquid_alternative_flowing);
 226         }
 227 };
 228
 229 class INodeDefManager
 230 {
 231 public:
 232         INodeDefManager(){}
 233         virtual ~INodeDefManager(){}
 234         // Get node definition
 235         virtual const ContentFeatures& get(content_t c) const=0;
 236         virtual const ContentFeatures& get(const MapNode &n) const=0;
 237         virtual bool getId(const std::string &name, content_t &result) const=0;
 238         virtual content_t getId(const std::string &name) const=0;
 239         // Allows "group:name" in addition to regular node names
 240         virtual void getIds(const std::string &name, std::set<content_t> &result)
 241                         const=0;
 242         virtual const ContentFeatures& get(const std::string &name) const=0;
 243
 244         virtual void serialize(std::ostream &os)=0;
 245 };
 246
 247 class IWritableNodeDefManager : public INodeDefManager
 248 {
 249 public:
 250         IWritableNodeDefManager(){}
 251         virtual ~IWritableNodeDefManager(){}
 252         virtual IWritableNodeDefManager* clone()=0;
 253         // Get node definition
 254         virtual const ContentFeatures& get(content_t c) const=0;
 255         virtual const ContentFeatures& get(const MapNode &n) const=0;
 256         virtual bool getId(const std::string &name, content_t &result) const=0;
 257         virtual content_t getId(const std::string &name) const=0;
 258         // Allows "group:name" in addition to regular node names
 259         virtual void getIds(const std::string &name, std::set<content_t> &result)
 260                         const=0;
 261         // If not found, returns the features of CONTENT_IGNORE
 262         virtual const ContentFeatures& get(const std::string &name) const=0;
 263
 264         // Register node definition
 265         virtual void set(content_t c, const ContentFeatures &def)=0;
 266         // Register node definition by name (allocate an id)
 267         // If returns CONTENT_IGNORE, could not allocate id
 268         virtual content_t set(const std::string &name,
 269                         const ContentFeatures &def)=0;
 270         // If returns CONTENT_IGNORE, could not allocate id
 271         virtual content_t allocateDummy(const std::string &name)=0;
 272
 273         /*
 274                 Update item alias mapping.
 275                 Call after updating item definitions.
 276         */
 277         virtual void updateAliases(IItemDefManager *idef)=0;
 278
 279         /*
 280                 Update tile textures to latest return values of TextueSource.
 281                 Call after updating the texture atlas of a TextureSource.
 282         */
 283         virtual void updateTextures(ITextureSource *tsrc)=0;
 284
 285         virtual void serialize(std::ostream &os)=0;
 286         virtual void deSerialize(std::istream &is)=0;
 287 };
 288
 289 IWritableNodeDefManager* createNodeDefManager();
 290
 291 #endif
 292