src/utility.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 #ifndef UTILITY_HEADER
  21 #define UTILITY_HEADER
  22
  23 #include <iostream>
  24 #include <fstream>
  25 #include <string>
  26 #include <sstream>
  27 #include <vector>
  28 #include <jthread.h>
  29 #include <jmutex.h>
  30 #include <jmutexautolock.h>
  31 #include <cstring>
  32
  33 #include "common_irrlicht.h"
  34 #include "debug.h"
  35 #include "exceptions.h"
  36 #include "porting.h"
  37 #include "strfnd.h" // For trim()
  38
  39 extern const v3s16 g_6dirs[6];
  40
  41 extern const v3s16 g_26dirs[26];
  42
  43 // 26th is (0,0,0)
  44 extern const v3s16 g_27dirs[27];
  45
  46 inline void writeU64(u8 *data, u64 i)
  47 {
  48         data[0] = ((i>>56)&0xff);
  49         data[1] = ((i>>48)&0xff);
  50         data[2] = ((i>>40)&0xff);
  51         data[3] = ((i>>32)&0xff);
  52         data[4] = ((i>>24)&0xff);
  53         data[5] = ((i>>16)&0xff);
  54         data[6] = ((i>> 8)&0xff);
  55         data[7] = ((i>> 0)&0xff);
  56 }
  57
  58 inline void writeU32(u8 *data, u32 i)
  59 {
  60         data[0] = ((i>>24)&0xff);
  61         data[1] = ((i>>16)&0xff);
  62         data[2] = ((i>> 8)&0xff);
  63         data[3] = ((i>> 0)&0xff);
  64 }
  65
  66 inline void writeU16(u8 *data, u16 i)
  67 {
  68         data[0] = ((i>> 8)&0xff);
  69         data[1] = ((i>> 0)&0xff);
  70 }
  71
  72 inline void writeU8(u8 *data, u8 i)
  73 {
  74         data[0] = ((i>> 0)&0xff);
  75 }
  76
  77 inline u64 readU64(u8 *data)
  78 {
  79         return ((u64)data[0]<<56) | ((u64)data[1]<<48)
  80                 | ((u64)data[2]<<40) | ((u64)data[3]<<32)
  81                 | ((u64)data[4]<<24) | ((u64)data[5]<<16)
  82                 | ((u64)data[6]<<8) | ((u64)data[7]<<0);
  83 }
  84
  85 inline u32 readU32(u8 *data)
  86 {
  87         return (data[0]<<24) | (data[1]<<16) | (data[2]<<8) | (data[3]<<0);
  88 }
  89
  90 inline u16 readU16(u8 *data)
  91 {
  92         return (data[0]<<8) | (data[1]<<0);
  93 }
  94
  95 inline u8 readU8(u8 *data)
  96 {
  97         return (data[0]<<0);
  98 }
  99
 100 inline void writeS32(u8 *data, s32 i){
 101         writeU32(data, (u32)i);
 102 }
 103 inline s32 readS32(u8 *data){
 104         return (s32)readU32(data);
 105 }
 106
 107 inline void writeS16(u8 *data, s16 i){
 108         writeU16(data, (u16)i);
 109 }
 110 inline s16 readS16(u8 *data){
 111         return (s16)readU16(data);
 112 }
 113
 114 inline void writeS8(u8 *data, s8 i){
 115         writeU8(data, (u8)i);
 116 }
 117 inline s8 readS8(u8 *data){
 118         return (s8)readU8(data);
 119 }
 120
 121 inline void writeF1000(u8 *data, f32 i){
 122         writeS32(data, i*1000);
 123 }
 124 inline f32 readF1000(u8 *data){
 125         return (f32)readS32(data)/1000.;
 126 }
 127
 128 inline void writeV3S32(u8 *data, v3s32 p)
 129 {
 130         writeS32(&data[0], p.X);
 131         writeS32(&data[4], p.Y);
 132         writeS32(&data[8], p.Z);
 133 }
 134 inline v3s32 readV3S32(u8 *data)
 135 {
 136         v3s32 p;
 137         p.X = readS32(&data[0]);
 138         p.Y = readS32(&data[4]);
 139         p.Z = readS32(&data[8]);
 140         return p;
 141 }
 142
 143 inline void writeV3F1000(u8 *data, v3f p)
 144 {
 145         writeF1000(&data[0], p.X);
 146         writeF1000(&data[4], p.Y);
 147         writeF1000(&data[8], p.Z);
 148 }
 149 inline v3f readV3F1000(u8 *data)
 150 {
 151         v3f p;
 152         p.X = (float)readF1000(&data[0]);
 153         p.Y = (float)readF1000(&data[4]);
 154         p.Z = (float)readF1000(&data[8]);
 155         return p;
 156 }
 157
 158 inline void writeV2F1000(u8 *data, v2f p)
 159 {
 160         writeF1000(&data[0], p.X);
 161         writeF1000(&data[4], p.Y);
 162 }
 163 inline v2f readV2F1000(u8 *data)
 164 {
 165         v2f p;
 166         p.X = (float)readF1000(&data[0]);
 167         p.Y = (float)readF1000(&data[4]);
 168         return p;
 169 }
 170
 171 inline void writeV2S16(u8 *data, v2s16 p)
 172 {
 173         writeS16(&data[0], p.X);
 174         writeS16(&data[2], p.Y);
 175 }
 176
 177 inline v2s16 readV2S16(u8 *data)
 178 {
 179         v2s16 p;
 180         p.X = readS16(&data[0]);
 181         p.Y = readS16(&data[2]);
 182         return p;
 183 }
 184
 185 inline void writeV2S32(u8 *data, v2s32 p)
 186 {
 187         writeS32(&data[0], p.X);
 188         writeS32(&data[2], p.Y);
 189 }
 190
 191 inline v2s32 readV2S32(u8 *data)
 192 {
 193         v2s32 p;
 194         p.X = readS32(&data[0]);
 195         p.Y = readS32(&data[2]);
 196         return p;
 197 }
 198
 199 inline void writeV3S16(u8 *data, v3s16 p)
 200 {
 201         writeS16(&data[0], p.X);
 202         writeS16(&data[2], p.Y);
 203         writeS16(&data[4], p.Z);
 204 }
 205
 206 inline v3s16 readV3S16(u8 *data)
 207 {
 208         v3s16 p;
 209         p.X = readS16(&data[0]);
 210         p.Y = readS16(&data[2]);
 211         p.Z = readS16(&data[4]);
 212         return p;
 213 }
 214
 215 /*
 216         The above stuff directly interfaced to iostream
 217 */
 218
 219 inline void writeU8(std::ostream &os, u8 p)
 220 {
 221         char buf[1];
 222         writeU8((u8*)buf, p);
 223         os.write(buf, 1);
 224 }
 225 inline u8 readU8(std::istream &is)
 226 {
 227         char buf[1];
 228         is.read(buf, 1);
 229         return readU8((u8*)buf);
 230 }
 231
 232 inline void writeU16(std::ostream &os, u16 p)
 233 {
 234         char buf[2];
 235         writeU16((u8*)buf, p);
 236         os.write(buf, 2);
 237 }
 238 inline u16 readU16(std::istream &is)
 239 {
 240         char buf[2];
 241         is.read(buf, 2);
 242         return readU16((u8*)buf);
 243 }
 244
 245 inline void writeU32(std::ostream &os, u32 p)
 246 {
 247         char buf[4];
 248         writeU32((u8*)buf, p);
 249         os.write(buf, 4);
 250 }
 251 inline u32 readU32(std::istream &is)
 252 {
 253         char buf[4];
 254         is.read(buf, 4);
 255         return readU32((u8*)buf);
 256 }
 257
 258 inline void writeS32(std::ostream &os, s32 p)
 259 {
 260         char buf[4];
 261         writeS32((u8*)buf, p);
 262         os.write(buf, 4);
 263 }
 264 inline s32 readS32(std::istream &is)
 265 {
 266         char buf[4];
 267         is.read(buf, 4);
 268         return readS32((u8*)buf);
 269 }
 270
 271 inline void writeS16(std::ostream &os, s16 p)
 272 {
 273         char buf[2];
 274         writeS16((u8*)buf, p);
 275         os.write(buf, 2);
 276 }
 277 inline s16 readS16(std::istream &is)
 278 {
 279         char buf[2];
 280         is.read(buf, 2);
 281         return readS16((u8*)buf);
 282 }
 283
 284 inline void writeS8(std::ostream &os, s8 p)
 285 {
 286         char buf[1];
 287         writeS8((u8*)buf, p);
 288         os.write(buf, 1);
 289 }
 290 inline s8 readS8(std::istream &is)
 291 {
 292         char buf[1];
 293         is.read(buf, 1);
 294         return readS8((u8*)buf);
 295 }
 296
 297 inline void writeF1000(std::ostream &os, f32 p)
 298 {
 299         char buf[4];
 300         writeF1000((u8*)buf, p);
 301         os.write(buf, 4);
 302 }
 303 inline f32 readF1000(std::istream &is)
 304 {
 305         char buf[4];
 306         is.read(buf, 4);
 307         return readF1000((u8*)buf);
 308 }
 309
 310 inline void writeV3F1000(std::ostream &os, v3f p)
 311 {
 312         char buf[12];
 313         writeV3F1000((u8*)buf, p);
 314         os.write(buf, 12);
 315 }
 316 inline v3f readV3F1000(std::istream &is)
 317 {
 318         char buf[12];
 319         is.read(buf, 12);
 320         return readV3F1000((u8*)buf);
 321 }
 322
 323 inline void writeV2F1000(std::ostream &os, v2f p)
 324 {
 325         char buf[8];
 326         writeV2F1000((u8*)buf, p);
 327         os.write(buf, 8);
 328 }
 329 inline v2f readV2F1000(std::istream &is)
 330 {
 331         char buf[8];
 332         is.read(buf, 8);
 333         return readV2F1000((u8*)buf);
 334 }
 335
 336 inline void writeV2S16(std::ostream &os, v2s16 p)
 337 {
 338         char buf[4];
 339         writeV2S16((u8*)buf, p);
 340         os.write(buf, 4);
 341 }
 342 inline v2s16 readV2S16(std::istream &is)
 343 {
 344         char buf[4];
 345         is.read(buf, 4);
 346         return readV2S16((u8*)buf);
 347 }
 348
 349 inline void writeV3S16(std::ostream &os, v3s16 p)
 350 {
 351         char buf[6];
 352         writeV3S16((u8*)buf, p);
 353         os.write(buf, 6);
 354 }
 355 inline v3s16 readV3S16(std::istream &is)
 356 {
 357         char buf[6];
 358         is.read(buf, 6);
 359         return readV3S16((u8*)buf);
 360 }
 361
 362 /*
 363         None of these are used at the moment
 364 */
 365
 366 template <typename T>
 367 class SharedPtr
 368 {
 369 public:
 370         SharedPtr(T *t=NULL)
 371         {
 372                 refcount = new int;
 373                 *refcount = 1;
 374                 ptr = t;
 375         }
 376         SharedPtr(SharedPtr<T> &t)
 377         {
 378                 //*this = t;
 379                 drop();
 380                 refcount = t.refcount;
 381                 (*refcount)++;
 382                 ptr = t.ptr;
 383         }
 384         ~SharedPtr()
 385         {
 386                 drop();
 387         }
 388         SharedPtr<T> & operator=(T *t)
 389         {
 390                 drop();
 391                 refcount = new int;
 392                 *refcount = 1;
 393                 ptr = t;
 394                 return *this;
 395         }
 396         SharedPtr<T> & operator=(SharedPtr<T> &t)
 397         {
 398                 drop();
 399                 refcount = t.refcount;
 400                 (*refcount)++;
 401                 ptr = t.ptr;
 402                 return *this;
 403         }
 404         T* operator->()
 405         {
 406                 return ptr;
 407         }
 408         T & operator*()
 409         {
 410                 return *ptr;
 411         }
 412         bool operator!=(T *t)
 413         {
 414                 return ptr != t;
 415         }
 416         bool operator==(T *t)
 417         {
 418                 return ptr == t;
 419         }
 420         T & operator[](unsigned int i)
 421         {
 422                 return ptr[i];
 423         }
 424 private:
 425         void drop()
 426         {
 427                 assert((*refcount) > 0);
 428                 (*refcount)--;
 429                 if(*refcount == 0)
 430                 {
 431                         delete refcount;
 432                         if(ptr != NULL)
 433                                 delete ptr;
 434                 }
 435         }
 436         T *ptr;
 437         int *refcount;
 438 };
 439
 440 template <typename T>
 441 class Buffer
 442 {
 443 public:
 444         Buffer()
 445         {
 446                 m_size = 0;
 447                 data = NULL;
 448         }
 449         Buffer(unsigned int size)
 450         {
 451                 m_size = size;
 452                 if(size != 0)
 453                         data = new T[size];
 454                 else
 455                         data = NULL;
 456         }
 457         Buffer(const Buffer &buffer)
 458         {
 459                 m_size = buffer.m_size;
 460                 if(m_size != 0)
 461                 {
 462                         data = new T[buffer.m_size];
 463                         memcpy(data, buffer.data, buffer.m_size);
 464                 }
 465                 else
 466                         data = NULL;
 467         }
 468         Buffer(const T *t, unsigned int size)
 469         {
 470                 m_size = size;
 471                 if(size != 0)
 472                 {
 473                         data = new T[size];
 474                         memcpy(data, t, size);
 475                 }
 476                 else
 477                         data = NULL;
 478         }
 479         ~Buffer()
 480         {
 481                 drop();
 482         }
 483         Buffer& operator=(const Buffer &buffer)
 484         {
 485                 if(this == &buffer)
 486                         return *this;
 487                 drop();
 488                 m_size = buffer.m_size;
 489                 if(m_size != 0)
 490                 {
 491                         data = new T[buffer.m_size];
 492                         memcpy(data, buffer.data, buffer.m_size);
 493                 }
 494                 else
 495                         data = NULL;
 496                 return *this;
 497         }
 498         T & operator[](unsigned int i) const
 499         {
 500                 return data[i];
 501         }
 502         T * operator*() const
 503         {
 504                 return data;
 505         }
 506         unsigned int getSize() const
 507         {
 508                 return m_size;
 509         }
 510 private:
 511         void drop()
 512         {
 513                 if(data)
 514                         delete[] data;
 515         }
 516         T *data;
 517         unsigned int m_size;
 518 };
 519
 520 template <typename T>
 521 class SharedBuffer
 522 {
 523 public:
 524         SharedBuffer()
 525         {
 526                 m_size = 0;
 527                 data = NULL;
 528                 refcount = new unsigned int;
 529                 (*refcount) = 1;
 530         }
 531         SharedBuffer(unsigned int size)
 532         {
 533                 m_size = size;
 534                 if(m_size != 0)
 535                         data = new T[m_size];
 536                 else
 537                         data = NULL;
 538                 refcount = new unsigned int;
 539                 (*refcount) = 1;
 540         }
 541         SharedBuffer(const SharedBuffer &buffer)
 542         {
 543                 //std::cout<<"SharedBuffer(const SharedBuffer &buffer)"<<std::endl;
 544                 m_size = buffer.m_size;
 545                 data = buffer.data;
 546                 refcount = buffer.refcount;
 547                 (*refcount)++;
 548         }
 549         SharedBuffer & operator=(const SharedBuffer & buffer)
 550         {
 551                 //std::cout<<"SharedBuffer & operator=(const SharedBuffer & buffer)"<<std::endl;
 552                 if(this == &buffer)
 553                         return *this;
 554                 drop();
 555                 m_size = buffer.m_size;
 556                 data = buffer.data;
 557                 refcount = buffer.refcount;
 558                 (*refcount)++;
 559                 return *this;
 560         }
 561         /*
 562                 Copies whole buffer
 563         */
 564         SharedBuffer(T *t, unsigned int size)
 565         {
 566                 m_size = size;
 567                 if(m_size != 0)
 568                 {
 569                         data = new T[m_size];
 570                         memcpy(data, t, m_size);
 571                 }
 572                 else
 573                         data = NULL;
 574                 refcount = new unsigned int;
 575                 (*refcount) = 1;
 576         }
 577         /*
 578                 Copies whole buffer
 579         */
 580         SharedBuffer(const Buffer<T> &buffer)
 581         {
 582                 m_size = buffer.getSize();
 583                 if(m_size != 0)
 584                 {
 585                         data = new T[m_size];
 586                         memcpy(data, *buffer, buffer.getSize());
 587                 }
 588                 else
 589                         data = NULL;
 590                 refcount = new unsigned int;
 591                 (*refcount) = 1;
 592         }
 593         ~SharedBuffer()
 594         {
 595                 drop();
 596         }
 597         T & operator[](unsigned int i) const
 598         {
 599                 //assert(i < m_size)
 600                 return data[i];
 601         }
 602         T * operator*() const
 603         {
 604                 return data;
 605         }
 606         unsigned int getSize() const
 607         {
 608                 return m_size;
 609         }
 610         operator Buffer<T>() const
 611         {
 612                 return Buffer<T>(data, m_size);
 613         }
 614 private:
 615         void drop()
 616         {
 617                 assert((*refcount) > 0);
 618                 (*refcount)--;
 619                 if(*refcount == 0)
 620                 {
 621                         if(data)
 622                                 delete[] data;
 623                         delete refcount;
 624                 }
 625         }
 626         T *data;
 627         unsigned int m_size;
 628         unsigned int *refcount;
 629 };
 630
 631 inline SharedBuffer<u8> SharedBufferFromString(const char *string)
 632 {
 633         SharedBuffer<u8> b((u8*)string, strlen(string)+1);
 634         return b;
 635 }
 636
 637 template<typename T>
 638 class MutexedVariable
 639 {
 640 public:
 641         MutexedVariable(T value):
 642                 m_value(value)
 643         {
 644                 m_mutex.Init();
 645         }
 646
 647         T get()
 648         {
 649                 JMutexAutoLock lock(m_mutex);
 650                 return m_value;
 651         }
 652
 653         void set(T value)
 654         {
 655                 JMutexAutoLock lock(m_mutex);
 656                 m_value = value;
 657         }
 658
 659         // You'll want to grab this in a SharedPtr
 660         JMutexAutoLock * getLock()
 661         {
 662                 return new JMutexAutoLock(m_mutex);
 663         }
 664
 665         // You pretty surely want to grab the lock when accessing this
 666         T m_value;
 667
 668 private:
 669         JMutex m_mutex;
 670 };
 671
 672 /*
 673         TimeTaker
 674 */
 675
 676 class TimeTaker
 677 {
 678 public:
 679         TimeTaker(const char *name, u32 *result=NULL);
 680
 681         ~TimeTaker()
 682         {
 683                 stop();
 684         }
 685
 686         u32 stop(bool quiet=false);
 687
 688         u32 getTime();
 689
 690 private:
 691         const char *m_name;
 692         u32 m_time1;
 693         bool m_running;
 694         u32 *m_result;
 695 };
 696
 697 // Calculates the borders of a "d-radius" cube
 698 inline void getFacePositions(core::list<v3s16> &list, u16 d)
 699 {
 700         if(d == 0)
 701         {
 702                 list.push_back(v3s16(0,0,0));
 703                 return;
 704         }
 705         if(d == 1)
 706         {
 707                 /*
 708                         This is an optimized sequence of coordinates.
 709                 */
 710                 list.push_back(v3s16( 0, 1, 0)); // top
 711                 list.push_back(v3s16( 0, 0, 1)); // back
 712                 list.push_back(v3s16(-1, 0, 0)); // left
 713                 list.push_back(v3s16( 1, 0, 0)); // right
 714                 list.push_back(v3s16( 0, 0,-1)); // front
 715                 list.push_back(v3s16( 0,-1, 0)); // bottom
 716                 // 6
 717                 list.push_back(v3s16(-1, 0, 1)); // back left
 718                 list.push_back(v3s16( 1, 0, 1)); // back right
 719                 list.push_back(v3s16(-1, 0,-1)); // front left
 720                 list.push_back(v3s16( 1, 0,-1)); // front right
 721                 list.push_back(v3s16(-1,-1, 0)); // bottom left
 722                 list.push_back(v3s16( 1,-1, 0)); // bottom right
 723                 list.push_back(v3s16( 0,-1, 1)); // bottom back
 724                 list.push_back(v3s16( 0,-1,-1)); // bottom front
 725                 list.push_back(v3s16(-1, 1, 0)); // top left
 726                 list.push_back(v3s16( 1, 1, 0)); // top right
 727                 list.push_back(v3s16( 0, 1, 1)); // top back
 728                 list.push_back(v3s16( 0, 1,-1)); // top front
 729                 // 18
 730                 list.push_back(v3s16(-1, 1, 1)); // top back-left
 731                 list.push_back(v3s16( 1, 1, 1)); // top back-right
 732                 list.push_back(v3s16(-1, 1,-1)); // top front-left
 733                 list.push_back(v3s16( 1, 1,-1)); // top front-right
 734                 list.push_back(v3s16(-1,-1, 1)); // bottom back-left
 735                 list.push_back(v3s16( 1,-1, 1)); // bottom back-right
 736                 list.push_back(v3s16(-1,-1,-1)); // bottom front-left
 737                 list.push_back(v3s16( 1,-1,-1)); // bottom front-right
 738                 // 26
 739                 return;
 740         }
 741
 742         // Take blocks in all sides, starting from y=0 and going +-y
 743         for(s16 y=0; y<=d-1; y++)
 744         {
 745                 // Left and right side, including borders
 746                 for(s16 z=-d; z<=d; z++)
 747                 {
 748                         list.push_back(v3s16(d,y,z));
 749                         list.push_back(v3s16(-d,y,z));
 750                         if(y != 0)
 751                         {
 752                                 list.push_back(v3s16(d,-y,z));
 753                                 list.push_back(v3s16(-d,-y,z));
 754                         }
 755                 }
 756                 // Back and front side, excluding borders
 757                 for(s16 x=-d+1; x<=d-1; x++)
 758                 {
 759                         list.push_back(v3s16(x,y,d));
 760                         list.push_back(v3s16(x,y,-d));
 761                         if(y != 0)
 762                         {
 763                                 list.push_back(v3s16(x,-y,d));
 764                                 list.push_back(v3s16(x,-y,-d));
 765                         }
 766                 }
 767         }
 768
 769         // Take the bottom and top face with borders
 770         // -d<x<d, y=+-d, -d<z<d
 771         for(s16 x=-d; x<=d; x++)
 772         for(s16 z=-d; z<=d; z++)
 773         {
 774                 list.push_back(v3s16(x,-d,z));
 775                 list.push_back(v3s16(x,d,z));
 776         }
 777 }
 778
 779 class IndentationRaiser
 780 {
 781 public:
 782         IndentationRaiser(u16 *indentation)
 783         {
 784                 m_indentation = indentation;
 785                 (*m_indentation)++;
 786         }
 787         ~IndentationRaiser()
 788         {
 789                 (*m_indentation)--;
 790         }
 791 private:
 792         u16 *m_indentation;
 793 };
 794
 795 inline s16 getContainerPos(s16 p, s16 d)
 796 {
 797         return (p>=0 ? p : p-d+1) / d;
 798 }
 799
 800 inline v2s16 getContainerPos(v2s16 p, s16 d)
 801 {
 802         return v2s16(
 803                 getContainerPos(p.X, d),
 804                 getContainerPos(p.Y, d)
 805         );
 806 }
 807
 808 inline v3s16 getContainerPos(v3s16 p, s16 d)
 809 {
 810         return v3s16(
 811                 getContainerPos(p.X, d),
 812                 getContainerPos(p.Y, d),
 813                 getContainerPos(p.Z, d)
 814         );
 815 }
 816
 817 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
 818 {
 819         return v2s16(
 820                 getContainerPos(p.X, d.X),
 821                 getContainerPos(p.Y, d.Y)
 822         );
 823 }
 824
 825 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
 826 {
 827         return v3s16(
 828                 getContainerPos(p.X, d.X),
 829                 getContainerPos(p.Y, d.Y),
 830                 getContainerPos(p.Z, d.Z)
 831         );
 832 }
 833
 834 inline bool isInArea(v3s16 p, s16 d)
 835 {
 836         return (
 837                 p.X >= 0 && p.X < d &&
 838                 p.Y >= 0 && p.Y < d &&
 839                 p.Z >= 0 && p.Z < d
 840         );
 841 }
 842
 843 inline bool isInArea(v2s16 p, s16 d)
 844 {
 845         return (
 846                 p.X >= 0 && p.X < d &&
 847                 p.Y >= 0 && p.Y < d
 848         );
 849 }
 850
 851 inline bool isInArea(v3s16 p, v3s16 d)
 852 {
 853         return (
 854                 p.X >= 0 && p.X < d.X &&
 855                 p.Y >= 0 && p.Y < d.Y &&
 856                 p.Z >= 0 && p.Z < d.Z
 857         );
 858 }
 859
 860 inline s16 rangelim(s16 i, s16 max)
 861 {
 862         if(i < 0)
 863                 return 0;
 864         if(i > max)
 865                 return max;
 866         return i;
 867 }
 868
 869 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d)>(max)?(max):(d)))
 870
 871 inline v3s16 arealim(v3s16 p, s16 d)
 872 {
 873         if(p.X < 0)
 874                 p.X = 0;
 875         if(p.Y < 0)
 876                 p.Y = 0;
 877         if(p.Z < 0)
 878                 p.Z = 0;
 879         if(p.X > d-1)
 880                 p.X = d-1;
 881         if(p.Y > d-1)
 882                 p.Y = d-1;
 883         if(p.Z > d-1)
 884                 p.Z = d-1;
 885         return p;
 886 }
 887
 888 inline std::wstring narrow_to_wide(const std::string& mbs)
 889 {
 890         size_t wcl = mbs.size();
 891         Buffer<wchar_t> wcs(wcl+1);
 892         size_t l = mbstowcs(*wcs, mbs.c_str(), wcl);
 893         if(l == (size_t)(-1))
 894                 return L"<invalid multibyte string>";
 895         wcs[l] = 0;
 896         return *wcs;
 897 }
 898
 899 inline std::string wide_to_narrow(const std::wstring& wcs)
 900 {
 901         size_t mbl = wcs.size()*4;
 902         SharedBuffer<char> mbs(mbl+1);
 903         size_t l = wcstombs(*mbs, wcs.c_str(), mbl);
 904         if(l == (size_t)(-1))
 905                 mbs[0] = 0;
 906         else
 907                 mbs[l] = 0;
 908         return *mbs;
 909 }
 910
 911 // Split a string using the given delimiter. Returns a vector containing
 912 // the component parts.
 913 inline std::vector<std::wstring> str_split(const std::wstring &str, wchar_t delimiter)
 914 {
 915         std::vector<std::wstring> parts;
 916         std::wstringstream sstr(str);
 917         std::wstring part;
 918         while(std::getline(sstr, part, delimiter))
 919                 parts.push_back(part);
 920         return parts;
 921 }
 922
 923
 924 /*
 925         See test.cpp for example cases.
 926         wraps degrees to the range of -360...360
 927         NOTE: Wrapping to 0...360 is not used because pitch needs negative values.
 928 */
 929 inline float wrapDegrees(float f)
 930 {
 931         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
 932         // This results in
 933         // 10, 720, -1, -361
 934         int i = floor(f);
 935         // 0, 2, 0, -1
 936         int l = i / 360;
 937         // NOTE: This would be used for wrapping to 0...360
 938         // 0, 2, -1, -2
 939         /*if(i < 0)
 940                 l -= 1;*/
 941         // 0, 720, 0, -360
 942         int k = l * 360;
 943         // 10, 0.5, -0.5, -0.5
 944         f -= float(k);
 945         return f;
 946 }
 947
 948 /* Wrap to 0...360 */
 949 inline float wrapDegrees_0_360(float f)
 950 {
 951         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
 952         // This results in
 953         // 10, 720, -1, -361
 954         int i = floor(f);
 955         // 0, 2, 0, -1
 956         int l = i / 360;
 957         // Wrap to 0...360
 958         // 0, 2, -1, -2
 959         if(i < 0)
 960                 l -= 1;
 961         // 0, 720, 0, -360
 962         int k = l * 360;
 963         // 10, 0.5, -0.5, -0.5
 964         f -= float(k);
 965         return f;
 966 }
 967
 968 /* Wrap to -180...180 */
 969 inline float wrapDegrees_180(float f)
 970 {
 971         f += 180;
 972         f = wrapDegrees_0_360(f);
 973         f -= 180;
 974         return f;
 975 }
 976
 977 inline std::string lowercase(const std::string &s)
 978 {
 979         std::string s2;
 980         for(size_t i=0; i<s.size(); i++)
 981         {
 982                 char c = s[i];
 983                 if(c >= 'A' && c <= 'Z')
 984                         c -= 'A' - 'a';
 985                 s2 += c;
 986         }
 987         return s2;
 988 }
 989
 990 inline bool is_yes(const std::string &s)
 991 {
 992         std::string s2 = lowercase(trim(s));
 993         if(s2 == "y" || s2 == "yes" || s2 == "true" || s2 == "1")
 994                 return true;
 995         return false;
 996 }
 997
 998 inline s32 mystoi(const std::string &s, s32 min, s32 max)
 999 {
1000         s32 i = atoi(s.c_str());
1001         if(i < min)
1002                 i = min;
1003         if(i > max)
1004                 i = max;
1005         return i;
1006 }
1007
1008
1009 // MSVC2010 includes it's own versions of these
1010 //#if !defined(_MSC_VER) || _MSC_VER < 1600
1011
1012 inline s32 mystoi(std::string s)
1013 {
1014         return atoi(s.c_str());
1015 }
1016
1017 inline s32 mystoi(std::wstring s)
1018 {
1019         return atoi(wide_to_narrow(s).c_str());
1020 }
1021
1022 inline float mystof(std::string s)
1023 {
1024         float f;
1025         std::istringstream ss(s);
1026         ss>>f;
1027         return f;
1028 }
1029
1030 //#endif
1031
1032 #define stoi mystoi
1033 #define stof mystof
1034
1035 inline std::string itos(s32 i)
1036 {
1037         std::ostringstream o;
1038         o<<i;
1039         return o.str();
1040 }
1041
1042 inline std::string ftos(float f)
1043 {
1044         std::ostringstream o;
1045         o<<f;
1046         return o.str();
1047 }
1048
1049 inline void str_replace(std::string & str, std::string const & pattern,
1050                 std::string const & replacement)
1051 {
1052         std::string::size_type start = str.find(pattern, 0);
1053         while(start != str.npos)
1054         {
1055                 str.replace(start, pattern.size(), replacement);
1056                 start = str.find(pattern, start+replacement.size());
1057         }
1058 }
1059
1060 inline void str_replace_char(std::string & str, char from, char to)
1061 {
1062         for(unsigned int i=0; i<str.size(); i++)
1063         {
1064                 if(str[i] == from)
1065                         str[i] = to;
1066         }
1067 }
1068
1069 /*
1070         A base class for simple background thread implementation
1071 */
1072
1073 class SimpleThread : public JThread
1074 {
1075         bool run;
1076         JMutex run_mutex;
1077
1078 public:
1079
1080         SimpleThread():
1081                 JThread(),
1082                 run(true)
1083         {
1084                 run_mutex.Init();
1085         }
1086
1087         virtual ~SimpleThread()
1088         {}
1089
1090         virtual void * Thread() = 0;
1091
1092         bool getRun()
1093         {
1094                 JMutexAutoLock lock(run_mutex);
1095                 return run;
1096         }
1097         void setRun(bool a_run)
1098         {
1099                 JMutexAutoLock lock(run_mutex);
1100                 run = a_run;
1101         }
1102
1103         void stop()
1104         {
1105                 setRun(false);
1106                 while(IsRunning())
1107                         sleep_ms(100);
1108         }
1109 };
1110
1111 /*
1112         FIFO queue (well, actually a FILO also)
1113 */
1114 template<typename T>
1115 class Queue
1116 {
1117 public:
1118         void push_back(T t)
1119         {
1120                 m_list.push_back(t);
1121         }
1122
1123         T pop_front()
1124         {
1125                 if(m_list.size() == 0)
1126                         throw ItemNotFoundException("Queue: queue is empty");
1127
1128                 typename core::list<T>::Iterator begin = m_list.begin();
1129                 T t = *begin;
1130                 m_list.erase(begin);
1131                 return t;
1132         }
1133         T pop_back()
1134         {
1135                 if(m_list.size() == 0)
1136                         throw ItemNotFoundException("Queue: queue is empty");
1137
1138                 typename core::list<T>::Iterator last = m_list.getLast();
1139                 T t = *last;
1140                 m_list.erase(last);
1141                 return t;
1142         }
1143
1144         u32 size()
1145         {
1146                 return m_list.size();
1147         }
1148
1149 protected:
1150         core::list<T> m_list;
1151 };
1152
1153 /*
1154         Thread-safe FIFO queue (well, actually a FILO also)
1155 */
1156
1157 template<typename T>
1158 class MutexedQueue
1159 {
1160 public:
1161         MutexedQueue()
1162         {
1163                 m_mutex.Init();
1164         }
1165         u32 size()
1166         {
1167                 JMutexAutoLock lock(m_mutex);
1168                 return m_list.size();
1169         }
1170         void push_back(T t)
1171         {
1172                 JMutexAutoLock lock(m_mutex);
1173                 m_list.push_back(t);
1174         }
1175         T pop_front(u32 wait_time_max_ms=0)
1176         {
1177                 u32 wait_time_ms = 0;
1178
1179                 for(;;)
1180                 {
1181                         {
1182                                 JMutexAutoLock lock(m_mutex);
1183
1184                                 if(m_list.size() > 0)
1185                                 {
1186                                         typename core::list<T>::Iterator begin = m_list.begin();
1187                                         T t = *begin;
1188                                         m_list.erase(begin);
1189                                         return t;
1190                                 }
1191
1192                                 if(wait_time_ms >= wait_time_max_ms)
1193                                         throw ItemNotFoundException("MutexedQueue: queue is empty");
1194                         }
1195
1196                         // Wait a while before trying again
1197                         sleep_ms(10);
1198                         wait_time_ms += 10;
1199                 }
1200         }
1201         T pop_back(u32 wait_time_max_ms=0)
1202         {
1203                 u32 wait_time_ms = 0;
1204
1205                 for(;;)
1206                 {
1207                         {
1208                                 JMutexAutoLock lock(m_mutex);
1209
1210                                 if(m_list.size() > 0)
1211                                 {
1212                                         typename core::list<T>::Iterator last = m_list.getLast();
1213                                         T t = *last;
1214                                         m_list.erase(last);
1215                                         return t;
1216                                 }
1217
1218                                 if(wait_time_ms >= wait_time_max_ms)
1219                                         throw ItemNotFoundException("MutexedQueue: queue is empty");
1220                         }
1221
1222                         // Wait a while before trying again
1223                         sleep_ms(10);
1224                         wait_time_ms += 10;
1225                 }
1226         }
1227
1228         JMutex & getMutex()
1229         {
1230                 return m_mutex;
1231         }
1232
1233         core::list<T> & getList()
1234         {
1235                 return m_list;
1236         }
1237
1238 protected:
1239         JMutex m_mutex;
1240         core::list<T> m_list;
1241 };
1242
1243 /*
1244         A single worker thread - multiple client threads queue framework.
1245 */
1246
1247 template<typename Caller, typename Data>
1248 class CallerInfo
1249 {
1250 public:
1251         Caller caller;
1252         Data data;
1253 };
1254
1255 template<typename Key, typename T, typename Caller, typename CallerData>
1256 class GetResult
1257 {
1258 public:
1259         Key key;
1260         T item;
1261         core::list<CallerInfo<Caller, CallerData> > callers;
1262 };
1263
1264 template<typename Key, typename T, typename Caller, typename CallerData>
1265 class ResultQueue: public MutexedQueue< GetResult<Key, T, Caller, CallerData> >
1266 {
1267 };
1268
1269 template<typename Key, typename T, typename Caller, typename CallerData>
1270 class GetRequest
1271 {
1272 public:
1273         GetRequest()
1274         {
1275                 dest = NULL;
1276         }
1277         GetRequest(ResultQueue<Key,T, Caller, CallerData> *a_dest)
1278         {
1279                 dest = a_dest;
1280         }
1281         GetRequest(ResultQueue<Key,T, Caller, CallerData> *a_dest,
1282                         Key a_key)
1283         {
1284                 dest = a_dest;
1285                 key = a_key;
1286         }
1287         ~GetRequest()
1288         {
1289         }
1290
1291         Key key;
1292         ResultQueue<Key, T, Caller, CallerData> *dest;
1293         core::list<CallerInfo<Caller, CallerData> > callers;
1294 };
1295
1296 template<typename Key, typename T, typename Caller, typename CallerData>
1297 class RequestQueue
1298 {
1299 public:
1300         u32 size()
1301         {
1302                 return m_queue.size();
1303         }
1304
1305         void add(Key key, Caller caller, CallerData callerdata,
1306                         ResultQueue<Key, T, Caller, CallerData> *dest)
1307         {
1308                 JMutexAutoLock lock(m_queue.getMutex());
1309
1310                 /*
1311                         If the caller is already on the list, only update CallerData
1312                 */
1313                 for(typename core::list< GetRequest<Key, T, Caller, CallerData> >::Iterator
1314                                 i = m_queue.getList().begin();
1315                                 i != m_queue.getList().end(); i++)
1316                 {
1317                         GetRequest<Key, T, Caller, CallerData> &request = *i;
1318
1319                         if(request.key == key)
1320                         {
1321                                 for(typename core::list< CallerInfo<Caller, CallerData> >::Iterator
1322                                                 i = request.callers.begin();
1323                                                 i != request.callers.end(); i++)
1324                                 {
1325                                         CallerInfo<Caller, CallerData> &ca = *i;
1326                                         if(ca.caller == caller)
1327                                         {
1328                                                 ca.data = callerdata;
1329                                                 return;
1330                                         }
1331                                 }
1332                                 CallerInfo<Caller, CallerData> ca;
1333                                 ca.caller = caller;
1334                                 ca.data = callerdata;
1335                                 request.callers.push_back(ca);
1336                                 return;
1337                         }
1338                 }
1339
1340                 /*
1341                         Else add a new request to the queue
1342                 */
1343
1344                 GetRequest<Key, T, Caller, CallerData> request;
1345                 request.key = key;
1346                 CallerInfo<Caller, CallerData> ca;
1347                 ca.caller = caller;
1348                 ca.data = callerdata;
1349                 request.callers.push_back(ca);
1350                 request.dest = dest;
1351
1352                 m_queue.getList().push_back(request);
1353         }
1354
1355         GetRequest<Key, T, Caller, CallerData> pop(bool wait_if_empty=false)
1356         {
1357                 return m_queue.pop_front(wait_if_empty);
1358         }
1359
1360 private:
1361         MutexedQueue< GetRequest<Key, T, Caller, CallerData> > m_queue;
1362 };
1363
1364 /*
1365         Pseudo-random (VC++ rand() sucks)
1366 */
1367 int myrand(void);
1368 void mysrand(unsigned seed);
1369 #define MYRAND_MAX 32767
1370
1371 int myrand_range(int min, int max);
1372
1373 /*
1374         Miscellaneous functions
1375 */
1376
1377 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
1378                 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
1379
1380 /*
1381         Queue with unique values with fast checking of value existence
1382 */
1383
1384 template<typename Value>
1385 class UniqueQueue
1386 {
1387 public:
1388
1389         /*
1390                 Does nothing if value is already queued.
1391                 Return value:
1392                         true: value added
1393                         false: value already exists
1394         */
1395         bool push_back(Value value)
1396         {
1397                 // Check if already exists
1398                 if(m_map.find(value) != NULL)
1399                         return false;
1400
1401                 // Add
1402                 m_map.insert(value, 0);
1403                 m_list.push_back(value);
1404
1405                 return true;
1406         }
1407
1408         Value pop_front()
1409         {
1410                 typename core::list<Value>::Iterator i = m_list.begin();
1411                 Value value = *i;
1412                 m_map.remove(value);
1413                 m_list.erase(i);
1414                 return value;
1415         }
1416
1417         u32 size()
1418         {
1419                 assert(m_list.size() == m_map.size());
1420                 return m_list.size();
1421         }
1422
1423 private:
1424         core::map<Value, u8> m_map;
1425         core::list<Value> m_list;
1426 };
1427
1428 #if 1
1429 template<typename Key, typename Value>
1430 class MutexedMap
1431 {
1432 public:
1433         MutexedMap()
1434         {
1435                 m_mutex.Init();
1436                 assert(m_mutex.IsInitialized());
1437         }
1438
1439         void set(const Key &name, const Value &value)
1440         {
1441                 JMutexAutoLock lock(m_mutex);
1442
1443                 m_values[name] = value;
1444         }
1445
1446         bool get(const Key &name, Value *result)
1447         {
1448                 JMutexAutoLock lock(m_mutex);
1449
1450                 typename core::map<Key, Value>::Node *n;
1451                 n = m_values.find(name);
1452
1453                 if(n == NULL)
1454                         return false;
1455
1456                 if(result != NULL)
1457                         *result = n->getValue();
1458
1459                 return true;
1460         }
1461
1462 private:
1463         core::map<Key, Value> m_values;
1464         JMutex m_mutex;
1465 };
1466 #endif
1467
1468 /*
1469         Generates ids for comparable values.
1470         Id=0 is reserved for "no value".
1471
1472         Is fast at:
1473         - Returning value by id (very fast)
1474         - Returning id by value
1475         - Generating a new id for a value
1476
1477         Is not able to:
1478         - Remove an id/value pair (is possible to implement but slow)
1479 */
1480 template<typename T>
1481 class MutexedIdGenerator
1482 {
1483 public:
1484         MutexedIdGenerator()
1485         {
1486                 m_mutex.Init();
1487                 assert(m_mutex.IsInitialized());
1488         }
1489
1490         // Returns true if found
1491         bool getValue(u32 id, T &value)
1492         {
1493                 if(id == 0)
1494                         return false;
1495                 JMutexAutoLock lock(m_mutex);
1496                 if(m_id_to_value.size() < id)
1497                         return false;
1498                 value = m_id_to_value[id-1];
1499                 return true;
1500         }
1501
1502         // If id exists for value, returns the id.
1503         // Otherwise generates an id for the value.
1504         u32 getId(const T &value)
1505         {
1506                 JMutexAutoLock lock(m_mutex);
1507                 typename core::map<T, u32>::Node *n;
1508                 n = m_value_to_id.find(value);
1509                 if(n != NULL)
1510                         return n->getValue();
1511                 m_id_to_value.push_back(value);
1512                 u32 new_id = m_id_to_value.size();
1513                 m_value_to_id.insert(value, new_id);
1514                 return new_id;
1515         }
1516
1517 private:
1518         JMutex m_mutex;
1519         // Values are stored here at id-1 position (id 1 = [0])
1520         core::array<T> m_id_to_value;
1521         core::map<T, u32> m_value_to_id;
1522 };
1523
1524 /*
1525         Checks if a string contains only supplied characters
1526 */
1527 inline bool string_allowed(const std::string &s, const std::string &allowed_chars)
1528 {
1529         for(u32 i=0; i<s.size(); i++)
1530         {
1531                 bool confirmed = false;
1532                 for(u32 j=0; j<allowed_chars.size(); j++)
1533                 {
1534                         if(s[i] == allowed_chars[j])
1535                         {
1536                                 confirmed = true;
1537                                 break;
1538                         }
1539                 }
1540                 if(confirmed == false)
1541                         return false;
1542         }
1543         return true;
1544 }
1545
1546 /*
1547         Forcefully wraps string into rows using \n
1548         (no word wrap, used for showing paths in gui)
1549 */
1550 inline std::string wrap_rows(const std::string &from, u32 rowlen)
1551 {
1552         std::string to;
1553         for(u32 i=0; i<from.size(); i++)
1554         {
1555                 if(i != 0 && i%rowlen == 0)
1556                         to += '\n';
1557                 to += from[i];
1558         }
1559         return to;
1560 }
1561
1562 /*
1563         Some helper stuff
1564 */
1565 #define MYMIN(a,b) ((a)<(b)?(a):(b))
1566 #define MYMAX(a,b) ((a)>(b)?(a):(b))
1567
1568 /*
1569         Returns integer position of node in given floating point position
1570 */
1571 inline v3s16 floatToInt(v3f p, f32 d)
1572 {
1573         v3s16 p2(
1574                 (p.X + (p.X>0 ? d/2 : -d/2))/d,
1575                 (p.Y + (p.Y>0 ? d/2 : -d/2))/d,
1576                 (p.Z + (p.Z>0 ? d/2 : -d/2))/d);
1577         return p2;
1578 }
1579
1580 /*
1581         Returns floating point position of node in given integer position
1582 */
1583 inline v3f intToFloat(v3s16 p, f32 d)
1584 {
1585         v3f p2(
1586                 (f32)p.X * d,
1587                 (f32)p.Y * d,
1588                 (f32)p.Z * d
1589         );
1590         return p2;
1591 }
1592
1593 /*
1594         More serialization stuff
1595 */
1596
1597 // Creates a string with the length as the first two bytes
1598 inline std::string serializeString(const std::string &plain)
1599 {
1600         //assert(plain.size() <= 65535);
1601         if(plain.size() > 65535)
1602                 throw SerializationError("String too long for serializeString");
1603         char buf[2];
1604         writeU16((u8*)&buf[0], plain.size());
1605         std::string s;
1606         s.append(buf, 2);
1607         s.append(plain);
1608         return s;
1609 }
1610
1611 // Creates a string with the length as the first two bytes from wide string
1612 inline std::string serializeWideString(const std::wstring &plain)
1613 {
1614         //assert(plain.size() <= 65535);
1615         if(plain.size() > 65535)
1616                 throw SerializationError("String too long for serializeString");
1617         char buf[2];
1618         writeU16((u8*)buf, plain.size());
1619         std::string s;
1620         s.append(buf, 2);
1621         for(u32 i=0; i<plain.size(); i++)
1622         {
1623                 writeU16((u8*)buf, plain[i]);
1624                 s.append(buf, 2);
1625         }
1626         return s;
1627 }
1628
1629 // Reads a string with the length as the first two bytes
1630 inline std::string deSerializeString(std::istream &is)
1631 {
1632         char buf[2];
1633         is.read(buf, 2);
1634         if(is.gcount() != 2)
1635                 throw SerializationError("deSerializeString: size not read");
1636         u16 s_size = readU16((u8*)buf);
1637         if(s_size == 0)
1638                 return "";
1639         Buffer<char> buf2(s_size);
1640         is.read(&buf2[0], s_size);
1641         std::string s;
1642         s.reserve(s_size);
1643         s.append(&buf2[0], s_size);
1644         return s;
1645 }
1646
1647 // Reads a wide string with the length as the first two bytes
1648 inline std::wstring deSerializeWideString(std::istream &is)
1649 {
1650         char buf[2];
1651         is.read(buf, 2);
1652         if(is.gcount() != 2)
1653                 throw SerializationError("deSerializeString: size not read");
1654         u16 s_size = readU16((u8*)buf);
1655         if(s_size == 0)
1656                 return L"";
1657         std::wstring s;
1658         s.reserve(s_size);
1659         for(u32 i=0; i<s_size; i++)
1660         {
1661                 is.read(&buf[0], 2);
1662                 wchar_t c16 = readU16((u8*)buf);
1663                 s.append(&c16, 1);
1664         }
1665         return s;
1666 }
1667
1668 // Creates a string with the length as the first four bytes
1669 inline std::string serializeLongString(const std::string &plain)
1670 {
1671         char buf[4];
1672         writeU32((u8*)&buf[0], plain.size());
1673         std::string s;
1674         s.append(buf, 4);
1675         s.append(plain);
1676         return s;
1677 }
1678
1679 // Reads a string with the length as the first four bytes
1680 inline std::string deSerializeLongString(std::istream &is)
1681 {
1682         char buf[4];
1683         is.read(buf, 4);
1684         if(is.gcount() != 4)
1685                 throw SerializationError("deSerializeLongString: size not read");
1686         u32 s_size = readU32((u8*)buf);
1687         if(s_size == 0)
1688                 return "";
1689         Buffer<char> buf2(s_size);
1690         is.read(&buf2[0], s_size);
1691         std::string s;
1692         s.reserve(s_size);
1693         s.append(&buf2[0], s_size);
1694         return s;
1695 }
1696
1697 // Creates a string encoded in JSON format (almost equivalent to a C string literal)
1698 std::string serializeJsonString(const std::string &plain);
1699
1700 // Reads a string encoded in JSON format
1701 std::string deSerializeJsonString(std::istream &is);
1702
1703 //
1704
1705 inline u32 time_to_daynight_ratio(u32 time_of_day)
1706 {
1707         const s32 daylength = 16;
1708         const s32 nightlength = 6;
1709         const s32 daytimelength = 8;
1710         s32 d = daylength;
1711         s32 t = (((time_of_day)%24000)/(24000/d));
1712         if(t < nightlength/2 || t >= d - nightlength/2)
1713                 //return 300;
1714                 return 350;
1715         else if(t >= d/2 - daytimelength/2 && t < d/2 + daytimelength/2)
1716                 return 1000;
1717         else
1718                 return 750;
1719 }
1720
1721 // Random helper. Usually d=BS
1722 inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
1723 {
1724         return core::aabbox3d<f32>(
1725                 (float)p.X * d - 0.5*d,
1726                 (float)p.Y * d - 0.5*d,
1727                 (float)p.Z * d - 0.5*d,
1728                 (float)p.X * d + 0.5*d,
1729                 (float)p.Y * d + 0.5*d,
1730                 (float)p.Z * d + 0.5*d
1731         );
1732 }
1733
1734 class IntervalLimiter
1735 {
1736 public:
1737         IntervalLimiter():
1738                 m_accumulator(0)
1739         {
1740         }
1741         /*
1742                 dtime: time from last call to this method
1743                 wanted_interval: interval wanted
1744                 return value:
1745                         true: action should be skipped
1746                         false: action should be done
1747         */
1748         bool step(float dtime, float wanted_interval)
1749         {
1750                 m_accumulator += dtime;
1751                 if(m_accumulator < wanted_interval)
1752                         return false;
1753                 m_accumulator -= wanted_interval;
1754                 return true;
1755         }
1756 protected:
1757         float m_accumulator;
1758 };
1759
1760 std::string translatePassword(std::string playername, std::wstring password);
1761
1762 enum PointedThingType
1763 {
1764         POINTEDTHING_NOTHING,
1765         POINTEDTHING_NODE,
1766         POINTEDTHING_OBJECT
1767 };
1768
1769 struct PointedThing
1770 {
1771         PointedThingType type;
1772         v3s16 node_undersurface;
1773         v3s16 node_abovesurface;
1774         s16 object_id;
1775
1776         PointedThing();
1777         std::string dump() const;
1778         void serialize(std::ostream &os) const;
1779         void deSerialize(std::istream &is);
1780         bool operator==(const PointedThing &pt2) const;
1781         bool operator!=(const PointedThing &pt2) const;
1782 };
1783
1784 #endif
1785