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                         InventoryList *dst_list = m_inventory->getList("dst");
 187                         if(!dst_list->roomForCookedItem(src_item))
 188                                 return "Furnace is overloaded";
 189                         return "Furnace is out of fuel";
 190                 }
 191                 else
 192                         return "Furnace is inactive";
 193         }
 194         else
 195         {
 196                 std::string s = "Furnace is active";
 197                 // Do this so it doesn't always show (0%) for weak fuel
 198                 if(m_fuel_totaltime > 3) {
 199                         s += " (";
 200                         s += itos(m_fuel_time/m_fuel_totaltime*100);
 201                         s += "%)";
 202                 }
 203                 return s;
 204         }
 205 }
 206 bool FurnaceNodeMetadata::nodeRemovalDisabled()
 207 {
 208         /*
 209                 Disable removal if furnace is not empty
 210         */
 211         InventoryList *list[3] = {m_inventory->getList("src"),
 212         m_inventory->getList("dst"), m_inventory->getList("fuel")};
 213
 214         for(int i = 0; i < 3; i++) {
 215                 if(list[i] == NULL)
 216                         continue;
 217                 if(list[i]->getUsedSlots() == 0)
 218                         continue;
 219                 return true;
 220         }
 221         return false;
 222
 223 }
 224 void FurnaceNodeMetadata::inventoryModified()
 225 {
 226         dstream<<"Furnace inventory modification callback"<<std::endl;
 227 }
 228 bool FurnaceNodeMetadata::step(float dtime)
 229 {
 230         if(dtime > 60.0)
 231                 dstream<<"Furnace stepping a long time ("<<dtime<<")"<<std::endl;
 232         // Update at a fixed frequency
 233         const float interval = 2.0;
 234         m_step_accumulator += dtime;
 235         bool changed = false;
 236         while(m_step_accumulator > interval)
 237         {
 238                 m_step_accumulator -= interval;
 239                 dtime = interval;
 240
 241                 //dstream<<"Furnace step dtime="<<dtime<<std::endl;
 242
 243                 InventoryList *dst_list = m_inventory->getList("dst");
 244                 assert(dst_list);
 245
 246                 InventoryList *src_list = m_inventory->getList("src");
 247                 assert(src_list);
 248                 const InventoryItem *src_item = src_list->getItem(0);
 249
 250                 bool room_available = false;
 251
 252                 if(src_item && src_item->isCookable())
 253                         room_available = dst_list->roomForCookedItem(src_item);
 254
 255                 // Start only if there are free slots in dst, so that it can
 256                 // accomodate any result item
 257                 if(room_available)
 258                 {
 259                         m_src_totaltime = 3;
 260                 }
 261                 else
 262                 {
 263                         m_src_time = 0;
 264                         m_src_totaltime = 0;
 265                 }
 266
 267                 /*
 268                         If fuel is burning, increment the burn counters.
 269                         If item finishes cooking, move it to result.
 270                 */
 271                 if(m_fuel_time < m_fuel_totaltime)
 272                 {
 273                         //dstream<<"Furnace is active"<<std::endl;
 274                         m_fuel_time += dtime;
 275                         m_src_time += dtime;
 276                         if(m_src_time >= m_src_totaltime && m_src_totaltime > 0.001
 277                                         && src_item)
 278                         {
 279                                 InventoryItem *cookresult = src_item->createCookResult();
 280                                 dst_list->addItem(cookresult);
 281                                 src_list->decrementMaterials(1);
 282                                 m_src_time = 0;
 283                                 m_src_totaltime = 0;
 284                         }
 285                         changed = true;
 286
 287                         // Fall through if the fuel item was used up this step
 288                         if(m_fuel_time < m_fuel_totaltime)
 289                                 continue;
 290                 }
 291
 292                 /*
 293                         If there is no source item or source item is not cookable,
 294                         or furnace became overloaded, stop loop.
 295                 */
 296                 if((m_fuel_time < m_fuel_totaltime || dst_list->roomForCookedItem(src_item) == false)
 297                         && (src_item == NULL || m_src_totaltime < 0.001))
 298                 {
 299                         m_step_accumulator = 0;
 300                         break;
 301                 }
 302
 303                 //dstream<<"Furnace is out of fuel"<<std::endl;
 304
 305                 InventoryList *fuel_list = m_inventory->getList("fuel");
 306                 assert(fuel_list);
 307                 const InventoryItem *fuel_item = fuel_list->getItem(0);
 308
 309                 if(ItemSpec(ITEM_MATERIAL, CONTENT_TREE).checkItem(fuel_item))
 310                 {
 311                         m_fuel_totaltime = 30;
 312                         m_fuel_time = 0;
 313                         fuel_list->decrementMaterials(1);
 314                         changed = true;
 315                 }
 316                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_JUNGLETREE).checkItem(fuel_item))
 317                 {
 318                         m_fuel_totaltime = 30;
 319                         m_fuel_time = 0;
 320                         fuel_list->decrementMaterials(1);
 321                         changed = true;
 322                 }
 323                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_FENCE).checkItem(fuel_item))
 324                 {
 325                         m_fuel_totaltime = 30/2;
 326                         m_fuel_time = 0;
 327                         fuel_list->decrementMaterials(1);
 328                         changed = true;
 329                 }
 330                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_WOOD).checkItem(fuel_item))
 331                 {
 332                         m_fuel_totaltime = 30/4;
 333                         m_fuel_time = 0;
 334                         fuel_list->decrementMaterials(1);
 335                         changed = true;
 336                 }
 337                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_BOOKSHELF).checkItem(fuel_item))
 338                 {
 339                         m_fuel_totaltime = 30/4;
 340                         m_fuel_time = 0;
 341                         fuel_list->decrementMaterials(1);
 342                         changed = true;
 343                 }
 344                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_LEAVES).checkItem(fuel_item))
 345                 {
 346                         m_fuel_totaltime = 30/16;
 347                         m_fuel_time = 0;
 348                         fuel_list->decrementMaterials(1);
 349                         changed = true;
 350                 }
 351                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_PAPYRUS).checkItem(fuel_item))
 352                 {
 353                         m_fuel_totaltime = 30/32;
 354                         m_fuel_time = 0;
 355                         fuel_list->decrementMaterials(1);
 356                         changed = true;
 357                 }
 358                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_JUNGLEGRASS).checkItem(fuel_item))
 359                 {
 360                         m_fuel_totaltime = 30/32;
 361                         m_fuel_time = 0;
 362                         fuel_list->decrementMaterials(1);
 363                         changed = true;
 364                 }
 365                 else if(ItemSpec(ITEM_MATERIAL, CONTENT_CACTUS).checkItem(fuel_item))
 366                 {
 367                         m_fuel_totaltime = 30/4;
 368                         m_fuel_time = 0;
 369                         fuel_list->decrementMaterials(1);
 370                         changed = true;
 371                 }
 372                 else if(ItemSpec(ITEM_CRAFT, "Stick").checkItem(fuel_item))
 373                 {
 374                         m_fuel_totaltime = 30/4/4;
 375                         m_fuel_time = 0;
 376                         fuel_list->decrementMaterials(1);
 377                         changed = true;
 378                 }
 379                 else if(ItemSpec(ITEM_CRAFT, "lump_of_coal").checkItem(fuel_item))
 380                 {
 381                         m_fuel_totaltime = 40;
 382                         m_fuel_time = 0;
 383                         fuel_list->decrementMaterials(1);
 384                         changed = true;
 385                 }
 386                 else
 387                 {
 388                         //dstream<<"No fuel found"<<std::endl;
 389                         // No fuel, stop loop.
 390                         m_step_accumulator = 0;
 391                         break;
 392                 }
 393         }
 394         return changed;
 395 }
 396 std::string FurnaceNodeMetadata::getInventoryDrawSpecString()
 397 {
 398         return
 399                 "invsize[8,9;]"
 400                 "list[current_name;fuel;2,3;1,1;]"
 401                 "list[current_name;src;2,1;1,1;]"
 402                 "list[current_name;dst;5,1;2,2;]"
 403                 "list[current_player;main;0,5;8,4;]";
 404 }
 405
 406