src/nodedef.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 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 Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser 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_bloated.h"
  24 #include <string>
  25 #include <iostream>
  26 #include <map>
  27 #include <list>
  28 #include "mapnode.h"
  29 #ifndef SERVER
  30 #include "client/tile.h"
  31 #include "shader.h"
  32 #endif
  33 #include "itemgroup.h"
  34 #include "sound.h" // SimpleSoundSpec
  35 #include "constants.h" // BS
  36
  37 class IItemDefManager;
  38 class ITextureSource;
  39 class IShaderSource;
  40 class IGameDef;
  41
  42 typedef std::list<std::pair<content_t, int> > GroupItems;
  43
  44 enum ContentParamType
  45 {
  46         CPT_NONE,
  47         CPT_LIGHT,
  48 };
  49
  50 enum ContentParamType2
  51 {
  52         CPT2_NONE,
  53         // Need 8-bit param2
  54         CPT2_FULL,
  55         // Flowing liquid properties
  56         CPT2_FLOWINGLIQUID,
  57         // Direction for chests and furnaces and such
  58         CPT2_FACEDIR,
  59         // Direction for signs, torches and such
  60         CPT2_WALLMOUNTED,
  61         // Block level like FLOWINGLIQUID
  62         CPT2_LEVELED,
  63 };
  64
  65 enum LiquidType
  66 {
  67         LIQUID_NONE,
  68         LIQUID_FLOWING,
  69         LIQUID_SOURCE,
  70 };
  71
  72 enum NodeBoxType
  73 {
  74         NODEBOX_REGULAR, // Regular block; allows buildable_to
  75         NODEBOX_FIXED, // Static separately defined box(es)
  76         NODEBOX_WALLMOUNTED, // Box for wall mounted nodes; (top, bottom, side)
  77         NODEBOX_LEVELED, // Same as fixed, but with dynamic height from param2. for snow, ...
  78 };
  79
  80 struct NodeBox
  81 {
  82         enum NodeBoxType type;
  83         // NODEBOX_REGULAR (no parameters)
  84         // NODEBOX_FIXED
  85         std::vector<aabb3f> fixed;
  86         // NODEBOX_WALLMOUNTED
  87         aabb3f wall_top;
  88         aabb3f wall_bottom;
  89         aabb3f wall_side; // being at the -X side
  90
  91         NodeBox()
  92         { reset(); }
  93
  94         void reset();
  95         void serialize(std::ostream &os, u16 protocol_version) const;
  96         void deSerialize(std::istream &is);
  97 };
  98
  99 struct MapNode;
 100 class NodeMetadata;
 101
 102 /*
 103         Stand-alone definition of a TileSpec (basically a server-side TileSpec)
 104 */
 105 enum TileAnimationType{
 106         TAT_NONE=0,
 107         TAT_VERTICAL_FRAMES=1,
 108 };
 109 struct TileDef
 110 {
 111         std::string name;
 112         bool backface_culling; // Takes effect only in special cases
 113         struct{
 114                 enum TileAnimationType type;
 115                 int aspect_w; // width for aspect ratio
 116                 int aspect_h; // height for aspect ratio
 117                 float length; // seconds
 118         } animation;
 119
 120         TileDef()
 121         {
 122                 name = "";
 123                 backface_culling = true;
 124                 animation.type = TAT_NONE;
 125                 animation.aspect_w = 1;
 126                 animation.aspect_h = 1;
 127                 animation.length = 1.0;
 128         }
 129
 130         void serialize(std::ostream &os, u16 protocol_version) const;
 131         void deSerialize(std::istream &is);
 132 };
 133
 134 enum NodeDrawType
 135 {
 136         NDT_NORMAL, // A basic solid block
 137         NDT_AIRLIKE, // Nothing is drawn
 138         NDT_LIQUID, // Do not draw face towards same kind of flowing/source liquid
 139         NDT_FLOWINGLIQUID, // A very special kind of thing
 140         NDT_GLASSLIKE, // Glass-like, don't draw faces towards other glass
 141         NDT_ALLFACES, // Leaves-like, draw all faces no matter what
 142         NDT_ALLFACES_OPTIONAL, // Fancy -> allfaces, fast -> normal
 143         NDT_TORCHLIKE,
 144         NDT_SIGNLIKE,
 145         NDT_PLANTLIKE,
 146         NDT_FENCELIKE,
 147         NDT_RAILLIKE,
 148         NDT_NODEBOX,
 149         NDT_GLASSLIKE_FRAMED, // Glass-like, draw connected frames and all all
 150                               // visible faces
 151                                                   // uses 2 textures, one for frames, second for faces
 152         NDT_FIRELIKE, // Draw faces slightly rotated and only on connecting nodes,
 153         NDT_GLASSLIKE_FRAMED_OPTIONAL,  // enabled -> connected, disabled -> Glass-like
 154                                                                         // uses 2 textures, one for frames, second for faces
 155         NDT_MESH, // Uses static meshes
 156 };
 157
 158 #define CF_SPECIAL_COUNT 6
 159
 160 struct ContentFeatures
 161 {
 162         /*
 163                 Cached stuff
 164         */
 165 #ifndef SERVER
 166         // 0     1     2     3     4     5
 167         // up    down  right left  back  front
 168         TileSpec tiles[6];
 169         // Special tiles
 170         // - Currently used for flowing liquids
 171         TileSpec special_tiles[CF_SPECIAL_COUNT];
 172         u8 solidness; // Used when choosing which face is drawn
 173         u8 visual_solidness; // When solidness=0, this tells how it looks like
 174         bool backface_culling;
 175 #endif
 176
 177         // Server-side cached callback existence for fast skipping
 178         bool has_on_construct;
 179         bool has_on_destruct;
 180         bool has_after_destruct;
 181
 182         /*
 183                 Actual data
 184         */
 185
 186         std::string name; // "" = undefined node
 187         ItemGroupList groups; // Same as in itemdef
 188
 189         // Visual definition
 190         enum NodeDrawType drawtype;
 191         std::string mesh;
 192 #ifndef SERVER
 193         scene::IMesh *mesh_ptr[24];
 194 #endif
 195         float visual_scale; // Misc. scale parameter
 196         TileDef tiledef[6];
 197         TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid
 198         u8 alpha;
 199
 200         // Post effect color, drawn when the camera is inside the node.
 201         video::SColor post_effect_color;
 202         // Type of MapNode::param1
 203         ContentParamType param_type;
 204         // Type of MapNode::param2
 205         ContentParamType2 param_type_2;
 206         // True for all ground-like things like stone and mud, false for eg. trees
 207         bool is_ground_content;
 208         bool light_propagates;
 209         bool sunlight_propagates;
 210         // This is used for collision detection.
 211         // Also for general solidness queries.
 212         bool walkable;
 213         // Player can point to these
 214         bool pointable;
 215         // Player can dig these
 216         bool diggable;
 217         // Player can climb these
 218         bool climbable;
 219         // Player can build on these
 220         bool buildable_to;
 221         // Player cannot build to these (placement prediction disabled)
 222         bool rightclickable;
 223         // Flowing liquid or snow, value = default level
 224         u8 leveled;
 225         // Whether the node is non-liquid, source liquid or flowing liquid
 226         enum LiquidType liquid_type;
 227         // If the content is liquid, this is the flowing version of the liquid.
 228         std::string liquid_alternative_flowing;
 229         // If the content is liquid, this is the source version of the liquid.
 230         std::string liquid_alternative_source;
 231         // Viscosity for fluid flow, ranging from 1 to 7, with
 232         // 1 giving almost instantaneous propagation and 7 being
 233         // the slowest possible
 234         u8 liquid_viscosity;
 235         // Is liquid renewable (new liquid source will be created between 2 existing)
 236         bool liquid_renewable;
 237         // Number of flowing liquids surrounding source
 238         u8 liquid_range;
 239         u8 drowning;
 240         // Amount of light the node emits
 241         u8 light_source;
 242         u32 damage_per_second;
 243         NodeBox node_box;
 244         NodeBox selection_box;
 245         NodeBox collision_box;
 246         // Used for waving leaves/plants
 247         u8 waving;
 248         // Compatibility with old maps
 249         // Set to true if paramtype used to be 'facedir_simple'
 250         bool legacy_facedir_simple;
 251         // Set to true if wall_mounted used to be set to true
 252         bool legacy_wallmounted;
 253
 254         // Sound properties
 255         SimpleSoundSpec sound_footstep;
 256         SimpleSoundSpec sound_dig;
 257         SimpleSoundSpec sound_dug;
 258
 259         /*
 260                 Methods
 261         */
 262
 263         ContentFeatures();
 264         ~ContentFeatures();
 265         void reset();
 266         void serialize(std::ostream &os, u16 protocol_version);
 267         void deSerialize(std::istream &is);
 268         void serializeOld(std::ostream &os, u16 protocol_version);
 269         void deSerializeOld(std::istream &is, int version);
 270
 271         /*
 272                 Some handy methods
 273         */
 274         bool isLiquid() const{
 275                 return (liquid_type != LIQUID_NONE);
 276         }
 277         bool sameLiquid(const ContentFeatures &f) const{
 278                 if(!isLiquid() || !f.isLiquid()) return false;
 279                 return (liquid_alternative_flowing == f.liquid_alternative_flowing);
 280         }
 281 };
 282
 283 class NodeResolver;
 284 class INodeDefManager;
 285
 286 struct NodeListInfo {
 287         NodeListInfo(u32 len)
 288         {
 289                 length       = len;
 290                 all_required = false;
 291                 c_fallback   = CONTENT_IGNORE;
 292         }
 293
 294         NodeListInfo(u32 len, content_t fallback)
 295         {
 296                 length       = len;
 297                 all_required = true;
 298                 c_fallback   = fallback;
 299         }
 300
 301         u32 length;
 302         bool all_required;
 303         content_t c_fallback;
 304 };
 305
 306 struct NodeResolveInfo {
 307         NodeResolveInfo(NodeResolver *nr)
 308         {
 309                 resolver = nr;
 310         }
 311
 312         std::vector<std::string> nodenames;
 313         std::list<NodeListInfo> nodelistinfo;
 314         NodeResolver *resolver;
 315 };
 316
 317 class INodeDefManager
 318 {
 319 public:
 320         INodeDefManager(){}
 321         virtual ~INodeDefManager(){}
 322         // Get node definition
 323         virtual const ContentFeatures& get(content_t c) const=0;
 324         virtual const ContentFeatures& get(const MapNode &n) const=0;
 325         virtual bool getId(const std::string &name, content_t &result) const=0;
 326         virtual content_t getId(const std::string &name) const=0;
 327         // Allows "group:name" in addition to regular node names
 328         virtual void getIds(const std::string &name, std::set<content_t> &result)
 329                         const=0;
 330         virtual const ContentFeatures& get(const std::string &name) const=0;
 331
 332         virtual void serialize(std::ostream &os, u16 protocol_version)=0;
 333
 334         virtual bool getNodeRegistrationStatus() const=0;
 335         virtual void setNodeRegistrationStatus(bool completed)=0;
 336
 337         virtual void pendNodeResolve(NodeResolveInfo *nri)=0;
 338         virtual void cancelNodeResolve(NodeResolver *resolver)=0;
 339         virtual void runNodeResolverCallbacks()=0;
 340
 341         virtual bool getIdFromResolveInfo(NodeResolveInfo *nri,
 342                 const std::string &node_alt, content_t c_fallback, content_t &result)=0;
 343         virtual bool getIdsFromResolveInfo(NodeResolveInfo *nri,
 344                 std::vector<content_t> &result)=0;
 345 };
 346
 347 class IWritableNodeDefManager : public INodeDefManager
 348 {
 349 public:
 350         IWritableNodeDefManager(){}
 351         virtual ~IWritableNodeDefManager(){}
 352         virtual IWritableNodeDefManager* clone()=0;
 353         // Get node definition
 354         virtual const ContentFeatures& get(content_t c) const=0;
 355         virtual const ContentFeatures& get(const MapNode &n) const=0;
 356         virtual bool getId(const std::string &name, content_t &result) const=0;
 357         // If not found, returns CONTENT_IGNORE
 358         virtual content_t getId(const std::string &name) const=0;
 359         // Allows "group:name" in addition to regular node names
 360         virtual void getIds(const std::string &name, std::set<content_t> &result)
 361                         const=0;
 362         // If not found, returns the features of CONTENT_UNKNOWN
 363         virtual const ContentFeatures& get(const std::string &name) const=0;
 364
 365         // Register node definition by name (allocate an id)
 366         // If returns CONTENT_IGNORE, could not allocate id
 367         virtual content_t set(const std::string &name,
 368                         const ContentFeatures &def)=0;
 369         // If returns CONTENT_IGNORE, could not allocate id
 370         virtual content_t allocateDummy(const std::string &name)=0;
 371
 372         /*
 373                 Update item alias mapping.
 374                 Call after updating item definitions.
 375         */
 376         virtual void updateAliases(IItemDefManager *idef)=0;
 377
 378         /*
 379                 Update tile textures to latest return values of TextueSource.
 380         */
 381         virtual void updateTextures(IGameDef *gamedef)=0;
 382
 383         virtual void serialize(std::ostream &os, u16 protocol_version)=0;
 384         virtual void deSerialize(std::istream &is)=0;
 385
 386         virtual bool getNodeRegistrationStatus() const=0;
 387         virtual void setNodeRegistrationStatus(bool completed)=0;
 388
 389         virtual void pendNodeResolve(NodeResolveInfo *nri)=0;
 390         virtual void cancelNodeResolve(NodeResolver *resolver)=0;
 391         virtual void runNodeResolverCallbacks()=0;
 392
 393         virtual bool getIdFromResolveInfo(NodeResolveInfo *nri,
 394                 const std::string &node_alt, content_t c_fallback, content_t &result)=0;
 395         virtual bool getIdsFromResolveInfo(NodeResolveInfo *nri,
 396                 std::vector<content_t> &result)=0;
 397 };
 398
 399 IWritableNodeDefManager *createNodeDefManager();
 400
 401 class NodeResolver {
 402 public:
 403         NodeResolver()
 404         {
 405                 m_lookup_done = false;
 406                 m_ndef = NULL;
 407         }
 408
 409         virtual ~NodeResolver()
 410         {
 411                 if (!m_lookup_done && m_ndef)
 412                         m_ndef->cancelNodeResolve(this);
 413         }
 414
 415         virtual void resolveNodeNames(NodeResolveInfo *nri) = 0;
 416
 417         bool m_lookup_done;
 418         INodeDefManager *m_ndef;
 419 };
 420
 421
 422 #endif
 423