3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
\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
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
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
21 =============================== NOTES ==============================
\r
22 NOTE: Things starting with TODO are sometimes only suggestions.
\r
24 NOTE: VBO cannot be turned on for fast-changing stuff because there
\r
25 is an apparanet memory leak in irrlicht when using it (not sure)
\r
27 NOTE: iostream.imbue(std::locale("C")) is very slow
\r
28 NOTE: Global locale is now set at initialization
\r
30 SUGGESTION: add a second lighting value to the MS nibble of param of
\r
31 air to tell how bright the air node is when there is no sunlight.
\r
32 When day changes to night, these two values can be interpolated.
\r
34 TODO: Fix address to be ipv6 compatible
\r
36 TODO: ESC Pause mode in which the cursor is not kept at the center of window.
\r
37 TODO: Stop player if focus of window is taken away (go to pause mode)
\r
38 TODO: Optimize and fix makeFastFace or whatever it's called
\r
39 - Face calculation is the source of CPU usage on the client
\r
40 SUGGESTION: The client will calculate and send lighting changes and
\r
41 the server will randomly check some of them and kick the client out
\r
42 if it fails to calculate them right.
\r
43 - Actually, it could just start ignoring them and calculate them
\r
45 SUGGESTION: Combine MapBlock's face caches to so big pieces that VBO
\r
47 - That is >500 vertices
\r
49 TODO: Better dungeons
\r
50 TODO: There should be very slight natural caves also, starting from
\r
51 only a straightened-up cliff
\r
53 TODO: Changing of block with mouse wheel or something
\r
58 - One single map container with ids as keys
\r
61 TODO: - Keep track of the place of the mob in the last few hundreth's
\r
62 of a second - then, if a player hits it, take the value that is
\r
63 avg_rtt/2 before the moment the packet is received.
\r
66 SUGGESTION: Modify client to calculate single changes asynchronously
\r
68 TODO: Moving players more smoothly. Calculate moving animation
\r
69 in a way that doesn't make the player jump to the right place
\r
70 immediately when the server sends a new position
\r
72 TODO: There are some lighting-related todos and fixmes in
\r
73 ServerMap::emergeBlock
\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
84 TODO: Proper handling of spawning place (try to find something that
\r
85 is not in the middle of an ocean (some land to stand on at
\r
86 least) and save it in map config.
\r
87 SUGG: Set server to automatically find a good spawning place in some
\r
88 place where there is water and land.
\r
89 - Map to have a getWalkableNear(p)
\r
90 - Is this a good idea? It's part of the game to find a good place.
\r
92 TODO: Transfer more blocks in a single packet
\r
93 SUGG: A blockdata combiner class, to which blocks are added and at
\r
94 destruction it sends all the stuff in as few packets as possible.
\r
96 SUGG: If player is on ground, mainly fetch ground-level blocks
\r
97 SUGG: Fetch stuff mainly from the viewing direction
\r
99 SUGG: Expose Connection's seqnums and ACKs to server and client.
\r
100 - This enables saving many packets and making a faster connection
\r
101 - This also enables server to check if client has received the
\r
102 most recent block sent, for example.
\r
103 TODO: Add a sane bandwidth throttling system to Connection
\r
105 SUGG: More fine-grained control of client's dumping of blocks from
\r
107 - ...What does this mean in the first place?
\r
109 TODO: Make the amount of blocks sending to client and the total
\r
110 amount of blocks dynamically limited. Transferring blocks is the
\r
111 main network eater of this system, so it is the one that has
\r
112 to be throttled so that RTTs stay low.
\r
114 TODO: Server to load starting inventory from disk
\r
116 TODO: PLayers to only be hidden when the client quits.
\r
117 TODO: - Players to be saved on disk, with inventory
\r
118 TODO: Players to be saved as text in map/players/<name>
\r
120 SUGG: A map editing mode (similar to dedicated server mode)
\r
122 TODO: Make fetching sector's blocks more efficient when rendering
\r
123 sectors that have very large amounts of blocks (on client)
\r
125 TODO: Make the video backend selectable
\r
127 Block object server side:
\r
128 - A "near blocks" buffer, in which some nearby blocks are stored.
\r
129 - For all blocks in the buffer, objects are stepped(). This
\r
130 means they are active.
\r
131 - TODO: A global active buffer is needed for the server
\r
132 - TODO: All blocks going in and out of the buffer are recorded.
\r
133 - TODO: For outgoing blocks, a timestamp is written.
\r
134 - TODO: For incoming blocks, the time difference is calculated and
\r
135 objects are stepped according to it.
\r
136 TODO: A timestamp to blocks
\r
138 SUGG: Add a time value to the param of footstepped grass and check it
\r
139 against a global timer when a block is accessed, to make old
\r
142 TODO: Add config parameters for server's sending and generating distance
\r
144 TODO: Copy the text of the last picked sign to inventory in creative
\r
147 TODO: Untie client network operations from framerate
\r
148 - Needs some input queues or something
\r
150 SUGG: Make a copy of close-range environment on client for showing
\r
151 on screen, with minimal mutexes to slow down the main loop
\r
153 SUGG: Make a PACKET_COMBINED which contains many subpackets. Utilize
\r
154 it by sending more stuff in a single packet.
\r
155 - Add a packet queue to RemoteClient, from which packets will be
\r
156 combined with object data packets
\r
157 - This is not exactly trivial: the object data packets are
\r
158 sometimes very big by themselves
\r
160 SUGG: Split MapBlockObject serialization to to-client and to-disk
\r
161 - This will allow saving ages of rats on disk but not sending
\r
164 TODO: Get rid of GotSplitPacketException
\r
166 SUGG: Implement lighting using VoxelManipulator
\r
167 - Would it be significantly faster?
\r
169 TODO: Check what goes wrong with caching map to disk (Kray)
\r
171 TODO: Remove LazyMeshUpdater. It is not used as supposed.
\r
173 FIXME: Rats somehow go underground sometimes (you can see it in water)
\r
174 - Does their position get saved to a border value or something?
\r
176 SUGG: MovingObject::move and Player::move are basically the same.
\r
179 TODO: Transfer sign texts as metadata of block and not as data of
\r
182 SUGG: Implement a "Fast check queue" (a queue with a map for checking
\r
183 if something is already in it)
\r
184 - TODO: Use it in active block queue in water flowing
\r
186 TODO: Proper looking torches.
\r
187 - Signs could be done in the same way?
\r
189 TODO: A mapper to map contents to tile names (for each side)
\r
192 ======================================================================
\r
194 ======================================================================
\r
199 Setting this to 1 enables a special camera mode that forces
\r
200 the renderers to think that the camera statically points from
\r
201 the starting place to a static direction.
\r
203 This allows one to move around with the player and see what
\r
204 is actually drawn behind solid things and behind the player.
\r
206 #define FIELD_OF_VIEW_TEST 0
\r
208 #ifdef UNITTEST_DISABLE
\r
210 #pragma message ("Disabling unit tests")
\r
212 #warning "Disabling unit tests"
\r
214 // Disable unit tests
\r
215 #define ENABLE_TESTS 0
\r
217 // Enable unit tests
\r
218 #define ENABLE_TESTS 1
\r
222 #pragma comment(lib, "Irrlicht.lib")
\r
223 #pragma comment(lib, "jthread.lib")
\r
224 // This would get rid of the console window
\r
225 //#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
\r
229 #define WIN32_LEAN_AND_MEAN
\r
230 #include <windows.h>
\r
231 #define sleep_ms(x) Sleep(x)
\r
233 #include <unistd.h>
\r
234 #define sleep_ms(x) usleep(x*1000)
\r
237 #include <iostream>
\r
240 #include <jmutexautolock.h>
\r
241 #include "common_irrlicht.h"
\r
244 #include "player.h"
\r
247 #include "environment.h"
\r
248 #include "server.h"
\r
249 #include "client.h"
\r
250 #include "serialization.h"
\r
251 #include "constants.h"
\r
252 #include "strfnd.h"
\r
253 #include "porting.h"
\r
254 #include <locale.h>
\r
256 IrrlichtDevice *g_device = NULL;
\r
258 const char *g_content_filenames[MATERIALS_COUNT] =
\r
260 "../data/stone.png",
\r
261 "../data/grass.png",
\r
262 "../data/water.png",
\r
263 "../data/torch_on_floor.png",
\r
264 "../data/tree.png",
\r
265 "../data/leaves.png",
\r
266 "../data/grass_footsteps.png",
\r
267 "../data/mese.png",
\r
269 "../data/water.png", // CONTENT_OCEAN
\r
273 video::SMaterial g_materials[MATERIALS_COUNT];
\r
276 TextureCache g_texturecache;
\r
279 // All range-related stuff below is locked behind this
\r
280 JMutex g_range_mutex;
\r
282 // Blocks are viewed in this range from the player
\r
283 s16 g_viewing_range_nodes = 60;
\r
285 // This is updated by the client's fetchBlocks routine
\r
286 //s16 g_actual_viewing_range_nodes = VIEWING_RANGE_NODES_DEFAULT;
\r
288 // If true, the preceding value has no meaning and all blocks
\r
289 // already existing in memory are drawn
\r
290 bool g_viewing_range_all = false;
\r
292 // This is the freetime ratio imposed by the dynamic viewing
\r
293 // range changing code.
\r
294 // It is controlled by the main loop to the smallest value that
\r
295 // inhibits glitches (dtime jitter) in the main loop.
\r
296 //float g_freetime_ratio = FREETIME_RATIO_MAX;
\r
301 These are loaded from the config file.
\r
304 Settings g_settings;
\r
306 // Sets default settings
\r
307 void set_default_settings()
\r
309 g_settings.set("dedicated_server", "");
\r
312 g_settings.set("wanted_fps", "30");
\r
313 g_settings.set("fps_max", "60");
\r
314 g_settings.set("viewing_range_nodes_max", "300");
\r
315 g_settings.set("viewing_range_nodes_min", "20");
\r
316 g_settings.set("screenW", "");
\r
317 g_settings.set("screenH", "");
\r
318 g_settings.set("host_game", "");
\r
319 g_settings.set("port", "");
\r
320 g_settings.set("address", "");
\r
321 g_settings.set("name", "");
\r
322 g_settings.set("random_input", "false");
\r
323 g_settings.set("client_delete_unused_sectors_timeout", "1200");
\r
324 g_settings.set("max_block_send_distance", "8");
\r
325 g_settings.set("max_block_generate_distance", "6");
\r
328 g_settings.set("creative_mode", "false");
\r
329 g_settings.set("heightmap_blocksize", "32");
\r
330 g_settings.set("height_randmax", "constant 50.0");
\r
331 g_settings.set("height_randfactor", "constant 0.6");
\r
332 g_settings.set("height_base", "linear 0 0 0");
\r
333 g_settings.set("plants_amount", "1.0");
\r
334 g_settings.set("ravines_amount", "1.0");
\r
335 g_settings.set("objectdata_interval", "0.2");
\r
336 g_settings.set("active_object_range", "2");
\r
337 g_settings.set("max_simultaneous_block_sends_per_client", "1");
\r
338 g_settings.set("max_simultaneous_block_sends_server_total", "4");
\r
339 g_settings.set("disable_water_climb", "true");
\r
340 g_settings.set("endless_water", "true");
\r
347 //u16 g_selected_material = 0;
\r
348 u16 g_selected_item = 0;
\r
350 bool g_esc_pressed = false;
\r
352 std::wstring g_text_buffer;
\r
353 bool g_text_buffer_accepted = false;
\r
355 // When true, the mouse and keyboard are grabbed
\r
356 bool g_game_focused = true;
\r
363 std::ostream *dout_con_ptr = &dummyout;
\r
364 std::ostream *derr_con_ptr = &dstream_no_stderr;
\r
365 //std::ostream *dout_con_ptr = &dstream_no_stderr;
\r
366 //std::ostream *derr_con_ptr = &dstream_no_stderr;
\r
367 //std::ostream *dout_con_ptr = &dstream;
\r
368 //std::ostream *derr_con_ptr = &dstream;
\r
371 std::ostream *dout_server_ptr = &dstream;
\r
372 std::ostream *derr_server_ptr = &dstream;
\r
375 std::ostream *dout_client_ptr = &dstream;
\r
376 std::ostream *derr_client_ptr = &dstream;
\r
383 JMutex g_timestamp_mutex;
\r
384 //std::string g_timestamp;
\r
386 std::string getTimestamp()
\r
388 if(g_timestamp_mutex.IsInitialized()==false)
\r
390 JMutexAutoLock lock(g_timestamp_mutex);
\r
391 //return g_timestamp;
\r
392 time_t t = time(NULL);
\r
393 struct tm *tm = localtime(&t);
\r
395 strftime(cs, 20, "%H:%M:%S", tm);
\r
399 class MyEventReceiver : public IEventReceiver
\r
402 // This is the one method that we have to implement
\r
403 virtual bool OnEvent(const SEvent& event)
\r
405 // Remember whether each key is down or up
\r
406 if(event.EventType == irr::EET_KEY_INPUT_EVENT)
\r
408 keyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;
\r
410 if(event.KeyInput.PressedDown)
\r
412 //dstream<<"Pressed key: "<<(char)event.KeyInput.Key<<std::endl;
\r
413 if(g_game_focused == false)
\r
415 s16 key = event.KeyInput.Key;
\r
416 if(key == irr::KEY_RETURN || key == irr::KEY_ESCAPE)
\r
418 g_text_buffer_accepted = true;
\r
420 else if(key == irr::KEY_BACK)
\r
422 if(g_text_buffer.size() > 0)
\r
423 g_text_buffer = g_text_buffer.substr
\r
424 (0, g_text_buffer.size()-1);
\r
428 wchar_t wc = event.KeyInput.Char;
\r
430 g_text_buffer += wc;
\r
434 if(event.KeyInput.Key == irr::KEY_ESCAPE)
\r
436 if(g_game_focused == true)
\r
438 dstream<<DTIME<<"ESC pressed"<<std::endl;
\r
439 g_esc_pressed = true;
\r
443 // Material selection
\r
444 if(event.KeyInput.Key == irr::KEY_KEY_F)
\r
446 if(g_game_focused == true)
\r
448 if(g_selected_item < PLAYER_INVENTORY_SIZE-1)
\r
451 g_selected_item = 0;
\r
452 dstream<<DTIME<<"Selected item: "
\r
453 <<g_selected_item<<std::endl;
\r
457 // Viewing range selection
\r
458 if(event.KeyInput.Key == irr::KEY_KEY_R
\r
461 JMutexAutoLock lock(g_range_mutex);
\r
462 if(g_viewing_range_all)
\r
464 g_viewing_range_all = false;
\r
465 dstream<<DTIME<<"Disabled full viewing range"<<std::endl;
\r
469 g_viewing_range_all = true;
\r
470 dstream<<DTIME<<"Enabled full viewing range"<<std::endl;
\r
474 // Print debug stacks
\r
475 if(event.KeyInput.Key == irr::KEY_KEY_P
\r
478 dstream<<"-----------------------------------------"
\r
480 dstream<<DTIME<<"Printing debug stacks:"<<std::endl;
\r
481 dstream<<"-----------------------------------------"
\r
483 debug_stacks_print();
\r
488 if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)
\r
490 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
\r
492 leftclicked = true;
\r
494 if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
\r
496 rightclicked = true;
\r
498 if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)
\r
500 /*dstream<<"event.MouseInput.Wheel="
\r
501 <<event.MouseInput.Wheel<<std::endl;*/
\r
502 if(event.MouseInput.Wheel < 0)
\r
504 if(g_selected_item < PLAYER_INVENTORY_SIZE-1)
\r
507 g_selected_item = 0;
\r
509 else if(event.MouseInput.Wheel > 0)
\r
511 if(g_selected_item > 0)
\r
514 g_selected_item = PLAYER_INVENTORY_SIZE-1;
\r
522 // This is used to check whether a key is being held down
\r
523 virtual bool IsKeyDown(EKEY_CODE keyCode) const
\r
525 return keyIsDown[keyCode];
\r
530 for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
\r
531 keyIsDown[i] = false;
\r
532 leftclicked = false;
\r
533 rightclicked = false;
\r
539 // We use this array to store the current state of each key
\r
540 bool keyIsDown[KEY_KEY_CODES_COUNT];
\r
551 virtual ~InputHandler()
\r
554 virtual bool isKeyDown(EKEY_CODE keyCode) = 0;
\r
555 virtual v2s32 getMousePos() = 0;
\r
556 virtual void setMousePos(s32 x, s32 y) = 0;
\r
557 virtual bool getLeftClicked() = 0;
\r
558 virtual bool getRightClicked() = 0;
\r
559 virtual void resetLeftClicked() = 0;
\r
560 virtual void resetRightClicked() = 0;
\r
562 virtual void step(float dtime) {};
\r
564 virtual void clear() {};
\r
567 InputHandler *g_input = NULL;
\r
572 g_game_focused = true;
\r
577 g_game_focused = false;
\r
580 class RealInputHandler : public InputHandler
\r
583 RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver):
\r
585 m_receiver(receiver)
\r
588 virtual bool isKeyDown(EKEY_CODE keyCode)
\r
590 return m_receiver->IsKeyDown(keyCode);
\r
592 virtual v2s32 getMousePos()
\r
594 return m_device->getCursorControl()->getPosition();
\r
596 virtual void setMousePos(s32 x, s32 y)
\r
598 m_device->getCursorControl()->setPosition(x, y);
\r
601 virtual bool getLeftClicked()
\r
603 if(g_game_focused == false)
\r
605 return m_receiver->leftclicked;
\r
607 virtual bool getRightClicked()
\r
609 if(g_game_focused == false)
\r
611 return m_receiver->rightclicked;
\r
613 virtual void resetLeftClicked()
\r
615 m_receiver->leftclicked = false;
\r
617 virtual void resetRightClicked()
\r
619 m_receiver->rightclicked = false;
\r
624 resetRightClicked();
\r
625 resetLeftClicked();
\r
628 IrrlichtDevice *m_device;
\r
629 MyEventReceiver *m_receiver;
\r
632 class RandomInputHandler : public InputHandler
\r
635 RandomInputHandler()
\r
637 leftclicked = false;
\r
638 rightclicked = false;
\r
639 for(u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
\r
640 keydown[i] = false;
\r
642 virtual bool isKeyDown(EKEY_CODE keyCode)
\r
644 return keydown[keyCode];
\r
646 virtual v2s32 getMousePos()
\r
650 virtual void setMousePos(s32 x, s32 y)
\r
652 mousepos = v2s32(x,y);
\r
655 virtual bool getLeftClicked()
\r
657 return leftclicked;
\r
659 virtual bool getRightClicked()
\r
661 return rightclicked;
\r
663 virtual void resetLeftClicked()
\r
665 leftclicked = false;
\r
667 virtual void resetRightClicked()
\r
669 rightclicked = false;
\r
672 virtual void step(float dtime)
\r
675 static float counter1 = 0;
\r
679 counter1 = 0.1*Rand(1,10);
\r
680 /*if(g_selected_material < USEFUL_CONTENT_COUNT-1)
\r
681 g_selected_material++;
\r
683 g_selected_material = 0;*/
\r
684 if(g_selected_item < PLAYER_INVENTORY_SIZE-1)
\r
687 g_selected_item = 0;
\r
691 static float counter1 = 0;
\r
695 counter1 = 0.1*Rand(1, 40);
\r
696 keydown[irr::KEY_SPACE] = !keydown[irr::KEY_SPACE];
\r
700 static float counter1 = 0;
\r
704 counter1 = 0.1*Rand(1, 40);
\r
705 keydown[irr::KEY_KEY_2] = !keydown[irr::KEY_KEY_2];
\r
709 static float counter1 = 0;
\r
713 counter1 = 0.1*Rand(1, 40);
\r
714 keydown[irr::KEY_KEY_W] = !keydown[irr::KEY_KEY_W];
\r
718 static float counter1 = 0;
\r
722 counter1 = 0.1*Rand(1, 40);
\r
723 keydown[irr::KEY_KEY_A] = !keydown[irr::KEY_KEY_A];
\r
727 static float counter1 = 0;
\r
731 counter1 = 0.1*Rand(1, 20);
\r
732 mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
\r
736 static float counter1 = 0;
\r
740 counter1 = 0.1*Rand(1, 30);
\r
741 leftclicked = true;
\r
745 static float counter1 = 0;
\r
749 counter1 = 0.1*Rand(1, 20);
\r
750 rightclicked = true;
\r
753 mousepos += mousespeed;
\r
756 s32 Rand(s32 min, s32 max)
\r
758 return (rand()%(max-min+1))+min;
\r
761 bool keydown[KEY_KEY_CODES_COUNT];
\r
768 void updateViewingRange(f32 frametime, Client *client)
\r
770 // Range_all messes up frametime_avg
\r
771 if(g_viewing_range_all == true)
\r
774 float wanted_fps = g_settings.getFloat("wanted_fps");
\r
776 // Initialize to the target value
\r
777 static float frametime_avg = 1.0/wanted_fps;
\r
778 frametime_avg = frametime_avg * 0.9 + frametime * 0.1;
\r
780 static f32 counter = 0;
\r
782 counter -= frametime;
\r
785 //counter = 1.0; //seconds
\r
786 counter = 0.5; //seconds
\r
788 //float freetime_ratio = 0.2;
\r
789 //float freetime_ratio = 0.4;
\r
790 float freetime_ratio = FREETIME_RATIO;
\r
792 float frametime_wanted = (1.0/(wanted_fps/(1.0-freetime_ratio)));
\r
794 float fraction = sqrt(frametime_avg / frametime_wanted);
\r
796 static bool fraction_is_good = false;
\r
798 float fraction_good_threshold = 0.1;
\r
799 float fraction_bad_threshold = 0.25;
\r
800 float fraction_limit;
\r
801 // Use high limit if fraction is good AND the fraction would
\r
802 // lower the range. We want to keep the range fairly high.
\r
803 if(fraction_is_good && fraction > 1.0)
\r
804 fraction_limit = fraction_bad_threshold;
\r
806 fraction_limit = fraction_good_threshold;
\r
808 if(fabs(fraction - 1.0) < fraction_limit)
\r
810 fraction_is_good = true;
\r
815 fraction_is_good = false;
\r
818 //dstream<<"frametime_avg="<<frametime_avg<<std::endl;
\r
819 //dstream<<"frametime_wanted="<<frametime_wanted<<std::endl;
\r
820 /*dstream<<"fetching="<<client->isFetchingBlocks()
\r
821 <<" faction = "<<fraction<<std::endl;*/
\r
823 JMutexAutoLock lock(g_range_mutex);
\r
825 s16 viewing_range_nodes_min = g_settings.getS16("viewing_range_nodes_min");
\r
826 s16 viewing_range_nodes_max = g_settings.getS16("viewing_range_nodes_max");
\r
828 s16 n = (float)g_viewing_range_nodes / fraction;
\r
829 if(n < viewing_range_nodes_min)
\r
830 n = viewing_range_nodes_min;
\r
831 if(n > viewing_range_nodes_max)
\r
832 n = viewing_range_nodes_max;
\r
834 bool can_change = true;
\r
836 if(client->isFetchingBlocks() == true && n > g_viewing_range_nodes)
\r
837 can_change = false;
\r
840 g_viewing_range_nodes = n;
\r
842 /*dstream<<"g_viewing_range_nodes = "
\r
843 <<g_viewing_range_nodes<<std::endl;*/
\r
846 class GUIQuickInventory : public IEventReceiver
\r
850 gui::IGUIEnvironment* env,
\r
851 gui::IGUIElement* parent,
\r
854 Inventory *inventory):
\r
855 m_itemcount(itemcount),
\r
856 m_inventory(inventory)
\r
858 core::rect<s32> imgsize(0,0,48,48);
\r
859 core::rect<s32> textsize(0,0,48,16);
\r
860 v2s32 spacing(0, 64);
\r
861 for(s32 i=0; i<m_itemcount; i++)
\r
863 m_images.push_back(env->addImage(
\r
864 imgsize + pos + spacing*i
\r
866 m_images[i]->setScaleImage(true);
\r
867 m_texts.push_back(env->addStaticText(
\r
869 textsize + pos + spacing*i,
\r
872 m_texts[i]->setBackgroundColor(
\r
873 video::SColor(128,0,0,0));
\r
874 m_texts[i]->setTextAlignment(
\r
876 gui::EGUIA_UPPERLEFT);
\r
880 virtual bool OnEvent(const SEvent& event)
\r
885 void setSelection(s32 i)
\r
894 start = m_selection - m_itemcount / 2;
\r
896 for(s32 i=0; i<m_itemcount; i++)
\r
900 if(j > (s32)m_inventory->getSize() - 1)
\r
901 j -= m_inventory->getSize();
\r
903 j += m_inventory->getSize();
\r
905 InventoryItem *item = m_inventory->getItem(j);
\r
909 m_images[i]->setImage(NULL);
\r
912 if(m_selection == j)
\r
913 swprintf(t, 10, L"<-");
\r
915 swprintf(t, 10, L"");
\r
916 m_texts[i]->setText(t);
\r
918 // The next ifs will segfault with a NULL pointer
\r
923 m_images[i]->setImage(item->getImage());
\r
926 if(m_selection == j)
\r
927 swprintf(t, 10, SWPRINTF_CHARSTRING L" <-", item->getText().c_str());
\r
929 swprintf(t, 10, SWPRINTF_CHARSTRING, item->getText().c_str());
\r
930 m_texts[i]->setText(t);
\r
936 core::array<gui::IGUIStaticText*> m_texts;
\r
937 core::array<gui::IGUIImage*> m_images;
\r
938 Inventory *m_inventory;
\r
942 int main(int argc, char *argv[])
\r
945 Low-level initialization
\r
948 bool disable_stderr = false;
\r
950 disable_stderr = true;
\r
953 // Initialize debug streams
\r
954 debugstreams_init(disable_stderr, DEBUGFILE);
\r
955 // Initialize debug stacks
\r
956 debug_stacks_init();
\r
958 DSTACK(__FUNCTION_NAME);
\r
964 Basic initialization
\r
967 // Initialize default settings
\r
968 set_default_settings();
\r
970 // Print startup message
\r
971 dstream<<DTIME<<"minetest-c55"
\r
972 " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
\r
973 <<", ENABLE_TESTS="<<ENABLE_TESTS
\r
976 // Set locale. This is for forcing '.' as the decimal point.
\r
977 std::locale::global(std::locale("C"));
\r
978 // This enables printing all characters in bitmap font
\r
979 setlocale(LC_CTYPE, "en_US");
\r
981 // Initialize sockets
\r
983 atexit(sockets_cleanup);
\r
985 // Initialize timestamp mutex
\r
986 g_timestamp_mutex.Init();
\r
1000 // Read config file
\r
1004 g_settings.readConfigFile(argv[1]);
\r
1008 const char *filenames[2] =
\r
1010 "../minetest.conf",
\r
1011 "../../minetest.conf"
\r
1014 for(u32 i=0; i<2; i++)
\r
1016 bool r = g_settings.readConfigFile(filenames[i]);
\r
1022 // Initialize random seed
\r
1025 g_range_mutex.Init();
\r
1026 assert(g_range_mutex.IsInitialized());
\r
1028 // Read map parameters from settings
\r
1030 HMParams hm_params;
\r
1031 hm_params.blocksize = g_settings.getU16("heightmap_blocksize");
\r
1032 hm_params.randmax = g_settings.get("height_randmax");
\r
1033 hm_params.randfactor = g_settings.get("height_randfactor");
\r
1034 hm_params.base = g_settings.get("height_base");
\r
1036 MapParams map_params;
\r
1037 map_params.plants_amount = g_settings.getFloat("plants_amount");
\r
1038 map_params.ravines_amount = g_settings.getFloat("ravines_amount");
\r
1044 std::cout<<std::endl<<std::endl;
\r
1047 <<" .__ __ __ "<<std::endl
\r
1048 <<" _____ |__| ____ _____/ |_ ____ _______/ |_ "<<std::endl
\r
1049 <<" / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\"<<std::endl
\r
1050 <<"| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | "<<std::endl
\r
1051 <<"|__|_| /__|___| /\\___ >__| \\___ >____ > |__| "<<std::endl
\r
1052 <<" \\/ \\/ \\/ \\/ \\/ "<<std::endl
\r
1054 <<"Now with more waterish water!"
\r
1057 std::cout<<std::endl;
\r
1058 char templine[100];
\r
1061 bool dedicated = g_settings.getBoolAsk
\r
1062 ("dedicated_server", "Dedicated server?", false);
\r
1063 std::cout<<"dedicated = "<<dedicated<<std::endl;
\r
1066 u16 port = g_settings.getU16Ask("port", "Port", 30000);
\r
1067 std::cout<<"-> "<<port<<std::endl;
\r
1071 DSTACK("Dedicated server branch");
\r
1073 std::cout<<std::endl;
\r
1074 std::cout<<"========================"<<std::endl;
\r
1075 std::cout<<"Running dedicated server"<<std::endl;
\r
1076 std::cout<<"========================"<<std::endl;
\r
1077 std::cout<<std::endl;
\r
1079 Server server("../map", hm_params, map_params);
\r
1080 server.start(port);
\r
1084 // This is kind of a hack but can be done like this
\r
1085 // because server.step() is very light
\r
1087 server.step(0.030);
\r
1089 static int counter = 0;
\r
1095 core::list<PlayerInfo> list = server.getPlayerInfo();
\r
1096 core::list<PlayerInfo>::Iterator i;
\r
1097 static u32 sum_old = 0;
\r
1098 u32 sum = PIChecksum(list);
\r
1099 if(sum != sum_old)
\r
1101 std::cout<<DTIME<<"Player info:"<<std::endl;
\r
1102 for(i=list.begin(); i!=list.end(); i++)
\r
1104 i->PrintLine(&std::cout);
\r
1114 bool hosting = false;
\r
1115 char connect_name[100] = "";
\r
1117 std::cout<<"Address to connect to [empty = host a game]: ";
\r
1118 if(g_settings.get("address") != "" && is_yes(g_settings.get("host_game")) == false)
\r
1120 std::cout<<g_settings.get("address")<<std::endl;
\r
1121 snprintf(connect_name, 100, "%s", g_settings.get("address").c_str());
\r
1125 std::cin.getline(connect_name, 100);
\r
1128 if(connect_name[0] == 0){
\r
1129 snprintf(connect_name, 100, "127.0.0.1");
\r
1134 std::cout<<"-> hosting"<<std::endl;
\r
1136 std::cout<<"-> "<<connect_name<<std::endl;
\r
1138 char playername[PLAYERNAME_SIZE] = "";
\r
1139 if(g_settings.get("name") != "")
\r
1141 snprintf(playername, PLAYERNAME_SIZE, "%s", g_settings.get("name").c_str());
\r
1145 std::cout<<"Name of player: ";
\r
1146 std::cin.getline(playername, PLAYERNAME_SIZE);
\r
1148 std::cout<<"-> \""<<playername<<"\""<<std::endl;
\r
1151 Resolution selection
\r
1156 bool fullscreen = false;
\r
1158 if(g_settings.get("screenW") != "" && g_settings.get("screenH") != "")
\r
1160 screenW = atoi(g_settings.get("screenW").c_str());
\r
1161 screenH = atoi(g_settings.get("screenH").c_str());
\r
1165 u16 resolutions[][3] = {
\r
1166 //W, H, fullscreen
\r
1177 u16 res_count = sizeof(resolutions)/sizeof(resolutions[0]);
\r
1179 for(u16 i=0; i<res_count; i++)
\r
1181 std::cout<<(i+1)<<": "<<resolutions[i][0]<<"x"
\r
1182 <<resolutions[i][1];
\r
1183 if(resolutions[i][2])
\r
1184 std::cout<<" fullscreen"<<std::endl;
\r
1186 std::cout<<" windowed"<<std::endl;
\r
1188 std::cout<<"Select a window resolution number [empty = 2]: ";
\r
1189 std::cin.getline(templine, 100);
\r
1192 if(templine[0] == 0)
\r
1195 r0 = atoi(templine);
\r
1197 if(r0 > res_count || r0 == 0)
\r
1203 std::cout<<(i+1)<<": "<<resolutions[i][0]<<"x"
\r
1204 <<resolutions[i][1];
\r
1205 if(resolutions[i][2])
\r
1206 std::cout<<" fullscreen"<<std::endl;
\r
1208 std::cout<<" windowed"<<std::endl;
\r
1211 screenW = resolutions[r0-1][0];
\r
1212 screenH = resolutions[r0-1][1];
\r
1213 fullscreen = resolutions[r0-1][2];
\r
1218 MyEventReceiver receiver;
\r
1220 video::E_DRIVER_TYPE driverType;
\r
1223 //driverType = video::EDT_DIRECT3D9; // Doesn't seem to work
\r
1224 driverType = video::EDT_OPENGL;
\r
1226 driverType = video::EDT_OPENGL;
\r
1229 // create device and exit if creation failed
\r
1231 IrrlichtDevice *device;
\r
1232 device = createDevice(driverType,
\r
1233 core::dimension2d<u32>(screenW, screenH),
\r
1234 16, fullscreen, false, false, &receiver);
\r
1236 /*device = createDevice(driverType,
\r
1237 core::dimension2d<u32>(screenW, screenH),
\r
1238 16, fullscreen, false, true, &receiver);*/
\r
1241 return 1; // could not create selected driver.
\r
1243 g_device = device;
\r
1245 device->setResizable(true);
\r
1247 if(g_settings.getBool("random_input"))
\r
1248 g_input = new RandomInputHandler();
\r
1250 g_input = new RealInputHandler(device, &receiver);
\r
1253 Continue initialization
\r
1256 video::IVideoDriver* driver = device->getVideoDriver();
\r
1257 // These make the textures not to show at all
\r
1258 //driver->setTextureCreationFlag(video::ETCF_ALWAYS_16_BIT);
\r
1259 //driver->setTextureCreationFlag(video::ETCF_OPTIMIZED_FOR_SPEED );
\r
1261 //driver->setMinHardwareBufferVertexCount(1);
\r
1263 scene::ISceneManager* smgr = device->getSceneManager();
\r
1265 gui::IGUIEnvironment* guienv = device->getGUIEnvironment();
\r
1266 gui::IGUISkin* skin = guienv->getSkin();
\r
1267 gui::IGUIFont* font = guienv->getFont("../data/fontlucida.png");
\r
1269 skin->setFont(font);
\r
1270 //skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
\r
1271 skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
\r
1272 //skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
\r
1273 //skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
\r
1274 skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
\r
1275 skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
\r
1277 const wchar_t *text = L"Loading and connecting...";
\r
1278 core::vector2d<s32> center(screenW/2, screenH/2);
\r
1279 core::dimension2d<u32> textd = font->getDimension(text);
\r
1280 std::cout<<DTIME<<"Text w="<<textd.Width<<" h="<<textd.Height<<std::endl;
\r
1281 // Have to add a bit to disable the text from word wrapping
\r
1282 //core::vector2d<s32> textsize(textd.Width+4, textd.Height);
\r
1283 core::vector2d<s32> textsize(300, textd.Height);
\r
1284 core::rect<s32> textrect(center - textsize/2, center + textsize/2);
\r
1286 gui::IGUIStaticText *gui_loadingtext = guienv->addStaticText(
\r
1287 text, textrect, false, false);
\r
1288 gui_loadingtext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
\r
1290 driver->beginScene(true, true, video::SColor(255,0,0,0));
\r
1291 guienv->drawAll();
\r
1292 driver->endScene();
\r
1295 Initialize material array
\r
1298 //video::SMaterial g_materials[MATERIALS_COUNT];
\r
1299 for(u16 i=0; i<MATERIALS_COUNT; i++)
\r
1301 g_materials[i].Lighting = false;
\r
1302 g_materials[i].BackfaceCulling = false;
\r
1304 const char *filename = g_content_filenames[i];
\r
1305 if(filename != NULL){
\r
1306 video::ITexture *t = driver->getTexture(filename);
\r
1308 std::cout<<DTIME<<"Texture could not be loaded: \""
\r
1309 <<filename<<"\""<<std::endl;
\r
1312 g_materials[i].setTexture(0, driver->getTexture(filename));
\r
1314 //g_materials[i].setFlag(video::EMF_TEXTURE_WRAP, video::ETC_REPEAT);
\r
1315 g_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);
\r
1316 //g_materials[i].setFlag(video::EMF_ANISOTROPIC_FILTER, false);
\r
1317 //g_materials[i].setFlag(video::EMF_FOG_ENABLE, true);
\r
1320 g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
\r
1321 //g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
\r
1322 g_materials[CONTENT_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
\r
1324 /*g_mesh_materials[0].setTexture(0, driver->getTexture("../data/water.png"));
\r
1325 g_mesh_materials[1].setTexture(0, driver->getTexture("../data/grass.png"));
\r
1326 g_mesh_materials[2].setTexture(0, driver->getTexture("../data/stone.png"));
\r
1327 for(u32 i=0; i<3; i++)
\r
1329 g_mesh_materials[i].Lighting = false;
\r
1330 g_mesh_materials[i].BackfaceCulling = false;
\r
1331 g_mesh_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);
\r
1332 g_mesh_materials[i].setFlag(video::EMF_FOG_ENABLE, true);
\r
1336 Preload some random textures that are used in threads
\r
1339 g_texturecache.set("torch", driver->getTexture("../data/torch.png"));
\r
1340 g_texturecache.set("torch_on_floor", driver->getTexture("../data/torch_on_floor.png"));
\r
1341 g_texturecache.set("torch_on_ceiling", driver->getTexture("../data/torch_on_ceiling.png"));
\r
1344 Make a scope here for the client so that it gets removed
\r
1345 before the irrlicht device
\r
1349 std::cout<<DTIME<<"Creating server and client"<<std::endl;
\r
1354 SharedPtr<Server> server;
\r
1356 server = new Server("../map", hm_params, map_params);
\r
1357 server->start(port);
\r
1364 // TODO: Get rid of the g_materials parameter or it's globalness
\r
1365 Client client(device, g_materials,
\r
1366 g_settings.getFloat("client_delete_unused_sectors_timeout"),
\r
1369 Address connect_address(0,0,0,0, port);
\r
1371 connect_address.Resolve(connect_name);
\r
1373 catch(ResolveError &e)
\r
1375 std::cout<<DTIME<<"Couldn't resolve address"<<std::endl;
\r
1379 std::cout<<DTIME<<"Connecting to server..."<<std::endl;
\r
1380 client.connect(connect_address);
\r
1383 while(client.connectedAndInitialized() == false)
\r
1386 if(server != NULL){
\r
1387 server->step(0.1);
\r
1392 catch(con::PeerNotFoundException &e)
\r
1394 std::cout<<DTIME<<"Timed out."<<std::endl;
\r
1401 scene::ISceneNode* skybox = smgr->addSkyBoxSceneNode(
\r
1402 driver->getTexture("../data/skybox2.png"),
\r
1403 driver->getTexture("../data/skybox3.png"),
\r
1404 driver->getTexture("../data/skybox1.png"),
\r
1405 driver->getTexture("../data/skybox1.png"),
\r
1406 driver->getTexture("../data/skybox1.png"),
\r
1407 driver->getTexture("../data/skybox1.png"));
\r
1408 /* driver->getTexture("../data/irrlicht2_up.jpg"),
\r
1409 driver->getTexture("../data/irrlicht2_dn.jpg"),
\r
1410 driver->getTexture("../data/irrlicht2_lf.jpg"),
\r
1411 driver->getTexture("../data/irrlicht2_rt.jpg"),
\r
1412 driver->getTexture("../data/irrlicht2_ft.jpg"),
\r
1413 driver->getTexture("../data/irrlicht2_bk.jpg"));*/
\r
1416 Create the camera node
\r
1419 scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(
\r
1420 0, // Camera parent
\r
1421 v3f(BS*100, BS*2, BS*100), // Look from
\r
1422 v3f(BS*100+1, BS*2, BS*100), // Look to
\r
1426 if(camera == NULL)
\r
1429 video::SColor skycolor = video::SColor(255,90,140,200);
\r
1431 camera->setFOV(FOV_ANGLE);
\r
1433 // Just so big a value that everything rendered is visible
\r
1434 camera->setFarValue(100000*BS);
\r
1436 /*//f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;
\r
1437 f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;
\r
1439 camera->setFarValue(range);
\r
1443 video::EFT_FOG_LINEAR,
\r
1451 f32 camera_yaw = 0; // "right/left"
\r
1452 f32 camera_pitch = 0; // "up/down"
\r
1454 gui_loadingtext->remove();
\r
1457 Add some gui stuff
\r
1460 // First line of debug text
\r
1461 gui::IGUIStaticText *guitext = guienv->addStaticText(
\r
1463 core::rect<s32>(5, 5, 5+600, 5+textsize.Y),
\r
1465 // Second line of debug text
\r
1466 gui::IGUIStaticText *guitext2 = guienv->addStaticText(
\r
1468 core::rect<s32>(5, 5+(textsize.Y+5)*1, 5+600, (5+textsize.Y)*2),
\r
1471 // At the middle of the screen
\r
1472 // Object infos are shown in this
\r
1473 gui::IGUIStaticText *guitext_info = guienv->addStaticText(
\r
1475 core::rect<s32>(100, 70, 100+400, 70+(textsize.Y+5)),
\r
1478 // This is a copy of the inventory that the client's environment has
\r
1479 Inventory local_inventory(PLAYER_INVENTORY_SIZE);
\r
1481 GUIQuickInventory *quick_inventory = new GUIQuickInventory
\r
1482 (guienv, NULL, v2s32(10, 70), 5, &local_inventory);
\r
1485 Some statistics are collected in these
\r
1488 u32 scenetime = 0;
\r
1489 u32 endscenetime = 0;
\r
1497 virtual void sendText(std::string text) = 0;
\r
1500 struct TextDestSign : public TextDest
\r
1502 TextDestSign(v3s16 blockpos, s16 id, Client *client)
\r
1504 m_blockpos = blockpos;
\r
1506 m_client = client;
\r
1508 void sendText(std::string text)
\r
1510 dstream<<"Changing text of a sign object: "
\r
1511 <<text<<std::endl;
\r
1512 m_client->sendSignText(m_blockpos, m_id, text);
\r
1520 TextDest *textbuf_dest = NULL;
\r
1522 //gui::IGUIWindow* input_window = NULL;
\r
1523 gui::IGUIStaticText* input_guitext = NULL;
\r
1529 bool first_loop_after_window_activation = true;
\r
1531 // Time is in milliseconds
\r
1532 // NOTE: getRealTime() without run()s causes strange problems in wine
\r
1533 // NOTE: Have to call run() between calls of this to update the timer
\r
1534 u32 lasttime = device->getTimer()->getTime();
\r
1536 while(device->run())
\r
1538 // Hilight boxes collected during the loop and displayed
\r
1539 core::list< core::aabbox3d<f32> > hilightboxes;
\r
1542 std::wstring infotext;
\r
1544 //TimeTaker //timer1("//timer1", device);
\r
1546 // Time of frame without fps limit
\r
1550 // not using getRealTime is necessary for wine
\r
1551 u32 time = device->getTimer()->getTime();
\r
1552 if(time > lasttime)
\r
1553 busytime_u32 = time - lasttime;
\r
1556 busytime = busytime_u32 / 1000.0;
\r
1559 //std::cout<<"busytime_u32="<<busytime_u32<<std::endl;
\r
1561 // Absolutelu necessary for wine!
\r
1568 //updateViewingRange(dtime, &client);
\r
1569 updateViewingRange(busytime, &client);
\r
1576 float fps_max = g_settings.getFloat("fps_max");
\r
1577 u32 frametime_min = 1000./fps_max;
\r
1579 if(busytime_u32 < frametime_min)
\r
1581 u32 sleeptime = frametime_min - busytime_u32;
\r
1582 device->sleep(sleeptime);
\r
1586 // Absolutelu necessary for wine!
\r
1590 Time difference calculation
\r
1592 f32 dtime; // in seconds
\r
1594 u32 time = device->getTimer()->getTime();
\r
1595 if(time > lasttime)
\r
1596 dtime = (time - lasttime) / 1000.0;
\r
1602 Time average and jitter calculation
\r
1605 static f32 dtime_avg1 = 0.0;
\r
1606 dtime_avg1 = dtime_avg1 * 0.98 + dtime * 0.02;
\r
1607 f32 dtime_jitter1 = dtime - dtime_avg1;
\r
1609 static f32 dtime_jitter1_max_sample = 0.0;
\r
1610 static f32 dtime_jitter1_max_fraction = 0.0;
\r
1612 static f32 jitter1_max = 0.0;
\r
1613 static f32 counter = 0.0;
\r
1614 if(dtime_jitter1 > jitter1_max)
\r
1615 jitter1_max = dtime_jitter1;
\r
1620 dtime_jitter1_max_sample = jitter1_max;
\r
1621 dtime_jitter1_max_fraction
\r
1622 = dtime_jitter1_max_sample / (dtime_avg1+0.001);
\r
1623 jitter1_max = 0.0;
\r
1626 Control freetime ratio
\r
1628 /*if(dtime_jitter1_max_fraction > DTIME_JITTER_MAX_FRACTION)
\r
1630 if(g_freetime_ratio < FREETIME_RATIO_MAX)
\r
1631 g_freetime_ratio += 0.01;
\r
1635 if(g_freetime_ratio > FREETIME_RATIO_MIN)
\r
1636 g_freetime_ratio -= 0.01;
\r
1642 Busytime average and jitter calculation
\r
1645 static f32 busytime_avg1 = 0.0;
\r
1646 busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
\r
1647 f32 busytime_jitter1 = busytime - busytime_avg1;
\r
1649 static f32 busytime_jitter1_max_sample = 0.0;
\r
1650 static f32 busytime_jitter1_min_sample = 0.0;
\r
1652 static f32 jitter1_max = 0.0;
\r
1653 static f32 jitter1_min = 0.0;
\r
1654 static f32 counter = 0.0;
\r
1655 if(busytime_jitter1 > jitter1_max)
\r
1656 jitter1_max = busytime_jitter1;
\r
1657 if(busytime_jitter1 < jitter1_min)
\r
1658 jitter1_min = busytime_jitter1;
\r
1660 if(counter > 0.0){
\r
1662 busytime_jitter1_max_sample = jitter1_max;
\r
1663 busytime_jitter1_min_sample = jitter1_min;
\r
1664 jitter1_max = 0.0;
\r
1665 jitter1_min = 0.0;
\r
1670 Debug info for client
\r
1673 static float counter = 0.0;
\r
1678 client.printDebugInfo(std::cout);
\r
1683 Input handler step()
\r
1685 g_input->step(dtime);
\r
1696 Player speed control
\r
1699 if(g_game_focused)
\r
1706 bool a_superspeed,
\r
1709 PlayerControl control(
\r
1710 g_input->isKeyDown(irr::KEY_KEY_W),
\r
1711 g_input->isKeyDown(irr::KEY_KEY_S),
\r
1712 g_input->isKeyDown(irr::KEY_KEY_A),
\r
1713 g_input->isKeyDown(irr::KEY_KEY_D),
\r
1714 g_input->isKeyDown(irr::KEY_SPACE),
\r
1715 g_input->isKeyDown(irr::KEY_KEY_2),
\r
1719 client.setPlayerControl(control);
\r
1723 // Set every key to inactive
\r
1724 PlayerControl control;
\r
1725 client.setPlayerControl(control);
\r
1730 Process environment
\r
1734 //TimeTaker timer("client.step(dtime)", device);
\r
1735 client.step(dtime);
\r
1736 //client.step(dtime_avg1);
\r
1739 if(server != NULL)
\r
1741 //TimeTaker timer("server->step(dtime)", device);
\r
1742 server->step(dtime);
\r
1745 v3f player_position = client.getPlayerPosition();
\r
1747 //TimeTaker //timer2("//timer2", device);
\r
1750 Mouse and camera control
\r
1753 if(device->isWindowActive() && g_game_focused)
\r
1755 device->getCursorControl()->setVisible(false);
\r
1757 if(first_loop_after_window_activation){
\r
1758 //std::cout<<"window active, first loop"<<std::endl;
\r
1759 first_loop_after_window_activation = false;
\r
1762 s32 dx = g_input->getMousePos().X - 320;
\r
1763 s32 dy = g_input->getMousePos().Y - 240;
\r
1764 //std::cout<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
\r
1765 camera_yaw -= dx*0.2;
\r
1766 camera_pitch += dy*0.2;
\r
1767 if(camera_pitch < -89.5) camera_pitch = -89.5;
\r
1768 if(camera_pitch > 89.5) camera_pitch = 89.5;
\r
1770 g_input->setMousePos(320, 240);
\r
1773 device->getCursorControl()->setVisible(true);
\r
1775 //std::cout<<"window inactive"<<std::endl;
\r
1776 first_loop_after_window_activation = true;
\r
1779 camera_yaw = wrapDegrees(camera_yaw);
\r
1780 camera_pitch = wrapDegrees(camera_pitch);
\r
1782 v3f camera_direction = v3f(0,0,1);
\r
1783 camera_direction.rotateYZBy(camera_pitch);
\r
1784 camera_direction.rotateXZBy(camera_yaw);
\r
1786 v3f camera_position =
\r
1787 player_position + v3f(0, BS+BS/2, 0);
\r
1789 camera->setPosition(camera_position);
\r
1790 // *100.0 helps in large map coordinates
\r
1791 camera->setTarget(camera_position + camera_direction * 100.0);
\r
1793 if(FIELD_OF_VIEW_TEST){
\r
1794 //client.m_env.getMap().updateCamera(v3f(0,0,0), v3f(0,0,1));
\r
1795 client.updateCamera(v3f(0,0,0), v3f(0,0,1));
\r
1798 //client.m_env.getMap().updateCamera(camera_position, camera_direction);
\r
1799 //TimeTaker timer("client.updateCamera", device);
\r
1800 client.updateCamera(camera_position, camera_direction);
\r
1804 //TimeTaker //timer3("//timer3", device);
\r
1807 Calculate what block is the crosshair pointing to
\r
1810 //u32 t1 = device->getTimer()->getRealTime();
\r
1812 //f32 d = 4; // max. distance
\r
1813 f32 d = 4; // max. distance
\r
1814 core::line3d<f32> shootline(camera_position,
\r
1815 camera_position + camera_direction * BS * (d+1));
\r
1817 MapBlockObject *selected_object = client.getSelectedObject
\r
1818 (d*BS, camera_position, shootline);
\r
1820 if(selected_object != NULL)
\r
1822 //dstream<<"Client returned selected_object != NULL"<<std::endl;
\r
1824 core::aabbox3d<f32> box_on_map
\r
1825 = selected_object->getSelectionBoxOnMap();
\r
1827 hilightboxes.push_back(box_on_map);
\r
1829 infotext = narrow_to_wide(selected_object->infoText());
\r
1831 if(g_input->getLeftClicked())
\r
1833 std::cout<<DTIME<<"Left-clicked object"<<std::endl;
\r
1834 client.clickObject(0, selected_object->getBlock()->getPos(),
\r
1835 selected_object->getId(), g_selected_item);
\r
1837 else if(g_input->getRightClicked())
\r
1839 std::cout<<DTIME<<"Right-clicked object"<<std::endl;
\r
1841 Check if we want to modify the object ourselves
\r
1843 if(selected_object->getTypeId() == MAPBLOCKOBJECT_TYPE_SIGN)
\r
1845 dstream<<"Sign object right-clicked"<<std::endl;
\r
1849 input_guitext = guienv->addStaticText(L"",
\r
1850 core::rect<s32>(150,100,350,120),
\r
1852 false, // wordwrap?
\r
1855 input_guitext->setDrawBackground(true);
\r
1857 g_text_buffer = L"";
\r
1858 g_text_buffer_accepted = false;
\r
1859 textbuf_dest = new TextDestSign(
\r
1860 selected_object->getBlock()->getPos(),
\r
1861 selected_object->getId(),
\r
1865 Otherwise pass the event to the server as-is
\r
1869 client.clickObject(1, selected_object->getBlock()->getPos(),
\r
1870 selected_object->getId(), g_selected_item);
\r
1874 else // selected_object == NULL
\r
1877 bool nodefound = false;
\r
1879 v3s16 neighbourpos;
\r
1880 core::aabbox3d<f32> nodefacebox;
\r
1881 f32 mindistance = BS * 1001;
\r
1883 v3s16 pos_i = floatToInt(player_position);
\r
1885 /*std::cout<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
\r
1889 s16 ystart = pos_i.Y + 0 - (camera_direction.Y<0 ? a : 1);
\r
1890 s16 zstart = pos_i.Z - (camera_direction.Z<0 ? a : 1);
\r
1891 s16 xstart = pos_i.X - (camera_direction.X<0 ? a : 1);
\r
1892 s16 yend = pos_i.Y + 1 + (camera_direction.Y>0 ? a : 1);
\r
1893 s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);
\r
1894 s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);
\r
1896 for(s16 y = ystart; y <= yend; y++)
\r
1897 for(s16 z = zstart; z <= zend; z++)
\r
1898 for(s16 x = xstart; x <= xend; x++)
\r
1903 n = client.getNode(v3s16(x,y,z));
\r
1904 if(content_pointable(n.d) == false)
\r
1907 catch(InvalidPositionException &e)
\r
1913 v3f npf = intToFloat(np);
\r
1918 v3s16(0,0,1), // back
\r
1919 v3s16(0,1,0), // top
\r
1920 v3s16(1,0,0), // right
\r
1921 v3s16(0,0,-1), // front
\r
1922 v3s16(0,-1,0), // bottom
\r
1923 v3s16(-1,0,0), // left
\r
1929 if(n.d == CONTENT_LIGHT)
\r
1931 v3s16 dir = unpackDir(n.dir);
\r
1932 v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
\r
1933 dir_f *= BS/2 - BS/6 - BS/20;
\r
1934 v3f cpf = npf + dir_f;
\r
1935 f32 distance = (cpf - camera_position).getLength();
\r
1937 core::aabbox3d<f32> box;
\r
1940 if(dir == v3s16(0,-1,0))
\r
1942 box = core::aabbox3d<f32>(
\r
1943 npf - v3f(BS/6, BS/2, BS/6),
\r
1944 npf + v3f(BS/6, -BS/2+BS/3*2, BS/6)
\r
1948 else if(dir == v3s16(0,1,0))
\r
1950 box = core::aabbox3d<f32>(
\r
1951 npf - v3f(BS/6, -BS/2+BS/3*2, BS/6),
\r
1952 npf + v3f(BS/6, BS/2, BS/6)
\r
1958 box = core::aabbox3d<f32>(
\r
1959 cpf - v3f(BS/6, BS/3, BS/6),
\r
1960 cpf + v3f(BS/6, BS/3, BS/6)
\r
1964 if(distance < mindistance)
\r
1966 if(box.intersectsWithLine(shootline))
\r
1970 neighbourpos = np;
\r
1971 mindistance = distance;
\r
1972 nodefacebox = box;
\r
1981 for(u16 i=0; i<6; i++)
\r
1983 v3f dir_f = v3f(dirs[i].X,
\r
1984 dirs[i].Y, dirs[i].Z);
\r
1985 v3f centerpoint = npf + dir_f * BS/2;
\r
1987 (centerpoint - camera_position).getLength();
\r
1989 if(distance < mindistance)
\r
1991 core::CMatrix4<f32> m;
\r
1992 m.buildRotateFromTo(v3f(0,0,1), dir_f);
\r
1994 // This is the back face
\r
1995 v3f corners[2] = {
\r
1996 v3f(BS/2, BS/2, BS/2),
\r
1997 v3f(-BS/2, -BS/2, BS/2+d)
\r
2000 for(u16 j=0; j<2; j++)
\r
2002 m.rotateVect(corners[j]);
\r
2003 corners[j] += npf;
\r
2006 core::aabbox3d<f32> facebox(corners[0]);
\r
2007 facebox.addInternalPoint(corners[1]);
\r
2009 if(facebox.intersectsWithLine(shootline))
\r
2013 neighbourpos = np + dirs[i];
\r
2014 mindistance = distance;
\r
2015 nodefacebox = facebox;
\r
2017 } // if distance < mindistance
\r
2019 } // regular block
\r
2024 //std::cout<<DTIME<<"nodefound == true"<<std::endl;
\r
2025 //std::cout<<DTIME<<"nodepos=("<<nodepos.X<<","<<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
\r
2026 //std::cout<<DTIME<<"neighbourpos=("<<neighbourpos.X<<","<<neighbourpos.Y<<","<<neighbourpos.Z<<")"<<std::endl;
\r
2028 static v3s16 nodepos_old(-1,-1,-1);
\r
2029 if(nodepos != nodepos_old){
\r
2030 std::cout<<DTIME<<"Pointing at ("<<nodepos.X<<","
\r
2031 <<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
\r
2032 nodepos_old = nodepos;
\r
2034 /*wchar_t positiontext[20];
\r
2035 swprintf(positiontext, 20, L"(%i,%i,%i)",
\r
2036 nodepos.X, nodepos.Y, nodepos.Z);
\r
2037 positiontextgui->setText(positiontext);*/
\r
2040 hilightboxes.push_back(nodefacebox);
\r
2042 if(g_input->getLeftClicked())
\r
2044 //std::cout<<DTIME<<"Removing node"<<std::endl;
\r
2045 //client.removeNode(nodepos);
\r
2046 std::cout<<DTIME<<"Ground left-clicked"<<std::endl;
\r
2047 client.clickGround(0, nodepos, neighbourpos, g_selected_item);
\r
2049 if(g_input->getRightClicked())
\r
2051 //std::cout<<DTIME<<"Placing node"<<std::endl;
\r
2052 //client.addNodeFromInventory(neighbourpos, g_selected_item);
\r
2053 std::cout<<DTIME<<"Ground right-clicked"<<std::endl;
\r
2054 client.clickGround(1, nodepos, neighbourpos, g_selected_item);
\r
2058 //std::cout<<DTIME<<"nodefound == false"<<std::endl;
\r
2059 //positiontextgui->setText(L"");
\r
2062 } // selected_object == NULL
\r
2064 g_input->resetLeftClicked();
\r
2065 g_input->resetRightClicked();
\r
2068 Calculate stuff for drawing
\r
2071 v2u32 screensize = driver->getScreenSize();
\r
2072 core::vector2d<s32> displaycenter(screensize.X/2,screensize.Y/2);
\r
2074 camera->setAspectRatio((f32)screensize.X / (f32)screensize.Y);
\r
2077 Update gui stuff (0ms)
\r
2080 //TimeTaker guiupdatetimer("Gui updating", device);
\r
2083 wchar_t temptext[100];
\r
2085 static float drawtime_avg = 0;
\r
2086 drawtime_avg = drawtime_avg * 0.98 + (float)drawtime*0.02;
\r
2087 static float scenetime_avg = 0;
\r
2088 scenetime_avg = scenetime_avg * 0.98 + (float)scenetime*0.02;
\r
2089 static float endscenetime_avg = 0;
\r
2090 endscenetime_avg = endscenetime_avg * 0.98 + (float)endscenetime*0.02;
\r
2092 swprintf(temptext, 100, L"Minetest-c55 ("
\r
2094 L", R: range_all=%i"
\r
2096 L" drawtime=%.0f, scenetime=%.0f, endscenetime=%.0f",
\r
2098 g_viewing_range_all,
\r
2104 guitext->setText(temptext);
\r
2108 wchar_t temptext[100];
\r
2109 /*swprintf(temptext, 100,
\r
2111 L"% .3f < btime_jitter < % .3f"
\r
2112 L", dtime_jitter = % .1f %%"
\r
2113 //L", ftime_ratio = % .3f"
\r
2115 busytime_jitter1_min_sample,
\r
2116 busytime_jitter1_max_sample,
\r
2117 dtime_jitter1_max_fraction * 100.0
\r
2118 //g_freetime_ratio
\r
2120 swprintf(temptext, 100,
\r
2121 L"(% .1f, % .1f, % .1f)"
\r
2122 L" (% .3f < btime_jitter < % .3f"
\r
2123 L", dtime_jitter = % .1f %%)",
\r
2124 player_position.X/BS,
\r
2125 player_position.Y/BS,
\r
2126 player_position.Z/BS,
\r
2127 busytime_jitter1_min_sample,
\r
2128 busytime_jitter1_max_sample,
\r
2129 dtime_jitter1_max_fraction * 100.0
\r
2132 guitext2->setText(temptext);
\r
2136 /*wchar_t temptext[100];
\r
2137 swprintf(temptext, 100,
\r
2138 SWPRINTF_CHARSTRING,
\r
2139 infotext.substr(0,99).c_str()
\r
2142 guitext_info->setText(temptext);*/
\r
2144 guitext_info->setText(infotext.c_str());
\r
2151 static u16 old_selected_item = 65535;
\r
2152 if(client.getLocalInventoryUpdated()
\r
2153 || g_selected_item != old_selected_item)
\r
2155 old_selected_item = g_selected_item;
\r
2156 //std::cout<<"Updating local inventory"<<std::endl;
\r
2157 client.getLocalInventory(local_inventory);
\r
2158 quick_inventory->setSelection(g_selected_item);
\r
2159 quick_inventory->update();
\r
2162 if(input_guitext != NULL)
\r
2164 /*wchar_t temptext[100];
\r
2165 swprintf(temptext, 100,
\r
2166 SWPRINTF_CHARSTRING,
\r
2167 g_text_buffer.substr(0,99).c_str()
\r
2169 input_guitext->setText(g_text_buffer.c_str());
\r
2175 if(input_guitext != NULL && g_text_buffer_accepted)
\r
2177 input_guitext->remove();
\r
2178 input_guitext = NULL;
\r
2180 if(textbuf_dest != NULL)
\r
2182 std::string text = wide_to_narrow(g_text_buffer);
\r
2183 dstream<<"Sending text: "<<text<<std::endl;
\r
2184 textbuf_dest->sendText(text);
\r
2185 delete textbuf_dest;
\r
2186 textbuf_dest = NULL;
\r
2192 //guiupdatetimer.stop();
\r
2198 TimeTaker drawtimer("Drawing", device);
\r
2201 Background color is choosen based on whether the player is
\r
2202 much beyond the initial ground level
\r
2204 /*video::SColor bgcolor;
\r
2205 v3s16 p0 = Map::floatToInt(player_position);
\r
2206 // Does this make short random delays?
\r
2207 // NOTE: no need for this, sky doesn't show underground with
\r
2209 bool is_underground = client.isNodeUnderground(p0);
\r
2210 //bool is_underground = false;
\r
2211 if(is_underground == false)
\r
2212 bgcolor = video::SColor(255,90,140,200);
\r
2214 bgcolor = video::SColor(255,0,0,0);*/
\r
2216 //video::SColor bgcolor = video::SColor(255,90,140,200);
\r
2217 video::SColor bgcolor = skycolor;
\r
2220 driver->beginScene(true, true, bgcolor);
\r
2224 //std::cout<<DTIME<<"smgr->drawAll()"<<std::endl;
\r
2227 TimeTaker timer("smgr", device);
\r
2229 scenetime = timer.stop(true);
\r
2233 //TimeTaker timer9("auxiliary drawings", device);
\r
2236 driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
\r
2237 displaycenter + core::vector2d<s32>(10,0),
\r
2238 video::SColor(255,255,255,255));
\r
2239 driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
\r
2240 displaycenter + core::vector2d<s32>(0,10),
\r
2241 video::SColor(255,255,255,255));
\r
2244 //TimeTaker //timer10("//timer10", device);
\r
2246 video::SMaterial m;
\r
2248 m.Lighting = false;
\r
2249 driver->setMaterial(m);
\r
2251 driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
\r
2253 for(core::list< core::aabbox3d<f32> >::Iterator i=hilightboxes.begin();
\r
2254 i != hilightboxes.end(); i++)
\r
2256 /*std::cout<<"hilightbox min="
\r
2257 <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
\r
2259 <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
\r
2261 driver->draw3DBox(*i, video::SColor(255,0,0,0));
\r
2267 //TimeTaker //timer11("//timer11", device);
\r
2273 guienv->drawAll();
\r
2277 TimeTaker timer("endScene", device);
\r
2278 driver->endScene();
\r
2279 endscenetime = timer.stop(true);
\r
2282 drawtime = drawtimer.stop(true);
\r
2288 static s16 lastFPS = 0;
\r
2289 //u16 fps = driver->getFPS();
\r
2290 u16 fps = (1.0/dtime_avg1);
\r
2292 if (lastFPS != fps)
\r
2294 core::stringw str = L"Minetest [";
\r
2295 str += driver->getName();
\r
2299 device->setWindowCaption(str.c_str());
\r
2305 device->yield();*/
\r
2308 } // client is deleted at this point
\r
2313 In the end, delete the Irrlicht device.
\r
2318 catch(con::PeerNotFoundException &e)
\r
2320 dstream<<DTIME<<"Connection timed out."<<std::endl;
\r
2322 #if CATCH_UNHANDLED_EXCEPTIONS
\r
2324 This is what has to be done in every thread to get suitable debug info
\r
2326 catch(std::exception &e)
\r
2328 dstream<<std::endl<<DTIME<<"An unhandled exception occurred: "
\r
2329 <<e.what()<<std::endl;
\r
2334 debugstreams_deinit();
\r