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