3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "network.h"

     8

#include "video/dedicated_v.h"

     9

    10

#ifdef ENABLE_NETWORK

    11

    12

#include "gfx.h"

    13

#include "window.h"

    14

#include "command.h"

    15

#include "console.h"

    16

#include "variables.h"

    17

    18

#ifdef __OS2__

    19

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

    20

#	include <sys/types.h>

    21

#	include <unistd.h>

    22

#	include <conio.h>

    23

    24

#	define INCL_DOS

    25

#	include <os2.h>

    26

    27

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

    28

    29

/** 

    30

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

    31

 * Necessary to see stdout, etc. */

    32

static void OS2_SwitchToConsoleMode(void)

    33

{

    34

	PPIB pib;

    35

	PTIB tib;

    36

    37

	DosGetInfoBlocks(&tib, &pib);

    38

    39

	// Change flag from PM to VIO

    40

	pib->pib_ultype = 3;

    41

}

    42

#endif

    43

    44

#ifdef UNIX

    45

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

    46

#	include <sys/types.h>

    47

#	include <unistd.h>

    48

#	include <signal.h>

    49

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

    50

    51

/* Signal handlers */

    52

static void DedicatedSignalHandler(int sig)

    53

{

    54

	_exit_game = true;

    55

	signal(sig, DedicatedSignalHandler);

    56

}

    57

#endif

    58

    59

#ifdef WIN32

    60

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

    61

#include <conio.h>

    62

#include <time.h>

    63

static HANDLE hEvent;

    64

static HANDLE hThread; // Thread to close

    65

static char _win_console_thread_buffer[200];

    66

    67

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

    68

static void WINAPI CheckForConsoleInput(void)

    69

{

    70

	while (true) {

    71

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

    72

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

    73

	}

    74

}

    75

    76

static void CreateWindowsConsoleThread(void)

    77

{

    78

	static char tbuffer[9];

    79

	DWORD dwThreadId;

    80

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

    81

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

    82

	if (hEvent == NULL)

    83

		error("Cannot create console event!");

    84

    85

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

    86

	if (hThread == NULL)

    87

		error("Cannot create console thread!");

    88

    89

	DEBUG(misc, 0) ("Windows console thread started...");

    90

}

    91

    92

static void CloseWindowsConsoleThread(void)

    93

{

    94

	CloseHandle(hThread);

    95

	CloseHandle(hEvent);

    96

	DEBUG(misc, 0) ("Windows console thread shut down...");

    97

}

    98

    99

#endif

   100

   101

   102

static void *_dedicated_video_mem;

   103

   104

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

   105

extern void SwitchMode(int new_mode);

   106

   107

   108

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

   109

{

   110

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

   111

	_screen.height = _cur_resolution[1];

   112

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

   113

   114

	_debug_net_level = 6;

   115

	_debug_misc_level = 0;

   116

   117

#ifdef WIN32

   118

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

   119

	CreateConsole();

   120

	CreateWindowsConsoleThread();

   121

	SetConsoleTitle("OpenTTD Dedicated Server");

   122

#endif

   123

   124

#ifdef __OS2__

   125

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

   126

	OS2_SwitchToConsoleMode();

   127

#endif

   128

   129

	DEBUG(misc,0)("Loading dedicated server...");

   130

	return NULL;

   131

}

   132

   133

static void DedicatedVideoStop(void)

   134

{

   135

#ifdef WIN32

   136

	CloseWindowsConsoleThread();

   137

#endif

   138

	free(_dedicated_video_mem);

   139

}

   140

   141

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

   142

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

   143

static void DedicatedVideoFullScreen(bool fs) {}

   144

   145

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

   146

static bool InputWaiting(void)

   147

{

   148

	struct timeval tv;

   149

	fd_set readfds;

   150

   151

	tv.tv_sec = 0;

   152

	tv.tv_usec = 1;

   153

   154

	FD_ZERO(&readfds);

   155

	FD_SET(STDIN, &readfds);

   156

   157

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

   158

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

   159

}

   160

   161

static uint32 GetTime(void)

   162

{

   163

	struct timeval tim;

   164

   165

	gettimeofday(&tim, NULL);

   166

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

   167

}

   168

   169

#else

   170

   171

static bool InputWaiting(void)

   172

{

   173

	return WaitForSingleObject(hEvent, 1) == WAIT_OBJECT_0;

   174

}

   175

   176

static uint32 GetTime(void)

   177

{

   178

	return GetTickCount();

   179

}

   180

   181

#endif

   182

   183

static void DedicatedHandleKeyInput(void)

   184

{

   185

	static char input_line[200] = "";

   186

   187

	if (!InputWaiting())

   188

		return;

   189

   190

	if (_exit_game)

   191

		return;

   192

   193

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

   194

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

   195

#else

   196

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

   197

#endif

   198

   199

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

   200

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

   201

	{ /* Remove any special control characters */

   202

		uint i;

   203

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

   204

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

   205

				input_line[i] = '\0';

   206

   207

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

   208

				break;

   209

   210

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

   211

				input_line[i] = ' ';

   212

		}

   213

	}

   214

   215

	IConsoleCmdExec(input_line); // execute command

   216

}

   217

   218

static int DedicatedVideoMainLoop(void)

   219

{

   220

	uint32 next_tick;

   221

	uint32 cur_ticks;

   222

   223

	next_tick = GetTime() + 30;

   224

   225

	/* Signal handlers */

   226

#ifdef UNIX

   227

	signal(SIGTERM, DedicatedSignalHandler);

   228

	signal(SIGINT, DedicatedSignalHandler);

   229

	signal(SIGQUIT, DedicatedSignalHandler);

   230

#endif

   231

   232

	// Load the dedicated server stuff

   233

	_is_network_server = true;

   234

	_network_dedicated = true;

   235

	_network_playas = OWNER_SPECTATOR;

   236

	_local_player = OWNER_SPECTATOR;

   237

   238

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

   239

	if (_switch_mode != SM_LOAD) {

   240

		_switch_mode = SM_NONE;

   241

		GenRandomNewGame(Random(), InteractiveRandom());

   242

	} else {

   243

		_switch_mode = SM_NONE;

   244

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

   245

		 *  intro game... */

   246

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

   247

			/* Loading failed, pop out.. */

   248

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

   249

			_networking = false;

   250

		} else {

   251

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

   252

			SwitchMode(SM_LOAD);

   253

		}

   254

	}

   255

   256

	// Done loading, start game!

   257

   258

	if (!_networking) {

   259

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

   260

		return ML_QUIT;

   261

	}

   262

   263

	while (true) {

   264

		InteractiveRandom(); // randomness

   265

   266

		if (_exit_game) return ML_QUIT;

   267

   268

		if (!_dedicated_forks)

   269

			DedicatedHandleKeyInput();

   270

   271

		cur_ticks = GetTime();

   272

   273

		if (cur_ticks >= next_tick) {

   274

			next_tick += 30;

   275

   276

			GameLoop();

   277

			_screen.dst_ptr = _dedicated_video_mem;

   278

			UpdateWindows();

   279

		}

   280

		CSleep(1);

   281

	}

   282

}

   283

   284

#else

   285

   286

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

   287

{

   288

	DEBUG(misc, 0) ("OpenTTD compiled without network support, exiting.");

   289

   290

	return NULL;

   291

}

   292

   293

static void DedicatedVideoStop(void) {}

   294

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

   295

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

   296

static void DedicatedVideoFullScreen(bool fs) {}

   297

static int DedicatedVideoMainLoop(void) { return ML_QUIT; }

   298

   299

#endif /* ENABLE_NETWORK */

   300

   301

const HalVideoDriver _dedicated_video_driver = {

   302

	DedicatedVideoStart,

   303

	DedicatedVideoStop,

   304

	DedicatedVideoMakeDirty,

   305

	DedicatedVideoMainLoop,

   306

	DedicatedVideoChangeRes,

   307

	DedicatedVideoFullScreen,

   308

};