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