src/video/dedicated_v.cpp

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