THREAD_FUN CNet::NetLoop(LPVOID p) {
CNet * pThis = (CNet *)p;
if (NULL == pThis) {
ASSERT(false);
return -1;
}
s32 code = 0;
s32 err = 0;
struct iocp_event * pEvent;
while (true) {
if (pThis->m_stop) {
CAutoLock(&(pThis->m_freelock));
pThis->m_nThreadCount--;
return 0;
}
pEvent = NULL;
code = get_event(&pEvent, &err);
if (ERROR_NO_ERROR == code && pEvent != NULL) {
NET_TRACE("event %d, code %d, last error %d, io bytes %d", pEvent->event, code, err, pEvent->ioBytes);
pThis->m_queue.add(pEvent);
} else {
if (pEvent != NULL) {
NET_ERROR("event %d, code %d, error %d", pEvent->event, code, err);
}
CSleep(10);
}
}
}
void CSelectModel::Stop() {
if (!m_bShutdown) {
m_bShutdown = true;
while (m_nThreadCount != 0) {
CSleep(1);
}
}
}
void CHttpEngine::Stop() {
if (!m_shutdown) {
m_shutdown = true;
while (m_nThreadCount != 0){
CSleep(10);
}
HttpBackCall(9999999);
}
}
void CNet::CStop() {
ASSERT(!m_stop);
LogModuleStop();
m_stop = true;
iocp_stop();
while (m_nThreadCount != 0) {
CSleep(10);
}
NET_TRACE("网络停止工作");
}
THREAD_FUN CHttpEngine::HttpThread(void * p) {
CHttpEngine * pThis = ((ThreadArgs * ) p)->pHttpEngine;
s32 nQueueID = ((ThreadArgs * ) p)->nQueueID;
TQueue<HTTPStream * , false, HTTP_QUEUE_SIZE> * pQueue = &(pThis->m_pHttpQueue[nQueueID]);
HTTPStream * pStream = NULL;
CURL * pCurlHandle = curl_easy_init();
while (true) {
if (pQueue->read(pStream)) {
curl_easy_reset(pCurlHandle);
curl_easy_setopt(pCurlHandle, CURLOPT_TIMEOUT, 10);
curl_easy_setopt(pCurlHandle, CURLOPT_VERBOSE, 0L);
curl_easy_setopt(pCurlHandle, CURLOPT_WRITEFUNCTION, write_callback);
ASSERT(pStream->size() == sizeof(HTTPContext));
HTTPContext * pHttp = (HTTPContext *)pStream->buff();
//这个变量可作为接收或传递数据的作用
curl_easy_setopt(pCurlHandle, CURLOPT_URL, pHttp->pUrl->buff());
HTTPStream * pBack = pThis->m_HTTPStreamPool.Create();
curl_easy_setopt(pCurlHandle, CURLOPT_WRITEDATA, pBack);
pHttp->code = curl_easy_perform(pCurlHandle);
char end = '\0';
pBack->in(&end, sizeof(end));
pHttp->pUrl->clear();
pThis->m_HTTPStreamPool.Recover(pHttp->pUrl);
pHttp->pBack = pBack;
pThis->m_backQueue.add(pStream);
} else if (pQueue->IsEmpty() && pThis->m_shutdown){
curl_easy_cleanup(pCurlHandle);
delete p;
CAutoLock(&(pThis->m_freelock));
pThis->m_nThreadCount--;
return 0;
} else {
CSleep(10);
}
}
}
THREAD_FUN CSelectModel::WriteThread(void * p) {
CSelectModel * pThis = (CSelectModel *) p;
ASSERT(pThis);
{
CAutoLock autoLock(&pThis->m_lock);
pThis->m_nThreadCount++;
}
while (true) {
if (pThis->m_bShutdown) {
CAutoLock autoLock(&pThis->m_lock);
pThis->ClearHandle();
pThis->m_nThreadCount--;
return 0;
}
pThis->CheckWrite();
CSleep(0);
}
return 0;
}
void MusicDriver_ExtMidi::DoStop()
{
if (this->pid <= 0) return;
/* First try to gracefully stop for about five seconds;
* 5 seconds = 5000 milliseconds, 10 ms per cycle => 500 cycles. */
for (int i = 0; i < 500; i++) {
kill(this->pid, SIGTERM);
if (waitpid(this->pid, NULL, WNOHANG) == this->pid) {
/* It has shut down, so we are done */
this->pid = -1;
return;
}
/* Wait 10 milliseconds. */
CSleep(10);
}
DEBUG(driver, 0, "extmidi: gracefully stopping failed, trying the hard way");
/* Gracefully stopping failed. Do it the hard way
* and wait till the process finally died. */
kill(this->pid, SIGKILL);
waitpid(this->pid, NULL, 0);
this->pid = -1;
}
void VideoDriver_SDL::MainLoop()
{
uint32 cur_ticks = SDL_CALL SDL_GetTicks();
uint32 last_cur_ticks = cur_ticks;
uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
uint32 mod;
int numkeys;
Uint8 *keys;
CheckPaletteAnim();
if (_draw_threaded) {
/* Initialise the mutex first, because that's the thing we *need*
* directly in the newly created thread. */
_draw_mutex = ThreadMutex::New();
if (_draw_mutex == NULL) {
_draw_threaded = false;
} else {
_draw_mutex->BeginCritical();
_draw_continue = true;
_draw_threaded = ThreadObject::New(&DrawSurfaceToScreenThread, NULL, &_draw_thread);
/* Free the mutex if we won't be able to use it. */
if (!_draw_threaded) {
_draw_mutex->EndCritical();
delete _draw_mutex;
_draw_mutex = NULL;
} else {
/* Wait till the draw mutex has started itself. */
_draw_mutex->WaitForSignal();
}
}
}
DEBUG(driver, 1, "SDL: using %sthreads", _draw_threaded ? "" : "no ");
for (;;) {
uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
InteractiveRandom(); // randomness
while (PollEvent() == -1) {}
if (_exit_game) break;
mod = SDL_CALL SDL_GetModState();
#if SDL_VERSION_ATLEAST(1, 3, 0)
keys = SDL_CALL SDL_GetKeyboardState(&numkeys);
#else
keys = SDL_CALL SDL_GetKeyState(&numkeys);
#endif
#if defined(_DEBUG)
if (_shift_pressed)
#else
/* Speedup when pressing tab, except when using ALT+TAB
* to switch to another application */
#if SDL_VERSION_ATLEAST(1, 3, 0)
if (keys[SDL_SCANCODE_TAB] && (mod & KMOD_ALT) == 0)
#else
if (keys[SDLK_TAB] && (mod & KMOD_ALT) == 0)
#endif /* SDL_VERSION_ATLEAST(1, 3, 0) */
#endif /* defined(_DEBUG) */
{
if (!_networking && _game_mode != GM_MENU) _fast_forward |= 2;
} else if (_fast_forward & 2) {
_fast_forward = 0;
}
cur_ticks = SDL_CALL SDL_GetTicks();
if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode) || cur_ticks < prev_cur_ticks) {
_realtime_tick += cur_ticks - last_cur_ticks;
last_cur_ticks = cur_ticks;
next_tick = cur_ticks + MILLISECONDS_PER_TICK;
bool old_ctrl_pressed = _ctrl_pressed;
_ctrl_pressed = !!(mod & KMOD_CTRL);
_shift_pressed = !!(mod & KMOD_SHIFT);
/* determine which directional keys are down */
_dirkeys =
#if SDL_VERSION_ATLEAST(1, 3, 0)
(keys[SDL_SCANCODE_LEFT] ? 1 : 0) |
(keys[SDL_SCANCODE_UP] ? 2 : 0) |
(keys[SDL_SCANCODE_RIGHT] ? 4 : 0) |
(keys[SDL_SCANCODE_DOWN] ? 8 : 0);
#else
(keys[SDLK_LEFT] ? 1 : 0) |
(keys[SDLK_UP] ? 2 : 0) |
(keys[SDLK_RIGHT] ? 4 : 0) |
(keys[SDLK_DOWN] ? 8 : 0);
#endif
if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
/* The gameloop is the part that can run asynchronously. The rest
* except sleeping can't. */
if (_draw_mutex != NULL) _draw_mutex->EndCritical();
GameLoop();
if (_draw_mutex != NULL) _draw_mutex->BeginCritical();
UpdateWindows();
_local_palette = _cur_palette;
} else {
/* Release the thread while sleeping */
if (_draw_mutex != NULL) _draw_mutex->EndCritical();
CSleep(1);
if (_draw_mutex != NULL) _draw_mutex->BeginCritical();
NetworkDrawChatMessage();
DrawMouseCursor();
}
/* End of the critical part. */
if (_draw_mutex != NULL && !HasModalProgress()) {
_draw_mutex->SendSignal();
} else {
/* Oh, we didn't have threads, then just draw unthreaded */
CheckPaletteAnim();
DrawSurfaceToScreen();
}
}
if (_draw_mutex != NULL) {
_draw_continue = false;
/* Sending signal if there is no thread blocked
* is very valid and results in noop */
_draw_mutex->SendSignal();
_draw_mutex->EndCritical();
_draw_thread->Join();
delete _draw_mutex;
delete _draw_thread;
_draw_mutex = NULL;
_draw_thread = NULL;
}
}
void VideoDriver_Allegro::MainLoop()
{
uint32 cur_ticks = GetTime();
uint32 last_cur_ticks = cur_ticks;
uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
CheckPaletteAnim();
for (;;) {
uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
InteractiveRandom(); // randomness
PollEvent();
if (_exit_game) return;
#if defined(_DEBUG)
if (_shift_pressed)
#else
/* Speedup when pressing tab, except when using ALT+TAB
* to switch to another application */
if (key[KEY_TAB] && (key_shifts & KB_ALT_FLAG) == 0)
#endif
{
if (!_networking && _game_mode != GM_MENU) _fast_forward |= 2;
} else if (_fast_forward & 2) {
_fast_forward = 0;
}
cur_ticks = GetTime();
if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode) || cur_ticks < prev_cur_ticks) {
_realtime_tick += cur_ticks - last_cur_ticks;
last_cur_ticks = cur_ticks;
next_tick = cur_ticks + MILLISECONDS_PER_TICK;
bool old_ctrl_pressed = _ctrl_pressed;
_ctrl_pressed = !!(key_shifts & KB_CTRL_FLAG);
_shift_pressed = !!(key_shifts & KB_SHIFT_FLAG);
/* determine which directional keys are down */
_dirkeys =
(key[KEY_LEFT] ? 1 : 0) |
(key[KEY_UP] ? 2 : 0) |
(key[KEY_RIGHT] ? 4 : 0) |
(key[KEY_DOWN] ? 8 : 0);
if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
GameLoop();
UpdateWindows();
CheckPaletteAnim();
DrawSurfaceToScreen();
} else {
CSleep(1);
NetworkDrawChatMessage();
DrawMouseCursor();
DrawSurfaceToScreen();
}
}
}
void VideoDriver_Dedicated::MainLoop()
{
uint32 cur_ticks = GetTime();
uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
/* Signal handlers */
#if defined(UNIX) || defined(PSP)
signal(SIGTERM, DedicatedSignalHandler);
signal(SIGINT, DedicatedSignalHandler);
signal(SIGQUIT, DedicatedSignalHandler);
#endif
/* Load the dedicated server stuff */
_is_network_server = true;
_network_dedicated = true;
_current_company = _local_company = COMPANY_SPECTATOR;
/* If SwitchMode is SM_LOAD_GAME, it means that the user used the '-g' options */
if (_switch_mode != SM_LOAD_GAME) {
StartNewGameWithoutGUI(GENERATE_NEW_SEED);
SwitchToMode(_switch_mode);
_switch_mode = SM_NONE;
} else {
_switch_mode = SM_NONE;
/* First we need to test if the savegame can be loaded, else we will end up playing the
* intro game... */
if (!SafeLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_NORMAL, BASE_DIR)) {
/* Loading failed, pop out.. */
DEBUG(net, 0, "Loading requested map failed, aborting");
_networking = false;
} else {
/* We can load this game, so go ahead */
SwitchToMode(SM_LOAD_GAME);
}
}
/* Done loading, start game! */
if (!_networking) {
DEBUG(net, 0, "Dedicated server could not be started, aborting");
return;
}
while (!_exit_game) {
uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
InteractiveRandom(); // randomness
if (!_dedicated_forks) DedicatedHandleKeyInput();
cur_ticks = GetTime();
_realtime_tick += cur_ticks - prev_cur_ticks;
if (cur_ticks >= next_tick || cur_ticks < prev_cur_ticks || _ddc_fastforward) {
next_tick = cur_ticks + MILLISECONDS_PER_TICK;
GameLoop();
UpdateWindows();
}
/* Don't sleep when fast forwarding (for desync debugging) */
if (!_ddc_fastforward) CSleep(1);
}
}
