\r
/*\r
=============================== NOTES ==============================\r
+NOTE: Things starting with TODO are sometimes only suggestions.\r
\r
NOTE: VBO cannot be turned on for fast-changing stuff because there\r
- is an apparanet memory leak in irrlicht when using it\r
+ is an apparanet memory leak in irrlicht when using it (not sure)\r
\r
-SUGGESTION: add a second lighting value to the MS nibble of param of\r
- air to tell how bright the air node is when there is no sunlight.\r
- When day changes to night, these two values can be interpolated.\r
-TODO: Fix address to be ipv6 compatible\r
-\r
-TODO: ESC Pause mode in which the cursor is not kept at the center of window.\r
-TODO: Stop player if focus of window is taken away (go to pause mode)\r
-TODO: Optimize and fix makeFastFace or whatever it's called\r
- - Face calculation is the source of CPU usage on the client\r
-SUGGESTION: The client will calculate and send lighting changes and\r
- the server will randomly check some of them and kick the client out\r
- if it fails to calculate them right.\r
- - Actually, it could just start ignoring them and calculate them\r
- itself.\r
-SUGGESTION: Combine MapBlock's face caches to so big pieces that VBO\r
- gets used\r
- - That is >500 vertices\r
-\r
-TODO: Better dungeons\r
-TODO: There should be very slight natural caves also, starting from\r
- only a straightened-up cliff\r
-\r
-TODO: Changing of block with mouse wheel or something\r
-TODO: Menus\r
-\r
-TODO: Mobs\r
- - Server:\r
- - One single map container with ids as keys\r
- - Client:\r
- - ?\r
-TODO: - Keep track of the place of the mob in the last few hundreth's\r
- of a second - then, if a player hits it, take the value that is\r
- avg_rtt/2 before the moment the packet is received.\r
-TODO: - Scripting\r
-\r
-SUGGESTION: Modify client to calculate single changes asynchronously\r
-\r
-TODO: Moving players more smoothly. Calculate moving animation from\r
- data sent by server.\r
-\r
-TODO: There are some lighting-related todos and fixmes in\r
- ServerMap::emergeBlock\r
+NOTE: iostream.imbue(std::locale("C")) is very slow\r
+NOTE: Global locale is now set at initialization\r
\r
-TODO: Make a dirt node and use it under water\r
+SUGG: Fix address to be ipv6 compatible\r
\r
FIXME: When a new sector is generated, it may change the ground level\r
of it's and it's neighbors border that two blocks that are\r
using for UnlimitedHeightmap? (getting all neighbors\r
when generating)\r
\r
-TODO: Set server to automatically find a good spawning place in some\r
- place where there is water and land.\r
- - Map to have a getWalkableNear(p)\r
-\r
-TODO: Transfer more blocks in a single packet\r
+SUGG: Transfer more blocks in a single packet\r
SUGG: A blockdata combiner class, to which blocks are added and at\r
destruction it sends all the stuff in as few packets as possible.\r
\r
-TODO: If player is on ground, mainly fetch ground-level blocks\r
-TODO: Fetch stuff mainly from the viewing direction\r
+SUGG: If player is on ground, mainly fetch ground-level blocks\r
+SUGG: Fetch stuff mainly from the viewing direction\r
\r
-TODO: Expose Connection's seqnums and ACKs to server and client.\r
+SUGG: Expose Connection's seqnums and ACKs to server and client.\r
- This enables saving many packets and making a faster connection\r
- This also enables server to check if client has received the\r
most recent block sent, for example.\r
+SUGG: Add a sane bandwidth throttling system to Connection\r
+\r
+SUGG: More fine-grained control of client's dumping of blocks from\r
+ memory\r
+ - ...What does this mean in the first place?\r
+\r
+SUGG: A map editing mode (similar to dedicated server mode)\r
\r
SUGG: Add a time value to the param of footstepped grass and check it\r
against a global timer when a block is accessed, to make old\r
steps fade away.\r
\r
-FIXME: There still are *some* tiny glitches in lighting as seen from\r
- the client side. The server calculates them right but sometimes\r
- they don't get transferred properly.\r
- - Server probably checks that a block is not sent, then continues\r
- to sending it, then the emerge thread marks it as unsent and then\r
- the sender sends the block as it was before emerging?\r
-TODO: How about adding a "revision" field to MapBlocks?\r
+SUGG: Make a copy of close-range environment on client for showing\r
+ on screen, with minimal mutexes to slow down the main loop\r
\r
-TODO: More fine-grained control of client's dumping of blocks from\r
- memory\r
+SUGG: Make a PACKET_COMBINED which contains many subpackets. Utilize\r
+ it by sending more stuff in a single packet.\r
+ - Add a packet queue to RemoteClient, from which packets will be\r
+ combined with object data packets\r
+ - This is not exactly trivial: the object data packets are\r
+ sometimes very big by themselves\r
+\r
+SUGG: Split MapBlockObject serialization to to-client and to-disk\r
+ - This will allow saving ages of rats on disk but not sending\r
+ them to clients\r
+\r
+SUGG: Implement lighting using VoxelManipulator\r
+ - Would it be significantly faster?\r
+\r
+FIXME: Rats somehow go underground sometimes (you can see it in water)\r
+ - Does their position get saved to a border value or something?\r
+ - Does this happen anymore?\r
+\r
+SUGG: MovingObject::move and Player::move are basically the same.\r
+ combine them.\r
+\r
+SUGG: Implement a "Fast check queue" (a queue with a map for checking\r
+ if something is already in it)\r
+ - Use it in active block queue in water flowing\r
+\r
+SUGG: Signs could be done in the same way as torches. For this, blocks\r
+ need an additional metadata field for the texts\r
+\r
+SUGG: Precalculate lighting translation table at runtime (at startup)\r
+\r
+SUGG: A version number to blocks, which increments when the block is\r
+ modified (node add/remove, water update, lighting update)\r
+ - This can then be used to make sure the most recent version of\r
+ a block has been sent to client\r
+\r
+TODO: Stop player if focus of window is taken away (go to pause mode)\r
+\r
+TODO: Combine MapBlock's face caches to so big pieces that VBO\r
+ gets used\r
+ - That is >500 vertices\r
+\r
+TODO: Better dungeons\r
+TODO: Cliffs, arcs\r
+\r
+TODO: Menus\r
+\r
+TODO: Mobs\r
+ - Server:\r
+ - One single map container with ids as keys\r
+ - Client:\r
+ - ?\r
+TODO: - Keep track of the place of the mob in the last few hundreth's\r
+ of a second - then, if a player hits it, take the value that is\r
+ avg_rtt/2 before the moment the packet is received.\r
+TODO: - Scripting\r
+\r
+TODO: Moving players more smoothly. Calculate moving animation\r
+ in a way that doesn't make the player jump to the right place\r
+ immediately when the server sends a new position\r
+\r
+TODO: There are some lighting-related todos and fixmes in\r
+ ServerMap::emergeBlock\r
+\r
+TODO: Proper handling of spawning place (try to find something that\r
+ is not in the middle of an ocean (some land to stand on at\r
+ least) and save it in map config.\r
\r
-TODO: Somehow prioritize the sending of blocks and combine the block\r
- send queue lengths\r
- - Take two blocks to be sent next from each client and assign\r
- a priority value to them\r
- - Priority is the same as distance from player\r
- - Take the highest priority ones and send them. Send as many as\r
- fits in the global send queue maximum length (sum of lengths\r
- of client queues)\r
TODO: Make the amount of blocks sending to client and the total\r
amount of blocks dynamically limited. Transferring blocks is the\r
main network eater of this system, so it is the one that has\r
to be throttled so that RTTs stay low.\r
-FIXME: There is a bug that sometimes the EmergeThread bumps to\r
- the client's emerge counter being already 0, and also the\r
- sending queue size of the client can float to 1 or 2, which\r
- stops the map from loading at all.\r
- - A quick hack could be applied to ignore the error of\r
- being at 0 and timing out old entries\r
-SUGG: Make client send GOTBLOCKS before updating meshes\r
\r
TODO: Server to load starting inventory from disk\r
\r
-NOTE: iostream.imbue(std::locale("C")) is very slow\r
-NOTE: Global locale is now set at initialization\r
-\r
-TODO: PLayers to only be hidden when the client quits.\r
+TODO: Players to only be hidden when the client quits.\r
TODO: - Players to be saved on disk, with inventory\r
TODO: Players to be saved as text in map/players/<name>\r
\r
-SUGGESTION: A map editing mode (similar to dedicated server mode)\r
-\r
-TODO: Maybe: Create a face calculation queue on the client that is\r
- processed in a separate thread\r
-TODO: Make client's mesh updates to happen in a thread similar to\r
- server's EmergeThread.\r
- - This is not really needed, mesh update is really fast\r
- - Instead, the lighting update can be slow\r
- - So, this todo is not really a todo. It is a not-todo.\r
-SUGG: Make server to send all modified blocks after a node change\r
- after all the stuff including lighting have been updated\r
-\r
TODO: Make fetching sector's blocks more efficient when rendering\r
sectors that have very large amounts of blocks (on client)\r
\r
- A "near blocks" buffer, in which some nearby blocks are stored.\r
- For all blocks in the buffer, objects are stepped(). This\r
means they are active.\r
- - TODO All blocks going in and out of the buffer are recorded.\r
- - TODO For outgoing blocks, a timestamp is written.\r
- - TODO For incoming blocks, the time difference is calculated and\r
+ - TODO: A global active buffer is needed for the server\r
+ - TODO: A timestamp to blocks\r
+ - TODO: All blocks going in and out of the buffer are recorded.\r
+ - TODO: For outgoing blocks, timestamp is written.\r
+ - TODO: For incoming blocks, time difference is calculated and\r
objects are stepped according to it.\r
-TODO: A timestamp to blocks\r
\r
TODO: Add config parameters for server's sending and generating distance\r
\r
mode\r
\r
TODO: Untie client network operations from framerate\r
+ - Needs some input queues or something\r
\r
-SUGG: Make a copy of close-range environment on client for showing\r
- on screen, with minimal mutexes to slow the main loop down\r
+TODO: Get rid of GotSplitPacketException\r
\r
-SUGG: Make a PACKET_COMBINED which contains many subpackets. Utilize\r
- it by sending more stuff in a single packet.\r
- - Add a packet queue to RemoteClient, from which packets will be\r
- combined with object data packets\r
- - This is not exactly trivial: the object data packets are\r
- sometimes very big by themselves\r
+TODO: Check what goes wrong with caching map to disk (Kray)\r
\r
-SUGG: Split MapBlockObject serialization to to-client and to-disk\r
- - This will allow saving ages of rats on disk but not sending\r
- them to clients\r
+TODO: Remove LazyMeshUpdater. It is not used as supposed.\r
\r
-TODO: Fix the long-lived Server Block Emerge Jam bug\r
- - Is it related to the client deleting blocks?\r
+TODO: Node cracking animation when digging\r
+ - TODO: A way to generate new textures by combining textures\r
+ - TODO: Mesh update to fetch cracked faces from the former\r
+\r
+TODO: Add server unused sector deletion settings to settings\r
+\r
+TODO: TOSERVER_LEAVE\r
\r
Doing now:\r
======================================================================\r
\r
-\r
======================================================================\r
\r
*/\r
the starting place to a static direction.\r
\r
This allows one to move around with the player and see what\r
- is actually drawn behind solid things etc.\r
+ is actually drawn behind solid things and behind the player.\r
*/\r
#define FIELD_OF_VIEW_TEST 0\r
\r
#ifdef _MSC_VER\r
#pragma comment(lib, "Irrlicht.lib")\r
#pragma comment(lib, "jthread.lib")\r
+#pragma comment(lib, "zlibwapi.lib")\r
// This would get rid of the console window\r
//#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")\r
#endif\r
#include <fstream>\r
#include <time.h>\r
#include <jmutexautolock.h>\r
+#include <locale.h>\r
#include "common_irrlicht.h"\r
#include "debug.h"\r
#include "map.h"\r
#include "constants.h"\r
#include "strfnd.h"\r
#include "porting.h"\r
-#include <locale.h>\r
+#include "guiPauseMenu.h"\r
\r
IrrlichtDevice *g_device = NULL;\r
\r
-const char *g_material_filenames[MATERIALS_COUNT] =\r
+/*const char *g_content_filenames[MATERIALS_COUNT] =\r
{\r
"../data/stone.png",\r
"../data/grass.png",\r
"../data/water.png",\r
- "../data/light.png",\r
+ "../data/torch_on_floor.png",\r
"../data/tree.png",\r
"../data/leaves.png",\r
"../data/grass_footsteps.png",\r
- "../data/mese.png"\r
+ "../data/mese.png",\r
+ "../data/mud.png",\r
+ "../data/water.png", // CONTENT_OCEAN\r
};\r
\r
-video::SMaterial g_materials[MATERIALS_COUNT];\r
-//video::SMaterial g_mesh_materials[3];\r
+// Material cache\r
+video::SMaterial g_materials[MATERIALS_COUNT];*/\r
+\r
+// Texture cache\r
+TextureCache g_texturecache;\r
+\r
\r
// All range-related stuff below is locked behind this\r
JMutex g_range_mutex;\r
\r
// Blocks are viewed in this range from the player\r
s16 g_viewing_range_nodes = 60;\r
+//s16 g_viewing_range_nodes = 0;\r
\r
// This is updated by the client's fetchBlocks routine\r
//s16 g_actual_viewing_range_nodes = VIEWING_RANGE_NODES_DEFAULT;\r
These are loaded from the config file.\r
*/\r
\r
-std::string g_dedicated_server;\r
-\r
-// Client stuff\r
-float g_wanted_fps = FPS_DEFAULT_WANTED;\r
-float g_fps_max = FPS_DEFAULT_MAX;\r
-s16 g_viewing_range_nodes_max = 300;\r
-s16 g_viewing_range_nodes_min = 20;\r
-std::string g_screenW;\r
-std::string g_screenH;\r
-std::string g_host_game;\r
-std::string g_port;\r
-std::string g_address;\r
-std::string g_name;\r
-bool g_random_input = false;\r
-float g_client_delete_unused_sectors_timeout = 1200;\r
-\r
-// Server stuff\r
-bool g_creative_mode = false;\r
-HMParams g_hm_params;\r
-MapParams g_map_params;\r
-float g_objectdata_interval = 0.2;\r
-u16 g_active_object_range = 2;\r
+Settings g_settings;\r
+\r
+// Sets default settings\r
+void set_default_settings()\r
+{\r
+ // Client stuff\r
+ g_settings.setDefault("wanted_fps", "30");\r
+ g_settings.setDefault("fps_max", "60");\r
+ g_settings.setDefault("viewing_range_nodes_max", "300");\r
+ g_settings.setDefault("viewing_range_nodes_min", "35");\r
+ g_settings.setDefault("screenW", "");\r
+ g_settings.setDefault("screenH", "");\r
+ g_settings.setDefault("host_game", "");\r
+ g_settings.setDefault("port", "");\r
+ g_settings.setDefault("address", "");\r
+ g_settings.setDefault("name", "");\r
+ g_settings.setDefault("random_input", "false");\r
+ g_settings.setDefault("client_delete_unused_sectors_timeout", "1200");\r
+ g_settings.setDefault("enable_fog", "true");\r
+\r
+ // Server stuff\r
+ g_settings.setDefault("creative_mode", "false");\r
+ g_settings.setDefault("heightmap_blocksize", "32");\r
+ g_settings.setDefault("height_randmax", "constant 50.0");\r
+ g_settings.setDefault("height_randfactor", "constant 0.6");\r
+ g_settings.setDefault("height_base", "linear 0 0 0");\r
+ g_settings.setDefault("plants_amount", "1.0");\r
+ g_settings.setDefault("ravines_amount", "1.0");\r
+ g_settings.setDefault("objectdata_interval", "0.2");\r
+ g_settings.setDefault("active_object_range", "2");\r
+ g_settings.setDefault("max_simultaneous_block_sends_per_client", "1");\r
+ g_settings.setDefault("max_simultaneous_block_sends_server_total", "4");\r
+ g_settings.setDefault("disable_water_climb", "true");\r
+ g_settings.setDefault("endless_water", "true");\r
+ g_settings.setDefault("max_block_send_distance", "5");\r
+ g_settings.setDefault("max_block_generate_distance", "4");\r
+}\r
\r
/*\r
Random stuff\r
std::ostream *dout_client_ptr = &dstream;\r
std::ostream *derr_client_ptr = &dstream;\r
\r
-/*\r
- Config stuff\r
-*/\r
-\r
-// Returns false on EOF\r
-bool parseConfigObject(std::istream &is)\r
-{\r
- // float g_wanted_fps\r
- // s16 g_viewing_range_nodes_max\r
-\r
- if(is.eof())\r
- return false;\r
- \r
- std::string line;\r
- std::getline(is, line);\r
- //dstream<<"got line: \""<<line<<"\""<<std::endl;\r
-\r
- std::string trimmedline = trim(line);\r
- \r
- // Ignore comments\r
- if(trimmedline[0] == '#')\r
- return true;\r
-\r
- //dstream<<"trimmedline=\""<<trimmedline<<"\""<<std::endl;\r
-\r
- Strfnd sf(trim(line));\r
-\r
- std::string name = sf.next("=");\r
- name = trim(name);\r
-\r
- if(name == "")\r
- return true;\r
- \r
- std::string value = sf.next("\n");\r
- value = trim(value);\r
-\r
- dstream<<"Config name=\""<<name<<"\" value=\""\r
- <<value<<"\""<<std::endl;\r
- \r
- if(name == "dedicated_server")\r
- g_dedicated_server = value;\r
- \r
- // Client stuff\r
- else if(name == "wanted_fps")\r
- {\r
- g_wanted_fps = atof(value.c_str());\r
- }\r
- else if(name == "fps_max")\r
- {\r
- g_fps_max = atof(value.c_str());\r
- }\r
- else if(name == "viewing_range_nodes_max")\r
- {\r
- g_viewing_range_nodes_max = stoi(value, 0, 32767);\r
- }\r
- else if(name == "viewing_range_nodes_min")\r
- {\r
- g_viewing_range_nodes_min = stoi(value, 0, 32767);\r
- }\r
- else if(name=="screenW")\r
- g_screenW = value;\r
- else if(name=="screenH")\r
- g_screenH = value;\r
- else if(name == "host_game")\r
- g_host_game = value;\r
- else if(name == "port")\r
- g_port = value;\r
- else if(name == "address")\r
- g_address = value;\r
- else if(name == "name")\r
- g_name = value;\r
- else if(name == "random_input")\r
- g_random_input = is_yes(value);\r
- else if(name == "client_delete_unused_sectors_timeout")\r
- {\r
- std::istringstream vis(value);\r
- //vis.imbue(std::locale("C"));\r
- vis>>g_client_delete_unused_sectors_timeout;\r
- }\r
- \r
- // Server stuff\r
- else if(name == "creative_mode")\r
- g_creative_mode = is_yes(value);\r
- else if(name == "mapgen_heightmap_blocksize")\r
- {\r
- s32 d = atoi(value.c_str());\r
- if(d > 0 && (d & (d-1)) == 0)\r
- g_hm_params.heightmap_blocksize = d;\r
- else\r
- dstream<<"Invalid value in config file: \""\r
- <<line<<"\""<<std::endl;\r
- }\r
- else if(name == "mapgen_height_randmax")\r
- g_hm_params.height_randmax = value;\r
- else if(name == "mapgen_height_randfactor")\r
- g_hm_params.height_randfactor = value;\r
- else if(name == "mapgen_height_base")\r
- g_hm_params.height_base = value;\r
- else if(name == "mapgen_plants_amount")\r
- {\r
- std::istringstream vis(value);\r
- vis>>g_map_params.plants_amount;\r
- }\r
- else if(name == "objectdata_inverval")\r
- {\r
- std::istringstream vis(value);\r
- vis>>g_objectdata_interval;\r
- }\r
- else if(name == "active_object_range")\r
- g_active_object_range = stoi(value, 0, 65535);\r
- \r
- else\r
- {\r
- dstream<<"Unknown option in config file: \""\r
- <<line<<"\""<<std::endl;\r
- }\r
-\r
- return true;\r
-}\r
-\r
-// Returns true on success\r
-bool readConfigFile(const char *filename)\r
-{\r
- std::ifstream is(filename);\r
- if(is.good() == false)\r
- {\r
- dstream<<DTIME<<"Error opening configuration file: "\r
- <<filename<<std::endl;\r
- return false;\r
- }\r
-\r
- dstream<<DTIME<<"Parsing configuration file: "\r
- <<filename<<std::endl;\r
- \r
- while(parseConfigObject(is));\r
- \r
- return true;\r
-}\r
\r
/*\r
Timestamp stuff\r
\r
if(event.KeyInput.Key == irr::KEY_ESCAPE)\r
{\r
+ //TODO: Not used anymore?\r
if(g_game_focused == true)\r
{\r
dstream<<DTIME<<"ESC pressed"<<std::endl;\r
dstream<<DTIME<<"Enabled full viewing range"<<std::endl;\r
}\r
}\r
+\r
+ // Print debug stacks\r
+ if(event.KeyInput.Key == irr::KEY_KEY_P\r
+ && g_game_focused)\r
+ {\r
+ dstream<<"-----------------------------------------"\r
+ <<std::endl;\r
+ dstream<<DTIME<<"Printing debug stacks:"<<std::endl;\r
+ dstream<<"-----------------------------------------"\r
+ <<std::endl;\r
+ debug_stacks_print();\r
+ }\r
}\r
}\r
\r
if(event.EventType == irr::EET_MOUSE_INPUT_EVENT)\r
{\r
+ left_active = event.MouseInput.isLeftPressed();\r
+ middle_active = event.MouseInput.isMiddlePressed();\r
+ right_active = event.MouseInput.isRightPressed();\r
+\r
if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)\r
{\r
leftclicked = true;\r
{\r
rightclicked = true;\r
}\r
+ if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)\r
+ {\r
+ leftreleased = true;\r
+ }\r
+ if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)\r
+ {\r
+ rightreleased = true;\r
+ }\r
if(event.MouseInput.Event == EMIE_MOUSE_WHEEL)\r
{\r
/*dstream<<"event.MouseInput.Wheel="\r
keyIsDown[i] = false;\r
leftclicked = false;\r
rightclicked = false;\r
+ leftreleased = false;\r
+ rightreleased = false;\r
+\r
+ left_active = false;\r
+ middle_active = false;\r
+ right_active = false;\r
}\r
\r
bool leftclicked;\r
bool rightclicked;\r
+ bool leftreleased;\r
+ bool rightreleased;\r
+\r
+ bool left_active;\r
+ bool middle_active;\r
+ bool right_active;\r
+\r
private:\r
// We use this array to store the current state of each key\r
bool keyIsDown[KEY_KEY_CODES_COUNT];\r
virtual ~InputHandler()\r
{\r
}\r
+\r
virtual bool isKeyDown(EKEY_CODE keyCode) = 0;\r
+\r
virtual v2s32 getMousePos() = 0;\r
virtual void setMousePos(s32 x, s32 y) = 0;\r
+\r
+ virtual bool getLeftState() = 0;\r
+ virtual bool getRightState() = 0;\r
+\r
virtual bool getLeftClicked() = 0;\r
virtual bool getRightClicked() = 0;\r
virtual void resetLeftClicked() = 0;\r
virtual void resetRightClicked() = 0;\r
+\r
+ virtual bool getLeftReleased() = 0;\r
+ virtual bool getRightReleased() = 0;\r
+ virtual void resetLeftReleased() = 0;\r
+ virtual void resetRightReleased() = 0;\r
\r
virtual void step(float dtime) {};\r
\r
m_device->getCursorControl()->setPosition(x, y);\r
}\r
\r
+ virtual bool getLeftState()\r
+ {\r
+ return m_receiver->left_active;\r
+ }\r
+ virtual bool getRightState()\r
+ {\r
+ return m_receiver->right_active;\r
+ }\r
+ \r
virtual bool getLeftClicked()\r
{\r
if(g_game_focused == false)\r
m_receiver->rightclicked = false;\r
}\r
\r
+ virtual bool getLeftReleased()\r
+ {\r
+ if(g_game_focused == false)\r
+ return false;\r
+ return m_receiver->leftreleased;\r
+ }\r
+ virtual bool getRightReleased()\r
+ {\r
+ if(g_game_focused == false)\r
+ return false;\r
+ return m_receiver->rightreleased;\r
+ }\r
+ virtual void resetLeftReleased()\r
+ {\r
+ m_receiver->leftreleased = false;\r
+ }\r
+ virtual void resetRightReleased()\r
+ {\r
+ m_receiver->rightreleased = false;\r
+ }\r
+\r
void clear()\r
{\r
resetRightClicked();\r
mousepos = v2s32(x,y);\r
}\r
\r
+ virtual bool getLeftState()\r
+ {\r
+ return false;\r
+ }\r
+ virtual bool getRightState()\r
+ {\r
+ return false;\r
+ }\r
+\r
virtual bool getLeftClicked()\r
{\r
return leftclicked;\r
rightclicked = false;\r
}\r
\r
+ virtual bool getLeftReleased()\r
+ {\r
+ return false;\r
+ }\r
+ virtual bool getRightReleased()\r
+ {\r
+ return false;\r
+ }\r
+ virtual void resetLeftReleased()\r
+ {\r
+ }\r
+ virtual void resetRightReleased()\r
+ {\r
+ }\r
+\r
virtual void step(float dtime)\r
{\r
{\r
if(counter1 < 0.0)\r
{\r
counter1 = 0.1*Rand(1,10);\r
- /*if(g_selected_material < USEFUL_MATERIAL_COUNT-1)\r
+ /*if(g_selected_material < USEFUL_CONTENT_COUNT-1)\r
g_selected_material++;\r
else\r
g_selected_material = 0;*/\r
// Range_all messes up frametime_avg\r
if(g_viewing_range_all == true)\r
return;\r
+\r
+ float wanted_fps = g_settings.getFloat("wanted_fps");\r
\r
// Initialize to the target value\r
- static float frametime_avg = 1.0/g_wanted_fps;\r
- frametime_avg = frametime_avg * 0.9 + frametime * 0.1;\r
+ static float frametime_avg = 1.0/wanted_fps;\r
+ //frametime_avg = frametime_avg * 0.9 + frametime * 0.1;\r
+ frametime_avg = frametime_avg * 0.7 + frametime * 0.3;\r
\r
static f32 counter = 0;\r
if(counter > 0){\r
//float freetime_ratio = 0.4;\r
float freetime_ratio = FREETIME_RATIO;\r
\r
- float frametime_wanted = (1.0/(g_wanted_fps/(1.0-freetime_ratio)));\r
+ float frametime_wanted = (1.0/(wanted_fps/(1.0-freetime_ratio)));\r
\r
float fraction = sqrt(frametime_avg / frametime_wanted);\r
\r
+ /*float fraction = sqrt(frametime_avg / frametime_wanted) / 2.0\r
+ + frametime_avg / frametime_wanted / 2.0;*/\r
+ \r
+ //float fraction = frametime_avg / frametime_wanted;\r
+\r
static bool fraction_is_good = false;\r
\r
float fraction_good_threshold = 0.1;\r
- float fraction_bad_threshold = 0.25;\r
+ //float fraction_bad_threshold = 0.25;\r
+ float fraction_bad_threshold = 0.1;\r
float fraction_limit;\r
// Use high limit if fraction is good AND the fraction would\r
// lower the range. We want to keep the range fairly high.\r
\r
JMutexAutoLock lock(g_range_mutex);\r
\r
+ s16 viewing_range_nodes_min = g_settings.getS16("viewing_range_nodes_min");\r
+ s16 viewing_range_nodes_max = g_settings.getS16("viewing_range_nodes_max");\r
+\r
s16 n = (float)g_viewing_range_nodes / fraction;\r
- if(n < g_viewing_range_nodes_min)\r
- n = g_viewing_range_nodes_min;\r
- if(n > g_viewing_range_nodes_max)\r
- n = g_viewing_range_nodes_max;\r
+ if(n < viewing_range_nodes_min)\r
+ n = viewing_range_nodes_min;\r
+ if(n > viewing_range_nodes_max)\r
+ n = viewing_range_nodes_max;\r
\r
bool can_change = true;\r
\r
disable_stderr = true;\r
#endif\r
\r
+ // Initialize debug streams\r
debugstreams_init(disable_stderr, DEBUGFILE);\r
+ // Initialize debug stacks\r
debug_stacks_init();\r
\r
-\r
DSTACK(__FUNCTION_NAME);\r
\r
try\r
{\r
\r
+ /*\r
+ Parse command line\r
+ */\r
+ \r
+ // List all allowed options\r
+ core::map<std::string, ValueSpec> allowed_options;\r
+ allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG));\r
+ allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,\r
+ "Run server directly"));\r
+ allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,\r
+ "Load configuration from specified file"));\r
+ allowed_options.insert("port", ValueSpec(VALUETYPE_STRING));\r
+ allowed_options.insert("address", ValueSpec(VALUETYPE_STRING));\r
+ allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG));\r
+ allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG));\r
+ allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG));\r
+\r
+ Settings cmd_args;\r
+ \r
+ bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);\r
+\r
+ if(ret == false || cmd_args.getFlag("help"))\r
+ {\r
+ dstream<<"Allowed options:"<<std::endl;\r
+ for(core::map<std::string, ValueSpec>::Iterator\r
+ i = allowed_options.getIterator();\r
+ i.atEnd() == false; i++)\r
+ {\r
+ dstream<<" --"<<i.getNode()->getKey();\r
+ if(i.getNode()->getValue().type == VALUETYPE_FLAG)\r
+ {\r
+ }\r
+ else\r
+ {\r
+ dstream<<" <value>";\r
+ }\r
+ dstream<<std::endl;\r
+\r
+ if(i.getNode()->getValue().help != NULL)\r
+ {\r
+ dstream<<" "<<i.getNode()->getValue().help\r
+ <<std::endl;\r
+ }\r
+ }\r
+\r
+ return cmd_args.getFlag("help") ? 0 : 1;\r
+ }\r
+\r
+\r
/*\r
Basic initialization\r
*/\r
\r
+ // Initialize default settings\r
+ set_default_settings();\r
+ \r
+ // Print startup message\r
dstream<<DTIME<<"minetest-c55"\r
" with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST\r
<<", ENABLE_TESTS="<<ENABLE_TESTS\r
// Initialize timestamp mutex\r
g_timestamp_mutex.Init();\r
\r
- /*\r
- Run unit tests\r
- */\r
- if(ENABLE_TESTS)\r
- {\r
- run_tests();\r
- }\r
- \r
/*\r
Initialization\r
*/\r
\r
- // Read config file\r
+ /*\r
+ Read config file\r
+ */\r
+ \r
+ // Path of configuration file in use\r
+ std::string configpath = "";\r
\r
- if(argc >= 2)\r
+ if(cmd_args.exists("config"))\r
{\r
- readConfigFile(argv[1]);\r
+ bool r = g_settings.readConfigFile(cmd_args.get("config").c_str());\r
+ if(r == false)\r
+ {\r
+ dstream<<"Could not read configuration from \""\r
+ <<cmd_args.get("config")<<"\""<<std::endl;\r
+ return 1;\r
+ }\r
+ configpath = cmd_args.get("config");\r
}\r
else\r
{\r
\r
for(u32 i=0; i<2; i++)\r
{\r
- bool r = readConfigFile(filenames[i]);\r
+ bool r = g_settings.readConfigFile(filenames[i]);\r
if(r)\r
+ {\r
+ configpath = filenames[i];\r
break;\r
+ }\r
}\r
}\r
\r
// Initialize random seed\r
srand(time(0));\r
\r
+ /*\r
+ Run unit tests\r
+ */\r
+ if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)\r
+ || cmd_args.getFlag("enable-unittests") == true)\r
+ {\r
+ run_tests();\r
+ }\r
+ \r
+ /*\r
+ Global range mutex\r
+ */\r
g_range_mutex.Init();\r
assert(g_range_mutex.IsInitialized());\r
\r
+ // Read map parameters from settings\r
+\r
+ HMParams hm_params;\r
+ hm_params.blocksize = g_settings.getU16("heightmap_blocksize");\r
+ hm_params.randmax = g_settings.get("height_randmax");\r
+ hm_params.randfactor = g_settings.get("height_randfactor");\r
+ hm_params.base = g_settings.get("height_base");\r
+\r
+ MapParams map_params;\r
+ map_params.plants_amount = g_settings.getFloat("plants_amount");\r
+ map_params.ravines_amount = g_settings.getFloat("ravines_amount");\r
+\r
/*\r
Ask some stuff\r
*/\r
\r
std::cout<<std::endl<<std::endl;\r
- char templine[100];\r
\r
- std::cout<<"Dedicated server? [y = yes]: ";\r
- if(g_dedicated_server != "")\r
- {\r
- std::cout<<g_dedicated_server<<std::endl;\r
- snprintf(templine, 100, "%s", g_dedicated_server.c_str());\r
- }\r
- else\r
- {\r
- std::cin.getline(templine, 100);\r
- }\r
-\r
- bool dedicated = false;\r
- if(templine[0] == 'y')\r
- dedicated = true;\r
- if(dedicated)\r
- std::cout<<"-> yes"<<std::endl;\r
- else\r
- std::cout<<"-> no"<<std::endl;\r
+ std::cout\r
+ <<" .__ __ __ "<<std::endl\r
+ <<" _____ |__| ____ _____/ |_ ____ _______/ |_ "<<std::endl\r
+ <<" / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\"<<std::endl\r
+ <<"| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | "<<std::endl\r
+ <<"|__|_| /__|___| /\\___ >__| \\___ >____ > |__| "<<std::endl\r
+ <<" \\/ \\/ \\/ \\/ \\/ "<<std::endl\r
+ <<std::endl\r
+ <<"Now with more waterish water!"\r
+ <<std::endl;\r
+\r
+ std::cout<<std::endl;\r
+ char templine[100];\r
\r
- std::cout<<"Port [empty=30000]: ";\r
- if(g_port != "")\r
+ // Port?\r
+ u16 port = 30000;\r
+ if(cmd_args.exists("port"))\r
{\r
- std::cout<<g_port<<std::endl;\r
- snprintf(templine, 100, "%s", g_port.c_str());\r
+ port = cmd_args.getU16("port");\r
}\r
else\r
{\r
- std::cin.getline(templine, 100);\r
+ port = g_settings.getU16Ask("port", "Port", 30000);\r
+ std::cout<<"-> "<<port<<std::endl;\r
}\r
- unsigned short port;\r
- if(templine[0] == 0)\r
- port = 30000;\r
- else\r
- port = atoi(templine);\r
- std::cout<<"-> "<<port<<std::endl;\r
\r
- if(dedicated)\r
+ if(cmd_args.getFlag("server"))\r
{\r
DSTACK("Dedicated server branch");\r
\r
std::cout<<"========================"<<std::endl;\r
std::cout<<std::endl;\r
\r
- Server server("../map", g_creative_mode, g_hm_params,\r
- g_map_params, g_objectdata_interval,\r
- g_active_object_range);\r
+ Server server("../map", hm_params, map_params);\r
server.start(port);\r
\r
for(;;)\r
{\r
// This is kind of a hack but can be done like this\r
// because server.step() is very light\r
- sleep_ms(100);\r
- server.step(0.1);\r
+ sleep_ms(30);\r
+ server.step(0.030);\r
\r
static int counter = 0;\r
counter--;\r
bool hosting = false;\r
char connect_name[100] = "";\r
\r
- std::cout<<"Address to connect to [empty = host a game]: ";\r
- if(g_address != "" && is_yes(g_host_game) == false)\r
+ if(cmd_args.exists("address"))\r
{\r
- std::cout<<g_address<<std::endl;\r
- snprintf(connect_name, 100, "%s", g_address.c_str());\r
+ snprintf(connect_name, 100, "%s", cmd_args.get("address").c_str());\r
+ }\r
+ else if(g_settings.get("address") != "" && is_yes(g_settings.get("host_game")) == false)\r
+ {\r
+ std::cout<<g_settings.get("address")<<std::endl;\r
+ snprintf(connect_name, 100, "%s", g_settings.get("address").c_str());\r
}\r
else\r
{\r
+ std::cout<<"Address to connect to [empty = host a game]: ";\r
std::cin.getline(connect_name, 100);\r
}\r
\r
}\r
\r
if(hosting)\r
- std::cout<<"-> hosting"<<std::endl;\r
+ std::cout<<"> Hosting game"<<std::endl;\r
else\r
- std::cout<<"-> "<<connect_name<<std::endl;\r
+ std::cout<<"> Connecting to "<<connect_name<<std::endl;\r
\r
char playername[PLAYERNAME_SIZE] = "";\r
- if(g_name != "")\r
+ if(g_settings.get("name") != "")\r
{\r
- snprintf(playername, PLAYERNAME_SIZE, "%s", g_name.c_str());\r
+ snprintf(playername, PLAYERNAME_SIZE, "%s", g_settings.get("name").c_str());\r
}\r
else\r
{\r
u16 screenH;\r
bool fullscreen = false;\r
\r
- if(g_screenW != "" && g_screenH != "")\r
+ if(g_settings.get("screenW") != "" && g_settings.get("screenH") != "")\r
{\r
- screenW = atoi(g_screenW.c_str());\r
- screenH = atoi(g_screenH.c_str());\r
+ screenW = atoi(g_settings.get("screenW").c_str());\r
+ screenH = atoi(g_settings.get("screenH").c_str());\r
}\r
else\r
{\r
\r
device->setResizable(true);\r
\r
- if(g_random_input)\r
+ bool random_input = g_settings.getBool("random_input")\r
+ || cmd_args.getFlag("random-input");\r
+ if(random_input)\r
g_input = new RandomInputHandler();\r
else\r
g_input = new RealInputHandler(device, &receiver);\r
//driver->setMinHardwareBufferVertexCount(1);\r
\r
scene::ISceneManager* smgr = device->getSceneManager();\r
+ \r
+ // Pause menu\r
+ guiPauseMenu pauseMenu(device, &receiver);\r
\r
gui::IGUIEnvironment* guienv = device->getGUIEnvironment();\r
gui::IGUISkin* skin = guienv->getSkin();\r
driver->endScene();\r
\r
/*\r
- Initialize material array\r
+ Preload some random textures that are used in threads\r
*/\r
-\r
- //video::SMaterial g_materials[MATERIALS_COUNT];\r
- for(u16 i=0; i<MATERIALS_COUNT; i++)\r
+ \r
+ g_texturecache.set("torch", driver->getTexture("../data/torch.png"));\r
+ g_texturecache.set("torch_on_floor", driver->getTexture("../data/torch_on_floor.png"));\r
+ g_texturecache.set("torch_on_ceiling", driver->getTexture("../data/torch_on_ceiling.png"));\r
+ \r
+ /*\r
+ Load tile textures\r
+ */\r
+ for(s32 i=0; i<TILES_COUNT; i++)\r
{\r
- g_materials[i].Lighting = false;\r
- g_materials[i].BackfaceCulling = false;\r
-\r
- const char *filename = g_material_filenames[i];\r
- if(filename != NULL){\r
- video::ITexture *t = driver->getTexture(filename);\r
- if(t == NULL){\r
- std::cout<<DTIME<<"Texture could not be loaded: \""\r
- <<filename<<"\""<<std::endl;\r
- return 1;\r
- }\r
- g_materials[i].setTexture(0, driver->getTexture(filename));\r
- }\r
- //g_materials[i].setFlag(video::EMF_TEXTURE_WRAP, video::ETC_REPEAT);\r
- g_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);\r
- //g_materials[i].setFlag(video::EMF_ANISOTROPIC_FILTER, false);\r
- //g_materials[i].setFlag(video::EMF_FOG_ENABLE, true);\r
- if(i == MATERIAL_WATER)\r
- {\r
- g_materials[i].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;\r
- //g_materials[i].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;\r
- }\r
+ if(g_tile_texture_names[i] == NULL)\r
+ continue;\r
+ std::string name = g_tile_texture_names[i];\r
+ std::string filename;\r
+ filename += "../data/";\r
+ filename += name;\r
+ filename += ".png";\r
+ g_texturecache.set(name, driver->getTexture(filename.c_str()));\r
}\r
\r
- /*g_mesh_materials[0].setTexture(0, driver->getTexture("../data/water.png"));\r
- g_mesh_materials[1].setTexture(0, driver->getTexture("../data/grass.png"));\r
- g_mesh_materials[2].setTexture(0, driver->getTexture("../data/stone.png"));\r
- for(u32 i=0; i<3; i++)\r
- {\r
- g_mesh_materials[i].Lighting = false;\r
- g_mesh_materials[i].BackfaceCulling = false;\r
- g_mesh_materials[i].setFlag(video::EMF_BILINEAR_FILTER, false);\r
- g_mesh_materials[i].setFlag(video::EMF_FOG_ENABLE, true);\r
- }*/\r
+ tile_materials_preload(g_texturecache);\r
\r
- // Make a scope here for the client so that it gets removed\r
- // before the irrlicht device\r
+ /*\r
+ Make a scope here for the client so that it gets removed\r
+ before the irrlicht device\r
+ */\r
{\r
\r
std::cout<<DTIME<<"Creating server and client"<<std::endl;\r
*/\r
SharedPtr<Server> server;\r
if(hosting){\r
- server = new Server("../map", g_creative_mode, g_hm_params,\r
- g_map_params, g_objectdata_interval,\r
- g_active_object_range);\r
+ server = new Server("../map", hm_params, map_params);\r
server->start(port);\r
}\r
\r
Create client\r
*/\r
\r
- // TODO: Get rid of the g_materials parameter or it's globalness\r
- Client client(device, g_materials,\r
- g_client_delete_unused_sectors_timeout,\r
- playername);\r
+ Client client(device, playername,\r
+ g_range_mutex,\r
+ g_viewing_range_nodes,\r
+ g_viewing_range_all);\r
\r
Address connect_address(0,0,0,0, port);\r
try{\r
std::cout<<DTIME<<"Timed out."<<std::endl;\r
return 0;\r
}\r
+\r
+ /*\r
+ Create skybox\r
+ */\r
+ /*scene::ISceneNode* skybox;\r
+ skybox = smgr->addSkyBoxSceneNode(\r
+ driver->getTexture("../data/skybox2.png"),\r
+ driver->getTexture("../data/skybox3.png"),\r
+ driver->getTexture("../data/skybox1.png"),\r
+ driver->getTexture("../data/skybox1.png"),\r
+ driver->getTexture("../data/skybox1.png"),\r
+ driver->getTexture("../data/skybox1.png"));*/\r
\r
/*\r
Create the camera node\r
// Just so big a value that everything rendered is visible\r
camera->setFarValue(100000*BS);\r
\r
- /*//f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;\r
- f32 range = BS*HEIGHTMAP_RANGE_NODES*0.9;\r
- \r
- camera->setFarValue(range);\r
- \r
- driver->setFog(\r
- skycolor,\r
- video::EFT_FOG_LINEAR,\r
- range*0.8,\r
- range,\r
- 0.01,\r
- false,\r
- false\r
- );*/\r
- \r
f32 camera_yaw = 0; // "right/left"\r
f32 camera_pitch = 0; // "up/down"\r
+\r
+ /*\r
+ Move into game\r
+ */\r
\r
gui_loadingtext->remove();\r
\r
+ pauseMenu.setVisible(true);\r
+\r
/*\r
Add some gui stuff\r
*/\r
// First line of debug text\r
gui::IGUIStaticText *guitext = guienv->addStaticText(\r
L"Minetest-c55",\r
- core::rect<s32>(5, 5, 5+600, 5+textsize.Y),\r
+ core::rect<s32>(5, 5, 795, 5+textsize.Y),\r
false, false);\r
// Second line of debug text\r
gui::IGUIStaticText *guitext2 = guienv->addStaticText(\r
L"",\r
- core::rect<s32>(5, 5+(textsize.Y+5)*1, 5+600, (5+textsize.Y)*2),\r
+ core::rect<s32>(5, 5+(textsize.Y+5)*1, 795, (5+textsize.Y)*2),\r
false, false);\r
\r
// At the middle of the screen\r
Some statistics are collected in these\r
*/\r
u32 drawtime = 0;\r
+ u32 beginscenetime = 0;\r
u32 scenetime = 0;\r
u32 endscenetime = 0;\r
\r
//gui::IGUIWindow* input_window = NULL;\r
gui::IGUIStaticText* input_guitext = NULL;\r
\r
+ /*\r
+ Digging animation\r
+ */\r
+ //f32 \r
+\r
/*\r
Main loop\r
*/\r
\r
while(device->run())\r
{\r
+ /*\r
+ Random calculations\r
+ */\r
+ v2u32 screensize = driver->getScreenSize();\r
+ core::vector2d<s32> displaycenter(screensize.X/2,screensize.Y/2);\r
+\r
// Hilight boxes collected during the loop and displayed\r
core::list< core::aabbox3d<f32> > hilightboxes;\r
\r
*/\r
\r
{\r
- float fps_max = g_fps_max;\r
+ float fps_max = g_settings.getFloat("fps_max");\r
u32 frametime_min = 1000./fps_max;\r
\r
if(busytime_u32 < frametime_min)\r
/*\r
Special keys\r
*/\r
- if(g_esc_pressed)\r
+ /*if(g_esc_pressed)\r
{\r
break;\r
- }\r
+ }*/\r
\r
/*\r
Player speed control\r
Mouse and camera control\r
*/\r
\r
- if(device->isWindowActive() && g_game_focused)\r
+ if((device->isWindowActive() && g_game_focused && !pauseMenu.isVisible())\r
+ || random_input)\r
{\r
- device->getCursorControl()->setVisible(false);\r
+ if(!random_input)\r
+ device->getCursorControl()->setVisible(false);\r
\r
if(first_loop_after_window_activation){\r
//std::cout<<"window active, first loop"<<std::endl;\r
first_loop_after_window_activation = false;\r
}\r
else{\r
- s32 dx = g_input->getMousePos().X - 320;\r
- s32 dy = g_input->getMousePos().Y - 240;\r
+ s32 dx = g_input->getMousePos().X - displaycenter.X;\r
+ s32 dy = g_input->getMousePos().Y - displaycenter.Y;\r
//std::cout<<"window active, pos difference "<<dx<<","<<dy<<std::endl;\r
camera_yaw -= dx*0.2;\r
camera_pitch += dy*0.2;\r
if(camera_pitch < -89.5) camera_pitch = -89.5;\r
if(camera_pitch > 89.5) camera_pitch = 89.5;\r
}\r
- g_input->setMousePos(320, 240);\r
+ g_input->setMousePos(displaycenter.X, displaycenter.Y);\r
}\r
else{\r
device->getCursorControl()->setVisible(true);\r
if(selected_object->getTypeId() == MAPBLOCKOBJECT_TYPE_SIGN)\r
{\r
dstream<<"Sign object right-clicked"<<std::endl;\r
-\r
+ \r
unFocusGame();\r
\r
input_guitext = guienv->addStaticText(L"",\r
\r
input_guitext->setDrawBackground(true);\r
\r
- g_text_buffer = L"";\r
- g_text_buffer_accepted = false;\r
+ if(random_input)\r
+ {\r
+ g_text_buffer = L"ASD LOL 8)";\r
+ g_text_buffer_accepted = true;\r
+ }\r
+ else\r
+ {\r
+ g_text_buffer = L"";\r
+ g_text_buffer_accepted = false;\r
+ }\r
+\r
textbuf_dest = new TextDestSign(\r
selected_object->getBlock()->getPos(),\r
selected_object->getId(),\r
}\r
else // selected_object == NULL\r
{\r
+\r
+ /*\r
+ Find out which node we are pointing at\r
+ */\r
\r
bool nodefound = false;\r
v3s16 nodepos;\r
s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);\r
s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);\r
\r
- for(s16 y = ystart; y <= yend; y++){\r
- for(s16 z = zstart; z <= zend; z++){\r
+ for(s16 y = ystart; y <= yend; y++)\r
+ for(s16 z = zstart; z <= zend; z++)\r
for(s16 x = xstart; x <= xend; x++)\r
{\r
- try{\r
- if(client.getNode(v3s16(x,y,z)).d == MATERIAL_AIR){\r
+ MapNode n;\r
+ try\r
+ {\r
+ n = client.getNode(v3s16(x,y,z));\r
+ if(content_pointable(n.d) == false)\r
continue;\r
- }\r
- }catch(InvalidPositionException &e){\r
+ }\r
+ catch(InvalidPositionException &e)\r
+ {\r
continue;\r
}\r
\r
\r
f32 d = 0.01;\r
\r
- v3s16 directions[6] = {\r
+ v3s16 dirs[6] = {\r
v3s16(0,0,1), // back\r
v3s16(0,1,0), // top\r
v3s16(1,0,0), // right\r
- v3s16(0,0,-1),\r
- v3s16(0,-1,0),\r
- v3s16(-1,0,0),\r
+ v3s16(0,0,-1), // front\r
+ v3s16(0,-1,0), // bottom\r
+ v3s16(-1,0,0), // left\r
};\r
+ \r
+ /*\r
+ Meta-objects\r
+ */\r
+ if(n.d == CONTENT_TORCH)\r
+ {\r
+ v3s16 dir = unpackDir(n.dir);\r
+ v3f dir_f = v3f(dir.X, dir.Y, dir.Z);\r
+ dir_f *= BS/2 - BS/6 - BS/20;\r
+ v3f cpf = npf + dir_f;\r
+ f32 distance = (cpf - camera_position).getLength();\r
\r
- for(u16 i=0; i<6; i++){\r
- //{u16 i=3;\r
- v3f dir_f = v3f(directions[i].X,\r
- directions[i].Y, directions[i].Z);\r
- v3f centerpoint = npf + dir_f * BS/2;\r
- f32 distance =\r
- (centerpoint - camera_position).getLength();\r
+ core::aabbox3d<f32> box;\r
\r
- if(distance < mindistance){\r
- //std::cout<<DTIME<<"for centerpoint=("<<centerpoint.X<<","<<centerpoint.Y<<","<<centerpoint.Z<<"): distance < mindistance"<<std::endl;\r
- //std::cout<<DTIME<<"npf=("<<npf.X<<","<<npf.Y<<","<<npf.Z<<")"<<std::endl;\r
- core::CMatrix4<f32> m;\r
- m.buildRotateFromTo(v3f(0,0,1), dir_f);\r
-\r
- // This is the back face\r
- v3f corners[2] = {\r
- v3f(BS/2, BS/2, BS/2),\r
- v3f(-BS/2, -BS/2, BS/2+d)\r
- };\r
- \r
- for(u16 j=0; j<2; j++){\r
- m.rotateVect(corners[j]);\r
- corners[j] += npf;\r
- //std::cout<<DTIME<<"box corners["<<j<<"]: ("<<corners[j].X<<","<<corners[j].Y<<","<<corners[j].Z<<")"<<std::endl;\r
- }\r
-\r
- //core::aabbox3d<f32> facebox(corners[0],corners[1]);\r
- core::aabbox3d<f32> facebox(corners[0]);\r
- facebox.addInternalPoint(corners[1]);\r
+ // bottom\r
+ if(dir == v3s16(0,-1,0))\r
+ {\r
+ box = core::aabbox3d<f32>(\r
+ npf - v3f(BS/6, BS/2, BS/6),\r
+ npf + v3f(BS/6, -BS/2+BS/3*2, BS/6)\r
+ );\r
+ }\r
+ // top\r
+ else if(dir == v3s16(0,1,0))\r
+ {\r
+ box = core::aabbox3d<f32>(\r
+ npf - v3f(BS/6, -BS/2+BS/3*2, BS/6),\r
+ npf + v3f(BS/6, BS/2, BS/6)\r
+ );\r
+ }\r
+ // side\r
+ else\r
+ {\r
+ box = core::aabbox3d<f32>(\r
+ cpf - v3f(BS/6, BS/3, BS/6),\r
+ cpf + v3f(BS/6, BS/3, BS/6)\r
+ );\r
+ }\r
\r
- if(facebox.intersectsWithLine(shootline)){\r
+ if(distance < mindistance)\r
+ {\r
+ if(box.intersectsWithLine(shootline))\r
+ {\r
nodefound = true;\r
nodepos = np;\r
- neighbourpos = np + directions[i];\r
+ neighbourpos = np;\r
mindistance = distance;\r
- nodefacebox = facebox;\r
+ nodefacebox = box;\r
}\r
}\r
}\r
- }}}\r
+ /*\r
+ Regular blocks\r
+ */\r
+ else\r
+ {\r
+ for(u16 i=0; i<6; i++)\r
+ {\r
+ v3f dir_f = v3f(dirs[i].X,\r
+ dirs[i].Y, dirs[i].Z);\r
+ v3f centerpoint = npf + dir_f * BS/2;\r
+ f32 distance =\r
+ (centerpoint - camera_position).getLength();\r
+ \r
+ if(distance < mindistance)\r
+ {\r
+ core::CMatrix4<f32> m;\r
+ m.buildRotateFromTo(v3f(0,0,1), dir_f);\r
+\r
+ // This is the back face\r
+ v3f corners[2] = {\r
+ v3f(BS/2, BS/2, BS/2),\r
+ v3f(-BS/2, -BS/2, BS/2+d)\r
+ };\r
+ \r
+ for(u16 j=0; j<2; j++)\r
+ {\r
+ m.rotateVect(corners[j]);\r
+ corners[j] += npf;\r
+ }\r
+\r
+ core::aabbox3d<f32> facebox(corners[0]);\r
+ facebox.addInternalPoint(corners[1]);\r
+\r
+ if(facebox.intersectsWithLine(shootline))\r
+ {\r
+ nodefound = true;\r
+ nodepos = np;\r
+ neighbourpos = np + dirs[i];\r
+ mindistance = distance;\r
+ nodefacebox = facebox;\r
+ }\r
+ } // if distance < mindistance\r
+ } // for dirs\r
+ } // regular block\r
+ } // for coords\r
+\r
+ /*static v3s16 oldnodepos;\r
+ static bool oldnodefound = false;*/\r
\r
if(nodefound)\r
{\r
if(nodepos != nodepos_old){\r
std::cout<<DTIME<<"Pointing at ("<<nodepos.X<<","\r
<<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;\r
- nodepos_old = nodepos;\r
-\r
- /*wchar_t positiontext[20];\r
- swprintf(positiontext, 20, L"(%i,%i,%i)",\r
- nodepos.X, nodepos.Y, nodepos.Z);\r
- positiontextgui->setText(positiontext);*/\r
}\r
\r
hilightboxes.push_back(nodefacebox);\r
\r
- if(g_input->getLeftClicked())\r
+ //if(g_input->getLeftClicked())\r
+ if(g_input->getLeftClicked() ||\r
+ (g_input->getLeftState() && nodepos != nodepos_old))\r
{\r
- //std::cout<<DTIME<<"Removing node"<<std::endl;\r
- //client.removeNode(nodepos);\r
std::cout<<DTIME<<"Ground left-clicked"<<std::endl;\r
- client.clickGround(0, nodepos, neighbourpos, g_selected_item);\r
+ client.pressGround(0, nodepos, neighbourpos, g_selected_item);\r
}\r
if(g_input->getRightClicked())\r
+ /*if(g_input->getRightClicked() ||\r
+ (g_input->getRightState() && nodepos != nodepos_old))*/\r
{\r
- //std::cout<<DTIME<<"Placing node"<<std::endl;\r
- //client.addNodeFromInventory(neighbourpos, g_selected_item);\r
std::cout<<DTIME<<"Ground right-clicked"<<std::endl;\r
- client.clickGround(1, nodepos, neighbourpos, g_selected_item);\r
+ client.pressGround(1, nodepos, neighbourpos, g_selected_item);\r
}\r
+ \r
+ nodepos_old = nodepos;\r
}\r
else{\r
//std::cout<<DTIME<<"nodefound == false"<<std::endl;\r
//positiontextgui->setText(L"");\r
}\r
\r
+ /*oldnodefound = nodefound;\r
+ oldnodepos = nodepos;*/\r
+\r
} // selected_object == NULL\r
\r
g_input->resetLeftClicked();\r
g_input->resetRightClicked();\r
\r
+ if(g_input->getLeftReleased())\r
+ {\r
+ std::cout<<DTIME<<"Left released"<<std::endl;\r
+ client.stopDigging();\r
+ }\r
+ if(g_input->getRightReleased())\r
+ {\r
+ //std::cout<<DTIME<<"Right released"<<std::endl;\r
+ // Nothing here\r
+ }\r
+ \r
+ g_input->resetLeftReleased();\r
+ g_input->resetRightReleased();\r
+ \r
/*\r
Calculate stuff for drawing\r
*/\r
\r
- v2u32 screensize = driver->getScreenSize();\r
- core::vector2d<s32> displaycenter(screensize.X/2,screensize.Y/2);\r
-\r
camera->setAspectRatio((f32)screensize.X / (f32)screensize.Y);\r
+ \r
+ // Background color is choosen based on whether the player is\r
+ // much beyond the initial ground level\r
+ /*video::SColor bgcolor;\r
+ v3s16 p0 = Map::floatToInt(player_position);\r
+ // Does this make short random delays?\r
+ // NOTE: no need for this, sky doesn't show underground with\r
+ // enough range\r
+ bool is_underground = client.isNodeUnderground(p0);\r
+ //bool is_underground = false;\r
+ if(is_underground == false)\r
+ bgcolor = video::SColor(255,90,140,200);\r
+ else\r
+ bgcolor = video::SColor(255,0,0,0);*/\r
+ \r
+ //video::SColor bgcolor = video::SColor(255,90,140,200);\r
+ //video::SColor bgcolor = skycolor;\r
+ \r
+ //s32 daynight_i = client.getDayNightIndex();\r
+ //video::SColor bgcolor = skycolor[daynight_i];\r
+\r
+ u32 daynight_ratio = client.getDayNightRatio();\r
+ video::SColor bgcolor = video::SColor(\r
+ 255,\r
+ skycolor.getRed() * daynight_ratio / 1000,\r
+ skycolor.getGreen() * daynight_ratio / 1000,\r
+ skycolor.getBlue() * daynight_ratio / 1000);\r
+\r
+ /*\r
+ Fog\r
+ */\r
+ \r
+ if(g_settings.getBool("enable_fog") == true)\r
+ {\r
+ f32 range = g_viewing_range_nodes * BS;\r
+ if(g_viewing_range_all)\r
+ range = 100000*BS;\r
+\r
+ driver->setFog(\r
+ bgcolor,\r
+ video::EFT_FOG_LINEAR,\r
+ range*0.6,\r
+ range,\r
+ 0.01,\r
+ false, // pixel fog\r
+ false // range fog\r
+ );\r
+ }\r
+\r
\r
/*\r
Update gui stuff (0ms)\r
//TimeTaker guiupdatetimer("Gui updating", device);\r
\r
{\r
- wchar_t temptext[100];\r
+ wchar_t temptext[150];\r
\r
static float drawtime_avg = 0;\r
drawtime_avg = drawtime_avg * 0.98 + (float)drawtime*0.02;\r
+ static float beginscenetime_avg = 0;\r
+ beginscenetime_avg = beginscenetime_avg * 0.98 + (float)beginscenetime*0.02;\r
static float scenetime_avg = 0;\r
scenetime_avg = scenetime_avg * 0.98 + (float)scenetime*0.02;\r
static float endscenetime_avg = 0;\r
endscenetime_avg = endscenetime_avg * 0.98 + (float)endscenetime*0.02;\r
\r
- swprintf(temptext, 100, L"Minetest-c55 ("\r
+ swprintf(temptext, 150, L"Minetest-c55 ("\r
L"F: item=%i"\r
L", R: range_all=%i"\r
L")"\r
- L" drawtime=%.0f, scenetime=%.0f, endscenetime=%.0f",\r
+ L" drawtime=%.0f, beginscenetime=%.0f, scenetime=%.0f, endscenetime=%.0f",\r
g_selected_item,\r
g_viewing_range_all,\r
drawtime_avg,\r
+ beginscenetime_avg,\r
scenetime_avg,\r
endscenetime_avg\r
);\r
}\r
\r
{\r
- wchar_t temptext[100];\r
- /*swprintf(temptext, 100,\r
- L"("\r
- L"% .3f < btime_jitter < % .3f"\r
- L", dtime_jitter = % .1f %%"\r
- //L", ftime_ratio = % .3f"\r
- L")",\r
- busytime_jitter1_min_sample,\r
- busytime_jitter1_max_sample,\r
- dtime_jitter1_max_fraction * 100.0\r
- //g_freetime_ratio\r
- );*/\r
- swprintf(temptext, 100,\r
+ wchar_t temptext[150];\r
+ swprintf(temptext, 150,\r
L"(% .1f, % .1f, % .1f)"\r
L" (% .3f < btime_jitter < % .3f"\r
L", dtime_jitter = % .1f %%)",\r
\r
TimeTaker drawtimer("Drawing", device);\r
\r
- /*\r
- Background color is choosen based on whether the player is\r
- much beyond the initial ground level\r
- */\r
- /*video::SColor bgcolor;\r
- v3s16 p0 = Map::floatToInt(player_position);\r
- // Does this make short random delays?\r
- // NOTE: no need for this, sky doesn't show underground with\r
- // enough range\r
- bool is_underground = client.isNodeUnderground(p0);\r
- //bool is_underground = false;\r
- if(is_underground == false)\r
- bgcolor = video::SColor(255,90,140,200);\r
- else\r
- bgcolor = video::SColor(255,0,0,0);*/\r
- \r
- //video::SColor bgcolor = video::SColor(255,90,140,200);\r
- video::SColor bgcolor = skycolor;\r
\r
- // 0ms\r
+ {\r
+ TimeTaker timer("beginScene", device);\r
driver->beginScene(true, true, bgcolor);\r
+ //driver->beginScene(false, true, bgcolor);\r
+ beginscenetime = timer.stop(true);\r
+ }\r
\r
//timer3.stop();\r
\r
device->yield();*/\r
}\r
\r
+ delete quick_inventory;\r
+\r
} // client is deleted at this point\r
\r
delete g_input;\r
\r
/*\r
- In the end, delete the Irrlicht device.\r
+ In the end, delete the Irrlicht device.\r
*/\r
device->drop();\r
+ \r
+ /*\r
+ Update configuration file\r
+ */\r
+ if(configpath != "")\r
+ {\r
+ g_settings.updateConfigFile(configpath.c_str());\r
+ }\r
\r
} //try\r
catch(con::PeerNotFoundException &e)\r
{\r
dstream<<DTIME<<"Connection timed out."<<std::endl;\r
}\r
-#if CATCH_EXCEPTIONS\r
+#if CATCH_UNHANDLED_EXCEPTIONS\r
/*\r
This is what has to be done in every thread to get suitable debug info\r
*/\r
projects / minetest.git / blobdiff