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

    25

#ifdef UNIX

    26

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

    27

#	include <sys/types.h>

    28

#	include <unistd.h>

    29

#	include <signal.h>

    30

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

    31

#endif

    32

#ifdef __MORPHOS__

    33

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

    34

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

    35

 */

    36

int morphos_dummy_fork() { return -1; }

    37

#define fork morphos_dummy_fork

    38

#endif

    39

    40

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

    41

    42

static void *_dedicated_video_mem;

    43

    44

#ifdef UNIX

    45

/* We want to fork our dedicated server */

    46

void DedicatedFork(void)

    47

{

    48

	/* Fork the program */

    49

	_dedicated_pid = fork();

    50

	switch (_dedicated_pid) {

    51

		case -1:

    52

			perror("Unable to fork");

    53

			exit(1);

    54

		case 0:

    55

			// We're the child

    56

    57

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

    58

			_log_file_fd = fopen(_log_file, "a");

    59

			if (!_log_file_fd) {

    60

				perror("Unable to open logfile");

    61

				exit(1);

    62

			}

    63

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

    64

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

    65

				perror("Re-routing stdout");

    66

				exit(1);

    67

			}

    68

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

    69

				perror("Re-routing stderr");

    70

				exit(1);

    71

			}

    72

			break;

    73

		default:

    74

			// We're the parent

    75

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

    76

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

    77

			exit(0);

    78

	}

    79

}

    80

    81

/* Signal handlers */

    82

static void DedicatedSignalHandler(int sig)

    83

{

    84

	_exit_game = true;

    85

	signal(sig, DedicatedSignalHandler);

    86

}

    87

#endif

    88

    89

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

    90

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

    91

	_screen.height = _cur_resolution[1];

    92

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

    93

    94

	_debug_net_level = 6;

    95

	_debug_misc_level = 0;

    96

    97

#ifdef WIN32

    98

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

    99

	CreateConsole();

   100

	SetConsoleTitle("OpenTTD Dedicated Server");

   101

#endif

   102

   103

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

   104

	return NULL;

   105

}

   106

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

   107

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

   108

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

   109

   110

#ifdef UNIX

   111

   112

static bool InputWaiting()

   113

{

   114

	struct timeval tv;

   115

	fd_set readfds;

   116

	byte ret;

   117

   118

	tv.tv_sec = 0;

   119

	tv.tv_usec = 1;

   120

   121

	FD_ZERO(&readfds);

   122

	FD_SET(STDIN, &readfds);

   123

   124

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

   125

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

   126

   127

	if (ret > 0)

   128

		return true;

   129

	else

   130

		return false;

   131

}

   132

#else

   133

static bool InputWaiting()

   134

{

   135

	return kbhit();

   136

}

   137

#endif

   138

   139

static void DedicatedHandleKeyInput()

   140

{

   141

#ifdef WIN32

   142

	char input;

   143

#endif

   144

	static char input_line[200] = "";

   145

   147

	if (InputWaiting()) {

   148

		if (_exit_game)

   149

			return;

   150

   151

		fgets(input_line, 200, stdin);

   152

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

   153

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

   154

		IConsoleCmdExec(input_line);

   155

	}

   156

#else

   157

	if (InputWaiting()) {

   158

		input = getch();

   159

		printf("%c", input);

   160

		if (input != '\r')

   161

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

   162

		else {

   163

			printf("\n");

   164

			IConsoleCmdExec(input_line);

   165

			sprintf(input_line, "");

   166

		}

   167

	}

   168

#endif

   169

}

   170

   171

static int DedicatedVideoMainLoop()

   172

{

   173

#ifndef WIN32

   174

	struct timeval tim;

   175

#endif

   176

	uint32 next_tick;

   177

	uint32 cur_ticks;

   178

   179

#ifdef WIN32

   180

	next_tick = GetTickCount() + 30;

   181

#else

   182

	gettimeofday(&tim, NULL);

   183

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

   184

#endif

   185

   186

	/* Signal handlers */

   187

#ifdef UNIX

   188

	signal(SIGTERM, DedicatedSignalHandler);

   189

	signal(SIGINT, DedicatedSignalHandler);

   190

	signal(SIGQUIT, DedicatedSignalHandler);

   191

#endif

   192

   193

	// Load the dedicated server stuff

   194

	_is_network_server = true;

   195

	_network_dedicated = true;

   196

	_switch_mode = SM_NONE;

   197

	_network_playas = OWNER_SPECTATOR;

   198

	_local_player = OWNER_SPECTATOR;

   199

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

   200

	// Done loading, start game!

   201

   202

	if (!_networking) {

   203

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

   204

		return ML_QUIT;

   205

	}

   206

   207

	while (true) {

   208

		InteractiveRandom(); // randomness

   209

   210

		if (_exit_game) return ML_QUIT;

   211

   212

		if (!_dedicated_forks)

   213

			DedicatedHandleKeyInput();

   214

   215

#ifdef WIN32

   216

		cur_ticks = GetTickCount();

   217

#else

   218

		gettimeofday(&tim, NULL);

   219

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

   220

#endif

   221

   222

		if (cur_ticks >= next_tick) {

   223

			next_tick += 30;

   224

   225

			GameLoop();

   226

			_screen.dst_ptr = _dedicated_video_mem;

   227

			UpdateWindows();

   228

		}

   229

		CSleep(1);

   230

	}

   231

   232

	return ML_QUIT;

   233

}

   234

   235

   236

const HalVideoDriver _dedicated_video_driver = {

   237

	DedicatedVideoStart,

   238

	DedicatedVideoStop,

   239

	DedicatedVideoMakeDirty,

   240

	DedicatedVideoMainLoop,

   241

	DedicatedVideoChangeRes,

   242

};

   243

   244

#else

   245

   246

static void *_dedicated_video_mem;

   247

   248

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

   249

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

   250

   251

	return NULL;

   252

}

   253

   254

void DedicatedFork(void) {}

   255

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

   256

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

   257

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

   258

static int DedicatedVideoMainLoop() { return ML_QUIT; }

   259

   260

const HalVideoDriver _dedicated_video_driver = {

   261

	DedicatedVideoStart,

   262

	DedicatedVideoStop,

   263

	DedicatedVideoMakeDirty,

   264

	DedicatedVideoMainLoop,

   265

	DedicatedVideoChangeRes,

   266

};

   267

   268

#endif /* ENABLE_NETWORK */