1

/* $Id$ */

     2

     3

/** @file dedicated_v.cpp Dedicated server video 'driver'. */

     4

     5

#include "../stdafx.h"

     6

     7

#ifdef ENABLE_NETWORK

     8

     9

#include "../openttd.h"

    10

#include "../debug.h"

    11

#include "../gfx_func.h"

    12

#include "../network/network.h"

    13

#include "../network/network_internal.h"

    14

#include "../console_func.h"

    15

#include "../variables.h"

    16

#include "../genworld.h"

    17

#include "../fileio_type.h"

    18

#include "../fios.h"

    19

#include "../blitter/factory.hpp"

    20

#include "../core/alloc_func.hpp"

    21

#include "../player_func.h"

    22

#include "../core/random_func.hpp"

    23

#include "dedicated_v.h"

    24

    25

#ifdef BEOS_NET_SERVER

    26

#include <net/socket.h>

    27

#endif

    28

    29

#ifdef __OS2__

    30

#	include <sys/time.h> /* gettimeofday */

    31

#	include <sys/types.h>

    32

#	include <unistd.h>

    33

#	include <conio.h>

    34

    35

#	define INCL_DOS

    36

#	include <os2.h>

    37

    38

#	define STDIN 0  /* file descriptor for standard input */

    39

    40

/**

    41

 * Switches OpenTTD to a console app at run-time, instead of a PM app

    42

 * Necessary to see stdout, etc. */

    43

static void OS2_SwitchToConsoleMode()

    44

{

    45

	PPIB pib;

    46

	PTIB tib;

    47

    48

	DosGetInfoBlocks(&tib, &pib);

    49

    50

	// Change flag from PM to VIO

    51

	pib->pib_ultype = 3;

    52

}

    53

#endif

    54

    55

#if defined(UNIX) || defined(PSP)

    56

#	include <sys/time.h> /* gettimeofday */

    57

#	include <sys/types.h>

    58

#	include <unistd.h>

    59

#	include <signal.h>

    60

#	define STDIN 0  /* file descriptor for standard input */

    61

#	if defined(PSP)

    62

#		include <sys/fd_set.h>

    63

#		include <sys/select.h>

    64

#	endif /* PSP */

    65

    66

/* Signal handlers */

    67

static void DedicatedSignalHandler(int sig)

    68

{

    69

	_exit_game = true;

    70

	signal(sig, DedicatedSignalHandler);

    71

}

    72

#endif

    73

    74

#if defined(WIN32)

    75

# include <windows.h> /* GetTickCount */

    76

# if !defined(WINCE)

    77

#  include <conio.h>

    78

# endif

    79

# include <time.h>

    80

# include <tchar.h>

    81

static HANDLE _hInputReady, _hWaitForInputHandling;

    82

static HANDLE _hThread; // Thread to close

    83

static char _win_console_thread_buffer[200];

    84

    85

/* Windows Console thread. Just loop and signal when input has been received */

    86

static void WINAPI CheckForConsoleInput()

    87

{

    88

#if defined(WINCE)

    89

	/* WinCE doesn't support console stuff */

    90

	return;

    91

#else

    92

	DWORD nb;

    93

	HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);

    94

	while (true) {

    95

		ReadFile(hStdin, _win_console_thread_buffer, lengthof(_win_console_thread_buffer), &nb, NULL);

    96

		/* Signal input waiting that input is read and wait for it being handled

    97

		 * SignalObjectAndWait() should be used here, but it's unsupported in Win98< */

    98

		SetEvent(_hInputReady);

    99

		WaitForSingleObject(_hWaitForInputHandling, INFINITE);

   100

	}

   101

#endif

   102

}

   103

   104

static void CreateWindowsConsoleThread()

   105

{

   106

	DWORD dwThreadId;

   107

	/* Create event to signal when console input is ready */

   108

	_hInputReady = CreateEvent(NULL, false, false, NULL);

   109

	_hWaitForInputHandling = CreateEvent(NULL, false, false, NULL);

   110

	if (_hInputReady == NULL || _hWaitForInputHandling == NULL) usererror("Cannot create console event!");

   111

   112

	_hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CheckForConsoleInput, NULL, 0, &dwThreadId);

   113

	if (_hThread == NULL) usererror("Cannot create console thread!");

   114

   115

	DEBUG(driver, 2, "Windows console thread started");

   116

}

   117

   118

static void CloseWindowsConsoleThread()

   119

{

   120

	CloseHandle(_hThread);

   121

	CloseHandle(_hInputReady);

   122

	CloseHandle(_hWaitForInputHandling);

   123

	DEBUG(driver, 2, "Windows console thread shut down");

   124

}

   125

   126

#endif

   127

   128

   129

static void *_dedicated_video_mem;

   130

   131

extern bool SafeSaveOrLoad(const char *filename, int mode, int newgm, Subdirectory subdir);

   132

extern void SwitchMode(int new_mode);

   133

   134

static FVideoDriver_Dedicated iFVideoDriver_Dedicated;

   135

   136

   137

const char *VideoDriver_Dedicated::Start(const char * const *parm)

   138

{

   139

	int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();

   140

	if (bpp == 0) _dedicated_video_mem = NULL;

   141

	else          _dedicated_video_mem = MallocT<byte>(_cur_resolution.width * _cur_resolution.height * (bpp / 8));

   142

   143

	_screen.width  = _screen.pitch = _cur_resolution.width;

   144

	_screen.height = _cur_resolution.height;

   145

	ScreenSizeChanged();

   146

   147

	SetDebugString("net=6");

   148

   149

#if defined(WINCE)

   150

	/* WinCE doesn't support console stuff */

   151

#elif defined(WIN32)

   152

	// For win32 we need to allocate a console (debug mode does the same)

   153

	CreateConsole();

   154

	CreateWindowsConsoleThread();

   155

	SetConsoleTitle(_T("OpenTTD Dedicated Server"));

   156

#endif

   157

   158

#ifdef __OS2__

   159

	// For OS/2 we also need to switch to console mode instead of PM mode

   160

	OS2_SwitchToConsoleMode();

   161

#endif

   162

   163

	DEBUG(driver, 1, "Loading dedicated server");

   164

	return NULL;

   165

}

   166

   167

void VideoDriver_Dedicated::Stop()

   168

{

   169

#ifdef WIN32

   170

	CloseWindowsConsoleThread();

   171

#endif

   172

	free(_dedicated_video_mem);

   173

}

   174

   175

void VideoDriver_Dedicated::MakeDirty(int left, int top, int width, int height) {}

   176

bool VideoDriver_Dedicated::ChangeResolution(int w, int h) { return false; }

   177

bool VideoDriver_Dedicated::ToggleFullscreen(bool fs) { return false; }

   178

   179

#if defined(UNIX) || defined(__OS2__) || defined(PSP)

   180

static bool InputWaiting()

   181

{

   182

	struct timeval tv;

   183

	fd_set readfds;

   184

   185

	tv.tv_sec = 0;

   186

	tv.tv_usec = 1;

   187

   188

	FD_ZERO(&readfds);

   189

	FD_SET(STDIN, &readfds);

   190

   191

	/* don't care about writefds and exceptfds: */

   192

	return select(STDIN + 1, &readfds, NULL, NULL, &tv) > 0;

   193

}

   194

   195

static uint32 GetTime()

   196

{

   197

	struct timeval tim;

   198

   199

	gettimeofday(&tim, NULL);

   200

	return tim.tv_usec / 1000 + tim.tv_sec * 1000;

   201

}

   202

   203

#else

   204

   205

static bool InputWaiting()

   206

{

   207

	return WaitForSingleObject(_hInputReady, 1) == WAIT_OBJECT_0;

   208

}

   209

   210

static uint32 GetTime()

   211

{

   212

	return GetTickCount();

   213

}

   214

   215

#endif

   216

   217

static void DedicatedHandleKeyInput()

   218

{

   219

	static char input_line[1024] = "";

   220

   221

	if (!InputWaiting()) return;

   222

   223

	if (_exit_game) return;

   224

   225

#if defined(UNIX) || defined(__OS2__) || defined(PSP)

   226

	if (fgets(input_line, lengthof(input_line), stdin) == NULL) return;

   227

#else

   228

	/* Handle console input, and singal console thread, it can accept input again */

   229

	assert_compile(lengthof(_win_console_thread_buffer) <= lengthof(input_line));

   230

	strcpy(input_line, _win_console_thread_buffer);

   231

	SetEvent(_hWaitForInputHandling);

   232

#endif

   233

   234

	/* strtok() does not 'forget' \r\n if the string starts with it,

   235

	 * so we have to manually remove that! */

   236

	strtok(input_line, "\r\n");

   237

	for (char *c = input_line; *c != '\0'; c++) {

   238

		if (*c == '\n' || *c == '\r' || c == lastof(input_line)) {

   239

			*c = '\0';

   240

			break;

   241

		}

   242

	}

   243

	str_validate(input_line);

   244

   245

	IConsoleCmdExec(input_line); // execute command

   246

}

   247

   248

void VideoDriver_Dedicated::MainLoop()

   249

{

   250

	uint32 cur_ticks = GetTime();

   251

	uint32 next_tick = cur_ticks + 30;

   252

   253

	/* Signal handlers */

   254

#if defined(UNIX) || defined(PSP)

   255

	signal(SIGTERM, DedicatedSignalHandler);

   256

	signal(SIGINT, DedicatedSignalHandler);

   257

	signal(SIGQUIT, DedicatedSignalHandler);

   258

#endif

   259

   260

	// Load the dedicated server stuff

   261

	_is_network_server = true;

   262

	_network_dedicated = true;

   265

   266

	/* If SwitchMode is SM_LOAD, it means that the user used the '-g' options */

   267

	if (_switch_mode != SM_LOAD) {

   268

		StartNewGameWithoutGUI(GENERATE_NEW_SEED);

   269

		SwitchMode(_switch_mode);

   270

		_switch_mode = SM_NONE;

   271

	} else {

   272

		_switch_mode = SM_NONE;

   273

		/* First we need to test if the savegame can be loaded, else we will end up playing the

   274

		 *  intro game... */

   275

		if (!SafeSaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_NORMAL, BASE_DIR)) {

   276

			/* Loading failed, pop out.. */

   277

			DEBUG(net, 0, "Loading requested map failed, aborting");

   278

			_networking = false;

   279

		} else {

   280

			/* We can load this game, so go ahead */

   281

			SwitchMode(SM_LOAD);

   282

		}

   283

	}

   284

   285

	// Done loading, start game!

   286

   287

	if (!_networking) {

   288

		DEBUG(net, 0, "Dedicated server could not be started, aborting");

   289

		return;

   290

	}

   291

   292

	while (!_exit_game) {

   293

		uint32 prev_cur_ticks = cur_ticks; // to check for wrapping

   294

		InteractiveRandom(); // randomness

   295

   296

		if (!_dedicated_forks)

   297

			DedicatedHandleKeyInput();

   298

   299

		cur_ticks = GetTime();

   300

		if (cur_ticks >= next_tick || cur_ticks < prev_cur_ticks) {

   301

			next_tick = cur_ticks + 30;

   302

   303

			GameLoop();

   304

			_screen.dst_ptr = _dedicated_video_mem;

   305

			UpdateWindows();

   306

		}

   307

		CSleep(1);

   308

	}

   309

}

   310

   311

#endif /* ENABLE_NETWORK */