src/inventory.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 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 /*
  21 (c) 2010 Perttu Ahola <celeron55@gmail.com>
  22 */
  23
  24 #ifndef INVENTORY_HEADER
  25 #define INVENTORY_HEADER
  26
  27 #include <iostream>
  28 #include <sstream>
  29 #include <string>
  30 #include "common_irrlicht.h"
  31 #include "debug.h"
  32 #include "mapblockobject.h"
  33 // For g_materials
  34 #include "main.h"
  35
  36 class InventoryItem
  37 {
  38 public:
  39         InventoryItem();
  40         virtual ~InventoryItem();
  41
  42         static InventoryItem* deSerialize(std::istream &is);
  43
  44         virtual const char* getName() const = 0;
  45         // Shall write the name and the parameters
  46         virtual void serialize(std::ostream &os) = 0;
  47         // Shall make an exact clone of the item
  48         virtual InventoryItem* clone() = 0;
  49 #ifndef SERVER
  50         // Shall return an image to show in the GUI (or NULL)
  51         virtual video::ITexture * getImage() { return NULL; }
  52 #endif
  53         // Shall return a text to show in the GUI
  54         virtual std::string getText() { return ""; }
  55
  56 private:
  57 };
  58
  59 #define MATERIAL_ITEM_MAX_COUNT 99
  60
  61 class MaterialItem : public InventoryItem
  62 {
  63 public:
  64         MaterialItem(u8 content, u16 count)
  65         {
  66                 m_content = content;
  67                 m_count = count;
  68         }
  69         /*
  70                 Implementation interface
  71         */
  72         virtual const char* getName() const
  73         {
  74                 return "MaterialItem";
  75         }
  76         virtual void serialize(std::ostream &os)
  77         {
  78                 //os.imbue(std::locale("C"));
  79                 os<<getName();
  80                 os<<" ";
  81                 os<<(unsigned int)m_content;
  82                 os<<" ";
  83                 os<<m_count;
  84         }
  85         virtual InventoryItem* clone()
  86         {
  87                 return new MaterialItem(m_content, m_count);
  88         }
  89 #ifndef SERVER
  90         video::ITexture * getImage()
  91         {
  92                 /*if(m_content == CONTENT_TORCH)
  93                         return g_texturecache.get("torch_on_floor");
  94
  95                 u16 tile = content_tile(m_content, v3s16(1,0,0));
  96                 return g_tile_contents[tile].getTexture(0);*/
  97
  98                 if(m_content >= USEFUL_CONTENT_COUNT)
  99                         return NULL;
 100
 101                 return g_irrlicht->getTexture(g_content_inventory_textures[m_content]);
 102         }
 103 #endif
 104         std::string getText()
 105         {
 106                 std::ostringstream os;
 107                 os<<m_count;
 108                 return os.str();
 109         }
 110         /*
 111                 Special methods
 112         */
 113         u8 getMaterial()
 114         {
 115                 return m_content;
 116         }
 117         u16 getCount()
 118         {
 119                 return m_count;
 120         }
 121         u16 freeSpace()
 122         {
 123                 if(m_count > MATERIAL_ITEM_MAX_COUNT)
 124                         return 0;
 125                 return MATERIAL_ITEM_MAX_COUNT - m_count;
 126         }
 127         void add(u16 count)
 128         {
 129                 assert(m_count + count <= MATERIAL_ITEM_MAX_COUNT);
 130                 m_count += count;
 131         }
 132         void remove(u16 count)
 133         {
 134                 assert(m_count >= count);
 135                 m_count -= count;
 136         }
 137 private:
 138         u8 m_content;
 139         u16 m_count;
 140 };
 141
 142 class MapBlockObjectItem : public InventoryItem
 143 {
 144 public:
 145         /*MapBlockObjectItem(MapBlockObject *obj)
 146         {
 147                 m_inventorystring = obj->getInventoryString();
 148         }*/
 149         MapBlockObjectItem(std::string inventorystring)
 150         {
 151                 m_inventorystring = inventorystring;
 152         }
 153
 154         /*
 155                 Implementation interface
 156         */
 157         virtual const char* getName() const
 158         {
 159                 return "MBOItem";
 160         }
 161         virtual void serialize(std::ostream &os)
 162         {
 163                 for(;;)
 164                 {
 165                         size_t t = m_inventorystring.find('|');
 166                         if(t == std::string::npos)
 167                                 break;
 168                         m_inventorystring[t] = '?';
 169                 }
 170                 os<<getName();
 171                 os<<" ";
 172                 os<<m_inventorystring;
 173                 os<<"|";
 174         }
 175         virtual InventoryItem* clone()
 176         {
 177                 return new MapBlockObjectItem(m_inventorystring);
 178         }
 179
 180 #ifndef SERVER
 181         video::ITexture * getImage();
 182 #endif
 183         std::string getText();
 184
 185         /*
 186                 Special methods
 187         */
 188         std::string getInventoryString()
 189         {
 190                 return m_inventorystring;
 191         }
 192
 193         MapBlockObject * createObject(v3f pos, f32 player_yaw, f32 player_pitch);
 194
 195 private:
 196         std::string m_inventorystring;
 197 };
 198
 199 class ToolItem : public InventoryItem
 200 {
 201 public:
 202         ToolItem(std::string toolname, u16 wear)
 203         {
 204                 m_toolname = toolname;
 205                 m_wear = wear;
 206         }
 207         /*
 208                 Implementation interface
 209         */
 210         virtual const char* getName() const
 211         {
 212                 return "ToolItem";
 213         }
 214         virtual void serialize(std::ostream &os)
 215         {
 216                 os<<getName();
 217                 os<<" ";
 218                 os<<m_toolname;
 219                 os<<" ";
 220                 os<<m_wear;
 221         }
 222         virtual InventoryItem* clone()
 223         {
 224                 return new ToolItem(m_toolname, m_wear);
 225         }
 226 #ifndef SERVER
 227         video::ITexture * getImage()
 228         {
 229                 std::string basename;
 230                 if(m_toolname == "WPick")
 231                         basename = "../data/tool_wpick.png";
 232                 else if(m_toolname == "STPick")
 233                         basename = "../data/tool_stpick.png";
 234                 // Default to cloud texture
 235                 else
 236                         basename = tile_texture_path_get(TILE_CLOUD);
 237
 238                 /*
 239                         Calculate some progress value with sane amount of
 240                         maximum states
 241                 */
 242                 u32 maxprogress = 30;
 243                 u32 toolprogress = (65535-m_wear)/(65535/maxprogress);
 244
 245                 // Make texture name for the new texture with a progress bar
 246                 std::ostringstream os;
 247                 os<<basename<<"-toolprogress-"<<toolprogress;
 248                 std::string finalname = os.str();
 249
 250                 float value_f = (float)toolprogress / (float)maxprogress;
 251
 252                 // Get such a texture
 253                 TextureMod *mod = new ProgressBarTextureMod(value_f);
 254                 return g_irrlicht->getTexture(TextureSpec(finalname, basename, mod));
 255         }
 256 #endif
 257         std::string getText()
 258         {
 259                 return "";
 260
 261                 /*std::ostringstream os;
 262                 u16 f = 4;
 263                 u16 d = 65535/f;
 264                 u16 i;
 265                 for(i=0; i<(65535-m_wear)/d; i++)
 266                         os<<'X';
 267                 for(; i<f; i++)
 268                         os<<'-';
 269                 return os.str();*/
 270
 271                 /*std::ostringstream os;
 272                 os<<m_toolname;
 273                 os<<" ";
 274                 os<<(m_wear/655);
 275                 return os.str();*/
 276         }
 277         /*
 278                 Special methods
 279         */
 280         std::string getToolName()
 281         {
 282                 return m_toolname;
 283         }
 284         u16 getWear()
 285         {
 286                 return m_wear;
 287         }
 288 private:
 289         std::string m_toolname;
 290         u16 m_wear;
 291 };
 292
 293 class InventoryList
 294 {
 295 public:
 296         InventoryList(std::string name, u32 size);
 297         ~InventoryList();
 298         void clearItems();
 299         void serialize(std::ostream &os);
 300         void deSerialize(std::istream &is);
 301
 302         InventoryList(const InventoryList &other);
 303         InventoryList & operator = (const InventoryList &other);
 304
 305         std::string getName();
 306         u32 getSize();
 307         // Count used slots
 308         u32 getUsedSlots();
 309
 310         // Get pointer to item
 311         InventoryItem * getItem(u32 i);
 312         // Returns old item (or NULL). Parameter can be NULL.
 313         InventoryItem * changeItem(u32 i, InventoryItem *newitem);
 314         // Delete item
 315         void deleteItem(u32 i);
 316         // Adds an item to a suitable place. Returns false if failed.
 317         bool addItem(InventoryItem *newitem);
 318         // If possible, adds item to given slot. Returns true on success.
 319         // Fails when slot is populated by a different kind of item.
 320         bool addItem(u32 i, InventoryItem *newitem);
 321
 322         // Decrements amount of every material item
 323         void decrementMaterials(u16 count);
 324
 325         void print(std::ostream &o);
 326
 327 private:
 328         core::array<InventoryItem*> m_items;
 329         u32 m_size;
 330         std::string m_name;
 331 };
 332
 333 class Inventory
 334 {
 335 public:
 336         ~Inventory();
 337
 338         void clear();
 339
 340         Inventory();
 341         Inventory(const Inventory &other);
 342         Inventory & operator = (const Inventory &other);
 343
 344         void serialize(std::ostream &os);
 345         void deSerialize(std::istream &is);
 346
 347         InventoryList * addList(const std::string &name, u32 size);
 348         InventoryList * getList(const std::string &name);
 349         bool deleteList(const std::string &name);
 350         // A shorthand for adding items
 351         bool addItem(const std::string &listname, InventoryItem *newitem)
 352         {
 353                 InventoryList *list = getList(listname);
 354                 if(list == NULL)
 355                         return false;
 356                 return list->addItem(newitem);
 357         }
 358
 359 private:
 360         // -1 if not found
 361         s32 getListIndex(const std::string &name);
 362
 363         core::array<InventoryList*> m_lists;
 364 };
 365
 366 #define IACTION_MOVE 0
 367
 368 struct InventoryAction
 369 {
 370         static InventoryAction * deSerialize(std::istream &is);
 371
 372         virtual u16 getType() const = 0;
 373         virtual void serialize(std::ostream &os) = 0;
 374         virtual void apply(Inventory *inventory) = 0;
 375 };
 376
 377 struct IMoveAction : public InventoryAction
 378 {
 379         u16 count;
 380         std::string from_name;
 381         s16 from_i;
 382         std::string to_name;
 383         s16 to_i;
 384
 385         IMoveAction()
 386         {
 387                 count = 0;
 388                 from_i = -1;
 389                 to_i = -1;
 390         }
 391         IMoveAction(std::istream &is)
 392         {
 393                 std::string ts;
 394
 395                 std::getline(is, ts, ' ');
 396                 count = stoi(ts);
 397
 398                 std::getline(is, from_name, ' ');
 399
 400                 std::getline(is, ts, ' ');
 401                 from_i = stoi(ts);
 402
 403                 std::getline(is, to_name, ' ');
 404
 405                 std::getline(is, ts, ' ');
 406                 to_i = stoi(ts);
 407         }
 408
 409         u16 getType() const
 410         {
 411                 return IACTION_MOVE;
 412         }
 413
 414         void serialize(std::ostream &os)
 415         {
 416                 os<<"Move ";
 417                 os<<count<<" ";
 418                 os<<from_name<<" ";
 419                 os<<from_i<<" ";
 420                 os<<to_name<<" ";
 421                 os<<to_i;
 422         }
 423
 424         void apply(Inventory *inventory);
 425 };
 426
 427 #endif
 428