celeron55
/
minetest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove servermain.cpp, use main.cpp with a couple of #ifdefs instead

master
Perttu Ahola 2012-03-10 16:46:19 +02:00
parent 1020707918
commit f3dba05143
3 changed files with 191 additions and 555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@ -184,7 +184,7 @@ set(minetest_SRCS
# Server sources
set(minetestserver_SRCS
${common_SRCS}
servermain.cpp
main.cpp
)
include_directories(

354
src/main.cpp
View File

@ -373,13 +373,14 @@ Doing currently:
#endif
#ifdef _MSC_VER
#ifndef SERVER // Dedicated server isn't linked with Irrlicht
#pragma comment(lib, "Irrlicht.lib")
//#pragma comment(lib, "jthread.lib")
#pragma comment(lib, "zlibwapi.lib")
#pragma comment(lib, "Shell32.lib")
// This would get rid of the console window
//#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
#endif
#pragma comment(lib, "zlibwapi.lib")
#pragma comment(lib, "Shell32.lib")
#endif
#include "irrlicht.h" // createDevice
@ -420,26 +421,6 @@ Settings *g_settings = &main_settings;
Profiler main_profiler;
Profiler *g_profiler = &main_profiler;
/*
Random stuff
*/
/*
mainmenumanager.h
*/
gui::IGUIEnvironment* guienv = NULL;
gui::IGUIStaticText *guiroot = NULL;
MainMenuManager g_menumgr;
bool noMenuActive()
{
return (g_menumgr.menuCount() == 0);
}
// Passed to menus to allow disconnecting and exiting
MainGameCallback *g_gamecallback = NULL;
/*
Debug streams
*/
@ -458,10 +439,40 @@ std::ostream *derr_server_ptr = &errorstream;
std::ostream *dout_client_ptr = &infostream;
std::ostream *derr_client_ptr = &errorstream;
#ifndef SERVER
/*
Random stuff
*/
/* mainmenumanager.h */
gui::IGUIEnvironment* guienv = NULL;
gui::IGUIStaticText *guiroot = NULL;
MainMenuManager g_menumgr;
bool noMenuActive()
{
return (g_menumgr.menuCount() == 0);
}
// Passed to menus to allow disconnecting and exiting
MainGameCallback *g_gamecallback = NULL;
#endif
/*
gettime.h implementation
*/
#ifdef SERVER
u32 getTimeMs()
{
/* Use imprecise system calls directly (from porting.h) */
return porting::getTimeMs();
}
#else
// A small helper class
class TimeGetter
{
@ -506,6 +517,30 @@ u32 getTimeMs()
return g_timegetter->getTime();
}
#endif
class StderrLogOutput: public ILogOutput
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
std::cerr<<line<<std::endl;
}
} main_stderr_log_out;
class DstreamNoStderrLogOutput: public ILogOutput
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
dstream_no_stderr<<line<<std::endl;
}
} main_dstream_no_stderr_log_out;
#ifndef SERVER
/*
Event handler for Irrlicht
@ -897,104 +932,6 @@ private:
bool rightreleased;
};
// These are defined global so that they're not optimized too much.
// Can't change them to volatile.
s16 temp16;
f32 tempf;
v3f tempv3f1;
v3f tempv3f2;
std::string tempstring;
std::string tempstring2;
void SpeedTests()
{
{
dstream<<"The following test should take around 20ms."<<std::endl;
TimeTaker timer("Testing std::string speed");
const u32 jj = 10000;
for(u32 j=0; j<jj; j++)
{
tempstring = "";
tempstring2 = "";
const u32 ii = 10;
for(u32 i=0; i<ii; i++){
tempstring2 += "asd";
}
for(u32 i=0; i<ii+1; i++){
tempstring += "asd";
if(tempstring == tempstring2)
break;
}
}
}
dstream<<"All of the following tests should take around 100ms each."
<<std::endl;
{
TimeTaker timer("Testing floating-point conversion speed");
tempf = 0.001;
for(u32 i=0; i<4000000; i++){
temp16 += tempf;
tempf += 0.001;
}
}
{
TimeTaker timer("Testing floating-point vector speed");
tempv3f1 = v3f(1,2,3);
tempv3f2 = v3f(4,5,6);
for(u32 i=0; i<10000000; i++){
tempf += tempv3f1.dotProduct(tempv3f2);
tempv3f2 += v3f(7,8,9);
}
}
{
TimeTaker timer("Testing core::map speed");
core::map<v2s16, f32> map1;
tempf = -324;
const s16 ii=300;
for(s16 y=0; y<ii; y++){
for(s16 x=0; x<ii; x++){
map1.insert(v2s16(x,y), tempf);
tempf += 1;
}
}
for(s16 y=ii-1; y>=0; y--){
for(s16 x=0; x<ii; x++){
tempf = map1[v2s16(x,y)];
}
}
}
{
dstream<<"Around 5000/ms should do well here."<<std::endl;
TimeTaker timer("Testing mutex speed");
JMutex m;
m.Init();
u32 n = 0;
u32 i = 0;
do{
n += 10000;
for(; i<n; i++){
m.Lock();
m.Unlock();
}
}
// Do at least 10ms
while(timer.getTime() < 10);
u32 dtime = timer.stop();
u32 per_ms = n / dtime;
dstream<<"Done. "<<dtime<<"ms, "
<<per_ms<<"/ms"<<std::endl;
}
}
void drawMenuBackground(video::IVideoDriver* driver)
{
core::dimension2d<u32> screensize = driver->getScreenSize();
@ -1042,25 +979,105 @@ void drawMenuBackground(video::IVideoDriver* driver)
}
}
class StderrLogOutput: public ILogOutput
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
std::cerr<<line<<std::endl;
}
} main_stderr_log_out;
#endif
class DstreamNoStderrLogOutput: public ILogOutput
// These are defined global so that they're not optimized too much.
// Can't change them to volatile.
s16 temp16;
f32 tempf;
v3f tempv3f1;
v3f tempv3f2;
std::string tempstring;
std::string tempstring2;
void SpeedTests()
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
dstream_no_stderr<<line<<std::endl;
infostream<<"The following test should take around 20ms."<<std::endl;
TimeTaker timer("Testing std::string speed");
const u32 jj = 10000;
for(u32 j=0; j<jj; j++)
{
tempstring = "";
tempstring2 = "";
const u32 ii = 10;
for(u32 i=0; i<ii; i++){
tempstring2 += "asd";
}
} main_dstream_no_stderr_log_out;
for(u32 i=0; i<ii+1; i++){
tempstring += "asd";
if(tempstring == tempstring2)
break;
}
}
}
infostream<<"All of the following tests should take around 100ms each."
<<std::endl;
{
TimeTaker timer("Testing floating-point conversion speed");
tempf = 0.001;
for(u32 i=0; i<4000000; i++){
temp16 += tempf;
tempf += 0.001;
}
}
{
TimeTaker timer("Testing floating-point vector speed");
tempv3f1 = v3f(1,2,3);
tempv3f2 = v3f(4,5,6);
for(u32 i=0; i<10000000; i++){
tempf += tempv3f1.dotProduct(tempv3f2);
tempv3f2 += v3f(7,8,9);
}
}
{
TimeTaker timer("Testing core::map speed");
core::map<v2s16, f32> map1;
tempf = -324;
const s16 ii=300;
for(s16 y=0; y<ii; y++){
for(s16 x=0; x<ii; x++){
map1.insert(v2s16(x,y), tempf);
tempf += 1;
}
}
for(s16 y=ii-1; y>=0; y--){
for(s16 x=0; x<ii; x++){
tempf = map1[v2s16(x,y)];
}
}
}
{
infostream<<"Around 5000/ms should do well here."<<std::endl;
TimeTaker timer("Testing mutex speed");
JMutex m;
m.Init();
u32 n = 0;
u32 i = 0;
do{
n += 10000;
for(; i<n; i++){
m.Lock();
m.Unlock();
}
}
// Do at least 10ms
while(timer.getTime() < 10);
u32 dtime = timer.stop();
u32 per_ms = n / dtime;
infostream<<"Done. "<<dtime<<"ms, "
<<per_ms<<"/ms"<<std::endl;
}
}
int main(int argc, char *argv[])
{
@ -1086,29 +1103,28 @@ int main(int argc, char *argv[])
core::map<std::string, ValueSpec> allowed_options;
allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG,
"Show allowed options"));
allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
"Run server directly"));
allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
"Load configuration from specified file"));
allowed_options.insert("port", ValueSpec(VALUETYPE_STRING,
"Set network port to connect to"));
allowed_options.insert("address", ValueSpec(VALUETYPE_STRING,
"Address to connect to"));
allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG,
"Enable random user input, for testing"));
"Set network port (UDP) to use"));
allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG,
"Disable unit tests"));
allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG,
"Enable unit tests"));
allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING,
"Map directory (where everything in the world is stored)"));
#ifdef _WIN32
allowed_options.insert("dstream-on-stderr", ValueSpec(VALUETYPE_FLAG));
#endif
allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG,
"Run speed tests"));
allowed_options.insert("info-on-stderr", ValueSpec(VALUETYPE_FLAG,
"Print debug information to console"));
#ifndef SERVER
allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG,
"Run speed tests"));
allowed_options.insert("address", ValueSpec(VALUETYPE_STRING,
"Address to connect to"));
allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG,
"Enable random user input, for testing"));
allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
"Run server directly"));
#endif
Settings cmd_args;
@ -1145,13 +1161,7 @@ int main(int argc, char *argv[])
Low-level initialization
*/
bool disable_stderr = false;
#ifdef _WIN32
if(cmd_args.getFlag("dstream-on-stderr") == false)
disable_stderr = true;
#endif
if(cmd_args.getFlag("info-on-stderr"))
if(cmd_args.getFlag("info-on-stderr") || cmd_args.getFlag("speedtests"))
log_add_output(&main_stderr_log_out, LMT_INFO);
porting::signal_handler_init();
@ -1170,6 +1180,7 @@ int main(int argc, char *argv[])
#else
std::string debugfile = porting::path_user+DIR_DELIM+DEBUGFILE;
#endif
bool disable_stderr = false;
debugstreams_init(disable_stderr, debugfile.c_str());
// Initialize debug stacks
debug_stacks_init();
@ -1261,13 +1272,6 @@ int main(int argc, char *argv[])
run_tests();
}
/*for(s16 y=-100; y<100; y++)
for(s16 x=-100; x<100; x++)
{
std::cout<<noise2d_gradient((double)x/10,(double)y/10, 32415)<<std::endl;
}
return 0;*/
/*
Game parameters
*/
@ -1299,24 +1303,42 @@ int main(int argc, char *argv[])
}
}
// Run dedicated server if asked to
if(cmd_args.getFlag("server"))
// Run dedicated server if asked to or no other option
#ifdef SERVER
bool run_dedicated_server = true;
#else
bool run_dedicated_server = cmd_args.getFlag("server");
#endif
if(run_dedicated_server)
{
DSTACK("Dedicated server branch");
// Create time getter
// Create time getter if built with Irrlicht
#ifndef SERVER
g_timegetter = new SimpleTimeGetter();
#endif
// Create server
Server server(map_dir, configpath, "mesetint");
server.start(port);
// ASCII art for the win!
dstream<<std::endl
<<" .__ __ __ "<<std::endl
<<" _____ |__| ____ _____/ |_ ____ _______/ |_ "<<std::endl
<<" / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\"<<std::endl
<<"| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | "<<std::endl
<<"|__|_| /__|___| /\\___ >__| \\___ >____ > |__| "<<std::endl
<<" \\/ \\/ \\/ \\/ \\/ "<<std::endl
<<std::endl;
// Run server
dedicated_server_loop(server, kill);
return 0;
}
#ifndef SERVER // Exclude from dedicated server build
/*
More parameters
@ -1680,6 +1702,8 @@ int main(int argc, char *argv[])
*/
device->drop();
#endif // !SERVER
END_DEBUG_EXCEPTION_HANDLER(errorstream)
debugstreams_deinit();

388
src/servermain.cpp
View File

@ -1,388 +0,0 @@
/*
Minetest-c55
Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/*
=============================== NOTES ==============================
*/
#ifndef SERVER
#ifdef _WIN32
#pragma error ("For a server build, SERVER must be defined globally")
#else
#error "For a server build, SERVER must be defined globally"
#endif
#endif
#ifdef NDEBUG
#ifdef _WIN32
#pragma message ("Disabling unit tests")
#else
#warning "Disabling unit tests"
#endif
// Disable unit tests
#define ENABLE_TESTS 0
#else
// Enable unit tests
#define ENABLE_TESTS 1
#endif
#ifdef _MSC_VER
#pragma comment(lib, "jthread.lib")
#pragma comment(lib, "zlibwapi.lib")
#endif
#include <iostream>
#include <fstream>
#include <time.h>
#include <jmutexautolock.h>
#include <locale.h>
#include "common_irrlicht.h"
#include "debug.h"
#include "map.h"
#include "player.h"
#include "main.h"
#include "test.h"
#include "environment.h"
#include "server.h"
#include "serialization.h"
#include "constants.h"
#include "strfnd.h"
#include "porting.h"
#include "config.h"
#include "filesys.h"
#include "defaultsettings.h"
#include "settings.h"
#include "profiler.h"
#include "log.h"
#include "nodedef.h" // For init_contentfeatures
#include "content_mapnode.h" // For content_mapnode_init
#include "mods.h"
/*
Settings.
These are loaded from the config file.
*/
Settings main_settings;
Settings *g_settings = &main_settings;
// Global profiler
Profiler main_profiler;
Profiler *g_profiler = &main_profiler;
/*
Debug streams
*/
// Connection
std::ostream *dout_con_ptr = &dummyout;
std::ostream *derr_con_ptr = &verbosestream;
// Server
std::ostream *dout_server_ptr = &infostream;
std::ostream *derr_server_ptr = &errorstream;
// Client
std::ostream *dout_client_ptr = &infostream;
std::ostream *derr_client_ptr = &errorstream;
/*
gettime.h implementation
*/
u32 getTimeMs()
{
/*
Use imprecise system calls directly (from porting.h)
*/
return porting::getTimeMs();
}
class StderrLogOutput: public ILogOutput
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
std::cerr<<line<<std::endl;
}
} main_stderr_log_out;
class DstreamNoStderrLogOutput: public ILogOutput
{
public:
/* line: Full line with timestamp, level and thread */
void printLog(const std::string &line)
{
dstream_no_stderr<<line<<std::endl;
}
} main_dstream_no_stderr_log_out;
int main(int argc, char *argv[])
{
/*
Initialization
*/
log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
log_add_output_all_levs(&main_dstream_no_stderr_log_out);
log_register_thread("main");
// Set locale. This is for forcing '.' as the decimal point.
std::locale::global(std::locale("C"));
// This enables printing all characters in bitmap font
setlocale(LC_CTYPE, "en_US");
/*
Low-level initialization
*/
bool disable_stderr = false;
#ifdef _WIN32
disable_stderr = true;
#endif
porting::signal_handler_init();
bool &kill = *porting::signal_handler_killstatus();
porting::initializePaths();
// Create user data directory
fs::CreateDir(porting::path_user);
// Initialize debug streams
#ifdef RUN_IN_PLACE
std::string debugfile = DEBUGFILE;
#else
std::string debugfile = porting::path_user+DIR_DELIM+DEBUGFILE;
#endif
debugstreams_init(disable_stderr, debugfile.c_str());
// Initialize debug stacks
debug_stacks_init();
DSTACK(__FUNCTION_NAME);
// Init material properties table
//initializeMaterialProperties();
// Debug handler
BEGIN_DEBUG_EXCEPTION_HANDLER
// Print startup message
actionstream<<PROJECT_NAME<<
" with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
<<", "<<BUILD_INFO
<<std::endl;
try
{
/*
Parse command line
*/
// List all allowed options
core::map<std::string, ValueSpec> allowed_options;
allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG,
"Show allowed options"));
allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
"Load configuration from specified file"));
allowed_options.insert("port", ValueSpec(VALUETYPE_STRING,
"Set network port (UDP) to use"));
allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG,
"Disable unit tests"));
allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG,
"Enable unit tests"));
allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING,
"Map directory (where everything in the world is stored)"));
allowed_options.insert("info-on-stderr", ValueSpec(VALUETYPE_FLAG,
"Print debug information to console"));
Settings cmd_args;
bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
if(ret == false || cmd_args.getFlag("help"))
{
dstream<<"Allowed options:"<<std::endl;
for(core::map<std::string, ValueSpec>::Iterator
i = allowed_options.getIterator();
i.atEnd() == false; i++)
{
dstream<<" --"<<i.getNode()->getKey();
if(i.getNode()->getValue().type == VALUETYPE_FLAG)
{
}
else
{
dstream<<" <value>";
}
dstream<<std::endl;
if(i.getNode()->getValue().help != NULL)
{
dstream<<" "<<i.getNode()->getValue().help
<<std::endl;
}
}
return cmd_args.getFlag("help") ? 0 : 1;
}
if(cmd_args.getFlag("info-on-stderr"))
log_add_output(&main_stderr_log_out, LMT_INFO);
/*
Basic initialization
*/
// Initialize default settings
set_default_settings(g_settings);
// Initialize sockets
sockets_init();
atexit(sockets_cleanup);
/*
Read config file
*/
// Path of configuration file in use
std::string configpath = "";
if(cmd_args.exists("config"))
{
bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
if(r == false)
{
errorstream<<"Could not read configuration from \""
<<cmd_args.get("config")<<"\""<<std::endl;
return 1;
}
configpath = cmd_args.get("config");
}
else
{
core::array<std::string> filenames;
filenames.push_back(porting::path_user +
DIR_DELIM + "minetest.conf");
// Legacy configuration file location
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#ifdef RUN_IN_PLACE
// Try also from a lower level (to aid having the same configuration
// for many RUN_IN_PLACE installs)
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#endif
for(u32 i=0; i<filenames.size(); i++)
{
bool r = g_settings->readConfigFile(filenames[i].c_str());
if(r)
{
configpath = filenames[i];
break;
}
}
}
// Initialize random seed
srand(time(0));
mysrand(time(0));
/*
Run unit tests
*/
if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
|| cmd_args.getFlag("enable-unittests") == true)
{
run_tests();
}
/*
Check parameters
*/
std::cout<<std::endl<<std::endl;
std::cout
<<" .__ __ __ "<<std::endl
<<" _____ |__| ____ _____/ |_ ____ _______/ |_ "<<std::endl
<<" / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\"<<std::endl
<<"| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | "<<std::endl
<<"|__|_| /__|___| /\\___ >__| \\___ >____ > |__| "<<std::endl
<<" \\/ \\/ \\/ \\/ \\/ "<<std::endl
<<std::endl;
std::cout<<std::endl;
// Port?
u16 port = 30000;
if(cmd_args.exists("port") && cmd_args.getU16("port") != 0)
port = cmd_args.getU16("port");
else if(g_settings->exists("port") && g_settings->getU16("port") != 0)
port = g_settings->getU16("port");
// Map directory
std::string map_dir = porting::path_user + DIR_DELIM + "server" + DIR_DELIM + "worlds" + DIR_DELIM + "world";
if(cmd_args.exists("map-dir"))
map_dir = cmd_args.get("map-dir");
else if(g_settings->exists("map-dir"))
map_dir = g_settings->get("map-dir");
else{
// No map-dir option was specified.
// Check if the world is found from the default directory, and if
// not, see if the legacy world directory exists.
std::string legacy_map_dir = porting::path_user+DIR_DELIM+".."+DIR_DELIM+"world";
if(!fs::PathExists(map_dir) && fs::PathExists(legacy_map_dir)){
errorstream<<"Warning: Using legacy world directory \""
<<legacy_map_dir<<"\""<<std::endl;
map_dir = legacy_map_dir;
}
}
// Create server
Server server(map_dir, configpath, "mesetint");
server.start(port);
// Run server
dedicated_server_loop(server, kill);
} //try
catch(con::PeerNotFoundException &e)
{
errorstream<<"Connection timed out."<<std::endl;
}
catch(ModError &e)
{
errorstream<<e.what()<<std::endl;
}
END_DEBUG_EXCEPTION_HANDLER(errorstream)
debugstreams_deinit();
return 0;
}
//END