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

#ifdef UNIX

    17

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

    18

#	include <sys/types.h>

    19

#	include <unistd.h>

    20

#	include <signal.h>

    21

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

    22

#endif

    23

#ifdef __MORPHOS__

    24

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

    25

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

    26

 */

    27

int morphos_dummy_fork() { return -1; }

    28

#define fork morphos_dummy_fork

    29

#endif

    30

    31

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

    32

    33

static void *_dedicated_video_mem;

    34

    35

#ifdef UNIX

    36

/* We want to fork our dedicated server */

    38

{

    39

	/* Fork the program */

    40

	_dedicated_pid = fork();

    41

	switch (_dedicated_pid) {

    42

		case -1:

    43

			perror("Unable to fork");

    44

			exit(1);

    45

		case 0:

    46

			// We're the child

    47

    48

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

    49

			_log_file_fd = fopen(_log_file, "a");

    50

			if (!_log_file_fd) {

    51

				perror("Unable to open logfile");

    52

				exit(1);

    53

			}

    54

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

    55

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

    56

				perror("Re-routing stdout");

    57

				exit(1);

    58

			}

    59

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

    60

				perror("Re-routing stderr");

    61

				exit(1);

    62

			}

    63

			break;

    64

		default:

    65

			// We're the parent

    66

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

    67

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

    68

			exit(0);

    69

	}

    70

}

    71

    72

/* Signal handlers */

    73

static void DedicatedSignalHandler(int sig)

    74

{

    75

	_exit_game = true;

    76

	signal(sig, DedicatedSignalHandler);

    77

}

    78

#endif

    79

    80

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

    81

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

    82

	_screen.height = _cur_resolution[1];

    83

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

    84

    85

	_debug_net_level = 6;

    86

	_debug_misc_level = 0;

    87

    88

#ifdef WIN32

    89

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

    90

	CreateConsole();

    91

	SetConsoleTitle("OpenTTD Dedicated Server");

    92

#endif

    93

    94

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

    95

	return NULL;

    96

}

    97

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

    98

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

    99

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

   100

   101

#ifdef UNIX

   102

   103

static bool InputWaiting()

   104

{

   105

	struct timeval tv;

   106

	fd_set readfds;

   107

	byte ret;

   108

   109

	tv.tv_sec = 0;

   110

	tv.tv_usec = 1;

   111

   112

	FD_ZERO(&readfds);

   113

	FD_SET(STDIN, &readfds);

   114

   115

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

   116

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

   117

   118

	if (ret > 0)

   119

		return true;

   120

	else

   121

		return false;

   122

}

   123

#else

   124

static bool InputWaiting()

   125

{

   126

	return kbhit();

   127

}

   128

#endif

   129

   130

static void DedicatedHandleKeyInput()

   131

{

   132

#ifdef WIN32

   133

	char input;

   134

#endif

   135

	static char input_line[200] = "";

   136

   137

#ifdef UNIX

   138

	if (InputWaiting()) {

   139

		if (_exit_game)

   140

			return;

   141

   142

		fgets(input_line, 200, stdin);

   143

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

   144

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

   145

		IConsoleCmdExec(input_line);

   146

	}

   147

#else

   148

	if (InputWaiting()) {

   149

		input = getch();

   150

		printf("%c", input);

   151

		if (input != '\r')

   152

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

   153

		else {

   154

			printf("\n");

   155

			IConsoleCmdExec(input_line);

   156

			sprintf(input_line, "");

   157

		}

   158

	}

   159

#endif

   160

}

   161

   162

static int DedicatedVideoMainLoop()

   163

{

   164

#ifndef WIN32

   165

	struct timeval tim;

   166

#endif

   167

	uint32 next_tick;

   168

	uint32 cur_ticks;

   169

   170

#ifdef WIN32

   171

	next_tick = GetTickCount() + 30;

   172

#else

   173

	gettimeofday(&tim, NULL);

   174

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

   175

#endif

   176

   177

	/* Signal handlers */

   178

#ifdef UNIX

   179

	signal(SIGTERM, DedicatedSignalHandler);

   180

	signal(SIGINT, DedicatedSignalHandler);

   181

	signal(SIGQUIT, DedicatedSignalHandler);

   182

#endif

   183

   184

	// Load the dedicated server stuff

   185

	_is_network_server = true;

   186

	_network_dedicated = true;

   187

	_switch_mode = SM_NONE;

   188

	_network_playas = OWNER_SPECTATOR;

   189

	_local_player = OWNER_SPECTATOR;

   190

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

   191

	// Done loading, start game!

   192

   193

	if (!_networking) {

   194

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

   195

		return ML_QUIT;

   196

	}

   197

   198

	while (true) {

   199

		InteractiveRandom(); // randomness

   200

   201

		if (_exit_game) return ML_QUIT;

   202

   203

		if (!_dedicated_forks)

   204

			DedicatedHandleKeyInput();

   205

   206

#ifdef WIN32

   207

		cur_ticks = GetTickCount();

   208

#else

   209

		gettimeofday(&tim, NULL);

   210

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

   211

#endif

   212

   213

		if (cur_ticks >= next_tick) {

   214

			next_tick += 30;

   215

   216

			GameLoop();

   217

			_screen.dst_ptr = _dedicated_video_mem;

   218

			UpdateWindows();

   219

		}

   220

		CSleep(1);

   221

	}

   222

   223

	return ML_QUIT;

   224

}

   225

   226

   227

const HalVideoDriver _dedicated_video_driver = {

   228

	DedicatedVideoStart,

   229

	DedicatedVideoStop,

   230

	DedicatedVideoMakeDirty,

   231

	DedicatedVideoMainLoop,

   232

	DedicatedVideoChangeRes,

   233

};

   234

   235

#else

   236

   237

static void *_dedicated_video_mem;

   238

   239

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

   240

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

   241

   242

	return NULL;

   243

}

   244

   246

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

   247

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

   248

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

   249

static int DedicatedVideoMainLoop() { return ML_QUIT; }

   250

   251

const HalVideoDriver _dedicated_video_driver = {

   252

	DedicatedVideoStart,

   253

	DedicatedVideoStop,

   254

	DedicatedVideoMakeDirty,

   255

	DedicatedVideoMainLoop,

   256

	DedicatedVideoChangeRes,

   257

};

   258

   259

#endif /* ENABLE_NETWORK */