1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "network.h"

     4

#include "hal.h"

     5

     6

#ifdef ENABLE_NETWORK

     7

     8

#include "gfx.h"

     9

#include "window.h"

    10

#include "command.h"

    11

#include "console.h"

    12

#ifdef WIN32

    13

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

    14

#	include <conio.h>

    15

#endif

    16

    17

#ifdef __OS2__

    18

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

    19

#	include <sys/types.h>

    20

#	include <unistd.h>

    21

#	include <conio.h>

    22

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

    25

#endif

    26

    27

#ifdef UNIX

    28

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

    29

#	include <sys/types.h>

    30

#	include <unistd.h>

    31

#	include <signal.h>

    32

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

    33

#endif

    34

#ifdef __MORPHOS__

    35

/*  voids the fork, option will be disabled for morphos build anyway, because MorphOS 

    36

 *  doesn't support forking (could only implemented with lots of code changes here).

    37

 */

    38

int morphos_dummy_fork() { return -1; }

    39

#define fork morphos_dummy_fork

    40

#endif

    41

    42

// This file handles all dedicated-server in- and outputs

    43

    44

static void *_dedicated_video_mem;

    45

    46

#ifdef UNIX

    47

/* We want to fork our dedicated server */

    48

void DedicatedFork(void)

    49

{

    50

	/* Fork the program */

    51

	_dedicated_pid = fork();

    52

	switch (_dedicated_pid) {

    53

		case -1:

    54

			perror("Unable to fork");

    55

			exit(1);

    56

		case 0:

    57

			// We're the child

    58

    59

			/* Open the log-file to log all stuff too */

    60

			_log_file_fd = fopen(_log_file, "a");

    61

			if (!_log_file_fd) {

    62

				perror("Unable to open logfile");

    63

				exit(1);

    64

			}

    65

			/* Redirect stdout and stderr to log-file */

    66

			if (dup2(fileno(_log_file_fd), fileno(stdout)) == -1) {

    67

				perror("Re-routing stdout");

    68

				exit(1);

    69

			}

    70

			if (dup2(fileno(_log_file_fd), fileno(stderr)) == -1) {

    71

				perror("Re-routing stderr");

    72

				exit(1);

    73

			}

    74

			break;

    75

		default:

    76

			// We're the parent

    77

			printf("Loading dedicated server...\n");

    78

			printf("  - Forked to background with pid %d\n", _dedicated_pid);

    79

			exit(0);

    80

	}

    81

}

    82

    83

/* Signal handlers */

    84

static void DedicatedSignalHandler(int sig)

    85

{

    86

	_exit_game = true;

    87

	signal(sig, DedicatedSignalHandler);

    88

}

    89

#endif

    90

    91

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

    92

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

    93

	_screen.height = _cur_resolution[1];

    94

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

    95

    96

	_debug_net_level = 6;

    97

	_debug_misc_level = 0;

    98

    99

#ifdef WIN32

   100

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

   101

	CreateConsole();

   102

	SetConsoleTitle("OpenTTD Dedicated Server");

   103

#endif

   104

   110

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

   111

	return NULL;

   112

}

   113

static void DedicatedVideoStop() { free(_dedicated_video_mem); }

   114

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

   115

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

   116

   117

#ifdef UNIX

   118

   119

static bool InputWaiting()

   120

{

   121

	struct timeval tv;

   122

	fd_set readfds;

   123

	byte ret;

   124

   125

	tv.tv_sec = 0;

   126

	tv.tv_usec = 1;

   127

   128

	FD_ZERO(&readfds);

   129

	FD_SET(STDIN, &readfds);

   130

   131

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

   132

	ret = select(STDIN + 1, &readfds, NULL, NULL, &tv);

   133

   134

	if (ret > 0)

   135

		return true;

   136

	else

   137

		return false;

   138

}

   139

#else

   140

static bool InputWaiting()

   141

{

   142

	return kbhit();

   143

}

   144

#endif

   145

   146

static void DedicatedHandleKeyInput()

   147

{

   148

#ifdef WIN32

   149

	char input;

   150

#endif

   151

	static char input_line[200] = "";

   152

   153

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

   154

	if (InputWaiting()) {

   155

		if (_exit_game)

   156

			return;

   157

   158

		fgets(input_line, 200, stdin);

   159

		// Forget about the final \n (or \r)

   160

		strtok(input_line, "\r\n");

   161

		IConsoleCmdExec(input_line);

   162

	}

   163

#else

   164

	if (InputWaiting()) {

   165

		input = getch();

   166

		printf("%c", input);

   167

		if (input != '\r')

   168

			snprintf(input_line, 200, "%s%c", input_line, input);

   169

		else {

   170

			printf("\n");

   171

			IConsoleCmdExec(input_line);

   172

			input_line[0] = '\0';

   173

		}

   174

	}

   175

#endif

   176

}

   177

   178

static int DedicatedVideoMainLoop()

   179

{

   180

#ifndef WIN32

   181

	struct timeval tim;

   182

#endif

   183

	uint32 next_tick;

   184

	uint32 cur_ticks;

   185

   186

#ifdef WIN32

   187

	next_tick = GetTickCount() + 30;

   188

#else

   189

	gettimeofday(&tim, NULL);

   190

	next_tick = (tim.tv_usec / 1000) + 30 + (tim.tv_sec * 1000);

   191

#endif

   192

   193

	/* Signal handlers */

   194

#ifdef UNIX

   195

	signal(SIGTERM, DedicatedSignalHandler);

   196

	signal(SIGINT, DedicatedSignalHandler);

   197

	signal(SIGQUIT, DedicatedSignalHandler);

   198

#endif

   199

   200

	// Load the dedicated server stuff

   201

	_is_network_server = true;

   202

	_network_dedicated = true;

   203

	_switch_mode = SM_NONE;

   204

	_network_playas = OWNER_SPECTATOR;

   205

	_local_player = OWNER_SPECTATOR;

   206

	DoCommandP(0, Random(), InteractiveRandom(), NULL, CMD_GEN_RANDOM_NEW_GAME);

   207

	// Done loading, start game!

   208

   209

	if (!_networking) {

   210

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

   211

		return ML_QUIT;

   212

	}

   213

   214

	while (true) {

   215

		InteractiveRandom(); // randomness

   216

   217

		if (_exit_game) return ML_QUIT;

   218

   219

		if (!_dedicated_forks)

   220

			DedicatedHandleKeyInput();

   221

   222

#ifdef WIN32

   223

		cur_ticks = GetTickCount();

   224

#else

   225

		gettimeofday(&tim, NULL);

   226

		cur_ticks = (tim.tv_usec / 1000) + (tim.tv_sec * 1000);

   227

#endif

   228

   229

		if (cur_ticks >= next_tick) {

   230

			next_tick += 30;

   231

   232

			GameLoop();

   233

			_screen.dst_ptr = _dedicated_video_mem;

   234

			UpdateWindows();

   235

		}

   236

		CSleep(1);

   237

	}

   238

   239

	return ML_QUIT;

   240

}

   241

   242

   243

const HalVideoDriver _dedicated_video_driver = {

   244

	DedicatedVideoStart,

   245

	DedicatedVideoStop,

   246

	DedicatedVideoMakeDirty,

   247

	DedicatedVideoMainLoop,

   248

	DedicatedVideoChangeRes,

   249

};

   250

   251

#else

   252

   253

static void *_dedicated_video_mem;

   254

   255

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

   256

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

   257

   258

	return NULL;

   259

}

   260

   261

void DedicatedFork(void) {}

   262

static void DedicatedVideoStop() { free(_dedicated_video_mem); }

   263

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

   264

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

   265

static int DedicatedVideoMainLoop() { return ML_QUIT; }

   266

   267

const HalVideoDriver _dedicated_video_driver = {

   268

	DedicatedVideoStart,

   269

	DedicatedVideoStop,

   270

	DedicatedVideoMakeDirty,

   271

	DedicatedVideoMainLoop,

   272

	DedicatedVideoChangeRes,

   273

};

   274

   275

#endif /* ENABLE_NETWORK */