src/video/dedicated_v.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD 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, version 2.
   6  * OpenTTD 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.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file dedicated_v.cpp Dedicated server video 'driver'. */
  11
  12 #include "../stdafx.h"
  13
  14 #ifdef ENABLE_NETWORK
  15
  16 #include "../gfx_func.h"
  17 #include "../network/network.h"
  18 #include "../network/network_internal.h"
  19 #include "../console_func.h"
  20 #include "../genworld.h"
  21 #include "../fileio_type.h"
  22 #include "../fios.h"
  23 #include "../blitter/factory.hpp"
  24 #include "../company_func.h"
  25 #include "../core/random_func.hpp"
  26 #include "../saveload/saveload.h"
  27 #include "dedicated_v.h"
  28
  29 #ifdef BEOS_NET_SERVER
  30 #include <net/socket.h>
  31 #endif
  32
  33 #ifdef __OS2__
  34 #       include <sys/time.h> /* gettimeofday */
  35 #       include <sys/types.h>
  36 #       include <unistd.h>
  37 #       include <conio.h>
  38
  39 #       define INCL_DOS
  40 #       include <os2.h>
  41
  42 #       define STDIN 0  /* file descriptor for standard input */
  43
  44 /**
  45  * Switches OpenTTD to a console app at run-time, instead of a PM app
  46  * Necessary to see stdout, etc.
  47  */
  48 static void OS2_SwitchToConsoleMode()
  49 {
  50         PPIB pib;
  51         PTIB tib;
  52
  53         DosGetInfoBlocks(&tib, &pib);
  54
  55         /* Change flag from PM to VIO */
  56         pib->pib_ultype = 3;
  57 }
  58 #endif
  59
  60 #if defined(UNIX) || defined(PSP)
  61 #       include <sys/time.h> /* gettimeofday */
  62 #       include <sys/types.h>
  63 #       include <unistd.h>
  64 #       include <signal.h>
  65 #       define STDIN 0  /* file descriptor for standard input */
  66 #       if defined(PSP)
  67 #               include <sys/fd_set.h>
  68 #               include <sys/select.h>
  69 #       endif /* PSP */
  70
  71 /* Signal handlers */
  72 static void DedicatedSignalHandler(int sig)
  73 {
  74         if (_game_mode == GM_NORMAL && _settings_client.gui.autosave_on_exit) DoExitSave();
  75         _exit_game = true;
  76         signal(sig, DedicatedSignalHandler);
  77 }
  78 #endif
  79
  80 #if defined(WIN32)
  81 # include <windows.h> /* GetTickCount */
  82 # if !defined(WINCE)
  83 #  include <conio.h>
  84 # endif
  85 # include <time.h>
  86 # include <tchar.h>
  87 # include "../os/windows/win32.h"
  88 static HANDLE _hInputReady, _hWaitForInputHandling;
  89 static HANDLE _hThread; // Thread to close
  90 static char _win_console_thread_buffer[200];
  91
  92 /* Windows Console thread. Just loop and signal when input has been received */
  93 static void WINAPI CheckForConsoleInput()
  94 {
  95 #if defined(WINCE)
  96         /* WinCE doesn't support console stuff */
  97         return;
  98 #else
  99         SetWin32ThreadName(-1, "ottd:win-console");
 100
 101         DWORD nb;
 102         HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
 103         for (;;) {
 104                 ReadFile(hStdin, _win_console_thread_buffer, lengthof(_win_console_thread_buffer), &nb, NULL);
 105                 if (nb >= lengthof(_win_console_thread_buffer)) nb = lengthof(_win_console_thread_buffer) - 1;
 106                 _win_console_thread_buffer[nb] = '\0';
 107
 108                 /* Signal input waiting that input is read and wait for it being handled
 109                  * SignalObjectAndWait() should be used here, but it's unsupported in Win98< */
 110                 SetEvent(_hInputReady);
 111                 WaitForSingleObject(_hWaitForInputHandling, INFINITE);
 112         }
 113 #endif
 114 }
 115
 116 static void CreateWindowsConsoleThread()
 117 {
 118         DWORD dwThreadId;
 119         /* Create event to signal when console input is ready */
 120         _hInputReady = CreateEvent(NULL, false, false, NULL);
 121         _hWaitForInputHandling = CreateEvent(NULL, false, false, NULL);
 122         if (_hInputReady == NULL || _hWaitForInputHandling == NULL) usererror("Cannot create console event!");
 123
 124         _hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CheckForConsoleInput, NULL, 0, &dwThreadId);
 125         if (_hThread == NULL) usererror("Cannot create console thread!");
 126
 127         DEBUG(driver, 2, "Windows console thread started");
 128 }
 129
 130 static void CloseWindowsConsoleThread()
 131 {
 132         CloseHandle(_hThread);
 133         CloseHandle(_hInputReady);
 134         CloseHandle(_hWaitForInputHandling);
 135         DEBUG(driver, 2, "Windows console thread shut down");
 136 }
 137
 138 #endif
 139
 140 #include "../safeguards.h"
 141
 142
 143 static void *_dedicated_video_mem;
 144
 145 /* Whether a fork has been done. */
 146 bool _dedicated_forks;
 147
 148 extern bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = NULL);
 149
 150 static FVideoDriver_Dedicated iFVideoDriver_Dedicated;
 151
 152
 153 const char *VideoDriver_Dedicated::Start(const char * const *parm)
 154 {
 155         int bpp = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
 156         _dedicated_video_mem = (bpp == 0) ? NULL : MallocT<byte>(_cur_resolution.width * _cur_resolution.height * (bpp / 8));
 157
 158         _screen.width  = _screen.pitch = _cur_resolution.width;
 159         _screen.height = _cur_resolution.height;
 160         _screen.dst_ptr = _dedicated_video_mem;
 161         ScreenSizeChanged();
 162         BlitterFactory::GetCurrentBlitter()->PostResize();
 163
 164 #if defined(WINCE)
 165         /* WinCE doesn't support console stuff */
 166 #elif defined(WIN32)
 167         /* For win32 we need to allocate a console (debug mode does the same) */
 168         CreateConsole();
 169         CreateWindowsConsoleThread();
 170         SetConsoleTitle(_T("OpenTTD Dedicated Server"));
 171 #endif
 172
 173 #ifdef _MSC_VER
 174         /* Disable the MSVC assertion message box. */
 175         _set_error_mode(_OUT_TO_STDERR);
 176 #endif
 177
 178 #ifdef __OS2__
 179         /* For OS/2 we also need to switch to console mode instead of PM mode */
 180         OS2_SwitchToConsoleMode();
 181 #endif
 182
 183         DEBUG(driver, 1, "Loading dedicated server");
 184         return NULL;
 185 }
 186
 187 void VideoDriver_Dedicated::Stop()
 188 {
 189 #ifdef WIN32
 190         CloseWindowsConsoleThread();
 191 #endif
 192         free(_dedicated_video_mem);
 193 }
 194
 195 void VideoDriver_Dedicated::MakeDirty(int left, int top, int width, int height) {}
 196 bool VideoDriver_Dedicated::ChangeResolution(int w, int h) { return false; }
 197 bool VideoDriver_Dedicated::ToggleFullscreen(bool fs) { return false; }
 198
 199 #if defined(UNIX) || defined(__OS2__) || defined(PSP)
 200 static bool InputWaiting()
 201 {
 202         struct timeval tv;
 203         fd_set readfds;
 204
 205         tv.tv_sec = 0;
 206         tv.tv_usec = 1;
 207
 208         FD_ZERO(&readfds);
 209         FD_SET(STDIN, &readfds);
 210
 211         /* don't care about writefds and exceptfds: */
 212         return select(STDIN + 1, &readfds, NULL, NULL, &tv) > 0;
 213 }
 214
 215 static uint32 GetTime()
 216 {
 217         struct timeval tim;
 218
 219         gettimeofday(&tim, NULL);
 220         return tim.tv_usec / 1000 + tim.tv_sec * 1000;
 221 }
 222
 223 #else
 224
 225 static bool InputWaiting()
 226 {
 227         return WaitForSingleObject(_hInputReady, 1) == WAIT_OBJECT_0;
 228 }
 229
 230 static uint32 GetTime()
 231 {
 232         return GetTickCount();
 233 }
 234
 235 #endif
 236
 237 static void DedicatedHandleKeyInput()
 238 {
 239         static char input_line[1024] = "";
 240
 241         if (!InputWaiting()) return;
 242
 243         if (_exit_game) return;
 244
 245 #if defined(UNIX) || defined(__OS2__) || defined(PSP)
 246         if (fgets(input_line, lengthof(input_line), stdin) == NULL) return;
 247 #else
 248         /* Handle console input, and signal console thread, it can accept input again */
 249         assert_compile(lengthof(_win_console_thread_buffer) <= lengthof(input_line));
 250         strecpy(input_line, _win_console_thread_buffer, lastof(input_line));
 251         SetEvent(_hWaitForInputHandling);
 252 #endif
 253
 254         /* Remove trailing \r or \n */
 255         for (char *c = input_line; *c != '\0'; c++) {
 256                 if (*c == '\n' || *c == '\r' || c == lastof(input_line)) {
 257                         *c = '\0';
 258                         break;
 259                 }
 260         }
 261         str_validate(input_line, lastof(input_line));
 262
 263         IConsoleCmdExec(input_line); // execute command
 264 }
 265
 266 void VideoDriver_Dedicated::MainLoop()
 267 {
 268         uint32 cur_ticks = GetTime();
 269         uint32 next_tick = cur_ticks + MILLISECONDS_PER_TICK;
 270
 271         /* Signal handlers */
 272 #if defined(UNIX) || defined(PSP)
 273         signal(SIGTERM, DedicatedSignalHandler);
 274         signal(SIGINT, DedicatedSignalHandler);
 275         signal(SIGQUIT, DedicatedSignalHandler);
 276 #endif
 277
 278         /* Load the dedicated server stuff */
 279         _is_network_server = true;
 280         _network_dedicated = true;
 281         _current_company = _local_company = COMPANY_SPECTATOR;
 282
 283         /* If SwitchMode is SM_LOAD_GAME, it means that the user used the '-g' options */
 284         if (_switch_mode != SM_LOAD_GAME) {
 285                 StartNewGameWithoutGUI(GENERATE_NEW_SEED);
 286                 SwitchToMode(_switch_mode);
 287                 _switch_mode = SM_NONE;
 288         } else {
 289                 _switch_mode = SM_NONE;
 290                 /* First we need to test if the savegame can be loaded, else we will end up playing the
 291                  *  intro game... */
 292                 if (!SafeLoad(_file_to_saveload.name, _file_to_saveload.file_op, _file_to_saveload.detail_ftype, GM_NORMAL, BASE_DIR)) {
 293                         /* Loading failed, pop out.. */
 294                         DEBUG(net, 0, "Loading requested map failed, aborting");
 295                         _networking = false;
 296                 } else {
 297                         /* We can load this game, so go ahead */
 298                         SwitchToMode(SM_LOAD_GAME);
 299                 }
 300         }
 301
 302         /* Done loading, start game! */
 303
 304         if (!_networking) {
 305                 DEBUG(net, 0, "Dedicated server could not be started, aborting");
 306                 return;
 307         }
 308
 309         while (!_exit_game) {
 310                 uint32 prev_cur_ticks = cur_ticks; // to check for wrapping
 311                 InteractiveRandom(); // randomness
 312
 313                 if (!_dedicated_forks) DedicatedHandleKeyInput();
 314
 315                 cur_ticks = GetTime();
 316                 _realtime_tick += cur_ticks - prev_cur_ticks;
 317                 if (cur_ticks >= next_tick || cur_ticks < prev_cur_ticks || _ddc_fastforward) {
 318                         next_tick = cur_ticks + MILLISECONDS_PER_TICK;
 319
 320                         GameLoop();
 321                         UpdateWindows();
 322                 }
 323
 324                 /* Don't sleep when fast forwarding (for desync debugging) */
 325                 if (!_ddc_fastforward) {
 326                         /* Sleep longer on a dedicated server, if the game is paused and no clients connected.
 327                          * That can allow the CPU to better use deep sleep states. */
 328                         if (_pause_mode != 0 && !HasClients()) {
 329                                 CSleep(100);
 330                         } else {
 331                                 CSleep(1);
 332                         }
 333                 }
 334         }
 335 }
 336
 337 #endif /* ENABLE_NETWORK */