LCOV - code coverage report
Current view: top level - src - itemdef.h (source / functions) Hit Total Coverage
Test: report Lines: 4 4 100.0 %
Date: 2015-07-11 18:23:49 Functions: 4 6 66.7 %

          Line data    Source code
       1             : /*
       2             : Minetest
       3             : Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
       4             : Copyright (C) 2013 Kahrl <kahrl@gmx.net>
       5             : 
       6             : This program is free software; you can redistribute it and/or modify
       7             : it under the terms of the GNU Lesser General Public License as published by
       8             : the Free Software Foundation; either version 2.1 of the License, or
       9             : (at your option) any later version.
      10             : 
      11             : This program is distributed in the hope that it will be useful,
      12             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : GNU Lesser General Public License for more details.
      15             : 
      16             : You should have received a copy of the GNU Lesser General Public License along
      17             : with this program; if not, write to the Free Software Foundation, Inc.,
      18             : 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      19             : */
      20             : 
      21             : #ifndef ITEMDEF_HEADER
      22             : #define ITEMDEF_HEADER
      23             : 
      24             : #include "irrlichttypes_extrabloated.h"
      25             : #include <string>
      26             : #include <iostream>
      27             : #include <set>
      28             : #include "itemgroup.h"
      29             : #include "sound.h"
      30             : class IGameDef;
      31             : struct ToolCapabilities;
      32             : 
      33             : /*
      34             :         Base item definition
      35             : */
      36             : 
      37             : enum ItemType
      38             : {
      39             :         ITEM_NONE,
      40             :         ITEM_NODE,
      41             :         ITEM_CRAFT,
      42             :         ITEM_TOOL,
      43             : };
      44             : 
      45             : struct ItemDefinition
      46             : {
      47             :         /*
      48             :                 Basic item properties
      49             :         */
      50             :         ItemType type;
      51             :         std::string name; // "" = hand
      52             :         std::string description; // Shown in tooltip.
      53             : 
      54             :         /*
      55             :                 Visual properties
      56             :         */
      57             :         std::string inventory_image; // Optional for nodes, mandatory for tools/craftitems
      58             :         std::string wield_image; // If empty, inventory_image or mesh (only nodes) is used
      59             :         v3f wield_scale;
      60             : 
      61             :         /*
      62             :                 Item stack and interaction properties
      63             :         */
      64             :         s16 stack_max;
      65             :         bool usable;
      66             :         bool liquids_pointable;
      67             :         // May be NULL. If non-NULL, deleted by destructor
      68             :         ToolCapabilities *tool_capabilities;
      69             :         ItemGroupList groups;
      70             :         SimpleSoundSpec sound_place;
      71             :         f32 range;
      72             : 
      73             :         // Client shall immediately place this node when player places the item.
      74             :         // Server will update the precise end result a moment later.
      75             :         // "" = no prediction
      76             :         std::string node_placement_prediction;
      77             : 
      78             :         /*
      79             :                 Some helpful methods
      80             :         */
      81             :         ItemDefinition();
      82             :         ItemDefinition(const ItemDefinition &def);
      83             :         ItemDefinition& operator=(const ItemDefinition &def);
      84             :         ~ItemDefinition();
      85             :         void reset();
      86             :         void serialize(std::ostream &os, u16 protocol_version) const;
      87             :         void deSerialize(std::istream &is);
      88             : private:
      89             :         void resetInitial();
      90             : };
      91             : 
      92             : class IItemDefManager
      93             : {
      94             : public:
      95           1 :         IItemDefManager(){}
      96           1 :         virtual ~IItemDefManager(){}
      97             : 
      98             :         // Get item definition
      99             :         virtual const ItemDefinition& get(const std::string &name) const=0;
     100             :         // Get alias definition
     101             :         virtual std::string getAlias(const std::string &name) const=0;
     102             :         // Get set of all defined item names and aliases
     103             :         virtual std::set<std::string> getAll() const=0;
     104             :         // Check if item is known
     105             :         virtual bool isKnown(const std::string &name) const=0;
     106             : #ifndef SERVER
     107             :         // Get item inventory texture
     108             :         virtual video::ITexture* getInventoryTexture(const std::string &name,
     109             :                         IGameDef *gamedef) const=0;
     110             :         // Get item wield mesh
     111             :         virtual scene::IMesh* getWieldMesh(const std::string &name,
     112             :                 IGameDef *gamedef) const=0;
     113             : #endif
     114             : 
     115             :         virtual void serialize(std::ostream &os, u16 protocol_version)=0;
     116             : };
     117             : 
     118             : class IWritableItemDefManager : public IItemDefManager
     119             : {
     120             : public:
     121           1 :         IWritableItemDefManager(){}
     122           1 :         virtual ~IWritableItemDefManager(){}
     123             : 
     124             :         // Get item definition
     125             :         virtual const ItemDefinition& get(const std::string &name) const=0;
     126             :         // Get alias definition
     127             :         virtual std::string getAlias(const std::string &name) const=0;
     128             :         // Get set of all defined item names and aliases
     129             :         virtual std::set<std::string> getAll() const=0;
     130             :         // Check if item is known
     131             :         virtual bool isKnown(const std::string &name) const=0;
     132             : #ifndef SERVER
     133             :         // Get item inventory texture
     134             :         virtual video::ITexture* getInventoryTexture(const std::string &name,
     135             :                         IGameDef *gamedef) const=0;
     136             :         // Get item wield mesh
     137             :         virtual scene::IMesh* getWieldMesh(const std::string &name,
     138             :                 IGameDef *gamedef) const=0;
     139             : #endif
     140             : 
     141             :         // Remove all registered item and node definitions and aliases
     142             :         // Then re-add the builtin item definitions
     143             :         virtual void clear()=0;
     144             :         // Register item definition
     145             :         virtual void registerItem(const ItemDefinition &def)=0;
     146             :         // Set an alias so that items named <name> will load as <convert_to>.
     147             :         // Alias is not set if <name> has already been defined.
     148             :         // Alias will be removed if <name> is defined at a later point of time.
     149             :         virtual void registerAlias(const std::string &name,
     150             :                         const std::string &convert_to)=0;
     151             : 
     152             :         virtual void serialize(std::ostream &os, u16 protocol_version)=0;
     153             :         virtual void deSerialize(std::istream &is)=0;
     154             : 
     155             :         // Do stuff asked by threads that can only be done in the main thread
     156             :         virtual void processQueue(IGameDef *gamedef)=0;
     157             : };
     158             : 
     159             : IWritableItemDefManager* createItemDefManager();
     160             : 
     161             : #endif

Generated by: LCOV version 1.11