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

    14

#include "../variables.h"

    15

#include "dedicated_v.h"

    16

    17

#ifdef BEOS_NET_SERVER

    18

#include <net/socket.h>

    19

#endif

    20

    21

#ifdef __OS2__

    22

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

    23

#	include <sys/types.h>

    24

#	include <unistd.h>

    25

#	include <conio.h>

    26

    27

#	define INCL_DOS

    28

#	include <os2.h>

    29

    30

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

    31

    32

/**

    33

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

    34

 * Necessary to see stdout, etc. */

    35

static void OS2_SwitchToConsoleMode(void)

    36

{

    37

	PPIB pib;

    38

	PTIB tib;

    39

    40

	DosGetInfoBlocks(&tib, &pib);

    41

    42

	// Change flag from PM to VIO

    43

	pib->pib_ultype = 3;

    44

}

    45

#endif

    46

    47

#ifdef UNIX

    48

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

    49

#	include <sys/types.h>

    50

#	include <unistd.h>

    51

#	include <signal.h>

    52

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

    53

    54

/* Signal handlers */

    55

static void DedicatedSignalHandler(int sig)

    56

{

    57

	_exit_game = true;

    58

	signal(sig, DedicatedSignalHandler);

    59

}

    60

#endif

    61

    62

#ifdef WIN32

    63

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

    64

#include <conio.h>

    65

#include <time.h>

    66

static HANDLE hEvent;

    67

static HANDLE hThread; // Thread to close

    68

static char _win_console_thread_buffer[200];

    69

    70

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

    71

static void WINAPI CheckForConsoleInput(void)

    72

{

    73

	while (true) {

    74

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

    75

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

    76

	}

    77

}

    78

    79

static void CreateWindowsConsoleThread(void)

    80

{

    81

	static char tbuffer[9];

    82

	DWORD dwThreadId;

    83

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

    84

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

    85

	if (hEvent == NULL)

    86

		error("Cannot create console event!");

    87

    88

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

    89

	if (hThread == NULL)

    90

		error("Cannot create console thread!");

    91

    92

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

    93

}

    94

    95

static void CloseWindowsConsoleThread(void)

    96

{

    97

	CloseHandle(hThread);

    98

	CloseHandle(hEvent);

    99

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

   100

}

   101

   102

#endif

   103

   104

   105

static void *_dedicated_video_mem;

   106

   107

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

   108

extern void SwitchMode(int new_mode);

   109

   110

   111

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

   112

{

   113

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

   114

	_screen.height = _cur_resolution[1];

   115

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

   116

   117

	_debug_net_level = 6;

   118

	_debug_misc_level = 0;

   119

   120

#ifdef WIN32

   121

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

   122

	CreateConsole();

   123

	CreateWindowsConsoleThread();

   124

	SetConsoleTitle("OpenTTD Dedicated Server");

   125

#endif

   126

   127

#ifdef __OS2__

   128

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

   129

	OS2_SwitchToConsoleMode();

   130

#endif

   131

   132

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

   133

	return NULL;

   134

}

   135

   136

static void DedicatedVideoStop(void)

   137

{

   138

#ifdef WIN32

   139

	CloseWindowsConsoleThread();

   140

#endif

   141

	free(_dedicated_video_mem);

   142

}

   143

   144

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

   145

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

   146

static void DedicatedVideoFullScreen(bool fs) {}

   147

   148

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

   149

static bool InputWaiting(void)

   150

{

   151

	struct timeval tv;

   152

	fd_set readfds;

   153

   154

	tv.tv_sec = 0;

   155

	tv.tv_usec = 1;

   156

   157

	FD_ZERO(&readfds);

   158

	FD_SET(STDIN, &readfds);

   159

   160

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

   161

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

   162

}

   163

   164

static uint32 GetTime(void)

   165

{

   166

	struct timeval tim;

   167

   168

	gettimeofday(&tim, NULL);

   169

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

   170

}

   171

   172

#else

   173

   174

static bool InputWaiting(void)

   175

{

   176

	return WaitForSingleObject(hEvent, 1) == WAIT_OBJECT_0;

   177

}

   178

   179

static uint32 GetTime(void)

   180

{

   181

	return GetTickCount();

   182

}

   183

   184

#endif

   185

   186

static void DedicatedHandleKeyInput(void)

   187

{

   188

	static char input_line[200] = "";

   189

   190

	if (!InputWaiting())

   191

		return;

   192

   193

	if (_exit_game)

   194

		return;

   195

   196

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

   197

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

   198

#else

   199

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

   200

#endif

   201

   202

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

   203

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

   204

	{ /* Remove any special control characters */

   205

		uint i;

   206

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

   207

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

   208

				input_line[i] = '\0';

   209

   210

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

   211

				break;

   212

   213

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

   214

				input_line[i] = ' ';

   215

		}

   216

	}

   217

   218

	IConsoleCmdExec(input_line); // execute command

   219

}

   220

   221

static void DedicatedVideoMainLoop(void)

   222

{

   223

	uint32 next_tick;

   224

	uint32 cur_ticks;

   225

   226

	next_tick = GetTime() + 30;

   227

   228

	/* Signal handlers */

   229

#ifdef UNIX

   230

	signal(SIGTERM, DedicatedSignalHandler);

   231

	signal(SIGINT, DedicatedSignalHandler);

   232

	signal(SIGQUIT, DedicatedSignalHandler);

   233

#endif

   234

   235

	// Load the dedicated server stuff

   236

	_is_network_server = true;

   237

	_network_dedicated = true;

   238

	_network_playas = OWNER_SPECTATOR;

   239

	_local_player = OWNER_SPECTATOR;

   240

   241

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

   242

	if (_switch_mode != SM_LOAD) {

   243

		_switch_mode = SM_NONE;

   244

		GenRandomNewGame(Random(), InteractiveRandom());

   245

	} else {

   246

		_switch_mode = SM_NONE;

   247

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

   248

		 *  intro game... */

   249

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

   250

			/* Loading failed, pop out.. */

   251

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

   252

			_networking = false;

   253

		} else {

   254

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

   255

			SwitchMode(SM_LOAD);

   256

		}

   257

	}

   258

   259

	// Done loading, start game!

   260

   261

	if (!_networking) {

   262

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

   263

		return;

   264

	}

   265

   266

	while (!_exit_game) {

   267

		InteractiveRandom(); // randomness

   268

   269

		if (!_dedicated_forks)

   270

			DedicatedHandleKeyInput();

   271

   272

		cur_ticks = GetTime();

   273

   274

		if (cur_ticks >= next_tick) {

   275

			next_tick += 30;

   276

   277

			GameLoop();

   278

			_screen.dst_ptr = _dedicated_video_mem;

   279

			UpdateWindows();

   280

		}

   281

		CSleep(1);

   282

	}

   283

}

   284

   285

const HalVideoDriver _dedicated_video_driver = {

   286

	DedicatedVideoStart,

   287

	DedicatedVideoStop,

   288

	DedicatedVideoMakeDirty,

   289

	DedicatedVideoMainLoop,

   290

	DedicatedVideoChangeRes,

   291

	DedicatedVideoFullScreen,

   292

};

   293

   294

#endif /* ENABLE_NETWORK */