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.h"

    12

#include "../window.h"

    13

#include "../command.h"

    14

#include "../console.h"

    15

#include "../variables.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

static HANDLE hEvent;

    68

static HANDLE hThread; // Thread to close

    69

static char _win_console_thread_buffer[200];

    70

    71

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

    72

static void WINAPI CheckForConsoleInput(void)

    73

{

    74

	while (true) {

    75

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

    76

		SetEvent(hEvent); // signal input waiting that the line is ready

    77

	}

    78

}

    79

    80

static void CreateWindowsConsoleThread(void)

    81

{

    82

	static char tbuffer[9];

    83

	DWORD dwThreadId;

    84

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

    85

	hEvent = CreateEvent(NULL, false, false, _strtime(tbuffer));

    86

	if (hEvent == NULL)

    87

		error("Cannot create console event!");

    88

    89

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

    90

	if (hThread == NULL)

    91

		error("Cannot create console thread!");

    92

    93

	DEBUG(driver, 1) ("Windows console thread started...");

    94

}

    95

    96

static void CloseWindowsConsoleThread(void)

    97

{

    98

	CloseHandle(hThread);

    99

	CloseHandle(hEvent);

   100

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

   101

}

   102

   103

#endif

   104

   105

   106

static void *_dedicated_video_mem;

   107

   108

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

   109

extern void SwitchMode(int new_mode);

   110

   111

   112

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

   113

{

   114

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

   115

	_screen.height = _cur_resolution[1];

   116

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

   117

   118

	_debug_net_level = 6;

   119

	_debug_misc_level = 0;

   120

   121

#ifdef WIN32

   122

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

   123

	CreateConsole();

   124

	CreateWindowsConsoleThread();

   125

	SetConsoleTitle("OpenTTD Dedicated Server");

   126

#endif

   127

   128

#ifdef __OS2__

   129

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

   130

	OS2_SwitchToConsoleMode();

   131

#endif

   132

   133

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

   134

	return NULL;

   135

}

   136

   137

static void DedicatedVideoStop(void)

   138

{

   139

#ifdef WIN32

   140

	CloseWindowsConsoleThread();

   141

#endif

   142

	free(_dedicated_video_mem);

   143

}

   144

   145

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

   146

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

   147

static void DedicatedVideoFullScreen(bool fs) {}

   148

   149

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

   150

static bool InputWaiting(void)

   151

{

   152

	struct timeval tv;

   153

	fd_set readfds;

   154

   155

	tv.tv_sec = 0;

   156

	tv.tv_usec = 1;

   157

   158

	FD_ZERO(&readfds);

   159

	FD_SET(STDIN, &readfds);

   160

   161

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

   162

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

   163

}

   164

   165

static uint32 GetTime(void)

   166

{

   167

	struct timeval tim;

   168

   169

	gettimeofday(&tim, NULL);

   170

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

   171

}

   172

   173

#else

   174

   175

static bool InputWaiting(void)

   176

{

   177

	return WaitForSingleObject(hEvent, 1) == WAIT_OBJECT_0;

   178

}

   179

   180

static uint32 GetTime(void)

   181

{

   182

	return GetTickCount();

   183

}

   184

   185

#endif

   186

   187

static void DedicatedHandleKeyInput(void)

   188

{

   189

	static char input_line[200] = "";

   190

   191

	if (!InputWaiting())

   192

		return;

   193

   194

	if (_exit_game)

   195

		return;

   196

   197

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

   198

		fgets(input_line, lengthof(input_line), stdin);

   199

#else

   200

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

   201

#endif

   202

   203

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

   204

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

   205

	{ /* Remove any special control characters */

   206

		uint i;

   207

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

   208

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

   209

				input_line[i] = '\0';

   210

   211

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

   212

				break;

   213

   214

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

   215

				input_line[i] = ' ';

   216

		}

   217

	}

   218

   219

	IConsoleCmdExec(input_line); // execute command

   220

}

   221

   222

static void DedicatedVideoMainLoop(void)

   223

{

   224

	uint32 next_tick;

   225

	uint32 cur_ticks;

   226

   227

	next_tick = GetTime() + 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 = OWNER_SPECTATOR;

   240

	_local_player = OWNER_SPECTATOR;

   241

   242

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

   243

	if (_switch_mode != SM_LOAD) {

   244

		_switch_mode = SM_NONE;

   245

		GenRandomNewGame(Random(), InteractiveRandom());

   246

	} else {

   247

		_switch_mode = SM_NONE;

   248

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

   249

		 *  intro game... */

   250

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

   251

			/* Loading failed, pop out.. */

   252

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

   253

			_networking = false;

   254

		} else {

   255

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

   256

			SwitchMode(SM_LOAD);

   257

		}

   258

	}

   259

   260

	// Done loading, start game!

   261

   262

	if (!_networking) {

   263

		DEBUG(net, 1)("Dedicated server could not be launched. Aborting.");

   264

		return;

   265

	}

   266

   267

	while (!_exit_game) {

   268

		InteractiveRandom(); // randomness

   269

   270

		if (!_dedicated_forks)

   271

			DedicatedHandleKeyInput();

   272

   273

		cur_ticks = GetTime();

   274

   275

		if (cur_ticks >= next_tick) {

   276

			next_tick += 30;

   277

   278

			GameLoop();

   279

			_screen.dst_ptr = _dedicated_video_mem;

   280

			UpdateWindows();

   281

		}

   282

		CSleep(1);

   283

	}

   284

}

   285

   286

const HalVideoDriver _dedicated_video_driver = {

   287

	DedicatedVideoStart,

   288

	DedicatedVideoStop,

   289

	DedicatedVideoMakeDirty,

   290

	DedicatedVideoMainLoop,

   291

	DedicatedVideoChangeRes,

   292

	DedicatedVideoFullScreen,

   293

};

   294

   295

#endif /* ENABLE_NETWORK */