src/content_nodemeta.cpp

   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 #include "content_nodemeta.h"
  21 #include "inventory.h"
  22 #include "content_mapnode.h"
  23
  24 /*
  25         SignNodeMetadata
  26 */
  27
  28 // Prototype
  29 SignNodeMetadata proto_SignNodeMetadata("");
  30
  31 SignNodeMetadata::SignNodeMetadata(std::string text):
  32         m_text(text)
  33 {
  34         NodeMetadata::registerType(typeId(), create);
  35 }
  36 u16 SignNodeMetadata::typeId() const
  37 {
  38         return CONTENT_SIGN_WALL;
  39 }
  40 NodeMetadata* SignNodeMetadata::create(std::istream &is)
  41 {
  42         std::string text = deSerializeString(is);
  43         return new SignNodeMetadata(text);
  44 }
  45 NodeMetadata* SignNodeMetadata::clone()
  46 {
  47         return new SignNodeMetadata(m_text);
  48 }
  49 void SignNodeMetadata::serializeBody(std::ostream &os)
  50 {
  51         os<<serializeString(m_text);
  52 }
  53 std::string SignNodeMetadata::infoText()
  54 {
  55         return std::string("\"")+m_text+"\"";
  56 }
  57
  58 /*
  59         ChestNodeMetadata
  60 */
  61
  62 // Prototype
  63 ChestNodeMetadata proto_ChestNodeMetadata;
  64
  65 ChestNodeMetadata::ChestNodeMetadata()
  66 {
  67         NodeMetadata::registerType(typeId(), create);
  68
  69         m_inventory = new Inventory();
  70         m_inventory->addList("0", 8*4);
  71 }
  72 ChestNodeMetadata::~ChestNodeMetadata()
  73 {
  74         delete m_inventory;
  75 }
  76 u16 ChestNodeMetadata::typeId() const
  77 {
  78         return CONTENT_CHEST;
  79 }
  80 NodeMetadata* ChestNodeMetadata::create(std::istream &is)
  81 {
  82         ChestNodeMetadata *d = new ChestNodeMetadata();
  83         d->m_inventory->deSerialize(is);
  84         return d;
  85 }
  86 NodeMetadata* ChestNodeMetadata::clone()
  87 {
  88         ChestNodeMetadata *d = new ChestNodeMetadata();
  89         *d->m_inventory = *m_inventory;
  90         return d;
  91 }
  92 void ChestNodeMetadata::serializeBody(std::ostream &os)
  93 {
  94         m_inventory->serialize(os);
  95 }
  96 std::string ChestNodeMetadata::infoText()
  97 {
  98         return "Chest";
  99 }
 100 bool ChestNodeMetadata::nodeRemovalDisabled()
 101 {
 102         /*
 103                 Disable removal if chest contains something
 104         */
 105         InventoryList *list = m_inventory->getList("0");
 106         if(list == NULL)
 107                 return false;
 108         if(list->getUsedSlots() == 0)
 109                 return false;
 110         return true;
 111 }
 112 std::string ChestNodeMetadata::getInventoryDrawSpecString()
 113 {
 114         return
 115                 "invsize[8,9;]"
 116                 "list[current_name;0;0,0;8,4;]"
 117                 "list[current_player;main;0,5;8,4;]";
 118 }
 119
 120 /*
 121         FurnaceNodeMetadata
 122 */
 123
 124 // Prototype
 125 FurnaceNodeMetadata proto_FurnaceNodeMetadata;
 126
 127 FurnaceNodeMetadata::FurnaceNodeMetadata()
 128 {
 129         NodeMetadata::registerType(typeId(), create);
 130
 131         m_inventory = new Inventory();
 132         m_inventory->addList("fuel", 1);
 133         m_inventory->addList("src", 1);
 134         m_inventory->addList("dst", 4);
 135
 136         m_step_accumulator = 0;
 137         m_fuel_totaltime = 0;
 138         m_fuel_time = 0;
 139         m_src_totaltime = 0;
 140         m_src_time = 0;
 141 }
 142 FurnaceNodeMetadata::~FurnaceNodeMetadata()
 143 {
 144         delete m_inventory;
 145 }
 146 u16 FurnaceNodeMetadata::typeId() const
 147 {
 148         return CONTENT_FURNACE;
 149 }
 150 NodeMetadata* FurnaceNodeMetadata::clone()
 151 {
 152         FurnaceNodeMetadata *d = new FurnaceNodeMetadata();
 153         *d->m_inventory = *m_inventory;
 154         return d;
 155 }
 156 NodeMetadata* FurnaceNodeMetadata::create(std::istream &is)
 157 {
 158         FurnaceNodeMetadata *d = new FurnaceNodeMetadata();
 159
 160         d->m_inventory->deSerialize(is);
 161
 162         int temp;
 163         is>>temp;
 164         d->m_fuel_totaltime = (float)temp/10;
 165         is>>temp;
 166         d->m_fuel_time = (float)temp/10;
 167
 168         return d;
 169 }
 170 void FurnaceNodeMetadata::serializeBody(std::ostream &os)
 171 {
 172         m_inventory->serialize(os);
 173         os<<itos(m_fuel_totaltime*10)<<" ";
 174         os<<itos(m_fuel_time*10)<<" ";
 175 }
 176 std::string FurnaceNodeMetadata::infoText()
 177 {
 178         //return "Furnace";
 179         if(m_fuel_time >= m_fuel_totaltime)
 180         {
 181                 const InventoryList *src_list = m_inventory->getList("src");
 182                 assert(src_list);
 183                 const InventoryItem *src_item = src_list->getItem(0);
 184
 185                 if(src_item)
 186                         return "Furnace is out of fuel";
 187                 else
 188                         return "Furnace is inactive";
 189         }
 190         else
 191         {
 192                 std::string s = "Furnace is active (";
 193                 s += itos(m_fuel_time/m_fuel_totaltime*100);
 194                 s += "%)";
 195                 return s;
 196         }
 197 }
 198 bool FurnaceNodeMetadata::nodeRemovalDisabled()
 199 {
 200         /*
 201                 Disable removal if furnace is not empty
 202         */
 203         InventoryList *list[3] = {m_inventory->getList("src"),
 204         m_inventory->getList("dst"), m_inventory->getList("fuel")};
 205
 206         for(int i = 0; i < 3; i++) {
 207                 if(list[i] == NULL)
 208                         continue;
 209                 if(list[i]->getUsedSlots() == 0)
 210                         continue;
 211                 return true;
 212         }
 213         return false;
 214
 215 }
 216 void FurnaceNodeMetadata::inventoryModified()
 217 {
 218         dstream<<"Furnace inventory modification callback"<<std::endl;
 219 }
 220 bool FurnaceNodeMetadata::step(float dtime)
 221 {
 222         if(dtime > 60.0)
 223                 dstream<<"Furnace stepping a long time ("<<dtime<<")"<<std::endl;
 224         // Update at a fixed frequency
 225         const float interval = 2.0;
 226         m_step_accumulator += dtime;
 227         bool changed = false;
 228         while(m_step_accumulator > interval)
 229         {
 230                 m_step_accumulator -= interval;
 231                 dtime = interval;
 232
 233                 //dstream<<"Furnace step dtime="<<dtime<<std::endl;
 234
 235                 InventoryList *dst_list = m_inventory->getList("dst");
 236                 assert(dst_list);
 237
 238                 InventoryList *src_list = m_inventory->getList("src");
 239                 assert(src_list);
 240                 const InventoryItem *src_item = src_list->getItem(0);
 241
 242                 // Start only if there are free slots in dst, so that it can
 243                 // accomodate any result item
 244                 if(dst_list->getFreeSlots() > 0 && src_item && src_item->isCookable())
 245                 {
 246                         m_src_totaltime = 3;
 247                 }
 248                 else
 249                 {
 250                         m_src_time = 0;
 251                         m_src_totaltime = 0;
 252                 }
 253
 254                 /*
 255                         If fuel is burning, increment the burn counters.
 256                         If item finishes cooking, move it to result.
 257                 */
 258                 if(m_fuel_time < m_fuel_totaltime)
 259                 {
 260                         //dstream<<"Furnace is active"<<std::endl;
 261                         m_fuel_time += dtime;
 262                         m_src_time += dtime;
 263                         if(m_src_time >= m_src_totaltime && m_src_totaltime > 0.001
 264                                         && src_item)
 265                         {
 266                                 InventoryItem *cookresult = src_item->createCookResult();
 267                                 dst_list->addItem(cookresult);
 268                                 src_list->decrementMaterials(1);
 269                                 m_src_time = 0;
 270                                 m_src_totaltime = 0;
 271                         }
 272                         changed = true;
 273                         continue;
 274                 }
 275
 276                 /*
 277                         If there is no source item or source item is not cookable, stop loop.
 278                 */
 279                 if(src_item == NULL || m_src_totaltime < 0.001)
 280                 {
 281                         m_step_accumulator = 0;
 282                         break;
 283                 }
 284
 285                 //dstream<<"Furnace is out of fuel"<<std::endl;
 286
 287                 InventoryList *fuel_list = m_inventory->getList("fuel");
 288                 assert(fuel_list);
 289                 const InventoryItem *fuel_item = fuel_list->getItem(0);
 290
 291                 if(ItemSpec(ITEM_MATERIAL, CONTENT_TREE).checkItem(fuel_item))
 292                 {
 293                         m_fuel_totaltime = 30;
 294                         m_fuel_time = 0;
 295                         fuel_list->decrementMaterials(1);
 296                         changed = true;
 297                 }
 298                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_JUNGLETREE).checkItem(fuel_item))
 299                 {
 300                         m_fuel_totaltime = 30;
 301                         m_fuel_time = 0;
 302                         fuel_list->decrementMaterials(1);
 303                         changed = true;
 304                 }
 305                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_FENCE).checkItem(fuel_item))
 306                 {
 307                         m_fuel_totaltime = 30/2;
 308                         m_fuel_time = 0;
 309                         fuel_list->decrementMaterials(1);
 310                         changed = true;
 311                 }
 312                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_WOOD).checkItem(fuel_item))
 313                 {
 314                         m_fuel_totaltime = 30/4;
 315                         m_fuel_time = 0;
 316                         fuel_list->decrementMaterials(1);
 317                         changed = true;
 318                 }
 319                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_BOOKSHELF).checkItem(fuel_item))
 320                 {
 321                         m_fuel_totaltime = 30/4;
 322                         m_fuel_time = 0;
 323                         fuel_list->decrementMaterials(1);
 324                         changed = true;
 325                 }
 326                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_LEAVES).checkItem(fuel_item))
 327                 {
 328                         m_fuel_totaltime = 30/16;
 329                         m_fuel_time = 0;
 330                         fuel_list->decrementMaterials(1);
 331                         changed = true;
 332                 }
 333                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_PAPYRUS).checkItem(fuel_item))
 334                 {
 335                         m_fuel_totaltime = 30/32;
 336                         m_fuel_time = 0;
 337                         fuel_list->decrementMaterials(1);
 338                         changed = true;
 339                 }
 340                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_JUNGLEGRASS).checkItem(fuel_item))
 341                 {
 342                         m_fuel_totaltime = 30/32;
 343                         m_fuel_time = 0;
 344                         fuel_list->decrementMaterials(1);
 345                         changed = true;
 346                 }
 347                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_CACTUS).checkItem(fuel_item))
 348                 {
 349                         m_fuel_totaltime = 30/4;
 350                         m_fuel_time = 0;
 351                         fuel_list->decrementMaterials(1);
 352                         changed = true;
 353                 }
 354                 else if(ItemSpec(ITEM_CRAFT, "Stick").checkItem(fuel_item))
 355                 {
 356                         m_fuel_totaltime = 30/4/4;
 357                         m_fuel_time = 0;
 358                         fuel_list->decrementMaterials(1);
 359                         changed = true;
 360                 }
 361                 else if(ItemSpec(ITEM_CRAFT, "lump_of_coal").checkItem(fuel_item))
 362                 {
 363                         m_fuel_totaltime = 40;
 364                         m_fuel_time = 0;
 365                         fuel_list->decrementMaterials(1);
 366                         changed = true;
 367                 }
 368                 else
 369                 {
 370                         //dstream<<"No fuel found"<<std::endl;
 371                         // No fuel, stop loop.
 372                         m_step_accumulator = 0;
 373                         break;
 374                 }
 375         }
 376         return changed;
 377 }
 378 std::string FurnaceNodeMetadata::getInventoryDrawSpecString()
 379 {
 380         return
 381                 "invsize[8,9;]"
 382                 "list[current_name;fuel;2,3;1,1;]"
 383                 "list[current_name;src;2,1;1,1;]"
 384                 "list[current_name;dst;5,1;2,2;]"
 385                 "list[current_player;main;0,5;8,4;]";
 386 }
 387
 388