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"

    18

#include "dedicated_v.h"

    19

    20

#ifdef BEOS_NET_SERVER

    21

#include <net/socket.h>

    22

#endif

    23

    24

#ifdef __OS2__

    25

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

    26

#	include <sys/types.h>

    27

#	include <unistd.h>

    28

#	include <conio.h>

    29

    30

#	define INCL_DOS

    31

#	include <os2.h>

    32

    33

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

    34

    35

/**

    36

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

    37

 * Necessary to see stdout, etc. */

    38

static void OS2_SwitchToConsoleMode()

    39

{

    40

	PPIB pib;

    41

	PTIB tib;

    42

    43

	DosGetInfoBlocks(&tib, &pib);

    44

    45

	// Change flag from PM to VIO

    46

	pib->pib_ultype = 3;

    47

}

    48

#endif

    49

    50

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

    51

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

    52

#	include <sys/types.h>

    53

#	include <unistd.h>

    54

#	include <signal.h>

    55

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

    56

#	if defined(PSP)

    57

#		include <sys/fd_set.h>

    58

#		include <sys/select.h>

    59

#	endif /* PSP */

    60

    61

/* Signal handlers */

    62

static void DedicatedSignalHandler(int sig)

    63

{

    64

	_exit_game = true;

    65

	signal(sig, DedicatedSignalHandler);

    66

}

    67

#endif

    68

    69

#ifdef WIN32

    70

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

    71

#include <conio.h>

    72

#include <time.h>

    73

#include <tchar.h>

    74

static HANDLE _hInputReady, _hWaitForInputHandling;

    75

static HANDLE _hThread; // Thread to close

    76

static char _win_console_thread_buffer[200];

    77

    78

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

    79

static void WINAPI CheckForConsoleInput()

    80

{

    81

	DWORD nb;

    82

	HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);

    83

	while (true) {

    84

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

    85

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

    86

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

    87

		SetEvent(_hInputReady);

    88

		WaitForSingleObject(_hWaitForInputHandling, INFINITE);

    89

	}

    90

}

    91

    92

static void CreateWindowsConsoleThread()

    93

{

    94

	DWORD dwThreadId;

    95

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

    96

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

    97

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

    98

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

    99

   100

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

   101

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

   102

   103

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

   104

}

   105

   106

static void CloseWindowsConsoleThread()

   107

{

   108

	CloseHandle(_hThread);

   109

	CloseHandle(_hInputReady);

   110

	CloseHandle(_hWaitForInputHandling);

   111

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

   112

}

   113

   114

#endif

   115

   116

   118

   120

extern void SwitchMode(int new_mode);

   121

   122

   123

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

   124

{

   129

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

   130

	_screen.height = _cur_resolution[1];

   131

   132

	SetDebugString("net=6");

   133

   134

#ifdef WIN32

   135

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

   136

	CreateConsole();

   137

	CreateWindowsConsoleThread();

   138

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

   139

#endif

   140

   141

#ifdef __OS2__

   142

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

   143

	OS2_SwitchToConsoleMode();

   144

#endif

   145

   146

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

   147

	return NULL;

   148

}

   149

   150

static void DedicatedVideoStop()

   151

{

   152

#ifdef WIN32

   153

	CloseWindowsConsoleThread();

   154

#endif

   155

	free(_dedicated_video_mem);

   156

}

   157

   158

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

   159

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

   160

static void DedicatedVideoFullScreen(bool fs) {}

   161

   162

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

   163

static bool InputWaiting()

   164

{

   165

	struct timeval tv;

   166

	fd_set readfds;

   167

   168

	tv.tv_sec = 0;

   169

	tv.tv_usec = 1;

   170

   171

	FD_ZERO(&readfds);

   172

	FD_SET(STDIN, &readfds);

   173

   174

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

   175

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

   176

}

   177

   178

static uint32 GetTime()

   179

{

   180

	struct timeval tim;

   181

   182

	gettimeofday(&tim, NULL);

   183

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

   184

}

   185

   186

#else

   187

   188

static bool InputWaiting()

   189

{

   190

	return WaitForSingleObject(_hInputReady, 1) == WAIT_OBJECT_0;

   191

}

   192

   193

static uint32 GetTime()

   194

{

   195

	return GetTickCount();

   196

}

   197

   198

#endif

   199

   200

static void DedicatedHandleKeyInput()

   201

{

   202

	static char input_line[200] = "";

   203

   204

	if (!InputWaiting()) return;

   205

   206

	if (_exit_game) return;

   207

   208

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

   209

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

   210

#else

   211

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

   212

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

   213

	SetEvent(_hWaitForInputHandling);

   214

#endif

   215

   216

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

   217

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

   218

	{ /* Remove any special control characters */

   219

		uint i;

   220

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

   221

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

   222

				input_line[i] = '\0';

   223

   224

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

   225

				break;

   226

   227

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

   228

				input_line[i] = ' ';

   229

		}

   230

	}

   231

   232

	IConsoleCmdExec(input_line); // execute command

   233

}

   234

   235

static void DedicatedVideoMainLoop()

   236

{

   237

	uint32 cur_ticks = GetTime();

   238

	uint32 next_tick = cur_ticks + 30;

   239

   240

	/* Signal handlers */

   241

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

   242

	signal(SIGTERM, DedicatedSignalHandler);

   243

	signal(SIGINT, DedicatedSignalHandler);

   244

	signal(SIGQUIT, DedicatedSignalHandler);

   245

#endif

   246

   247

	// Load the dedicated server stuff

   248

	_is_network_server = true;

   249

	_network_dedicated = true;

   250

	_network_playas = PLAYER_SPECTATOR;

   251

	_local_player = PLAYER_SPECTATOR;

   252

   253

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

   254

	if (_switch_mode != SM_LOAD) {

   255

		StartNewGameWithoutGUI(GENERATE_NEW_SEED);

   256

		SwitchMode(_switch_mode);

   257

		_switch_mode = SM_NONE;

   258

	} else {

   259

		_switch_mode = SM_NONE;

   260

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

   261

		 *  intro game... */

   263

			/* Loading failed, pop out.. */

   264

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

   265

			_networking = false;

   266

		} else {

   267

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

   268

			SwitchMode(SM_LOAD);

   269

		}

   270

	}

   271

   272

	// Done loading, start game!

   273

   274

	if (!_networking) {

   275

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

   276

		return;

   277

	}

   278

   279

	while (!_exit_game) {

   280

		uint32 prev_cur_ticks = cur_ticks; // to check for wrapping

   281

		InteractiveRandom(); // randomness

   282

   283

		if (!_dedicated_forks)

   284

			DedicatedHandleKeyInput();

   285

   286

		cur_ticks = GetTime();

   287

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

   288

			next_tick = cur_ticks + 30;

   289

   290

			GameLoop();

   291

			_screen.dst_ptr = _dedicated_video_mem;

   292

			UpdateWindows();

   293

		}

   294

		CSleep(1);

   295

	}

   296

}

   297

   298

const HalVideoDriver _dedicated_video_driver = {

   299

	DedicatedVideoStart,

   300

	DedicatedVideoStop,

   301

	DedicatedVideoMakeDirty,

   302

	DedicatedVideoMainLoop,

   303

	DedicatedVideoChangeRes,

   304

	DedicatedVideoFullScreen,

   305

};

   306

   307

#endif /* ENABLE_NETWORK */