1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

     5

#ifdef ENABLE_NETWORK

     6

     7

#include "../openttd.h"

     8

#include "../debug.h"

     9

#include "../functions.h"

    10

#include "../gfx.h"

    11

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

    12

#include "../window.h"

    13

#include "../console.h"

    14

#include "../variables.h"

    15

#include "../genworld.h"

    16

#include "dedicated_v.h"

    17

    18

#ifdef BEOS_NET_SERVER

    19

#include <net/socket.h>

    20

#endif

    21

    22

#ifdef __OS2__

    23

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

    24

#	include <sys/types.h>

    25

#	include <unistd.h>

    26

#	include <conio.h>

    27

    28

#	define INCL_DOS

    29

#	include <os2.h>

    30

    31

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

    32

    33

/**

    34

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

    35

 * Necessary to see stdout, etc. */

    36

static void OS2_SwitchToConsoleMode(void)

    37

{

    38

	PPIB pib;

    39

	PTIB tib;

    40

    41

	DosGetInfoBlocks(&tib, &pib);

    42

    43

	// Change flag from PM to VIO

    44

	pib->pib_ultype = 3;

    45

}

    46

#endif

    47

    48

#ifdef UNIX

    49

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

    50

#	include <sys/types.h>

    51

#	include <unistd.h>

    52

#	include <signal.h>

    53

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

    54

    55

/* Signal handlers */

    56

static void DedicatedSignalHandler(int sig)

    57

{

    58

	_exit_game = true;

    59

	signal(sig, DedicatedSignalHandler);

    60

}

    61

#endif

    62

    63

#ifdef WIN32

    64

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

    65

#include <conio.h>

    66

#include <time.h>

    67

#include <tchar.h>

    68

static HANDLE _hInputReady, _hWaitForInputHandling;

    69

static HANDLE _hThread; // Thread to close

    70

static char _win_console_thread_buffer[200];

    71

    72

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

    73

static void WINAPI CheckForConsoleInput(void)

    74

{

    75

	while (true) {

    76

		fgets(_win_console_thread_buffer, lengthof(_win_console_thread_buffer), stdin);

    77

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

    78

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

    79

		SetEvent(_hInputReady);

    80

		WaitForSingleObject(_hWaitForInputHandling, INFINITE);

    81

	}

    82

}

    83

    84

static void CreateWindowsConsoleThread(void)

    85

{

    86

	DWORD dwThreadId;

    87

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

    88

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

    89

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

    90

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

    91

    92

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

    93

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

    94

    95

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

    96

}

    97

    98

static void CloseWindowsConsoleThread(void)

    99

{

   100

	CloseHandle(_hThread);

   101

	CloseHandle(_hInputReady);

   102

	CloseHandle(_hWaitForInputHandling);

   103

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

   104

}

   105

   106

#endif

   107

   108

   109

static void *_dedicated_video_mem;

   110

   111

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

   112

extern void SwitchMode(int new_mode);

   113

   114

   115

static const char *DedicatedVideoStart(const char * const *parm)

   116

{

   117

	_screen.width = _screen.pitch = _cur_resolution[0];

   118

	_screen.height = _cur_resolution[1];

   119

	_dedicated_video_mem = malloc(_cur_resolution[0]*_cur_resolution[1]);

   120

   121

	SetDebugString("net=6");

   122

   123

#ifdef WIN32

   124

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

   125

	CreateConsole();

   126

	CreateWindowsConsoleThread();

   127

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

   128

#endif

   129

   130

#ifdef __OS2__

   131

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

   132

	OS2_SwitchToConsoleMode();

   133

#endif

   134

   135

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

   136

	return NULL;

   137

}

   138

   139

static void DedicatedVideoStop(void)

   140

{

   141

#ifdef WIN32

   142

	CloseWindowsConsoleThread();

   143

#endif

   144

	free(_dedicated_video_mem);

   145

}

   146

   147

static void DedicatedVideoMakeDirty(int left, int top, int width, int height) {}

   148

static bool DedicatedVideoChangeRes(int w, int h) { return false; }

   149

static void DedicatedVideoFullScreen(bool fs) {}

   150

   151

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

   152

static bool InputWaiting(void)

   153

{

   154

	struct timeval tv;

   155

	fd_set readfds;

   156

   157

	tv.tv_sec = 0;

   158

	tv.tv_usec = 1;

   159

   160

	FD_ZERO(&readfds);

   161

	FD_SET(STDIN, &readfds);

   162

   163

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

   164

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

   165

}

   166

   167

static uint32 GetTime(void)

   168

{

   169

	struct timeval tim;

   170

   171

	gettimeofday(&tim, NULL);

   172

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

   173

}

   174

   175

#else

   176

   177

static bool InputWaiting(void)

   178

{

   179

	return WaitForSingleObject(_hInputReady, 1) == WAIT_OBJECT_0;

   180

}

   181

   182

static uint32 GetTime(void)

   183

{

   184

	return GetTickCount();

   185

}

   186

   187

#endif

   188

   189

static void DedicatedHandleKeyInput(void)

   190

{

   191

	static char input_line[200] = "";

   192

   193

	if (!InputWaiting()) return;

   194

   195

	if (_exit_game) return;

   196

   197

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

   198

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

   199

#else

   200

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

   201

	strncpy(input_line, _win_console_thread_buffer, lengthof(input_line));

   202

	SetEvent(_hWaitForInputHandling);

   203

#endif

   204

   205

	/* XXX - strtok() does not 'forget' \n\r if it is the first character! */

   206

	strtok(input_line, "\r\n"); // Forget about the final \n (or \r)

   207

	{ /* Remove any special control characters */

   208

		uint i;

   209

		for (i = 0; i < lengthof(input_line); i++) {

   210

			if (input_line[i] == '\n' || input_line[i] == '\r') // cut missed beginning '\0'

   211

				input_line[i] = '\0';

   212

   213

			if (input_line[i] == '\0')

   214

				break;

   215

   216

			if (!IS_INT_INSIDE(input_line[i], ' ', 256))

   217

				input_line[i] = ' ';

   218

		}

   219

	}

   220

   221

	IConsoleCmdExec(input_line); // execute command

   222

}

   223

   224

static void DedicatedVideoMainLoop(void)

   225

{

   226

	uint32 cur_ticks = GetTime();

   227

	uint32 next_tick = cur_ticks + 30;

   228

   229

	/* Signal handlers */

   230

#ifdef UNIX

   231

	signal(SIGTERM, DedicatedSignalHandler);

   232

	signal(SIGINT, DedicatedSignalHandler);

   233

	signal(SIGQUIT, DedicatedSignalHandler);

   234

#endif

   235

   236

	// Load the dedicated server stuff

   237

	_is_network_server = true;

   238

	_network_dedicated = true;

   239

	_network_playas = PLAYER_SPECTATOR;

   240

	_local_player = PLAYER_SPECTATOR;

   241

   242

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

   243

	if (_switch_mode != SM_LOAD) {

   244

		StartNewGameWithoutGUI(GENERATE_NEW_SEED);

   245

		SwitchMode(_switch_mode);

   246

		_switch_mode = SM_NONE;

   247

	} else {

   248

		_switch_mode = SM_NONE;

   249

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

   250

		 *  intro game... */

   251

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

   252

			/* Loading failed, pop out.. */

   253

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

   254

			_networking = false;

   255

		} else {

   256

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

   257

			SwitchMode(SM_LOAD);

   258

		}

   259

	}

   260

   261

	// Done loading, start game!

   262

   263

	if (!_networking) {

   264

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

   265

		return;

   266

	}

   267

   268

	while (!_exit_game) {

   269

		uint32 prev_cur_ticks = cur_ticks; // to check for wrapping

   270

		InteractiveRandom(); // randomness

   271

   272

		if (!_dedicated_forks)

   273

			DedicatedHandleKeyInput();

   274

   275

		cur_ticks = GetTime();

   276

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

   277

			next_tick = cur_ticks + 30;

   278

   279

			GameLoop();

   280

			_screen.dst_ptr = (Pixel*)_dedicated_video_mem;

   281

			UpdateWindows();

   282

		}

   283

		CSleep(1);

   284

	}

   285

}

   286

   287

const HalVideoDriver _dedicated_video_driver = {

   288

	DedicatedVideoStart,

   289

	DedicatedVideoStop,

   290

	DedicatedVideoMakeDirty,

   291

	DedicatedVideoMainLoop,

   292

	DedicatedVideoChangeRes,

   293

	DedicatedVideoFullScreen,

   294

};

   295

   296

#endif /* ENABLE_NETWORK */