src/main.cpp

   1 /*\r
   2 Minetest-c55\r
   3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>\r
   4 \r
   5 This program is free software; you can redistribute it and/or modify\r
   6 it under the terms of the GNU General Public License as published by\r
   7 the Free Software Foundation; either version 2 of the License, or\r
   8 (at your option) any later version.\r
   9 \r
  10 This program is distributed in the hope that it will be useful,\r
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 GNU General Public License for more details.\r
  14 \r
  15 You should have received a copy of the GNU General Public License along\r
  16 with this program; if not, write to the Free Software Foundation, Inc.,\r
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
  18 */\r
  19 \r
  20 /*\r
  21 =============================== NOTES ==============================\r
  22 NOTE: Things starting with TODO are sometimes only suggestions.\r
  23 \r
  24 NOTE: VBO cannot be turned on for fast-changing stuff because there\r
  25       is an apparanet memory leak in irrlicht when using it (not sure)\r
  26 \r
  27 NOTE: iostream.imbue(std::locale("C")) is very slow\r
  28 NOTE: Global locale is now set at initialization\r
  29 \r
  30 SUGGESTION: add a second lighting value to the MS nibble of param of\r
  31         air to tell how bright the air node is when there is no sunlight.\r
  32         When day changes to night, these two values can be interpolated.\r
  33 \r
  34 TODO: Fix address to be ipv6 compatible\r
  35 \r
  36 TODO: ESC Pause mode in which the cursor is not kept at the center of window.\r
  37 TODO: Stop player if focus of window is taken away (go to pause mode)\r
  38 TODO: Optimize and fix makeFastFace or whatever it's called\r
  39       - Face calculation is the source of CPU usage on the client\r
  40 SUGGESTION: The client will calculate and send lighting changes and\r
  41   the server will randomly check some of them and kick the client out\r
  42   if it fails to calculate them right.\r
  43   - Actually, it could just start ignoring them and calculate them\r
  44     itself.\r
  45 SUGGESTION: Combine MapBlock's face caches to so big pieces that VBO\r
  46             gets used\r
  47             - That is >500 vertices\r
  48 \r
  49 TODO: Better dungeons\r
  50 TODO: There should be very slight natural caves also, starting from\r
  51       only a straightened-up cliff\r
  52 \r
  53 TODO: Changing of block with mouse wheel or something\r
  54 TODO: Menus\r
  55 \r
  56 TODO: Mobs\r
  57       - Server:\r
  58         - One single map container with ids as keys\r
  59       - Client:\r
  60             - ?\r
  61 TODO: - Keep track of the place of the mob in the last few hundreth's\r
  62         of a second - then, if a player hits it, take the value that is\r
  63                 avg_rtt/2 before the moment the packet is received.\r
  64 TODO: - Scripting\r
  65 \r
  66 SUGGESTION: Modify client to calculate single changes asynchronously\r
  67 \r
  68 TODO: Moving players more smoothly. Calculate moving animation\r
  69       in a way that doesn't make the player jump to the right place\r
  70           immediately when the server sends a new position\r
  71 \r
  72 TODO: There are some lighting-related todos and fixmes in\r
  73       ServerMap::emergeBlock\r
  74 \r
  75 FIXME: When a new sector is generated, it may change the ground level\r
  76        of it's and it's neighbors border that two blocks that are\r
  77            above and below each other and that are generated before and\r
  78            after the sector heightmap generation (order doesn't matter),\r
  79            can have a small gap between each other at the border.\r
  80 SUGGESTION: Use same technique for sector heightmaps as what we're\r
  81             using for UnlimitedHeightmap? (getting all neighbors\r
  82                         when generating)\r
  83 \r
  84 TODO: Proper handling of spawning place (try to find something that\r
  85       is not in the middle of an ocean (some land to stand on at\r
  86           least) and save it in map config.\r
  87 SUGG: Set server to automatically find a good spawning place in some\r
  88       place where there is water and land.\r
  89           - Map to have a getWalkableNear(p)\r
  90           - Is this a good idea? It's part of the game to find a good place.\r
  91 \r
  92 TODO: Transfer more blocks in a single packet\r
  93 SUGG: A blockdata combiner class, to which blocks are added and at\r
  94       destruction it sends all the stuff in as few packets as possible.\r
  95 \r
  96 SUGG: If player is on ground, mainly fetch ground-level blocks\r
  97 SUGG: Fetch stuff mainly from the viewing direction\r
  98 \r
  99 SUGG: Expose Connection's seqnums and ACKs to server and client.\r
 100       - This enables saving many packets and making a faster connection\r
 101           - This also enables server to check if client has received the\r
 102             most recent block sent, for example.\r
 103 TODO: Add a sane bandwidth throttling system to Connection\r
 104 \r
 105 SUGG: More fine-grained control of client's dumping of blocks from\r
 106       memory\r
 107           - ...What does this mean in the first place?\r
 108 \r
 109 TODO: Make the amount of blocks sending to client and the total\r
 110           amount of blocks dynamically limited. Transferring blocks is the\r
 111           main network eater of this system, so it is the one that has\r
 112           to be throttled so that RTTs stay low.\r
 113 \r
 114 TODO: Server to load starting inventory from disk\r
 115 \r
 116 TODO: PLayers to only be hidden when the client quits.\r
 117 TODO: - Players to be saved on disk, with inventory\r
 118 TODO: Players to be saved as text in map/players/<name>\r
 119 \r
 120 SUGG: A map editing mode (similar to dedicated server mode)\r
 121 \r
 122 TODO: Make fetching sector's blocks more efficient when rendering\r
 123       sectors that have very large amounts of blocks (on client)\r
 124 \r
 125 TODO: Make the video backend selectable\r
 126 \r
 127 Block object server side:\r
 128       - A "near blocks" buffer, in which some nearby blocks are stored.\r
 129           - For all blocks in the buffer, objects are stepped(). This\r
 130             means they are active.\r
 131           - TODO: A global active buffer is needed for the server\r
 132       - TODO: All blocks going in and out of the buffer are recorded.\r
 133             - TODO: For outgoing blocks, a timestamp is written.\r
 134             - TODO: For incoming blocks, the time difference is calculated and\r
 135               objects are stepped according to it.\r
 136 TODO: A timestamp to blocks\r
 137 \r
 138 SUGG: Add a time value to the param of footstepped grass and check it\r
 139       against a global timer when a block is accessed, to make old\r
 140           steps fade away.\r
 141 \r
 142 TODO: Add config parameters for server's sending and generating distance\r
 143 \r
 144 TODO: Copy the text of the last picked sign to inventory in creative\r
 145       mode\r
 146 \r
 147 TODO: Untie client network operations from framerate\r
 148       - Needs some input queues or something\r
 149 \r
 150 SUGG: Make a copy of close-range environment on client for showing\r
 151       on screen, with minimal mutexes to slow down the main loop\r
 152 \r
 153 SUGG: Make a PACKET_COMBINED which contains many subpackets. Utilize\r
 154       it by sending more stuff in a single packet.\r
 155           - Add a packet queue to RemoteClient, from which packets will be\r
 156             combined with object data packets\r
 157                 - This is not exactly trivial: the object data packets are\r
 158                   sometimes very big by themselves\r
 159 \r
 160 SUGG: Split MapBlockObject serialization to to-client and to-disk\r
 161       - This will allow saving ages of rats on disk but not sending\r
 162             them to clients\r
 163 \r
 164 TODO: Get rid of GotSplitPacketException\r
 165 \r
 166 SUGG: Implement lighting using VoxelManipulator\r
 167       - Would it be significantly faster?\r
 168 \r
 169 TODO: Check what goes wrong with caching map to disk (Kray)\r
 170 \r
 171 TODO: Remove LazyMeshUpdater. It is not used as supposed.\r
 172 \r
 173 FIXME: Rats somehow go underground sometimes (you can see it in water)\r
 174        - Does their position get saved to a border value or something?\r
 175 \r
 176 SUGG: MovingObject::move and Player::move are basically the same.\r
 177       combine them.\r
 178 \r
 179 TODO: Transfer sign texts as metadata of block and not as data of\r
 180       object\r
 181 \r
 182 SUGG: Implement a "Fast check queue" (a queue with a map for checking\r
 183       if something is already in it)\r
 184       - TODO: Use it in active block queue in water flowing\r
 185 \r
 186 TODO: Proper looking torches.\r
 187       - Signs could be done in the same way?\r
 188 \r
 189 TODO: A mapper to map contents to tile names (for each side)\r
 190 \r
 191 Doing now:\r
 192 ======================================================================\r
 193 \r
 194 ======================================================================\r
 195 \r
 196 */\r
 197 \r
 198 /*\r
 199         Setting this to 1 enables a special camera mode that forces\r
 200         the renderers to think that the camera statically points from\r
 201         the starting place to a static direction.\r
 202 \r
 203         This allows one to move around with the player and see what\r
 204         is actually drawn behind solid things and behind the player.\r
 205 */\r
 206 #define FIELD_OF_VIEW_TEST 0\r
 207 \r
 208 #ifdef UNITTEST_DISABLE\r
 209         #ifdef _WIN32\r
 210                 #pragma message ("Disabling unit tests")\r
 211         #else\r
 212                 #warning "Disabling unit tests"\r
 213         #endif\r
 214         // Disable unit tests\r
 215         #define ENABLE_TESTS 0\r
 216 #else\r
 217         // Enable unit tests\r
 218         #define ENABLE_TESTS 1\r
 219 #endif\r
 220 \r
 221 #ifdef _MSC_VER\r
 222 #pragma comment(lib, "Irrlicht.lib")\r
 223 #pragma comment(lib, "jthread.lib")\r
 224 // This would get rid of the console window\r
 225 //#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")\r
 226 #endif\r
 227 \r
 228 #ifdef _WIN32\r
 229         #define WIN32_LEAN_AND_MEAN\r
 230         #include <windows.h>\r
 231         #define sleep_ms(x) Sleep(x)\r
 232 #else\r
 233         #include <unistd.h>\r
 234         #define sleep_ms(x) usleep(x*1000)\r
 235 #endif\r
 236 \r
 237 #include <iostream>\r
 238 #include <fstream>\r
 239 #include <time.h>\r
 240 #include <jmutexautolock.h>\r
 241 #include "common_irrlicht.h"\r
 242 #include "debug.h"\r
 243 #include "map.h"\r
 244 #include "player.h"\r
 245 #include "main.h"\r
 246 #include "test.h"\r
 247 #include "environment.h"\r
 248 #include "server.h"\r
 249 #include "client.h"\r
 250 #include "serialization.h"\r
 251 #include "constants.h"\r
 252 #include "strfnd.h"\r
 253 #include "porting.h"\r
 254 #include <locale.h>\r
 255 \r
 256 IrrlichtDevice *g_device = NULL;\r
 257 \r
 258 const char *g_content_filenames[MATERIALS_COUNT] =\r
 259 {\r
 260         "../data/stone.png",\r
 261         "../data/grass.png",\r
 262         "../data/water.png",\r
 263         "../data/torch_on_floor.png",\r
 264         "../data/tree.png",\r
 265         "../data/leaves.png",\r
 266         "../data/grass_footsteps.png",\r
 267         "../data/mese.png",\r
 268         "../data/mud.png",\r
 269         "../data/water.png", // CONTENT_OCEAN\r
 270 };\r
 271 \r
 272 // Material cache\r
 273 video::SMaterial g_materials[MATERIALS_COUNT];\r
 274 \r
 275 // Texture cache\r
 276 TextureCache g_texturecache;\r
 277 \r
 278 \r
 279 // All range-related stuff below is locked behind this\r
 280 JMutex g_range_mutex;\r
 281 \r
 282 // Blocks are viewed in this range from the player\r
 283 s16 g_viewing_range_nodes = 60;\r
 284 \r
 285 // This is updated by the client's fetchBlocks routine\r
 286 //s16 g_actual_viewing_range_nodes = VIEWING_RANGE_NODES_DEFAULT;\r
 287 \r
 288 // If true, the preceding value has no meaning and all blocks\r
 289 // already existing in memory are drawn\r
 290 bool g_viewing_range_all = false;\r
 291 \r
 292 // This is the freetime ratio imposed by the dynamic viewing\r
 293 // range changing code.\r
 294 // It is controlled by the main loop to the smallest value that\r
 295 // inhibits glitches (dtime jitter) in the main loop.\r
 296 //float g_freetime_ratio = FREETIME_RATIO_MAX;\r
 297 \r
 298 \r
 299 /*\r
 300         Settings.\r
 301         These are loaded from the config file.\r
 302 */\r
 303 \r
 304 Settings g_settings;\r
 305 \r
 306 // Sets default settings\r
 307 void set_default_settings()\r
 308 {\r
 309         g_settings.set("dedicated_server", "");\r
 310 \r
 311         // Client stuff\r
 312         g_settings.set("wanted_fps", "30");\r
 313         g_settings.set("fps_max", "60");\r
 314         g_settings.set("viewing_range_nodes_max", "300");\r
 315         g_settings.set("viewing_range_nodes_min", "20");\r
 316         g_settings.set("screenW", "");\r
 317         g_settings.set("screenH", "");\r
 318         g_settings.set("host_game", "");\r
 319         g_settings.set("port", "");\r
 320         g_settings.set("address", "");\r
 321         g_settings.set("name", "");\r
 322         g_settings.set("random_input", "false");\r
 323         g_settings.set("client_delete_unused_sectors_timeout", "1200");\r
 324         g_settings.set("max_block_send_distance", "8");\r
 325         g_settings.set("max_block_generate_distance", "6");\r
 326 \r
 327         // Server stuff\r
 328         g_settings.set("creative_mode", "false");\r
 329         g_settings.set("heightmap_blocksize", "32");\r
 330         g_settings.set("height_randmax", "constant 50.0");\r
 331         g_settings.set("height_randfactor", "constant 0.6");\r
 332         g_settings.set("height_base", "linear 0 0 0");\r
 333         g_settings.set("plants_amount", "1.0");\r
 334         g_settings.set("ravines_amount", "1.0");\r
 335         g_settings.set("objectdata_interval", "0.2");\r
 336         g_settings.set("active_object_range", "2");\r
 337         g_settings.set("max_simultaneous_block_sends_per_client", "1");\r
 338         g_settings.set("max_simultaneous_block_sends_server_total", "4");\r
 339         g_settings.set("disable_water_climb", "true");\r
 340         g_settings.set("endless_water", "true");\r
 341 }\r
 342 \r
 343 /*\r
 344         Random stuff\r
 345 */\r
 346 \r
 347 //u16 g_selected_material = 0;\r
 348 u16 g_selected_item = 0;\r
 349 \r
 350 bool g_esc_pressed = false;\r
 351 \r
 352 std::wstring g_text_buffer;\r
 353 bool g_text_buffer_accepted = false;\r
 354 \r
 355 // When true, the mouse and keyboard are grabbed\r
 356 bool g_game_focused = true;\r
 357 \r
 358 /*\r
 359         Debug streams\r
 360 */\r
 361 \r
 362 // Connection\r
 363 std::ostream *dout_con_ptr = &dummyout;\r
 364 std::ostream *derr_con_ptr = &dstream_no_stderr;\r
 365 //std::ostream *dout_con_ptr = &dstream_no_stderr;\r
 366 //std::ostream *derr_con_ptr = &dstream_no_stderr;\r
 367 //std::ostream *dout_con_ptr = &dstream;\r
 368 //std::ostream *derr_con_ptr = &dstream;\r
 369 \r
 370 // Server\r
 371 std::ostream *dout_server_ptr = &dstream;\r
 372 std::ostream *derr_server_ptr = &dstream;\r
 373 \r
 374 // Client\r
 375 std::ostream *dout_client_ptr = &dstream;\r
 376 std::ostream *derr_client_ptr = &dstream;\r
 377 \r
 378 \r
 379 /*\r
 380         Timestamp stuff\r
 381 */\r
 382 \r
 383 JMutex g_timestamp_mutex;\r
 384 //std::string g_timestamp;\r
 385 \r
 386 std::string getTimestamp()\r
 387 {\r
 388         if(g_timestamp_mutex.IsInitialized()==false)\r
 389                 return "";\r
 390         JMutexAutoLock lock(g_timestamp_mutex);\r
 391         //return g_timestamp;\r
 392         time_t t = time(NULL);\r
 393         struct tm *tm = localtime(&t);\r
 394         char cs[20];\r
 395         strftime(cs, 20, "%H:%M:%S", tm);\r
 396         return cs;\r
 397 }\r
 398 \r
 399 class MyEventReceiver : public IEventReceiver\r
 400 {\r
 401 public:\r
 402         // This is the one method that we have to implement\r
 403         virtual bool OnEvent(const SEvent& event)\r
 404         {\r
 405                 // Remember whether each key is down or up\r
 406                 if(event.EventType == irr::EET_KEY_INPUT_EVENT)\r
 407                 {\r
 408                         keyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;\r
 409 \r
 410                         if(event.KeyInput.PressedDown)\r
 411                         {\r
 412                                 //dstream<<"Pressed key: "<<(char)event.KeyInput.Key<<std::endl;\r
 413                                 if(g_game_focused == false)\r
 414                                 {\r
 415                                         s16 key = event.KeyInput.Key;\r
 416                                         if(key == irr::KEY_RETURN || key == irr::KEY_ESCAPE)\r
 417                                         {\r
 418                                                 g_text_buffer_accepted = true;\r
 419                                         }\r
 420                                         else if(key == irr::KEY_BACK)\r
 421                                         {\r
 422                                                 if(g_text_buffer.size() > 0)\r
 423                                                         g_text_buffer = g_text_buffer.substr\r
 424                                                                         (0, g_text_buffer.size()-1);\r
 425                                         }\r
 426                                         else\r
 427                                         {\r
 428                                                 wchar_t wc = event.KeyInput.Char;\r
 429                                                 if(wc != 0)\r
 430                                                         g_text_buffer += wc;\r
 431                                         }\r
 432                                 }\r
 433                                 \r
 434                                 if(event.KeyInput.Key == irr::KEY_ESCAPE)\r
 435                                 {\r
 436                                         if(g_game_focused == true)\r
 437                                         {\r
 438                                                 dstream<<DTIME<<"ESC pressed"<<std::endl;\r
 439                                                 g_esc_pressed = true;\r
 440                                         }\r
 441                                 }\r
 442 \r
 443                                 // Material selection\r
 444                                 if(event.KeyInput.Key == irr::KEY_KEY_F)\r
 445                                 {\r
 446                                         if(g_game_focused == true)\r
 447                                         {\r
 448                                                 if(g_selected_item < PLAYER_INVENTORY_SIZE-1)\r
 449                                                         g_selected_item++;\r
 450                                                 else\r
 451                                                         g_selected_item = 0;\r
 452                                                 dstream<<DTIME<<"Selected item: "\r
 453                                                                 <<g_selected_item<<std::endl;\r
 454                                         }\r
 455                                 }\r
 456 \r
 457                                 // Viewing range selection\r
 458                                 if(event.KeyInput.Key == irr::KEY_KEY_R\r
 459                                                 && g_game_focused)\r
 460                                 {\r
 461                                         JMutexAutoLock lock(g_range_mutex);\r
 462                                         if(g_viewing_range_all)\r
 463                                         {\r
 464                                                 g_viewing_range_all = false;\r
 465                                                 dstream<<DTIME<<"Disabled full viewing range"<<std::endl;\r
 466                                         }\r
 467                                         else\r
 468                                         {\r
 469                                                 g_viewing_range_all = true;\r
 470                                                 dstream<<DTIME<<"Enabled full viewing range"<<std::endl;\r
 471                                         }\r
 472                                 }\r
 473 \r
 474                                 // Print debug stacks\r
 475                                 if(event.KeyInput.Key == irr::KEY_KEY_P\r
 476                                                 && g_game_focused)\r
 477                                 {\r
 478                                         dstream<<"-----------------------------------------"\r
 479                                                         <<std::endl;\r
 480                                         dstream<<DTIME<<"Printing debug stacks:"<<std::endl;\r
 481                                         dstream<<"-----------------------------------------"\r
 482                                                         <<std::endl;\r
 483                                         debug_stacks_print();\r
 484                                 }\r
 485                         }\r
 486                 }\r
 487 \r
 488                 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)\r
 489                 {\r
 490                         if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)\r
 491                         {\r
 492                                 leftclicked = true;\r
 493                         }\r
 494                         if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)\r
 495                         {\r
 496                                 rightclicked = true;\r
 497                         }\r
 498                         if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)\r
 499                         {\r
 500                                 /*dstream<<"event.MouseInput.Wheel="\r
 501                                                 <<event.MouseInput.Wheel<<std::endl;*/\r
 502                                 if(event.MouseInput.Wheel < 0)\r
 503                                 {\r
 504                                         if(g_selected_item < PLAYER_INVENTORY_SIZE-1)\r
 505                                                 g_selected_item++;\r
 506                                         else\r
 507                                                 g_selected_item = 0;\r
 508                                 }\r
 509                                 else if(event.MouseInput.Wheel > 0)\r
 510                                 {\r
 511                                         if(g_selected_item > 0)\r
 512                                                 g_selected_item--;\r
 513                                         else\r
 514                                                 g_selected_item = PLAYER_INVENTORY_SIZE-1;\r
 515                                 }\r
 516                         }\r
 517                 }\r
 518 \r
 519                 return false;\r
 520         }\r
 521 \r
 522         // This is used to check whether a key is being held down\r
 523         virtual bool IsKeyDown(EKEY_CODE keyCode) const\r
 524         {\r
 525                 return keyIsDown[keyCode];\r
 526         }\r
 527 \r
 528         MyEventReceiver()\r
 529         {\r
 530                 for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)\r
 531                                 keyIsDown[i] = false;\r
 532                 leftclicked = false;\r
 533                 rightclicked = false;\r
 534         }\r
 535 \r
 536         bool leftclicked;\r
 537         bool rightclicked;\r
 538 private:\r
 539         // We use this array to store the current state of each key\r
 540         bool keyIsDown[KEY_KEY_CODES_COUNT];\r
 541         //s32 mouseX;\r
 542         //s32 mouseY;\r
 543 };\r
 544 \r
 545 class InputHandler\r
 546 {\r
 547 public:\r
 548         InputHandler()\r
 549         {\r
 550         }\r
 551         virtual ~InputHandler()\r
 552         {\r
 553         }\r
 554         virtual bool isKeyDown(EKEY_CODE keyCode) = 0;\r
 555         virtual v2s32 getMousePos() = 0;\r
 556         virtual void setMousePos(s32 x, s32 y) = 0;\r
 557         virtual bool getLeftClicked() = 0;\r
 558         virtual bool getRightClicked() = 0;\r
 559         virtual void resetLeftClicked() = 0;\r
 560         virtual void resetRightClicked() = 0;\r
 561         \r
 562         virtual void step(float dtime) {};\r
 563 \r
 564         virtual void clear() {};\r
 565 };\r
 566 \r
 567 InputHandler *g_input = NULL;\r
 568 \r
 569 void focusGame()\r
 570 {\r
 571         g_input->clear();\r
 572         g_game_focused = true;\r
 573 }\r
 574 \r
 575 void unFocusGame()\r
 576 {\r
 577         g_game_focused = false;\r
 578 }\r
 579 \r
 580 class RealInputHandler : public InputHandler\r
 581 {\r
 582 public:\r
 583         RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):\r
 584                 m_device(device),\r
 585                 m_receiver(receiver)\r
 586         {\r
 587         }\r
 588         virtual bool isKeyDown(EKEY_CODE keyCode)\r
 589         {\r
 590                 return m_receiver->IsKeyDown(keyCode);\r
 591         }\r
 592         virtual v2s32 getMousePos()\r
 593         {\r
 594                 return m_device->getCursorControl()->getPosition();\r
 595         }\r
 596         virtual void setMousePos(s32 x, s32 y)\r
 597         {\r
 598                 m_device->getCursorControl()->setPosition(x, y);\r
 599         }\r
 600 \r
 601         virtual bool getLeftClicked()\r
 602         {\r
 603                 if(g_game_focused == false)\r
 604                         return false;\r
 605                 return m_receiver->leftclicked;\r
 606         }\r
 607         virtual bool getRightClicked()\r
 608         {\r
 609                 if(g_game_focused == false)\r
 610                         return false;\r
 611                 return m_receiver->rightclicked;\r
 612         }\r
 613         virtual void resetLeftClicked()\r
 614         {\r
 615                 m_receiver->leftclicked = false;\r
 616         }\r
 617         virtual void resetRightClicked()\r
 618         {\r
 619                 m_receiver->rightclicked = false;\r
 620         }\r
 621 \r
 622         void clear()\r
 623         {\r
 624                 resetRightClicked();\r
 625                 resetLeftClicked();\r
 626         }\r
 627 private:\r
 628         IrrlichtDevice *m_device;\r
 629         MyEventReceiver *m_receiver;\r
 630 };\r
 631 \r
 632 class RandomInputHandler : public InputHandler\r
 633 {\r
 634 public:\r
 635         RandomInputHandler()\r
 636         {\r
 637                 leftclicked = false;\r
 638                 rightclicked = false;\r
 639                 for(u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)\r
 640                         keydown[i] = false;\r
 641         }\r
 642         virtual bool isKeyDown(EKEY_CODE keyCode)\r
 643         {\r
 644                 return keydown[keyCode];\r
 645         }\r
 646         virtual v2s32 getMousePos()\r
 647         {\r
 648                 return mousepos;\r
 649         }\r
 650         virtual void setMousePos(s32 x, s32 y)\r
 651         {\r
 652                 mousepos = v2s32(x,y);\r
 653         }\r
 654 \r
 655         virtual bool getLeftClicked()\r
 656         {\r
 657                 return leftclicked;\r
 658         }\r
 659         virtual bool getRightClicked()\r
 660         {\r
 661                 return rightclicked;\r
 662         }\r
 663         virtual void resetLeftClicked()\r
 664         {\r
 665                 leftclicked = false;\r
 666         }\r
 667         virtual void resetRightClicked()\r
 668         {\r
 669                 rightclicked = false;\r
 670         }\r
 671 \r
 672         virtual void step(float dtime)\r
 673         {\r
 674                 {\r
 675                         static float counter1 = 0;\r
 676                         counter1 -= dtime;\r
 677                         if(counter1 < 0.0)\r
 678                         {\r
 679                                 counter1 = 0.1*Rand(1,10);\r
 680                                 /*if(g_selected_material < USEFUL_CONTENT_COUNT-1)\r
 681                                         g_selected_material++;\r
 682                                 else\r
 683                                         g_selected_material = 0;*/\r
 684                                 if(g_selected_item < PLAYER_INVENTORY_SIZE-1)\r
 685                                         g_selected_item++;\r
 686                                 else\r
 687                                         g_selected_item = 0;\r
 688                         }\r
 689                 }\r
 690                 {\r
 691                         static float counter1 = 0;\r
 692                         counter1 -= dtime;\r
 693                         if(counter1 < 0.0)\r
 694                         {\r
 695                                 counter1 = 0.1*Rand(1, 40);\r
 696                                 keydown[irr::KEY_SPACE] = !keydown[irr::KEY_SPACE];\r
 697                         }\r
 698                 }\r
 699                 {\r
 700                         static float counter1 = 0;\r
 701                         counter1 -= dtime;\r
 702                         if(counter1 < 0.0)\r
 703                         {\r
 704                                 counter1 = 0.1*Rand(1, 40);\r
 705                                 keydown[irr::KEY_KEY_2] = !keydown[irr::KEY_KEY_2];\r
 706                         }\r
 707                 }\r
 708                 {\r
 709                         static float counter1 = 0;\r
 710                         counter1 -= dtime;\r
 711                         if(counter1 < 0.0)\r
 712                         {\r
 713                                 counter1 = 0.1*Rand(1, 40);\r
 714                                 keydown[irr::KEY_KEY_W] = !keydown[irr::KEY_KEY_W];\r
 715                         }\r
 716                 }\r
 717                 {\r
 718                         static float counter1 = 0;\r
 719                         counter1 -= dtime;\r
 720                         if(counter1 < 0.0)\r
 721                         {\r
 722                                 counter1 = 0.1*Rand(1, 40);\r
 723                                 keydown[irr::KEY_KEY_A] = !keydown[irr::KEY_KEY_A];\r
 724                         }\r
 725                 }\r
 726                 {\r
 727                         static float counter1 = 0;\r
 728                         counter1 -= dtime;\r
 729                         if(counter1 < 0.0)\r
 730                         {\r
 731                                 counter1 = 0.1*Rand(1, 20);\r
 732                                 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));\r
 733                         }\r
 734                 }\r
 735                 {\r
 736                         static float counter1 = 0;\r
 737                         counter1 -= dtime;\r
 738                         if(counter1 < 0.0)\r
 739                         {\r
 740                                 counter1 = 0.1*Rand(1, 30);\r
 741                                 leftclicked = true;\r
 742                         }\r
 743                 }\r
 744                 {\r
 745                         static float counter1 = 0;\r
 746                         counter1 -= dtime;\r
 747                         if(counter1 < 0.0)\r
 748                         {\r
 749                                 counter1 = 0.1*Rand(1, 20);\r
 750                                 rightclicked = true;\r
 751                         }\r
 752                 }\r
 753                 mousepos += mousespeed;\r
 754         }\r
 755 \r
 756         s32 Rand(s32 min, s32 max)\r
 757         {\r
 758                 return (rand()%(max-min+1))+min;\r
 759         }\r
 760 private:\r
 761         bool keydown[KEY_KEY_CODES_COUNT];\r
 762         v2s32 mousepos;\r
 763         v2s32 mousespeed;\r
 764         bool leftclicked;\r
 765         bool rightclicked;\r
 766 };\r
 767 \r
 768 void updateViewingRange(f32 frametime, Client *client)\r
 769 {\r
 770         // Range_all messes up frametime_avg\r
 771         if(g_viewing_range_all == true)\r
 772                 return;\r
 773 \r
 774         float wanted_fps = g_settings.getFloat("wanted_fps");\r
 775         \r
 776         // Initialize to the target value\r
 777         static float frametime_avg = 1.0/wanted_fps;\r
 778         frametime_avg = frametime_avg * 0.9 + frametime * 0.1;\r
 779 \r
 780         static f32 counter = 0;\r
 781         if(counter > 0){\r
 782                 counter -= frametime;\r
 783                 return;\r
 784         }\r
 785         //counter = 1.0; //seconds\r
 786         counter = 0.5; //seconds\r
 787 \r
 788         //float freetime_ratio = 0.2;\r
 789         //float freetime_ratio = 0.4;\r
 790         float freetime_ratio = FREETIME_RATIO;\r
 791 \r
 792         float frametime_wanted = (1.0/(wanted_fps/(1.0-freetime_ratio)));\r
 793 \r
 794         float fraction = sqrt(frametime_avg / frametime_wanted);\r
 795 \r
 796         static bool fraction_is_good = false;\r
 797         \r
 798         float fraction_good_threshold = 0.1;\r
 799         float fraction_bad_threshold = 0.25;\r
 800         float fraction_limit;\r
 801         // Use high limit if fraction is good AND the fraction would\r
 802         // lower the range. We want to keep the range fairly high.\r
 803         if(fraction_is_good && fraction > 1.0)\r
 804                 fraction_limit = fraction_bad_threshold;\r
 805         else\r
 806                 fraction_limit = fraction_good_threshold;\r
 807 \r
 808         if(fabs(fraction - 1.0) < fraction_limit)\r
 809         {\r
 810                 fraction_is_good = true;\r
 811                 return;\r
 812         }\r
 813         else\r
 814         {\r
 815                 fraction_is_good = false;\r
 816         }\r
 817 \r
 818         //dstream<<"frametime_avg="<<frametime_avg<<std::endl;\r
 819         //dstream<<"frametime_wanted="<<frametime_wanted<<std::endl;\r
 820         /*dstream<<"fetching="<<client->isFetchingBlocks()\r
 821                         <<" faction = "<<fraction<<std::endl;*/\r
 822 \r
 823         JMutexAutoLock lock(g_range_mutex);\r
 824         \r
 825         s16 viewing_range_nodes_min = g_settings.getS16("viewing_range_nodes_min");\r
 826         s16 viewing_range_nodes_max = g_settings.getS16("viewing_range_nodes_max");\r
 827 \r
 828         s16 n = (float)g_viewing_range_nodes / fraction;\r
 829         if(n < viewing_range_nodes_min)\r
 830                 n = viewing_range_nodes_min;\r
 831         if(n > viewing_range_nodes_max)\r
 832                 n = viewing_range_nodes_max;\r
 833 \r
 834         bool can_change = true;\r
 835 \r
 836         if(client->isFetchingBlocks() == true && n > g_viewing_range_nodes)\r
 837                 can_change = false;\r
 838         \r
 839         if(can_change)\r
 840                 g_viewing_range_nodes = n;\r
 841 \r
 842         /*dstream<<"g_viewing_range_nodes = "\r
 843                         <<g_viewing_range_nodes<<std::endl;*/\r
 844 }\r
 845 \r
 846 class GUIQuickInventory : public IEventReceiver\r
 847 {\r
 848 public:\r
 849         GUIQuickInventory(\r
 850                         gui::IGUIEnvironment* env,\r
 851                         gui::IGUIElement* parent,\r
 852                         v2s32 pos,\r
 853                         s32 itemcount,\r
 854                         Inventory *inventory):\r
 855                 m_itemcount(itemcount),\r
 856                 m_inventory(inventory)\r
 857         {\r
 858                 core::rect<s32> imgsize(0,0,48,48);\r
 859                 core::rect<s32> textsize(0,0,48,16);\r
 860                 v2s32 spacing(0, 64);\r
 861                 for(s32 i=0; i<m_itemcount; i++)\r
 862                 {\r
 863                         m_images.push_back(env->addImage(\r
 864                                 imgsize + pos + spacing*i\r
 865                         ));\r
 866                         m_images[i]->setScaleImage(true);\r
 867                         m_texts.push_back(env->addStaticText(\r
 868                                 L"",\r
 869                                 textsize + pos + spacing*i,\r
 870                                 false, false\r
 871                         ));\r
 872                         m_texts[i]->setBackgroundColor(\r
 873                                         video::SColor(128,0,0,0));\r
 874                         m_texts[i]->setTextAlignment(\r
 875                                         gui::EGUIA_CENTER,\r
 876                                         gui::EGUIA_UPPERLEFT);\r
 877                 }\r
 878         }\r
 879 \r
 880         virtual bool OnEvent(const SEvent& event)\r
 881         {\r
 882                 return false;\r
 883         }\r
 884 \r
 885         void setSelection(s32 i)\r
 886         {\r
 887                 m_selection = i;\r
 888         }\r
 889 \r
 890         void update()\r
 891         {\r
 892                 s32 start = 0;\r
 893 \r
 894                 start = m_selection - m_itemcount / 2;\r
 895 \r
 896                 for(s32 i=0; i<m_itemcount; i++)\r
 897                 {\r
 898                         s32 j = i + start;\r
 899 \r
 900                         if(j > (s32)m_inventory->getSize() - 1)\r
 901                                 j -= m_inventory->getSize();\r
 902                         if(j < 0)\r
 903                                 j += m_inventory->getSize();\r
 904                         \r
 905                         InventoryItem *item = m_inventory->getItem(j);\r
 906                         // Null items\r
 907                         if(item == NULL)\r
 908                         {\r
 909                                 m_images[i]->setImage(NULL);\r
 910 \r
 911                                 wchar_t t[10];\r
 912                                 if(m_selection == j)\r
 913                                         swprintf(t, 10, L"<-");\r
 914                                 else\r
 915                                         swprintf(t, 10, L"");\r
 916                                 m_texts[i]->setText(t);\r
 917 \r
 918                                 // The next ifs will segfault with a NULL pointer\r
 919                                 continue;\r
 920                         }\r
 921                         \r
 922                         \r
 923                         m_images[i]->setImage(item->getImage());\r
 924                         \r
 925                         wchar_t t[10];\r
 926                         if(m_selection == j)\r
 927                                 swprintf(t, 10, SWPRINTF_CHARSTRING L" <-", item->getText().c_str());\r
 928                         else\r
 929                                 swprintf(t, 10, SWPRINTF_CHARSTRING, item->getText().c_str());\r
 930                         m_texts[i]->setText(t);\r
 931                 }\r
 932         }\r
 933 \r
 934 private:\r
 935         s32 m_itemcount;\r
 936         core::array<gui::IGUIStaticText*> m_texts;\r
 937         core::array<gui::IGUIImage*> m_images;\r
 938         Inventory *m_inventory;\r
 939         s32 m_selection;\r
 940 };\r
 941 \r
 942 int main(int argc, char *argv[])\r
 943 {\r
 944         /*\r
 945                 Low-level initialization\r
 946         */\r
 947 \r
 948         bool disable_stderr = false;\r
 949 #ifdef _WIN32\r
 950         disable_stderr = true;\r
 951 #endif\r
 952 \r
 953         // Initialize debug streams\r
 954         debugstreams_init(disable_stderr, DEBUGFILE);\r
 955         // Initialize debug stacks\r
 956         debug_stacks_init();\r
 957 \r
 958         DSTACK(__FUNCTION_NAME);\r
 959 \r
 960         try\r
 961         {\r
 962         \r
 963         /*\r
 964                 Basic initialization\r
 965         */\r
 966 \r
 967         // Initialize default settings\r
 968         set_default_settings();\r
 969         \r
 970         // Print startup message\r
 971         dstream<<DTIME<<"minetest-c55"\r
 972                         " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST\r
 973                         <<", ENABLE_TESTS="<<ENABLE_TESTS\r
 974                         <<std::endl;\r
 975         \r
 976         // Set locale. This is for forcing '.' as the decimal point.\r
 977         std::locale::global(std::locale("C"));\r
 978         // This enables printing all characters in bitmap font\r
 979         setlocale(LC_CTYPE, "en_US");\r
 980 \r
 981         // Initialize sockets\r
 982         sockets_init();\r
 983         atexit(sockets_cleanup);\r
 984         \r
 985         // Initialize timestamp mutex\r
 986         g_timestamp_mutex.Init();\r
 987 \r
 988         /*\r
 989                 Run unit tests\r
 990         */\r
 991         if(ENABLE_TESTS)\r
 992         {\r
 993                 run_tests();\r
 994         }\r
 995         \r
 996         /*\r
 997                 Initialization\r
 998         */\r
 999 \r
1000         // Read config file\r
1001         \r
1002         if(argc >= 2)\r
1003         {\r
1004                 g_settings.readConfigFile(argv[1]);\r
1005         }\r
1006         else\r
1007         {\r
1008                 const char *filenames[2] =\r
1009                 {\r
1010                         "../minetest.conf",\r
1011                         "../../minetest.conf"\r
1012                 };\r
1013 \r
1014                 for(u32 i=0; i<2; i++)\r
1015                 {\r
1016                         bool r = g_settings.readConfigFile(filenames[i]);\r
1017                         if(r)\r
1018                                 break;\r
1019                 }\r
1020         }\r
1021 \r
1022         // Initialize random seed\r
1023         srand(time(0));\r
1024 \r
1025         g_range_mutex.Init();\r
1026         assert(g_range_mutex.IsInitialized());\r
1027 \r
1028         // Read map parameters from settings\r
1029 \r
1030         HMParams hm_params;\r
1031         hm_params.blocksize = g_settings.getU16("heightmap_blocksize");\r
1032         hm_params.randmax = g_settings.get("height_randmax");\r
1033         hm_params.randfactor = g_settings.get("height_randfactor");\r
1034         hm_params.base = g_settings.get("height_base");\r
1035 \r
1036         MapParams map_params;\r
1037         map_params.plants_amount = g_settings.getFloat("plants_amount");\r
1038         map_params.ravines_amount = g_settings.getFloat("ravines_amount");\r
1039 \r
1040         /*\r
1041                 Ask some stuff\r
1042         */\r
1043 \r
1044         std::cout<<std::endl<<std::endl;\r
1045         \r
1046         std::cout\r
1047         <<"        .__               __                   __   "<<std::endl\r
1048         <<"  _____ |__| ____   _____/  |_  ____   _______/  |_ "<<std::endl\r
1049         <<" /     \\|  |/    \\_/ __ \\   __\\/ __ \\ /  ___/\\   __\\"<<std::endl\r
1050         <<"|  Y Y  \\  |   |  \\  ___/|  | \\  ___/ \\___ \\  |  |  "<<std::endl\r
1051         <<"|__|_|  /__|___|  /\\___  >__|  \\___  >____  > |__|  "<<std::endl\r
1052         <<"      \\/        \\/     \\/          \\/     \\/        "<<std::endl\r
1053         <<std::endl\r
1054         <<"Now with more waterish water!"\r
1055         <<std::endl;\r
1056 \r
1057         std::cout<<std::endl;\r
1058         char templine[100];\r
1059         \r
1060         // Dedicated?\r
1061         bool dedicated = g_settings.getBoolAsk\r
1062                         ("dedicated_server", "Dedicated server?", false);\r
1063         std::cout<<"dedicated = "<<dedicated<<std::endl;\r
1064         \r
1065         // Port?\r
1066         u16 port = g_settings.getU16Ask("port", "Port", 30000);\r
1067         std::cout<<"-> "<<port<<std::endl;\r
1068         \r
1069         if(dedicated)\r
1070         {\r
1071                 DSTACK("Dedicated server branch");\r
1072                 \r
1073                 std::cout<<std::endl;\r
1074                 std::cout<<"========================"<<std::endl;\r
1075                 std::cout<<"Running dedicated server"<<std::endl;\r
1076                 std::cout<<"========================"<<std::endl;\r
1077                 std::cout<<std::endl;\r
1078 \r
1079                 Server server("../map", hm_params, map_params);\r
1080                 server.start(port);\r
1081         \r
1082                 for(;;)\r
1083                 {\r
1084                         // This is kind of a hack but can be done like this\r
1085                         // because server.step() is very light\r
1086                         sleep_ms(30);\r
1087                         server.step(0.030);\r
1088 \r
1089                         static int counter = 0;\r
1090                         counter--;\r
1091                         if(counter <= 0)\r
1092                         {\r
1093                                 counter = 10;\r
1094 \r
1095                                 core::list<PlayerInfo> list = server.getPlayerInfo();\r
1096                                 core::list<PlayerInfo>::Iterator i;\r
1097                                 static u32 sum_old = 0;\r
1098                                 u32 sum = PIChecksum(list);\r
1099                                 if(sum != sum_old)\r
1100                                 {\r
1101                                         std::cout<<DTIME<<"Player info:"<<std::endl;\r
1102                                         for(i=list.begin(); i!=list.end(); i++)\r
1103                                         {\r
1104                                                 i->PrintLine(&std::cout);\r
1105                                         }\r
1106                                 }\r
1107                                 sum_old = sum;\r
1108                         }\r
1109                 }\r
1110 \r
1111                 return 0;\r
1112         }\r
1113 \r
1114         bool hosting = false;\r
1115         char connect_name[100] = "";\r
1116 \r
1117         std::cout<<"Address to connect to [empty = host a game]: ";\r
1118         if(g_settings.get("address") != "" && is_yes(g_settings.get("host_game")) == false)\r
1119         {\r
1120                 std::cout<<g_settings.get("address")<<std::endl;\r
1121                 snprintf(connect_name, 100, "%s", g_settings.get("address").c_str());\r
1122         }\r
1123         else\r
1124         {\r
1125                 std::cin.getline(connect_name, 100);\r
1126         }\r
1127         \r
1128         if(connect_name[0] == 0){\r
1129                 snprintf(connect_name, 100, "127.0.0.1");\r
1130                 hosting = true;\r
1131         }\r
1132         \r
1133         if(hosting)\r
1134                 std::cout<<"-> hosting"<<std::endl;\r
1135         else\r
1136                 std::cout<<"-> "<<connect_name<<std::endl;\r
1137         \r
1138         char playername[PLAYERNAME_SIZE] = "";\r
1139         if(g_settings.get("name") != "")\r
1140         {\r
1141                 snprintf(playername, PLAYERNAME_SIZE, "%s", g_settings.get("name").c_str());\r
1142         }\r
1143         else\r
1144         {\r
1145                 std::cout<<"Name of player: ";\r
1146                 std::cin.getline(playername, PLAYERNAME_SIZE);\r
1147         }\r
1148         std::cout<<"-> \""<<playername<<"\""<<std::endl;\r
1149 \r
1150         /*\r
1151                 Resolution selection\r
1152         */\r
1153 \r
1154         u16 screenW;\r
1155         u16 screenH;\r
1156         bool fullscreen = false;\r
1157         \r
1158         if(g_settings.get("screenW") != "" && g_settings.get("screenH") != "")\r
1159         {\r
1160                 screenW = atoi(g_settings.get("screenW").c_str());\r
1161                 screenH = atoi(g_settings.get("screenH").c_str());\r
1162         }\r
1163         else\r
1164         {\r
1165                 u16 resolutions[][3] = {\r
1166                         //W, H, fullscreen\r
1167                         {640,480, 0},\r
1168                         {800,600, 0},\r
1169                         {1024,768, 0},\r
1170                         {1280,1024, 0},\r
1171                         /*{640,480, 1},\r
1172                         {800,600, 1},\r
1173                         {1024,768, 1},\r
1174                         {1280,1024, 1},*/\r
1175                 };\r
1176 \r
1177                 u16 res_count = sizeof(resolutions)/sizeof(resolutions[0]);\r
1178                 \r
1179                 for(u16 i=0; i<res_count; i++)\r
1180                 {\r
1181                         std::cout<<(i+1)<<": "<<resolutions[i][0]<<"x"\r
1182                                         <<resolutions[i][1];\r
1183                         if(resolutions[i][2])\r
1184                                 std::cout<<" fullscreen"<<std::endl;\r
1185                         else\r
1186                                 std::cout<<" windowed"<<std::endl;\r
1187                 }\r
1188                 std::cout<<"Select a window resolution number [empty = 2]: ";\r
1189                 std::cin.getline(templine, 100);\r
1190 \r
1191                 u16 r0;\r
1192                 if(templine[0] == 0)\r
1193                         r0 = 2;\r
1194                 else\r
1195                         r0 = atoi(templine);\r
1196 \r
1197                 if(r0 > res_count || r0 == 0)\r
1198                         r0 = 2;\r
1199                 \r
1200                 {\r
1201                         u16 i = r0-1;\r
1202                         std::cout<<"-> ";\r
1203                         std::cout<<(i+1)<<": "<<resolutions[i][0]<<"x"\r
1204                                         <<resolutions[i][1];\r
1205                         if(resolutions[i][2])\r
1206                                 std::cout<<" fullscreen"<<std::endl;\r
1207                         else\r
1208                                 std::cout<<" windowed"<<std::endl;\r
1209                 }\r
1210 \r
1211                 screenW = resolutions[r0-1][0];\r
1212                 screenH = resolutions[r0-1][1];\r
1213                 fullscreen = resolutions[r0-1][2];\r
1214         }\r
1215 \r
1216         //\r
1217 \r
1218         MyEventReceiver receiver;\r
1219 \r
1220         video::E_DRIVER_TYPE driverType;\r
1221 \r
1222 #ifdef _WIN32\r
1223         //driverType = video::EDT_DIRECT3D9; // Doesn't seem to work\r
1224         driverType = video::EDT_OPENGL;\r
1225 #else\r
1226         driverType = video::EDT_OPENGL;\r
1227 #endif\r
1228 \r
1229         // create device and exit if creation failed\r
1230 \r
1231         IrrlichtDevice *device;\r
1232         device = createDevice(driverType,\r
1233                         core::dimension2d<u32>(screenW, screenH),\r
1234                         16, fullscreen, false, false, &receiver);\r
1235         // With vsync\r
1236         /*device = createDevice(driverType,\r
1237                         core::dimension2d<u32>(screenW, screenH),\r
1238                         16, fullscreen, false, true, &receiver);*/\r
1239 \r
1240         if (device == 0)\r
1241                 return 1; // could not create selected driver.\r
1242 \r
1243         g_device = device;\r
1244         \r
1245         device->setResizable(true);\r
1246 \r
1247         if(g_settings.getBool("random_input"))\r
1248                 g_input = new RandomInputHandler();\r
1249         else\r
1250                 g_input = new RealInputHandler(device, &receiver);\r
1251         \r
1252         /*\r
1253                 Continue initialization\r
1254         */\r
1255 \r
1256         video::IVideoDriver* driver = device->getVideoDriver();\r
1257         // These make the textures not to show at all\r
1258         //driver->setTextureCreationFlag(video::ETCF_ALWAYS_16_BIT);\r
1259         //driver->setTextureCreationFlag(video::ETCF_OPTIMIZED_FOR_SPEED );\r
1260 \r
1261         //driver->setMinHardwareBufferVertexCount(1);\r
1262 \r
1263         scene::ISceneManager* smgr = device->getSceneManager();\r
1264 \r
1265         gui::IGUIEnvironment* guienv = device->getGUIEnvironment();\r
1266         gui::IGUISkin* skin = guienv->getSkin();\r
1267         gui::IGUIFont* font = guienv->getFont("../data/fontlucida.png");\r
1268         if(font)\r
1269                 skin->setFont(font);\r
1270         //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));\r
1271         skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));\r
1272         //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));\r
1273         //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));\r
1274         skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));\r
1275         skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));\r
1276         \r
1277         const wchar_t *text = L"Loading and connecting...";\r
1278         core::vector2d<s32> center(screenW/2, screenH/2);\r
1279         core::dimension2d<u32> textd = font->getDimension(text);\r
1280         std::cout<<DTIME<<"Text w="<<textd.Width<<" h="<<textd.Height<<std::endl;\r
1281         // Have to add a bit to disable the text from word wrapping\r
1282         //core::vector2d<s32> textsize(textd.Width+4, textd.Height);\r
1283         core::vector2d<s32> textsize(300, textd.Height);\r
1284         core::rect<s32> textrect(center - textsize/2, center + textsize/2);\r
1285 \r
1286         gui::IGUIStaticText *gui_loadingtext = guienv->addStaticText(\r
1287                         text, textrect, false, false);\r
1288         gui_loadingtext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);\r
1289 \r
1290         driver->beginScene(true, true, video::SColor(255,0,0,0));\r
1291         guienv->drawAll();\r
1292         driver->endScene();\r
1293 \r
1294         /*\r
1295                 Initialize material array\r
1296         */\r
1297 \r
1298         //video::SMaterial g_materials[MATERIALS_COUNT];\r
1299         for(u16 i=0; i<MATERIALS_COUNT; i++)\r
1300         {\r
1301                 g_materials[i].Lighting = false;\r
1302                 g_materials[i].BackfaceCulling = false;\r
1303 \r
1304                 const char *filename = g_content_filenames[i];\r
1305                 if(filename != NULL){\r
1306                         video::ITexture *t = driver->getTexture(filename);\r
1307                         if(t == NULL){\r
1308                                 std::cout<<DTIME<<"Texture could not be loaded: \""\r
1309                                                 <<filename<<"\""<<std::endl;\r
1310                                 return 1;\r
1311                         }\r
1312                         g_materials[i].setTexture(0, driver->getTexture(filename));\r
1313                 }\r
1314                 //g_materials[i].setFlag(video::EMF_TEXTURE_WRAP, video::ETC_REPEAT);\r
1315                 g_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);\r
1316                 //g_materials[i].setFlag(video::EMF_ANISOTROPIC_FILTER, false);\r
1317                 //g_materials[i].setFlag(video::EMF_FOG_ENABLE, true);\r
1318         }\r
1319 \r
1320         g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;\r
1321         //g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;\r
1322         g_materials[CONTENT_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;\r
1323 \r
1324         /*g_mesh_materials[0].setTexture(0, driver->getTexture("../data/water.png"));\r
1325         g_mesh_materials[1].setTexture(0, driver->getTexture("../data/grass.png"));\r
1326         g_mesh_materials[2].setTexture(0, driver->getTexture("../data/stone.png"));\r
1327         for(u32 i=0; i<3; i++)\r
1328         {\r
1329                 g_mesh_materials[i].Lighting = false;\r
1330                 g_mesh_materials[i].BackfaceCulling = false;\r
1331                 g_mesh_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);\r
1332                 g_mesh_materials[i].setFlag(video::EMF_FOG_ENABLE, true);\r
1333         }*/\r
1334 \r
1335         /*\r
1336                 Preload some random textures that are used in threads\r
1337         */\r
1338         \r
1339         g_texturecache.set("torch", driver->getTexture("../data/torch.png"));\r
1340         g_texturecache.set("torch_on_floor", driver->getTexture("../data/torch_on_floor.png"));\r
1341         g_texturecache.set("torch_on_ceiling", driver->getTexture("../data/torch_on_ceiling.png"));\r
1342 \r
1343         /*\r
1344                 Make a scope here for the client so that it gets removed\r
1345                 before the irrlicht device\r
1346         */\r
1347         {\r
1348 \r
1349         std::cout<<DTIME<<"Creating server and client"<<std::endl;\r
1350         \r
1351         /*\r
1352                 Create server\r
1353         */\r
1354         SharedPtr<Server> server;\r
1355         if(hosting){\r
1356                 server = new Server("../map", hm_params, map_params);\r
1357                 server->start(port);\r
1358         }\r
1359         \r
1360         /*\r
1361                 Create client\r
1362         */\r
1363 \r
1364         // TODO: Get rid of the g_materials parameter or it's globalness\r
1365         Client client(device, g_materials,\r
1366                         g_settings.getFloat("client_delete_unused_sectors_timeout"),\r
1367                         playername);\r
1368         \r
1369         Address connect_address(0,0,0,0, port);\r
1370         try{\r
1371                 connect_address.Resolve(connect_name);\r
1372         }\r
1373         catch(ResolveError &e)\r
1374         {\r
1375                 std::cout<<DTIME<<"Couldn't resolve address"<<std::endl;\r
1376                 return 0;\r
1377         }\r
1378         \r
1379         std::cout<<DTIME<<"Connecting to server..."<<std::endl;\r
1380         client.connect(connect_address);\r
1381         \r
1382         try{\r
1383                 while(client.connectedAndInitialized() == false)\r
1384                 {\r
1385                         client.step(0.1);\r
1386                         if(server != NULL){\r
1387                                 server->step(0.1);\r
1388                         }\r
1389                         sleep_ms(100);\r
1390                 }\r
1391         }\r
1392         catch(con::PeerNotFoundException &e)\r
1393         {\r
1394                 std::cout<<DTIME<<"Timed out."<<std::endl;\r
1395                 return 0;\r
1396         }\r
1397 \r
1398         /*\r
1399                 Create skybox\r
1400         */\r
1401         scene::ISceneNode* skybox = smgr->addSkyBoxSceneNode(\r
1402                 driver->getTexture("../data/skybox2.png"),\r
1403                 driver->getTexture("../data/skybox3.png"),\r
1404                 driver->getTexture("../data/skybox1.png"),\r
1405                 driver->getTexture("../data/skybox1.png"),\r
1406                 driver->getTexture("../data/skybox1.png"),\r
1407                 driver->getTexture("../data/skybox1.png"));\r
1408         /*      driver->getTexture("../data/irrlicht2_up.jpg"),\r
1409                 driver->getTexture("../data/irrlicht2_dn.jpg"),\r
1410                 driver->getTexture("../data/irrlicht2_lf.jpg"),\r
1411                 driver->getTexture("../data/irrlicht2_rt.jpg"),\r
1412                 driver->getTexture("../data/irrlicht2_ft.jpg"),\r
1413                 driver->getTexture("../data/irrlicht2_bk.jpg"));*/\r
1414         \r
1415         /*\r
1416                 Create the camera node\r
1417         */\r
1418 \r
1419         scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(\r
1420                 0, // Camera parent\r
1421                 v3f(BS*100, BS*2, BS*100), // Look from\r
1422                 v3f(BS*100+1, BS*2, BS*100), // Look to\r
1423                 -1 // Camera ID\r
1424         );\r
1425 \r
1426         if(camera == NULL)\r
1427                 return 1;\r
1428         \r
1429         video::SColor skycolor = video::SColor(255,90,140,200);\r
1430 \r
1431         camera->setFOV(FOV_ANGLE);\r
1432 \r
1433         // Just so big a value that everything rendered is visible\r
1434         camera->setFarValue(100000*BS);\r
1435 \r
1436         /*//f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;\r
1437         f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;\r
1438         \r
1439         camera->setFarValue(range);\r
1440         \r
1441         driver->setFog(\r
1442                 skycolor,\r
1443                 video::EFT_FOG_LINEAR,\r
1444                 range*0.8,\r
1445                 range,\r
1446                 0.01,\r
1447                 false,\r
1448                 false\r
1449                 );*/\r
1450         \r
1451         f32 camera_yaw = 0; // "right/left"\r
1452         f32 camera_pitch = 0; // "up/down"\r
1453         \r
1454         gui_loadingtext->remove();\r
1455 \r
1456         /*\r
1457                 Add some gui stuff\r
1458         */\r
1459         \r
1460         // First line of debug text\r
1461         gui::IGUIStaticText *guitext = guienv->addStaticText(\r
1462                         L"Minetest-c55",\r
1463                         core::rect<s32>(5, 5, 5+600, 5+textsize.Y),\r
1464                         false, false);\r
1465         // Second line of debug text\r
1466         gui::IGUIStaticText *guitext2 = guienv->addStaticText(\r
1467                         L"",\r
1468                         core::rect<s32>(5, 5+(textsize.Y+5)*1, 5+600, (5+textsize.Y)*2),\r
1469                         false, false);\r
1470         \r
1471         // At the middle of the screen\r
1472         // Object infos are shown in this\r
1473         gui::IGUIStaticText *guitext_info = guienv->addStaticText(\r
1474                         L"test",\r
1475                         core::rect<s32>(100, 70, 100+400, 70+(textsize.Y+5)),\r
1476                         false, false);\r
1477         \r
1478         // This is a copy of the inventory that the client's environment has\r
1479         Inventory local_inventory(PLAYER_INVENTORY_SIZE);\r
1480         \r
1481         GUIQuickInventory *quick_inventory = new GUIQuickInventory\r
1482                         (guienv, NULL, v2s32(10, 70), 5, &local_inventory);\r
1483         \r
1484         /*\r
1485                 Some statistics are collected in these\r
1486         */\r
1487         u32 drawtime = 0;\r
1488         u32 scenetime = 0;\r
1489         u32 endscenetime = 0;\r
1490 \r
1491         /*\r
1492                 Text input system\r
1493         */\r
1494         \r
1495         struct TextDest\r
1496         {\r
1497                 virtual void sendText(std::string text) = 0;\r
1498         };\r
1499         \r
1500         struct TextDestSign : public TextDest\r
1501         {\r
1502                 TextDestSign(v3s16 blockpos, s16 id, Client *client)\r
1503                 {\r
1504                         m_blockpos = blockpos;\r
1505                         m_id = id;\r
1506                         m_client = client;\r
1507                 }\r
1508                 void sendText(std::string text)\r
1509                 {\r
1510                         dstream<<"Changing text of a sign object: "\r
1511                                         <<text<<std::endl;\r
1512                         m_client->sendSignText(m_blockpos, m_id, text);\r
1513                 }\r
1514 \r
1515                 v3s16 m_blockpos;\r
1516                 s16 m_id;\r
1517                 Client *m_client;\r
1518         };\r
1519 \r
1520         TextDest *textbuf_dest = NULL;\r
1521         \r
1522         //gui::IGUIWindow* input_window = NULL;\r
1523         gui::IGUIStaticText* input_guitext = NULL;\r
1524 \r
1525         /*\r
1526                 Main loop\r
1527         */\r
1528 \r
1529         bool first_loop_after_window_activation = true;\r
1530 \r
1531         // Time is in milliseconds\r
1532         // NOTE: getRealTime() without run()s causes strange problems in wine\r
1533         // NOTE: Have to call run() between calls of this to update the timer\r
1534         u32 lasttime = device->getTimer()->getTime();\r
1535 \r
1536         while(device->run())\r
1537         {\r
1538                 // Hilight boxes collected during the loop and displayed\r
1539                 core::list< core::aabbox3d<f32> > hilightboxes;\r
1540                 \r
1541                 // Info text\r
1542                 std::wstring infotext;\r
1543 \r
1544                 //TimeTaker //timer1("//timer1", device);\r
1545                 \r
1546                 // Time of frame without fps limit\r
1547                 float busytime;\r
1548                 u32 busytime_u32;\r
1549                 {\r
1550                         // not using getRealTime is necessary for wine\r
1551                         u32 time = device->getTimer()->getTime();\r
1552                         if(time > lasttime)\r
1553                                 busytime_u32 = time - lasttime;\r
1554                         else\r
1555                                 busytime_u32 = 0;\r
1556                         busytime = busytime_u32 / 1000.0;\r
1557                 }\r
1558 \r
1559                 //std::cout<<"busytime_u32="<<busytime_u32<<std::endl;\r
1560         \r
1561                 // Absolutelu necessary for wine!\r
1562                 device->run();\r
1563 \r
1564                 /*\r
1565                         Viewing range\r
1566                 */\r
1567                 \r
1568                 //updateViewingRange(dtime, &client);\r
1569                 updateViewingRange(busytime, &client);\r
1570                 \r
1571                 /*\r
1572                         FPS limiter\r
1573                 */\r
1574 \r
1575                 {\r
1576                         float fps_max = g_settings.getFloat("fps_max");\r
1577                         u32 frametime_min = 1000./fps_max;\r
1578                         \r
1579                         if(busytime_u32 < frametime_min)\r
1580                         {\r
1581                                 u32 sleeptime = frametime_min - busytime_u32;\r
1582                                 device->sleep(sleeptime);\r
1583                         }\r
1584                 }\r
1585 \r
1586                 // Absolutelu necessary for wine!\r
1587                 device->run();\r
1588 \r
1589                 /*\r
1590                         Time difference calculation\r
1591                 */\r
1592                 f32 dtime; // in seconds\r
1593                 \r
1594                 u32 time = device->getTimer()->getTime();\r
1595                 if(time > lasttime)\r
1596                         dtime = (time - lasttime) / 1000.0;\r
1597                 else\r
1598                         dtime = 0;\r
1599                 lasttime = time;\r
1600 \r
1601                 /*\r
1602                         Time average and jitter calculation\r
1603                 */\r
1604 \r
1605                 static f32 dtime_avg1 = 0.0;\r
1606                 dtime_avg1 = dtime_avg1 * 0.98 + dtime * 0.02;\r
1607                 f32 dtime_jitter1 = dtime - dtime_avg1;\r
1608 \r
1609                 static f32 dtime_jitter1_max_sample = 0.0;\r
1610                 static f32 dtime_jitter1_max_fraction = 0.0;\r
1611                 {\r
1612                         static f32 jitter1_max = 0.0;\r
1613                         static f32 counter = 0.0;\r
1614                         if(dtime_jitter1 > jitter1_max)\r
1615                                 jitter1_max = dtime_jitter1;\r
1616                         counter += dtime;\r
1617                         if(counter > 0.0)\r
1618                         {\r
1619                                 counter -= 3.0;\r
1620                                 dtime_jitter1_max_sample = jitter1_max;\r
1621                                 dtime_jitter1_max_fraction\r
1622                                                 = dtime_jitter1_max_sample / (dtime_avg1+0.001);\r
1623                                 jitter1_max = 0.0;\r
1624                                 \r
1625                                 /*\r
1626                                         Control freetime ratio\r
1627                                 */\r
1628                                 /*if(dtime_jitter1_max_fraction > DTIME_JITTER_MAX_FRACTION)\r
1629                                 {\r
1630                                         if(g_freetime_ratio < FREETIME_RATIO_MAX)\r
1631                                                 g_freetime_ratio += 0.01;\r
1632                                 }\r
1633                                 else\r
1634                                 {\r
1635                                         if(g_freetime_ratio > FREETIME_RATIO_MIN)\r
1636                                                 g_freetime_ratio -= 0.01;\r
1637                                 }*/\r
1638                         }\r
1639                 }\r
1640                 \r
1641                 /*\r
1642                         Busytime average and jitter calculation\r
1643                 */\r
1644 \r
1645                 static f32 busytime_avg1 = 0.0;\r
1646                 busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;\r
1647                 f32 busytime_jitter1 = busytime - busytime_avg1;\r
1648                 \r
1649                 static f32 busytime_jitter1_max_sample = 0.0;\r
1650                 static f32 busytime_jitter1_min_sample = 0.0;\r
1651                 {\r
1652                         static f32 jitter1_max = 0.0;\r
1653                         static f32 jitter1_min = 0.0;\r
1654                         static f32 counter = 0.0;\r
1655                         if(busytime_jitter1 > jitter1_max)\r
1656                                 jitter1_max = busytime_jitter1;\r
1657                         if(busytime_jitter1 < jitter1_min)\r
1658                                 jitter1_min = busytime_jitter1;\r
1659                         counter += dtime;\r
1660                         if(counter > 0.0){\r
1661                                 counter -= 3.0;\r
1662                                 busytime_jitter1_max_sample = jitter1_max;\r
1663                                 busytime_jitter1_min_sample = jitter1_min;\r
1664                                 jitter1_max = 0.0;\r
1665                                 jitter1_min = 0.0;\r
1666                         }\r
1667                 }\r
1668                 \r
1669                 /*\r
1670                         Debug info for client\r
1671                 */\r
1672                 {\r
1673                         static float counter = 0.0;\r
1674                         counter -= dtime;\r
1675                         if(counter < 0)\r
1676                         {\r
1677                                 counter = 30.0;\r
1678                                 client.printDebugInfo(std::cout);\r
1679                         }\r
1680                 }\r
1681 \r
1682                 /*\r
1683                         Input handler step()\r
1684                 */\r
1685                 g_input->step(dtime);\r
1686 \r
1687                 /*\r
1688                         Special keys\r
1689                 */\r
1690                 if(g_esc_pressed)\r
1691                 {\r
1692                         break;\r
1693                 }\r
1694 \r
1695                 /*\r
1696                         Player speed control\r
1697                 */\r
1698                 \r
1699                 if(g_game_focused)\r
1700                 {\r
1701                         /*bool a_up,\r
1702                         bool a_down,\r
1703                         bool a_left,\r
1704                         bool a_right,\r
1705                         bool a_jump,\r
1706                         bool a_superspeed,\r
1707                         float a_pitch,\r
1708                         float a_yaw*/\r
1709                         PlayerControl control(\r
1710                                 g_input->isKeyDown(irr::KEY_KEY_W),\r
1711                                 g_input->isKeyDown(irr::KEY_KEY_S),\r
1712                                 g_input->isKeyDown(irr::KEY_KEY_A),\r
1713                                 g_input->isKeyDown(irr::KEY_KEY_D),\r
1714                                 g_input->isKeyDown(irr::KEY_SPACE),\r
1715                                 g_input->isKeyDown(irr::KEY_KEY_2),\r
1716                                 camera_pitch,\r
1717                                 camera_yaw\r
1718                         );\r
1719                         client.setPlayerControl(control);\r
1720                 }\r
1721                 else\r
1722                 {\r
1723                         // Set every key to inactive\r
1724                         PlayerControl control;\r
1725                         client.setPlayerControl(control);\r
1726                 }\r
1727 \r
1728                 //timer1.stop();\r
1729                 /*\r
1730                         Process environment\r
1731                 */\r
1732                 \r
1733                 {\r
1734                         //TimeTaker timer("client.step(dtime)", device);\r
1735                         client.step(dtime);\r
1736                         //client.step(dtime_avg1);\r
1737                 }\r
1738 \r
1739                 if(server != NULL)\r
1740                 {\r
1741                         //TimeTaker timer("server->step(dtime)", device);\r
1742                         server->step(dtime);\r
1743                 }\r
1744 \r
1745                 v3f player_position = client.getPlayerPosition();\r
1746                 \r
1747                 //TimeTaker //timer2("//timer2", device);\r
1748 \r
1749                 /*\r
1750                         Mouse and camera control\r
1751                 */\r
1752                 \r
1753                 if(device->isWindowActive() && g_game_focused)\r
1754                 {\r
1755                         device->getCursorControl()->setVisible(false);\r
1756 \r
1757                         if(first_loop_after_window_activation){\r
1758                                 //std::cout<<"window active, first loop"<<std::endl;\r
1759                                 first_loop_after_window_activation = false;\r
1760                         }\r
1761                         else{\r
1762                                 s32 dx = g_input->getMousePos().X - 320;\r
1763                                 s32 dy = g_input->getMousePos().Y - 240;\r
1764                                 //std::cout<<"window active, pos difference "<<dx<<","<<dy<<std::endl;\r
1765                                 camera_yaw -= dx*0.2;\r
1766                                 camera_pitch += dy*0.2;\r
1767                                 if(camera_pitch < -89.5) camera_pitch = -89.5;\r
1768                                 if(camera_pitch > 89.5) camera_pitch = 89.5;\r
1769                         }\r
1770                         g_input->setMousePos(320, 240);\r
1771                 }\r
1772                 else{\r
1773                         device->getCursorControl()->setVisible(true);\r
1774 \r
1775                         //std::cout<<"window inactive"<<std::endl;\r
1776                         first_loop_after_window_activation = true;\r
1777                 }\r
1778 \r
1779                 camera_yaw = wrapDegrees(camera_yaw);\r
1780                 camera_pitch = wrapDegrees(camera_pitch);\r
1781                 \r
1782                 v3f camera_direction = v3f(0,0,1);\r
1783                 camera_direction.rotateYZBy(camera_pitch);\r
1784                 camera_direction.rotateXZBy(camera_yaw);\r
1785 \r
1786                 v3f camera_position =\r
1787                                 player_position + v3f(0, BS+BS/2, 0);\r
1788 \r
1789                 camera->setPosition(camera_position);\r
1790                 // *100.0 helps in large map coordinates\r
1791                 camera->setTarget(camera_position + camera_direction * 100.0);\r
1792 \r
1793                 if(FIELD_OF_VIEW_TEST){\r
1794                         //client.m_env.getMap().updateCamera(v3f(0,0,0), v3f(0,0,1));\r
1795                         client.updateCamera(v3f(0,0,0), v3f(0,0,1));\r
1796                 }\r
1797                 else{\r
1798                         //client.m_env.getMap().updateCamera(camera_position, camera_direction);\r
1799                         //TimeTaker timer("client.updateCamera", device);\r
1800                         client.updateCamera(camera_position, camera_direction);\r
1801                 }\r
1802                 \r
1803                 //timer2.stop();\r
1804                 //TimeTaker //timer3("//timer3", device);\r
1805 \r
1806                 /*\r
1807                         Calculate what block is the crosshair pointing to\r
1808                 */\r
1809                 \r
1810                 //u32 t1 = device->getTimer()->getRealTime();\r
1811                 \r
1812                 //f32 d = 4; // max. distance\r
1813                 f32 d = 4; // max. distance\r
1814                 core::line3d<f32> shootline(camera_position,\r
1815                                 camera_position + camera_direction * BS * (d+1));\r
1816 \r
1817                 MapBlockObject *selected_object = client.getSelectedObject\r
1818                                 (d*BS, camera_position, shootline);\r
1819 \r
1820                 if(selected_object != NULL)\r
1821                 {\r
1822                         //dstream<<"Client returned selected_object != NULL"<<std::endl;\r
1823 \r
1824                         core::aabbox3d<f32> box_on_map\r
1825                                         = selected_object->getSelectionBoxOnMap();\r
1826 \r
1827                         hilightboxes.push_back(box_on_map);\r
1828 \r
1829                         infotext = narrow_to_wide(selected_object->infoText());\r
1830 \r
1831                         if(g_input->getLeftClicked())\r
1832                         {\r
1833                                 std::cout<<DTIME<<"Left-clicked object"<<std::endl;\r
1834                                 client.clickObject(0, selected_object->getBlock()->getPos(),\r
1835                                                 selected_object->getId(), g_selected_item);\r
1836                         }\r
1837                         else if(g_input->getRightClicked())\r
1838                         {\r
1839                                 std::cout<<DTIME<<"Right-clicked object"<<std::endl;\r
1840                                 /*\r
1841                                         Check if we want to modify the object ourselves\r
1842                                 */\r
1843                                 if(selected_object->getTypeId() == MAPBLOCKOBJECT_TYPE_SIGN)\r
1844                                 {\r
1845                                         dstream<<"Sign object right-clicked"<<std::endl;\r
1846 \r
1847                                         unFocusGame();\r
1848 \r
1849                                         input_guitext = guienv->addStaticText(L"",\r
1850                                                         core::rect<s32>(150,100,350,120),\r
1851                                                         true, // border?\r
1852                                                         false, // wordwrap?\r
1853                                                         NULL);\r
1854 \r
1855                                         input_guitext->setDrawBackground(true);\r
1856 \r
1857                                         g_text_buffer = L"";\r
1858                                         g_text_buffer_accepted = false;\r
1859                                         textbuf_dest = new TextDestSign(\r
1860                                                         selected_object->getBlock()->getPos(),\r
1861                                                         selected_object->getId(),\r
1862                                                         &client);\r
1863                                 }\r
1864                                 /*\r
1865                                         Otherwise pass the event to the server as-is\r
1866                                 */\r
1867                                 else\r
1868                                 {\r
1869                                         client.clickObject(1, selected_object->getBlock()->getPos(),\r
1870                                                         selected_object->getId(), g_selected_item);\r
1871                                 }\r
1872                         }\r
1873                 }\r
1874                 else // selected_object == NULL\r
1875                 {\r
1876                 \r
1877                 bool nodefound = false;\r
1878                 v3s16 nodepos;\r
1879                 v3s16 neighbourpos;\r
1880                 core::aabbox3d<f32> nodefacebox;\r
1881                 f32 mindistance = BS * 1001;\r
1882                 \r
1883                 v3s16 pos_i = floatToInt(player_position);\r
1884 \r
1885                 /*std::cout<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"\r
1886                                 <<std::endl;*/\r
1887 \r
1888                 s16 a = d;\r
1889                 s16 ystart = pos_i.Y + 0 - (camera_direction.Y<0 ? a : 1);\r
1890                 s16 zstart = pos_i.Z - (camera_direction.Z<0 ? a : 1);\r
1891                 s16 xstart = pos_i.X - (camera_direction.X<0 ? a : 1);\r
1892                 s16 yend = pos_i.Y + 1 + (camera_direction.Y>0 ? a : 1);\r
1893                 s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);\r
1894                 s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);\r
1895                 \r
1896                 for(s16 y = ystart; y <= yend; y++)\r
1897                 for(s16 z = zstart; z <= zend; z++)\r
1898                 for(s16 x = xstart; x <= xend; x++)\r
1899                 {\r
1900                         MapNode n;\r
1901                         try\r
1902                         {\r
1903                                 n = client.getNode(v3s16(x,y,z));\r
1904                                 if(content_pointable(n.d) == false)\r
1905                                         continue;\r
1906                         }\r
1907                         catch(InvalidPositionException &e)\r
1908                         {\r
1909                                 continue;\r
1910                         }\r
1911 \r
1912                         v3s16 np(x,y,z);\r
1913                         v3f npf = intToFloat(np);\r
1914                         \r
1915                         f32 d = 0.01;\r
1916                         \r
1917                         v3s16 dirs[6] = {\r
1918                                 v3s16(0,0,1), // back\r
1919                                 v3s16(0,1,0), // top\r
1920                                 v3s16(1,0,0), // right\r
1921                                 v3s16(0,0,-1), // front\r
1922                                 v3s16(0,-1,0), // bottom\r
1923                                 v3s16(-1,0,0), // left\r
1924                         };\r
1925                         \r
1926                         /*\r
1927                                 Meta-objects\r
1928                         */\r
1929                         if(n.d == CONTENT_LIGHT)\r
1930                         {\r
1931                                 v3s16 dir = unpackDir(n.dir);\r
1932                                 v3f dir_f = v3f(dir.X, dir.Y, dir.Z);\r
1933                                 dir_f *= BS/2 - BS/6 - BS/20;\r
1934                                 v3f cpf = npf + dir_f;\r
1935                                 f32 distance = (cpf - camera_position).getLength();\r
1936 \r
1937                                 core::aabbox3d<f32> box;\r
1938                                 \r
1939                                 // bottom\r
1940                                 if(dir == v3s16(0,-1,0))\r
1941                                 {\r
1942                                         box = core::aabbox3d<f32>(\r
1943                                                 npf - v3f(BS/6, BS/2, BS/6),\r
1944                                                 npf + v3f(BS/6, -BS/2+BS/3*2, BS/6)\r
1945                                         );\r
1946                                 }\r
1947                                 // top\r
1948                                 else if(dir == v3s16(0,1,0))\r
1949                                 {\r
1950                                         box = core::aabbox3d<f32>(\r
1951                                                 npf - v3f(BS/6, -BS/2+BS/3*2, BS/6),\r
1952                                                 npf + v3f(BS/6, BS/2, BS/6)\r
1953                                         );\r
1954                                 }\r
1955                                 // side\r
1956                                 else\r
1957                                 {\r
1958                                         box = core::aabbox3d<f32>(\r
1959                                                 cpf - v3f(BS/6, BS/3, BS/6),\r
1960                                                 cpf + v3f(BS/6, BS/3, BS/6)\r
1961                                         );\r
1962                                 }\r
1963 \r
1964                                 if(distance < mindistance)\r
1965                                 {\r
1966                                         if(box.intersectsWithLine(shootline))\r
1967                                         {\r
1968                                                 nodefound = true;\r
1969                                                 nodepos = np;\r
1970                                                 neighbourpos = np;\r
1971                                                 mindistance = distance;\r
1972                                                 nodefacebox = box;\r
1973                                         }\r
1974                                 }\r
1975                         }\r
1976                         /*\r
1977                                 Regular blocks\r
1978                         */\r
1979                         else\r
1980                         {\r
1981                                 for(u16 i=0; i<6; i++)\r
1982                                 {\r
1983                                         v3f dir_f = v3f(dirs[i].X,\r
1984                                                         dirs[i].Y, dirs[i].Z);\r
1985                                         v3f centerpoint = npf + dir_f * BS/2;\r
1986                                         f32 distance =\r
1987                                                         (centerpoint - camera_position).getLength();\r
1988                                         \r
1989                                         if(distance < mindistance)\r
1990                                         {\r
1991                                                 core::CMatrix4<f32> m;\r
1992                                                 m.buildRotateFromTo(v3f(0,0,1), dir_f);\r
1993 \r
1994                                                 // This is the back face\r
1995                                                 v3f corners[2] = {\r
1996                                                         v3f(BS/2, BS/2, BS/2),\r
1997                                                         v3f(-BS/2, -BS/2, BS/2+d)\r
1998                                                 };\r
1999                                                 \r
2000                                                 for(u16 j=0; j<2; j++)\r
2001                                                 {\r
2002                                                         m.rotateVect(corners[j]);\r
2003                                                         corners[j] += npf;\r
2004                                                 }\r
2005 \r
2006                                                 core::aabbox3d<f32> facebox(corners[0]);\r
2007                                                 facebox.addInternalPoint(corners[1]);\r
2008 \r
2009                                                 if(facebox.intersectsWithLine(shootline))\r
2010                                                 {\r
2011                                                         nodefound = true;\r
2012                                                         nodepos = np;\r
2013                                                         neighbourpos = np + dirs[i];\r
2014                                                         mindistance = distance;\r
2015                                                         nodefacebox = facebox;\r
2016                                                 }\r
2017                                         } // if distance < mindistance\r
2018                                 } // for dirs\r
2019                         } // regular block\r
2020                 } // for coords\r
2021 \r
2022                 if(nodefound)\r
2023                 {\r
2024                         //std::cout<<DTIME<<"nodefound == true"<<std::endl;\r
2025                         //std::cout<<DTIME<<"nodepos=("<<nodepos.X<<","<<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;\r
2026                         //std::cout<<DTIME<<"neighbourpos=("<<neighbourpos.X<<","<<neighbourpos.Y<<","<<neighbourpos.Z<<")"<<std::endl;\r
2027 \r
2028                         static v3s16 nodepos_old(-1,-1,-1);\r
2029                         if(nodepos != nodepos_old){\r
2030                                 std::cout<<DTIME<<"Pointing at ("<<nodepos.X<<","\r
2031                                                 <<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;\r
2032                                 nodepos_old = nodepos;\r
2033 \r
2034                                 /*wchar_t positiontext[20];\r
2035                                 swprintf(positiontext, 20, L"(%i,%i,%i)",\r
2036                                                 nodepos.X, nodepos.Y, nodepos.Z);\r
2037                                 positiontextgui->setText(positiontext);*/\r
2038                         }\r
2039 \r
2040                         hilightboxes.push_back(nodefacebox);\r
2041                         \r
2042                         if(g_input->getLeftClicked())\r
2043                         {\r
2044                                 //std::cout<<DTIME<<"Removing node"<<std::endl;\r
2045                                 //client.removeNode(nodepos);\r
2046                                 std::cout<<DTIME<<"Ground left-clicked"<<std::endl;\r
2047                                 client.clickGround(0, nodepos, neighbourpos, g_selected_item);\r
2048                         }\r
2049                         if(g_input->getRightClicked())\r
2050                         {\r
2051                                 //std::cout<<DTIME<<"Placing node"<<std::endl;\r
2052                                 //client.addNodeFromInventory(neighbourpos, g_selected_item);\r
2053                                 std::cout<<DTIME<<"Ground right-clicked"<<std::endl;\r
2054                                 client.clickGround(1, nodepos, neighbourpos, g_selected_item);\r
2055                         }\r
2056                 }\r
2057                 else{\r
2058                         //std::cout<<DTIME<<"nodefound == false"<<std::endl;\r
2059                         //positiontextgui->setText(L"");\r
2060                 }\r
2061 \r
2062                 } // selected_object == NULL\r
2063                 \r
2064                 g_input->resetLeftClicked();\r
2065                 g_input->resetRightClicked();\r
2066                 \r
2067                 /*\r
2068                         Calculate stuff for drawing\r
2069                 */\r
2070 \r
2071                 v2u32 screensize = driver->getScreenSize();\r
2072                 core::vector2d<s32> displaycenter(screensize.X/2,screensize.Y/2);\r
2073 \r
2074                 camera->setAspectRatio((f32)screensize.X / (f32)screensize.Y);\r
2075 \r
2076                 /*\r
2077                         Update gui stuff (0ms)\r
2078                 */\r
2079 \r
2080                 //TimeTaker guiupdatetimer("Gui updating", device);\r
2081                 \r
2082                 {\r
2083                         wchar_t temptext[100];\r
2084 \r
2085                         static float drawtime_avg = 0;\r
2086                         drawtime_avg = drawtime_avg * 0.98 + (float)drawtime*0.02;\r
2087                         static float scenetime_avg = 0;\r
2088                         scenetime_avg = scenetime_avg * 0.98 + (float)scenetime*0.02;\r
2089                         static float endscenetime_avg = 0;\r
2090                         endscenetime_avg = endscenetime_avg * 0.98 + (float)endscenetime*0.02;\r
2091                         \r
2092                         swprintf(temptext, 100, L"Minetest-c55 ("\r
2093                                         L"F: item=%i"\r
2094                                         L", R: range_all=%i"\r
2095                                         L")"\r
2096                                         L" drawtime=%.0f, scenetime=%.0f, endscenetime=%.0f",\r
2097                                         g_selected_item,\r
2098                                         g_viewing_range_all,\r
2099                                         drawtime_avg,\r
2100                                         scenetime_avg,\r
2101                                         endscenetime_avg\r
2102                                         );\r
2103                         \r
2104                         guitext->setText(temptext);\r
2105                 }\r
2106                 \r
2107                 {\r
2108                         wchar_t temptext[100];\r
2109                         /*swprintf(temptext, 100,\r
2110                                         L"("\r
2111                                         L"% .3f < btime_jitter < % .3f"\r
2112                                         L", dtime_jitter = % .1f %%"\r
2113                                         //L", ftime_ratio = % .3f"\r
2114                                         L")",\r
2115                                         busytime_jitter1_min_sample,\r
2116                                         busytime_jitter1_max_sample,\r
2117                                         dtime_jitter1_max_fraction * 100.0\r
2118                                         //g_freetime_ratio\r
2119                                         );*/\r
2120                         swprintf(temptext, 100,\r
2121                                         L"(% .1f, % .1f, % .1f)"\r
2122                                         L" (% .3f < btime_jitter < % .3f"\r
2123                                         L", dtime_jitter = % .1f %%)",\r
2124                                         player_position.X/BS,\r
2125                                         player_position.Y/BS,\r
2126                                         player_position.Z/BS,\r
2127                                         busytime_jitter1_min_sample,\r
2128                                         busytime_jitter1_max_sample,\r
2129                                         dtime_jitter1_max_fraction * 100.0\r
2130                                         );\r
2131 \r
2132                         guitext2->setText(temptext);\r
2133                 }\r
2134                 \r
2135                 {\r
2136                         /*wchar_t temptext[100];\r
2137                         swprintf(temptext, 100,\r
2138                                         SWPRINTF_CHARSTRING,\r
2139                                         infotext.substr(0,99).c_str()\r
2140                                         );\r
2141 \r
2142                         guitext_info->setText(temptext);*/\r
2143 \r
2144                         guitext_info->setText(infotext.c_str());\r
2145                 }\r
2146 \r
2147                 /*\r
2148                         Inventory\r
2149                 */\r
2150                 \r
2151                 static u16 old_selected_item = 65535;\r
2152                 if(client.getLocalInventoryUpdated()\r
2153                                 || g_selected_item != old_selected_item)\r
2154                 {\r
2155                         old_selected_item = g_selected_item;\r
2156                         //std::cout<<"Updating local inventory"<<std::endl;\r
2157                         client.getLocalInventory(local_inventory);\r
2158                         quick_inventory->setSelection(g_selected_item);\r
2159                         quick_inventory->update();\r
2160                 }\r
2161 \r
2162                 if(input_guitext != NULL)\r
2163                 {\r
2164                         /*wchar_t temptext[100];\r
2165                         swprintf(temptext, 100,\r
2166                                         SWPRINTF_CHARSTRING,\r
2167                                         g_text_buffer.substr(0,99).c_str()\r
2168                                         );*/\r
2169                         input_guitext->setText(g_text_buffer.c_str());\r
2170                 }\r
2171 \r
2172                 /*\r
2173                         Text input stuff\r
2174                 */\r
2175                 if(input_guitext != NULL && g_text_buffer_accepted)\r
2176                 {\r
2177                         input_guitext->remove();\r
2178                         input_guitext = NULL;\r
2179                         \r
2180                         if(textbuf_dest != NULL)\r
2181                         {\r
2182                                 std::string text = wide_to_narrow(g_text_buffer);\r
2183                                 dstream<<"Sending text: "<<text<<std::endl;\r
2184                                 textbuf_dest->sendText(text);\r
2185                                 delete textbuf_dest;\r
2186                                 textbuf_dest = NULL;\r
2187                         }\r
2188 \r
2189                         focusGame();\r
2190                 }\r
2191 \r
2192                 //guiupdatetimer.stop();\r
2193 \r
2194                 /*\r
2195                         Drawing begins\r
2196                 */\r
2197 \r
2198                 TimeTaker drawtimer("Drawing", device);\r
2199 \r
2200                 /*\r
2201                         Background color is choosen based on whether the player is\r
2202                         much beyond the initial ground level\r
2203                 */\r
2204                 /*video::SColor bgcolor;\r
2205                 v3s16 p0 = Map::floatToInt(player_position);\r
2206                 // Does this make short random delays?\r
2207                 // NOTE: no need for this, sky doesn't show underground with\r
2208                 // enough range\r
2209                 bool is_underground = client.isNodeUnderground(p0);\r
2210                 //bool is_underground = false;\r
2211                 if(is_underground == false)\r
2212                         bgcolor = video::SColor(255,90,140,200);\r
2213                 else\r
2214                         bgcolor = video::SColor(255,0,0,0);*/\r
2215                         \r
2216                 //video::SColor bgcolor = video::SColor(255,90,140,200);\r
2217                 video::SColor bgcolor = skycolor;\r
2218                 \r
2219                 // 0ms\r
2220                 driver->beginScene(true, true, bgcolor);\r
2221 \r
2222                 //timer3.stop();\r
2223                 \r
2224                 //std::cout<<DTIME<<"smgr->drawAll()"<<std::endl;\r
2225                 \r
2226                 {\r
2227                 TimeTaker timer("smgr", device);\r
2228                 smgr->drawAll();\r
2229                 scenetime = timer.stop(true);\r
2230                 }\r
2231                 \r
2232                 {\r
2233                 //TimeTaker timer9("auxiliary drawings", device);\r
2234                 // 0ms\r
2235 \r
2236                 driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),\r
2237                                 displaycenter + core::vector2d<s32>(10,0),\r
2238                                 video::SColor(255,255,255,255));\r
2239                 driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),\r
2240                                 displaycenter + core::vector2d<s32>(0,10),\r
2241                                 video::SColor(255,255,255,255));\r
2242 \r
2243                 //timer9.stop();\r
2244                 //TimeTaker //timer10("//timer10", device);\r
2245                 \r
2246                 video::SMaterial m;\r
2247                 m.Thickness = 10;\r
2248                 m.Lighting = false;\r
2249                 driver->setMaterial(m);\r
2250 \r
2251                 driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);\r
2252 \r
2253                 for(core::list< core::aabbox3d<f32> >::Iterator i=hilightboxes.begin();\r
2254                                 i != hilightboxes.end(); i++)\r
2255                 {\r
2256                         /*std::cout<<"hilightbox min="\r
2257                                         <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"\r
2258                                         <<" max="\r
2259                                         <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"\r
2260                                         <<std::endl;*/\r
2261                         driver->draw3DBox(*i, video::SColor(255,0,0,0));\r
2262                 }\r
2263 \r
2264                 }\r
2265 \r
2266                 //timer10.stop();\r
2267                 //TimeTaker //timer11("//timer11", device);\r
2268 \r
2269                 /*\r
2270                         Draw gui\r
2271                 */\r
2272                 // 0-1ms\r
2273                 guienv->drawAll();\r
2274                 \r
2275                 // End drawing\r
2276                 {\r
2277                 TimeTaker timer("endScene", device);\r
2278                 driver->endScene();\r
2279                 endscenetime = timer.stop(true);\r
2280                 }\r
2281 \r
2282                 drawtime = drawtimer.stop(true);\r
2283 \r
2284                 /*\r
2285                         Drawing ends\r
2286                 */\r
2287                 \r
2288                 static s16 lastFPS = 0;\r
2289                 //u16 fps = driver->getFPS();\r
2290                 u16 fps = (1.0/dtime_avg1);\r
2291 \r
2292                 if (lastFPS != fps)\r
2293                 {\r
2294                         core::stringw str = L"Minetest [";\r
2295                         str += driver->getName();\r
2296                         str += "] FPS:";\r
2297                         str += fps;\r
2298 \r
2299                         device->setWindowCaption(str.c_str());\r
2300                         lastFPS = fps;\r
2301                 }\r
2302                 \r
2303                 /*}\r
2304                 else\r
2305                         device->yield();*/\r
2306         }\r
2307 \r
2308         } // client is deleted at this point\r
2309         \r
2310         delete g_input;\r
2311 \r
2312         /*\r
2313                 In the end, delete the Irrlicht device.\r
2314         */\r
2315         device->drop();\r
2316 \r
2317         } //try\r
2318         catch(con::PeerNotFoundException &e)\r
2319         {\r
2320                 dstream<<DTIME<<"Connection timed out."<<std::endl;\r
2321         }\r
2322 #if CATCH_UNHANDLED_EXCEPTIONS\r
2323         /*\r
2324                 This is what has to be done in every thread to get suitable debug info\r
2325         */\r
2326         catch(std::exception &e)\r
2327         {\r
2328                 dstream<<std::endl<<DTIME<<"An unhandled exception occurred: "\r
2329                                 <<e.what()<<std::endl;\r
2330                 assert(0);\r
2331         }\r
2332 #endif\r
2333 \r
2334         debugstreams_deinit();\r
2335         \r
2336         return 0;\r
2337 }\r
2338 \r
2339 //END\r