3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
20 #ifndef NODEDEF_HEADER
21 #define NODEDEF_HEADER
23 #include "irrlichttypes_bloated.h"
33 #include "itemgroup.h"
34 #include "sound.h" // SimpleSoundSpec
35 #include "constants.h" // BS
37 class IItemDefManager;
42 typedef std::list<std::pair<content_t, int> > GroupItems;
50 enum ContentParamType2
55 // Flowing liquid properties
57 // Direction for chests and furnaces and such
59 // Direction for signs, torches and such
61 // Block level like FLOWINGLIQUID
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, ...
82 enum NodeBoxType type;
83 // NODEBOX_REGULAR (no parameters)
85 std::vector<aabb3f> fixed;
86 // NODEBOX_WALLMOUNTED
89 aabb3f wall_side; // being at the -X side
95 void serialize(std::ostream &os, u16 protocol_version) const;
96 void deSerialize(std::istream &is);
103 Stand-alone definition of a TileSpec (basically a server-side TileSpec)
105 enum TileAnimationType{
107 TAT_VERTICAL_FRAMES=1,
112 bool backface_culling; // Takes effect only in special cases
114 enum TileAnimationType type;
115 int aspect_w; // width for aspect ratio
116 int aspect_h; // height for aspect ratio
117 float length; // seconds
123 backface_culling = true;
124 animation.type = TAT_NONE;
125 animation.aspect_w = 1;
126 animation.aspect_h = 1;
127 animation.length = 1.0;
130 void serialize(std::ostream &os, u16 protocol_version) const;
131 void deSerialize(std::istream &is);
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
149 NDT_GLASSLIKE_FRAMED, // Glass-like, draw connected frames and all all
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
158 #define CF_SPECIAL_COUNT 6
160 struct ContentFeatures
167 // up down right left back front
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;
177 // Server-side cached callback existence for fast skipping
178 bool has_on_construct;
179 bool has_on_destruct;
180 bool has_after_destruct;
186 std::string name; // "" = undefined node
187 ItemGroupList groups; // Same as in itemdef
190 enum NodeDrawType drawtype;
193 scene::IMesh *mesh_ptr[24];
195 float visual_scale; // Misc. scale parameter
197 TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid
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.
213 // Player can point to these
215 // Player can dig these
217 // Player can climb these
219 // Player can build on these
221 // Player cannot build to these (placement prediction disabled)
223 // Flowing liquid or snow, value = default level
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
235 // Is liquid renewable (new liquid source will be created between 2 existing)
236 bool liquid_renewable;
237 // Ice for water, water for ice
238 std::string freezemelt;
239 // Number of flowing liquids surrounding source
242 // Amount of light the node emits
244 u32 damage_per_second;
246 NodeBox selection_box;
247 NodeBox collision_box;
248 // Used for waving leaves/plants
250 // Compatibility with old maps
251 // Set to true if paramtype used to be 'facedir_simple'
252 bool legacy_facedir_simple;
253 // Set to true if wall_mounted used to be set to true
254 bool legacy_wallmounted;
257 SimpleSoundSpec sound_footstep;
258 SimpleSoundSpec sound_dig;
259 SimpleSoundSpec sound_dug;
268 void serialize(std::ostream &os, u16 protocol_version);
269 void deSerialize(std::istream &is);
270 void serializeOld(std::ostream &os, u16 protocol_version);
271 void deSerializeOld(std::istream &is, int version);
276 bool isLiquid() const{
277 return (liquid_type != LIQUID_NONE);
279 bool sameLiquid(const ContentFeatures &f) const{
280 if(!isLiquid() || !f.isLiquid()) return false;
281 return (liquid_alternative_flowing == f.liquid_alternative_flowing);
285 struct NodeResolveInfo {
286 std::string n_wanted;
288 content_t c_fallback;
292 #define NR_STATUS_FAILURE 0
293 #define NR_STATUS_PENDING 1
294 #define NR_STATUS_SUCCESS 2
299 NodeResolver attempts to resolve node names to content ID integers. If the
300 node registration phase has not yet finished at the time the resolution
301 request is placed, the request is marked as pending and added to an internal
302 queue. The name resolution request is later satisfied by writing directly
303 to the output location when the node registration phase has been completed.
305 This is primarily intended to be used for objects registered during script
306 initialization (i.e. while nodes are being registered) that reference
311 NodeResolver(INodeDefManager *ndef);
315 Add a request to resolve the node n_wanted and set *content to the
316 result, or alternatively, n_alt if n_wanted is not found. If n_alt
317 cannot be found either, or has not been specified, *content is set
320 If node registration is complete, the request is finished immediately
321 and NR_STATUS_SUCCESS is returned (or NR_STATUS_FAILURE if no node can
322 be found). Otherwise, NR_STATUS_PENDING is returned and the resolution
325 N.B. If the memory in which content is located has been deallocated
326 before the pending request had been satisfied, cancelNode() must be
329 @param n_wanted Name of node that is wanted.
330 @param n_alt Name of node in case n_wanted could not be found. Blank
331 if no alternative node is desired.
332 @param c_fallback Content ID that content is set to in case of node
333 resolution failure (should be CONTENT_AIR, CONTENT_IGNORE, etc.)
334 @param content Pointer to content_t that receives the result of the
335 node name resolution.
336 @return Status of node resolution request.
338 int addNode(std::string n_wanted, std::string n_alt,
339 content_t c_fallback, content_t *content);
342 Add a request to resolve the node(s) specified by nodename.
344 If node registration is complete, the request is finished immediately
345 and NR_STATUS_SUCCESS is returned if at least one node is resolved; if
346 zero were resolved, NR_STATUS_FAILURE. Otherwise, NR_STATUS_PENDING is
347 returned and the resolution request is queued.
349 N.B. If the memory in which content_vec is located has been deallocated
350 before the pending request had been satisfied, cancelNodeList() must be
353 @param nodename Name of node (or node group) to be resolved.
354 @param content_vec Pointer to content_t vector onto which the results
357 @return Status of node resolution request.
359 int addNodeList(const char *nodename, std::vector<content_t> *content_vec);
362 Removes all pending requests from the resolution queue to be satisfied
365 @param content Location of the content ID for the request being
367 @return Number of pending requests cancelled.
369 bool cancelNode(content_t *content);
372 Removes all pending requests from the resolution queue to be satisfied
375 @param content_vec Location of the content ID vector for requests being
377 @return Number of pending requests cancelled.
379 int cancelNodeList(std::vector<content_t> *content_vec);
382 Carries out all pending node resolution requests. Call this when the
383 node registration phase has completed.
385 Internally marks node registration as complete.
387 @return Number of failed pending requests.
392 Returns the status of the node registration phase.
394 @return Boolean of whether the registration phase is complete.
396 bool isNodeRegFinished() { return m_is_node_registration_complete; }
399 INodeDefManager *m_ndef;
400 bool m_is_node_registration_complete;
401 std::list<NodeResolveInfo *> m_pending_contents;
402 std::list<std::pair<std::string, std::vector<content_t> *> > m_pending_content_vecs;
405 class INodeDefManager
409 virtual ~INodeDefManager(){}
410 // Get node definition
411 virtual const ContentFeatures& get(content_t c) const=0;
412 virtual const ContentFeatures& get(const MapNode &n) const=0;
413 virtual bool getId(const std::string &name, content_t &result) const=0;
414 virtual content_t getId(const std::string &name) const=0;
415 // Allows "group:name" in addition to regular node names
416 virtual void getIds(const std::string &name, std::set<content_t> &result)
418 virtual const ContentFeatures& get(const std::string &name) const=0;
420 virtual void serialize(std::ostream &os, u16 protocol_version)=0;
422 virtual NodeResolver *getResolver()=0;
425 class IWritableNodeDefManager : public INodeDefManager
428 IWritableNodeDefManager(){}
429 virtual ~IWritableNodeDefManager(){}
430 virtual IWritableNodeDefManager* clone()=0;
431 // Get node definition
432 virtual const ContentFeatures& get(content_t c) const=0;
433 virtual const ContentFeatures& get(const MapNode &n) const=0;
434 virtual bool getId(const std::string &name, content_t &result) const=0;
435 // If not found, returns CONTENT_IGNORE
436 virtual content_t getId(const std::string &name) const=0;
437 // Allows "group:name" in addition to regular node names
438 virtual void getIds(const std::string &name, std::set<content_t> &result)
440 // If not found, returns the features of CONTENT_UNKNOWN
441 virtual const ContentFeatures& get(const std::string &name) const=0;
443 // Register node definition by name (allocate an id)
444 // If returns CONTENT_IGNORE, could not allocate id
445 virtual content_t set(const std::string &name,
446 const ContentFeatures &def)=0;
447 // If returns CONTENT_IGNORE, could not allocate id
448 virtual content_t allocateDummy(const std::string &name)=0;
451 Update item alias mapping.
452 Call after updating item definitions.
454 virtual void updateAliases(IItemDefManager *idef)=0;
457 Update tile textures to latest return values of TextueSource.
459 virtual void updateTextures(IGameDef *gamedef)=0;
461 virtual void serialize(std::ostream &os, u16 protocol_version)=0;
462 virtual void deSerialize(std::istream &is)=0;
464 virtual NodeResolver *getResolver()=0;
467 IWritableNodeDefManager *createNodeDefManager();