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