1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

     5

#ifdef ENABLE_NETWORK

     6

     7

#include "../openttd.h"

     8

#include "../debug.h"

     9

#include "../gfx_func.h"

    10

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

    11

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

    12

#include "../console.h"

    13

#include "../variables.h"

    14

#include "../genworld.h"

    15

#include "../fileio.h"

    16

#include "../fios.h"

    17

#include "../blitter/factory.hpp"

    18

#include "../core/alloc_func.hpp"

    19

#include "../player_func.h"

    20

#include "../core/random_func.hpp"

    21

#include "dedicated_v.h"

    22

    23

#ifdef BEOS_NET_SERVER

    24

#include <net/socket.h>

    25

#endif

    26

    27

#ifdef __OS2__

    28

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

    29

#	include <sys/types.h>

    30

#	include <unistd.h>

    31

#	include <conio.h>

    32

    33

#	define INCL_DOS

    34

#	include <os2.h>

    35

    36

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

    37

    38

/**

    39

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

    40

 * Necessary to see stdout, etc. */

    41

static void OS2_SwitchToConsoleMode()

    42

{

    43

	PPIB pib;

    44

	PTIB tib;

    45

    46

	DosGetInfoBlocks(&tib, &pib);

    47

    48

	// Change flag from PM to VIO

    49

	pib->pib_ultype = 3;

    50

}

    51

#endif

    52

    53

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

    54

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

    55

#	include <sys/types.h>

    56

#	include <unistd.h>

    57

#	include <signal.h>

    58

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

    59

#	if defined(PSP)

    60

#		include <sys/fd_set.h>

    61

#		include <sys/select.h>

    62

#	endif /* PSP */

    63

    64

/* Signal handlers */

    65

static void DedicatedSignalHandler(int sig)

    66

{

    67

	_exit_game = true;

    68

	signal(sig, DedicatedSignalHandler);

    69

}

    70

#endif

    71

    72

#if defined(WIN32)

    73

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

    74

# if !defined(WINCE)

    75

#  include <conio.h>

    76

# endif

    77

# include <time.h>

    78

# include <tchar.h>

    79

static HANDLE _hInputReady, _hWaitForInputHandling;

    80

static HANDLE _hThread; // Thread to close

    81

static char _win_console_thread_buffer[200];

    82

    83

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

    84

static void WINAPI CheckForConsoleInput()

    85

{

    86

#if defined(WINCE)

    87

	/* WinCE doesn't support console stuff */

    88

	return;

    89

#else

    90

	DWORD nb;

    91

	HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);

    92

	while (true) {

    93

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

    94

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

    95

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

    96

		SetEvent(_hInputReady);

    97

		WaitForSingleObject(_hWaitForInputHandling, INFINITE);

    98

	}

    99

#endif

   100

}

   101

   102

static void CreateWindowsConsoleThread()

   103

{

   104

	DWORD dwThreadId;

   105

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

   106

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

   107

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

   108

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

   109

   110

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

   111

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

   112

   113

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

   114

}

   115

   116

static void CloseWindowsConsoleThread()

   117

{

   118

	CloseHandle(_hThread);

   119

	CloseHandle(_hInputReady);

   120

	CloseHandle(_hWaitForInputHandling);

   121

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

   122

}

   123

   124

#endif

   125

   126

   127

static void *_dedicated_video_mem;

   128

   129

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

   130

extern void SwitchMode(int new_mode);

   131

   132

static FVideoDriver_Dedicated iFVideoDriver_Dedicated;

   133

   134

   135

const char *VideoDriver_Dedicated::Start(const char * const *parm)

   136

{

   137

	int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();

   138

	if (bpp == 0) _dedicated_video_mem = NULL;

   139

	else          _dedicated_video_mem = MallocT<byte>(_cur_resolution[0] * _cur_resolution[1] * (bpp / 8));

   140

   141

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

   142

	_screen.height = _cur_resolution[1];

   143

   144

	SetDebugString("net=6");

   145

   146

#if defined(WINCE)

   147

	/* WinCE doesn't support console stuff */

   148

#elif defined(WIN32)

   149

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

   150

	CreateConsole();

   151

	CreateWindowsConsoleThread();

   152

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

   153

#endif

   154

   155

#ifdef __OS2__

   156

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

   157

	OS2_SwitchToConsoleMode();

   158

#endif

   159

   160

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

   161

	return NULL;

   162

}

   163

   164

void VideoDriver_Dedicated::Stop()

   165

{

   166

#ifdef WIN32

   167

	CloseWindowsConsoleThread();

   168

#endif

   169

	free(_dedicated_video_mem);

   170

}

   171

   172

void VideoDriver_Dedicated::MakeDirty(int left, int top, int width, int height) {}

   173

bool VideoDriver_Dedicated::ChangeResolution(int w, int h) { return false; }

   174

bool VideoDriver_Dedicated::ToggleFullscreen(bool fs) { return false; }

   175

   176

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

   177

static bool InputWaiting()

   178

{

   179

	struct timeval tv;

   180

	fd_set readfds;

   181

   182

	tv.tv_sec = 0;

   183

	tv.tv_usec = 1;

   184

   185

	FD_ZERO(&readfds);

   186

	FD_SET(STDIN, &readfds);

   187

   188

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

   189

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

   190

}

   191

   192

static uint32 GetTime()

   193

{

   194

	struct timeval tim;

   195

   196

	gettimeofday(&tim, NULL);

   197

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

   198

}

   199

   200

#else

   201

   202

static bool InputWaiting()

   203

{

   204

	return WaitForSingleObject(_hInputReady, 1) == WAIT_OBJECT_0;

   205

}

   206

   207

static uint32 GetTime()

   208

{

   209

	return GetTickCount();

   210

}

   211

   212

#endif

   213

   214

static void DedicatedHandleKeyInput()

   215

{

   216

	static char input_line[200] = "";

   217

   218

	if (!InputWaiting()) return;

   219

   220

	if (_exit_game) return;

   221

   222

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

   223

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

   224

#else

   225

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

   226

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

   227

	SetEvent(_hWaitForInputHandling);

   228

#endif

   229

   230

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

   231

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

   232

	{ /* Remove any special control characters */

   233

		uint i;

   234

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

   235

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

   236

				input_line[i] = '\0';

   237

   238

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

   239

				break;

   240

   241

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

   242

				input_line[i] = ' ';

   243

		}

   244

	}

   245

   246

	IConsoleCmdExec(input_line); // execute command

   247

}

   248

   249

void VideoDriver_Dedicated::MainLoop()

   250

{

   251

	uint32 cur_ticks = GetTime();

   252

	uint32 next_tick = cur_ticks + 30;

   253

   254

	/* Signal handlers */

   255

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

   256

	signal(SIGTERM, DedicatedSignalHandler);

   257

	signal(SIGINT, DedicatedSignalHandler);

   258

	signal(SIGQUIT, DedicatedSignalHandler);

   259

#endif

   260

   261

	// Load the dedicated server stuff

   262

	_is_network_server = true;

   263

	_network_dedicated = true;

   264

	_network_playas = PLAYER_SPECTATOR;

   265

	_local_player = PLAYER_SPECTATOR;

   266

   267

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

   268

	if (_switch_mode != SM_LOAD) {

   269

		StartNewGameWithoutGUI(GENERATE_NEW_SEED);

   270

		SwitchMode(_switch_mode);

   271

		_switch_mode = SM_NONE;

   272

	} else {

   273

		_switch_mode = SM_NONE;

   274

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

   275

		 *  intro game... */

   276

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

   277

			/* Loading failed, pop out.. */

   278

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

   279

			_networking = false;

   280

		} else {

   281

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

   282

			SwitchMode(SM_LOAD);

   283

		}

   284

	}

   285

   286

	// Done loading, start game!

   287

   288

	if (!_networking) {

   289

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

   290

		return;

   291

	}

   292

   293

	while (!_exit_game) {

   294

		uint32 prev_cur_ticks = cur_ticks; // to check for wrapping

   295

		InteractiveRandom(); // randomness

   296

   297

		if (!_dedicated_forks)

   298

			DedicatedHandleKeyInput();

   299

   300

		cur_ticks = GetTime();

   301

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

   302

			next_tick = cur_ticks + 30;

   303

   304

			GameLoop();

   305

			_screen.dst_ptr = _dedicated_video_mem;

   306

			UpdateWindows();

   307

		}

   308

		CSleep(1);

   309

	}

   310

}

   311

   312

#endif /* ENABLE_NETWORK */