Trinity Daemon

Macros
#define	_TRINITY_CORE_CONFIG   "worldserver.conf"
#define	WORLD_SLEEP_CONST   50

Functions
void	utf8print (void *, const char *str)
void	commandFinished (void *, bool)
void	CliThread ()
	Thread start More...
boost::asio::deadline_timer	_freezeCheckTimer (_ioService)
uint32	_worldLoopCounter (0)
uint32	_lastChangeMsTime (0)
uint32	_maxCoreStuckTimeInMs (0)
void	SignalHandler (const boost::system::error_code &error, int signalNumber)
void	FreezeDetectorHandler (const boost::system::error_code &error)
AsyncAcceptor *	StartRaSocketAcceptor (boost::asio::io_service &ioService)
bool	StartDB ()
	Initialize connection to the databases. More...
void	StopDB ()
void	WorldUpdateLoop ()
void	ClearOnlineAccounts ()
	Clear 'online' status for all accounts with characters in this realm. More...
void	ShutdownCLIThread (std::thread *cliThread)
void	ShutdownThreadPool (std::vector< std::thread > &threadPool)
bool	LoadRealmInfo ()
variables_map	GetConsoleArguments (int argc, char **argv, std::string &cfg_file, std::string &cfg_service)
int	main (int argc, char **argv)
	Launch the Trinity server. More...

Variables
boost::asio::io_service	_ioService

Detailed Description

Macro Definition Documentation

#define _TRINITY_CORE_CONFIG   "worldserver.conf"

#define WORLD_SLEEP_CONST   50

Function Documentation

boost::asio::deadline_timer _freezeCheckTimer

(

_ioService

)

Here is the caller graph for this function:

uint32 _lastChangeMsTime

(

0

)

Here is the caller graph for this function:

uint32 _maxCoreStuckTimeInMs

(

0

)

Here is the caller graph for this function:

uint32 _worldLoopCounter

(

0

)

Here is the caller graph for this function:

void ClearOnlineAccounts

(

)

Clear 'online' status for all accounts with characters in this realm.

{
 // Reset online status for all accounts with characters on the current realm
 LoginDatabase.DirectPExecute("UPDATE account SET online = 0 WHERE online > 0 AND id IN (SELECT acctid FROM realmcharacters WHERE realmid = %d)", realm.Id.Realm);

 // Reset online status for all characters
 CharacterDatabase.DirectExecute("UPDATE characters SET online = 0 WHERE online <> 0");

 // Battleground instance ids reset at server restart
 CharacterDatabase.DirectExecute("UPDATE character_battleground_data SET instanceId = 0");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CliThread

(

)

Thread start

• Display the list of available CLI functions then beep
• As long as the World is running (no World::m_stopEvent), get the command line and handle it

{
 //TC_LOG_INFO("server.worldserver", "");
#if PLATFORM != PLATFORM_WINDOWS
 rl_attempted_completion_function = cli_completion;
 rl_event_hook = cli_hook_func;
#endif

 if (sConfigMgr->GetBoolDefault("BeepAtStart", true))
 printf("\a"); // \a = Alert

 // print this here the first time
 // later it will be printed after command queue updates
 printf("TC>");

 while (!World::IsStopped())
 {
 fflush(stdout);

 char *command_str ; // = fgets(commandbuf, sizeof(commandbuf), stdin);

#if PLATFORM == PLATFORM_WINDOWS
 char commandbuf[256];
 command_str = fgets(commandbuf, sizeof(commandbuf), stdin);
#else
 command_str = readline("TC>");
 rl_bind_key('\t', rl_complete);
#endif

 if (command_str != NULL)
 {
 for (int x=0; command_str[x]; ++x)
 if (command_str[x] == '\r' || command_str[x] == '\n')
 {
 command_str[x] = 0;
 break;
 }

 if (!*command_str)
 {
#if PLATFORM == PLATFORM_WINDOWS
 printf("TC>");
#else
 free(command_str);
#endif
 continue;
 }

 std::string command;
 if (!consoleToUtf8(command_str, command)) // convert from console encoding to utf8
 {
#if PLATFORM == PLATFORM_WINDOWS
 printf("TC>");
#else
 free(command_str);
#endif
 continue;
 }

 fflush(stdout);
 sWorld->QueueCliCommand(new CliCommandHolder(NULL, command.c_str(), &utf8print, &commandFinished));
#if PLATFORM != PLATFORM_WINDOWS
 add_history(command.c_str());
 free(command_str);
#endif
 }
 else if (feof(stdin))
 {
 World::StopNow(SHUTDOWN_EXIT_CODE);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void commandFinished	(	void *	,
		bool
	)

{
 printf("TC> ");
 fflush(stdout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void FreezeDetectorHandler

(

const boost::system::error_code &

error

)

{
 if (!error)
 {
 uint32 curtime = getMSTime();

 uint32 worldLoopCounter = World::m_worldLoopCounter;
 if (_worldLoopCounter != worldLoopCounter)
 {
 _lastChangeMsTime = curtime;
 _worldLoopCounter = worldLoopCounter;
 }
 // possible freeze
 else if (getMSTimeDiff(_lastChangeMsTime, curtime) > _maxCoreStuckTimeInMs)
 {
 TC_LOG_ERROR("server.worldserver", "World Thread hangs, kicking out server!");
 ABORT();
 }

 _freezeCheckTimer.expires_from_now(boost::posix_time::seconds(1));
 _freezeCheckTimer.async_wait(FreezeDetectorHandler);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

variables_map GetConsoleArguments	(	int	argc,
		char **	argv,
		std::string &	cfg_file,
		std::string &	cfg_service
	)

{
 // Silences warning about configService not be used if the OS is not Windows
 (void)configService;

 options_description all("Allowed options");
 all.add_options()
 ("help,h", "print usage message")
 ("version,v", "print version build info")
 ("config,c", value<std::string>(&configFile)->default_value(_TRINITY_CORE_CONFIG), "use <arg> as configuration file")
 ;
#ifdef _WIN32
 options_description win("Windows platform specific options");
 win.add_options()
 ("service,s", value<std::string>(&configService)->default_value(""), "Windows service options: [install | uninstall]")
 ;

 all.add(win);
#endif
 variables_map vm;
 try
 {
 store(command_line_parser(argc, argv).options(all).allow_unregistered().run(), vm);
 notify(vm);
 }
 catch (std::exception& e)
 {
 std::cerr << e.what() << "\n";
 }

 if (vm.count("help"))
 {
 std::cout << all << "\n";
 }
 else if (vm.count("version"))
 {
 std::cout << GitRevision::GetFullVersion() << "\n";
 }

 return vm;
}

Here is the call graph for this function:

bool LoadRealmInfo

(

)

{
 boost::asio::ip::tcp::resolver resolver(_ioService);
 boost::asio::ip::tcp::resolver::iterator end;

 QueryResult result = LoginDatabase.PQuery("SELECT id, name, address, localAddress, localSubnetMask, port, icon, flag, timezone, allowedSecurityLevel, population, gamebuild, Region, Battlegroup FROM realmlist WHERE id = %u", realm.Id.Realm);
 if (!result)
 return false;

 Field* fields = result->Fetch();
 realm.Name = fields[1].GetString();
 boost::asio::ip::tcp::resolver::query externalAddressQuery(ip::tcp::v4(), fields[2].GetString(), "");

 boost::system::error_code ec;
 boost::asio::ip::tcp::resolver::iterator endPoint = resolver.resolve(externalAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[2].GetString().c_str());
 return false;
 }

 realm.ExternalAddress = (*endPoint).endpoint().address();

 boost::asio::ip::tcp::resolver::query localAddressQuery(ip::tcp::v4(), fields[3].GetString(), "");
 endPoint = resolver.resolve(localAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[3].GetString().c_str());
 return false;
 }

 realm.LocalAddress = (*endPoint).endpoint().address();

 boost::asio::ip::tcp::resolver::query localSubmaskQuery(ip::tcp::v4(), fields[4].GetString(), "");
 endPoint = resolver.resolve(localSubmaskQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("server.worldserver", "Could not resolve address %s", fields[4].GetString().c_str());
 return false;
 }

 realm.LocalSubnetMask = (*endPoint).endpoint().address();

 realm.Port = fields[5].GetUInt16();
 realm.Type = fields[6].GetUInt8();
 realm.Flags = RealmFlags(fields[7].GetUInt8());
 realm.Timezone = fields[8].GetUInt8();
 realm.AllowedSecurityLevel = AccountTypes(fields[9].GetUInt8());
 realm.PopulationLevel = fields[10].GetFloat();
 realm.Id.Region = fields[12].GetUInt8();
 realm.Id.Site = fields[13].GetUInt8();
 realm.Build = fields[11].GetUInt32();
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Launch the Trinity server.

worldserver PID file creation

• Clean database before leaving

{
 signal(SIGABRT, &Trinity::AbortHandler);

 std::string configFile = _TRINITY_CORE_CONFIG;
 std::string configService;

 auto vm = GetConsoleArguments(argc, argv, configFile, configService);
 // exit if help or version is enabled
 if (vm.count("help") || vm.count("version"))
 return 0;

 GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef _WIN32
 if (configService.compare("install") == 0)
 return WinServiceInstall() ? 0 : 1;
 else if (configService.compare("uninstall") == 0)
 return WinServiceUninstall() ? 0 : 1;
 else if (configService.compare("run") == 0)
 return WinServiceRun() ? 0 : 0;
#endif

 std::string configError;
 if (!sConfigMgr->LoadInitial(configFile, configError))
 {
 printf("Error in config file: %s\n", configError.c_str());
 return 1;
 }

 sLog->RegisterAppender<AppenderDB>();
 // If logs are supposed to be handled async then we need to pass the io_service into the Log singleton
 sLog->Initialize(sConfigMgr->GetBoolDefault("Log.Async.Enable", false) ? &_ioService : nullptr);

 TC_LOG_INFO("server.worldserver", "%s (worldserver-daemon)", GitRevision::GetFullVersion());
 TC_LOG_INFO("server.worldserver", "<Ctrl-C> to stop.\n");
 TC_LOG_INFO("server.worldserver", " ______ __");
 TC_LOG_INFO("server.worldserver", "/\\__ _\\ __ __/\\ \\__");
 TC_LOG_INFO("server.worldserver", "\\/_/\\ \\/ _ __ /\\_\\ ___ /\\_\\ \\, _\\ __ __");
 TC_LOG_INFO("server.worldserver", " \\ \\ \\/\\`'__\\/\\ \\ /' _ `\\/\\ \\ \\ \\/ /\\ \\/\\ \\");
 TC_LOG_INFO("server.worldserver", " \\ \\ \\ \\ \\/ \\ \\ \\/\\ \\/\\ \\ \\ \\ \\ \\_\\ \\ \\_\\ \\");
 TC_LOG_INFO("server.worldserver", " \\ \\_\\ \\_\\ \\ \\_\\ \\_\\ \\_\\ \\_\\ \\__\\\\/`____ \\");
 TC_LOG_INFO("server.worldserver", " \\/_/\\/_/ \\/_/\\/_/\\/_/\\/_/\\/__/ `/___/> \\");
 TC_LOG_INFO("server.worldserver", " C O R E /\\___/");
 TC_LOG_INFO("server.worldserver", "http://TrinityCore.org \\/__/\n");
 TC_LOG_INFO("server.worldserver", "Using configuration file %s.", configFile.c_str());
 TC_LOG_INFO("server.worldserver", "Using SSL version: %s (library: %s)", OPENSSL_VERSION_TEXT, SSLeay_version(SSLEAY_VERSION));
 TC_LOG_INFO("server.worldserver", "Using Boost version: %i.%i.%i", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);

 OpenSSLCrypto::threadsSetup();

 // Seed the OpenSSL's PRNG here.
 // That way it won't auto-seed when calling BigNumber::SetRand and slow down the first world login
 BigNumber seed;
 seed.SetRand(16 * 8);

 std::string pidFile = sConfigMgr->GetStringDefault("PidFile", "");
 if (!pidFile.empty())
 {
 if (uint32 pid = CreatePIDFile(pidFile))
 TC_LOG_INFO("server.worldserver", "Daemon PID: %u\n", pid);
 else
 {
 TC_LOG_ERROR("server.worldserver", "Cannot create PID file %s.\n", pidFile.c_str());
 return 1;
 }
 }

 // Set signal handlers (this must be done before starting io_service threads, because otherwise they would unblock and exit)
 boost::asio::signal_set signals(_ioService, SIGINT, SIGTERM);
#if PLATFORM == PLATFORM_WINDOWS
 signals.add(SIGBREAK);
#endif
 signals.async_wait(SignalHandler);

 // Start the Boost based thread pool
 int numThreads = sConfigMgr->GetIntDefault("ThreadPool", 1);
 std::vector<std::thread> threadPool;

 if (numThreads < 1)
 numThreads = 1;

 for (int i = 0; i < numThreads; ++i)
 threadPool.push_back(std::thread(boost::bind(&boost::asio::io_service::run, &_ioService)));

 // Set process priority according to configuration settings
 SetProcessPriority("server.worldserver");

 // Start the databases
 if (!StartDB())
 {
 ShutdownThreadPool(threadPool);
 return 1;
 }

 // Set server offline (not connectable)
 LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = flag | %u WHERE id = '%d'", REALM_FLAG_OFFLINE, realm.Id.Realm);

 sRealmList->Initialize(_ioService, sConfigMgr->GetIntDefault("RealmsStateUpdateDelay", 10));

 LoadRealmInfo();

 // Initialize the World
 sScriptMgr->SetScriptLoader(AddScripts);
 sWorld->SetInitialWorldSettings();

 // Launch CliRunnable thread
 std::thread* cliThread = nullptr;
#ifdef _WIN32
 if (sConfigMgr->GetBoolDefault("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/)
#else
 if (sConfigMgr->GetBoolDefault("Console.Enable", true))
#endif
 {
 cliThread = new std::thread(CliThread);
 }

 // Start the Remote Access port (acceptor) if enabled
 AsyncAcceptor* raAcceptor = nullptr;
 if (sConfigMgr->GetBoolDefault("Ra.Enable", false))
 raAcceptor = StartRaSocketAcceptor(_ioService);

 // Start soap serving thread if enabled
 std::thread* soapThread = nullptr;
 if (sConfigMgr->GetBoolDefault("SOAP.Enabled", false))
 {
 soapThread = new std::thread(TCSoapThread, sConfigMgr->GetStringDefault("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetIntDefault("SOAP.Port", 7878)));
 }

 // Launch the worldserver listener socket
 uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD));
 std::string worldListener = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0");

 int networkThreads = sConfigMgr->GetIntDefault("Network.Threads", 1);

 if (networkThreads <= 0)
 {
 TC_LOG_ERROR("server.worldserver", "Network.Threads must be greater than 0");
 return false;
 }

 sWorldSocketMgr.StartNetwork(_ioService, worldListener, worldPort, networkThreads);

 // Set server online (allow connecting now)
 LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = flag & ~%u, population = 0 WHERE id = '%u'", REALM_FLAG_OFFLINE, realm.Id.Realm);
 realm.PopulationLevel = 0.0f;
 realm.Flags = RealmFlags(realm.Flags & ~uint32(REALM_FLAG_OFFLINE));

 // Start the freeze check callback cycle in 5 seconds (cycle itself is 1 sec)
 if (int coreStuckTime = sConfigMgr->GetIntDefault("MaxCoreStuckTime", 0))
 {
 _maxCoreStuckTimeInMs = coreStuckTime * 1000;
 _freezeCheckTimer.expires_from_now(boost::posix_time::seconds(5));
 _freezeCheckTimer.async_wait(FreezeDetectorHandler);
 TC_LOG_INFO("server.worldserver", "Starting up anti-freeze thread (%u seconds max stuck time)...", coreStuckTime);
 }

 TC_LOG_INFO("server.worldserver", "%s (worldserver-daemon) ready...", GitRevision::GetFullVersion());

 sScriptMgr->OnStartup();

 WorldUpdateLoop();

 // Shutdown starts here
 ShutdownThreadPool(threadPool);

 sLog->SetSynchronous();

 sScriptMgr->OnShutdown();

 sWorld->KickAll(); // save and kick all players
 sWorld->UpdateSessions(1); // real players unload required UpdateSessions call

 // unload battleground templates before different singletons destroyed
 sBattlegroundMgr->DeleteAllBattlegrounds();

 sWorldSocketMgr.StopNetwork();

 sInstanceSaveMgr->Unload();
 sOutdoorPvPMgr->Die(); // unload it before MapManager
 sMapMgr->UnloadAll(); // unload all grids (including locked in memory)
 sScriptMgr->Unload();

 // set server offline
 LoginDatabase.DirectPExecute("UPDATE realmlist SET flag = flag | %u WHERE id = '%d'", REALM_FLAG_OFFLINE, realm.Id.Realm);
 sRealmList->Close();

 // Clean up threads if any
 if (soapThread != nullptr)
 {
 soapThread->join();
 delete soapThread;
 }

 delete raAcceptor;

 ClearOnlineAccounts();

 StopDB();

 TC_LOG_INFO("server.worldserver", "Halting process...");

 ShutdownCLIThread(cliThread);

 OpenSSLCrypto::threadsCleanup();

 google::protobuf::ShutdownProtobufLibrary();

 // 0 - normal shutdown
 // 1 - shutdown at error
 // 2 - restart command used, this code can be used by restarter for restart Trinityd

 return World::GetExitCode();
}

Here is the call graph for this function:

void ShutdownCLIThread

(

std::thread *

cliThread

)

{
 if (cliThread != nullptr)
 {
#ifdef _WIN32
 // First try to cancel any I/O in the CLI thread
 if (!CancelSynchronousIo(cliThread->native_handle()))
 {
 // if CancelSynchronousIo() fails, print the error and try with old way
 DWORD errorCode = GetLastError();
 LPSTR errorBuffer;

 DWORD formatReturnCode = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS,
 nullptr, errorCode, 0, (LPTSTR)&errorBuffer, 0, nullptr);
 if (!formatReturnCode)
 errorBuffer = "Unknown error";

 TC_LOG_DEBUG("server.worldserver", "Error cancelling I/O of CliThread, error code %u, detail: %s",
 uint32(errorCode), errorBuffer);
 LocalFree(errorBuffer);

 // send keyboard input to safely unblock the CLI thread
 INPUT_RECORD b[4];
 HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
 b[0].EventType = KEY_EVENT;
 b[0].Event.KeyEvent.bKeyDown = TRUE;
 b[0].Event.KeyEvent.uChar.AsciiChar = 'X';
 b[0].Event.KeyEvent.wVirtualKeyCode = 'X';
 b[0].Event.KeyEvent.wRepeatCount = 1;

 b[1].EventType = KEY_EVENT;
 b[1].Event.KeyEvent.bKeyDown = FALSE;
 b[1].Event.KeyEvent.uChar.AsciiChar = 'X';
 b[1].Event.KeyEvent.wVirtualKeyCode = 'X';
 b[1].Event.KeyEvent.wRepeatCount = 1;

 b[2].EventType = KEY_EVENT;
 b[2].Event.KeyEvent.bKeyDown = TRUE;
 b[2].Event.KeyEvent.dwControlKeyState = 0;
 b[2].Event.KeyEvent.uChar.AsciiChar = '\r';
 b[2].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
 b[2].Event.KeyEvent.wRepeatCount = 1;
 b[2].Event.KeyEvent.wVirtualScanCode = 0x1c;

 b[3].EventType = KEY_EVENT;
 b[3].Event.KeyEvent.bKeyDown = FALSE;
 b[3].Event.KeyEvent.dwControlKeyState = 0;
 b[3].Event.KeyEvent.uChar.AsciiChar = '\r';
 b[3].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
 b[3].Event.KeyEvent.wVirtualScanCode = 0x1c;
 b[3].Event.KeyEvent.wRepeatCount = 1;
 DWORD numb;
 WriteConsoleInput(hStdIn, b, 4, &numb);
 }
#endif
 cliThread->join();
 delete cliThread;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShutdownThreadPool

(

std::vector< std::thread > &

threadPool

)

{
 sScriptMgr->OnNetworkStop();

 _ioService.stop();

 for (auto& thread : threadPool)
 {
 thread.join();
 }
}

Here is the caller graph for this function:

void SignalHandler	(	const boost::system::error_code &	error,
		int	signalNumber
	)

{
 if (!error)
 World::StopNow(SHUTDOWN_EXIT_CODE);
}

Here is the call graph for this function:

bool StartDB

(

)

Initialize connection to the databases.

• Get the realm Id from the configuration file
• Clean the database before starting
• Insert version info into DB

{
 MySQL::Library_Init();

 // Load databases
 DatabaseLoader loader("server.worldserver", DatabaseLoader::DATABASE_NONE);
 loader
 .AddDatabase(LoginDatabase, "Login")
 .AddDatabase(CharacterDatabase, "Character")
 .AddDatabase(WorldDatabase, "World")
 .AddDatabase(HotfixDatabase, "Hotfix");

 if (!loader.Load())
 return false;

 realm.Id.Realm = sConfigMgr->GetIntDefault("RealmID", 0);
 if (!realm.Id.Realm)
 {
 TC_LOG_ERROR("server.worldserver", "Realm ID not defined in configuration file");
 return false;
 }

 TC_LOG_INFO("server.worldserver", "Realm running as realm ID %u", realm.Id.Realm);

 ClearOnlineAccounts();

 WorldDatabase.PExecute("UPDATE version SET core_version = '%s', core_revision = '%s'", GitRevision::GetFullVersion(), GitRevision::GetHash()); // One-time query

 sWorld->LoadDBVersion();

 TC_LOG_INFO("server.worldserver", "Using World DB: %s", sWorld->GetDBVersion());
 return true;
}

Here is the call graph for this function:

AsyncAcceptor * StartRaSocketAcceptor

(

boost::asio::io_service &

ioService

)

{
 uint16 raPort = uint16(sConfigMgr->GetIntDefault("Ra.Port", 3443));
 std::string raListener = sConfigMgr->GetStringDefault("Ra.IP", "0.0.0.0");

 AsyncAcceptor* acceptor = new AsyncAcceptor(ioService, raListener, raPort);
 acceptor->AsyncAccept<RASession>();
 return acceptor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void StopDB

(

)

{
 CharacterDatabase.Close();
 WorldDatabase.Close();
 LoginDatabase.Close();

 MySQL::Library_End();
}

Here is the call graph for this function:

void utf8print	(	void *	,
		const char *	str
	)

{
#if PLATFORM == PLATFORM_WINDOWS
 wchar_t wtemp_buf[6000];
 size_t wtemp_len = 6000-1;
 if (!Utf8toWStr(str, strlen(str), wtemp_buf, wtemp_len))
 return;

 char temp_buf[6000];
 CharToOemBuffW(&wtemp_buf[0], &temp_buf[0], wtemp_len+1);
 printf(temp_buf);
#else
{
 printf("%s", str);
 fflush(stdout);
}
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldUpdateLoop

(

)

• While we have not World::m_stopEvent, update the world

{
 uint32 realCurrTime = 0;
 uint32 realPrevTime = getMSTime();

 uint32 prevSleepTime = 0; // used for balanced full tick time length near WORLD_SLEEP_CONST

 while (!World::IsStopped())
 {
 ++World::m_worldLoopCounter;
 realCurrTime = getMSTime();

 uint32 diff = getMSTimeDiff(realPrevTime, realCurrTime);

 sWorld->Update(diff);
 realPrevTime = realCurrTime;

 // diff (D0) include time of previous sleep (d0) + tick time (t0)
 // we want that next d1 + t1 == WORLD_SLEEP_CONST
 // we can't know next t1 and then can use (t0 + d1) == WORLD_SLEEP_CONST requirement
 // d1 = WORLD_SLEEP_CONST - t0 = WORLD_SLEEP_CONST - (D0 - d0) = WORLD_SLEEP_CONST + d0 - D0
 if (diff <= WORLD_SLEEP_CONST + prevSleepTime)
 {
 prevSleepTime = WORLD_SLEEP_CONST + prevSleepTime - diff;

 std::this_thread::sleep_for(std::chrono::milliseconds(prevSleepTime));
 }
 else
 prevSleepTime = 0;

#ifdef _WIN32
 if (m_ServiceStatus == 0)
 World::StopNow(SHUTDOWN_EXIT_CODE);

 while (m_ServiceStatus == 2)
 Sleep(1000);
#endif
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

boost::asio::io_service _ioService