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

    24

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

    25

    26

static void *_dedicated_video_mem;

    27

    28

#ifdef UNIX

    29

/* We want to fork our dedicated server */

    30

void DedicatedFork()

    31

{

    32

	/* Fork the program */

    33

	_dedicated_pid = fork();

    34

	switch (_dedicated_pid) {

    35

		case -1:

    36

			perror("Unable to fork");

    37

			exit(1);

    38

		case 0:

    39

			// We're the child

    40

    41

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

    42

			_log_file_fd = fopen(_log_file, "a");

    43

			if (!_log_file_fd) {

    44

				perror("Unable to open logfile");

    45

				exit(1);

    46

			}

    47

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

    48

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

    49

				perror("Re-routing stdout");

    50

				exit(1);

    51

			}

    52

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

    53

				perror("Re-routing stderr");

    54

				exit(1);

    55

			}

    56

			break;

    57

		default:

    58

			// We're the parent

    59

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

    60

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

    61

			exit(0);

    62

	}

    63

}

    64

    65

/* Signal handlers */

    66

static void DedicatedSignalHandler(int sig)

    67

{

    68

	_exit_game = true;

    69

	signal(sig, DedicatedSignalHandler);

    70

}

    71

#endif

    72

    73

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

    74

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

    75

	_screen.height = _cur_resolution[1];

    76

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

    77

    78

	_debug_net_level = 6;

    79

	_debug_misc_level = 0;

    80

    81

#ifdef WIN32

    82

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

    83

	CreateConsole();

    84

	SetConsoleTitle("OpenTTD Dedicated Server");

    85

#endif

    86

    87

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

    88

	return NULL;

    89

}

    90

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

    91

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

    92

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

    93

    94

#ifdef UNIX

    95

    96

static bool InputWaiting()

    97

{

    98

	struct timeval tv;

    99

	fd_set readfds;

   100

	byte ret;

   101

   102

	tv.tv_sec = 0;

   103

	tv.tv_usec = 1;

   104

   105

	FD_ZERO(&readfds);

   106

	FD_SET(STDIN, &readfds);

   107

   108

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

   109

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

   110

   111

	if (ret > 0)

   112

		return true;

   113

	else

   114

		return false;

   115

}

   116

#else

   117

static bool InputWaiting()

   118

{

   119

	return kbhit();

   120

}

   121

#endif

   122

   123

static void DedicatedHandleKeyInput()

   124

{

   125

#ifdef WIN32

   126

	char input;

   127

#endif

   128

	static char input_line[200] = "";

   129

   130

#ifdef UNIX

   131

	if (InputWaiting()) {

   132

		if (_exit_game)

   133

			return;

   134

   135

		fgets(input_line, 200, stdin);

   136

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

   137

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

   138

		IConsoleCmdExec(input_line);

   139

	}

   140

#else

   141

	if (InputWaiting()) {

   142

		input = getch();

   143

		printf("%c", input);

   144

		if (input != '\r')

   145

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

   146

		else {

   147

			printf("\n");

   148

			IConsoleCmdExec(input_line);

   149

			sprintf(input_line, "");

   150

		}

   151

	}

   152

#endif

   153

}

   154

   155

static int DedicatedVideoMainLoop()

   156

{

   157

#ifndef WIN32

   158

	struct timeval tim;

   159

#endif

   160

	uint32 next_tick;

   161

	uint32 cur_ticks;

   162

   163

#ifdef WIN32

   164

	next_tick = GetTickCount() + 30;

   165

#else

   166

	gettimeofday(&tim, NULL);

   167

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

   168

#endif

   169

   170

	/* Siganl handlers */

   171

#ifdef UNIX

   172

	signal(SIGTERM, DedicatedSignalHandler);

   173

	signal(SIGINT, DedicatedSignalHandler);

   174

	signal(SIGQUIT, DedicatedSignalHandler);

   175

#endif

   176

   177

	// Load the dedicated server stuff

   178

	_is_network_server = true;

   179

	_network_dedicated = true;

   180

	_switch_mode = SM_NONE;

   181

	_network_playas = OWNER_SPECTATOR;

   182

	_local_player = OWNER_SPECTATOR;

   183

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

   184

	// Done loading, start game!

   185

   186

	if (!_networking) {

   187

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

   188

		return ML_QUIT;

   189

	}

   190

   191

	while (true) {

   192

		InteractiveRandom(); // randomness

   193

   194

		if (_exit_game) return ML_QUIT;

   195

   196

		if (!_dedicated_forks)

   197

			DedicatedHandleKeyInput();

   198

   199

#ifdef WIN32

   200

		cur_ticks = GetTickCount();

   201

#else

   202

		gettimeofday(&tim, NULL);

   203

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

   204

#endif

   205

   206

		if (cur_ticks >= next_tick) {

   207

			next_tick += 30;

   208

   209

			GameLoop();

   210

			_screen.dst_ptr = _dedicated_video_mem;

   211

			UpdateWindows();

   212

		}

   213

		CSleep(1);

   214

	}

   215

   216

	return ML_QUIT;

   217

}

   218

   219

   220

const HalVideoDriver _dedicated_video_driver = {

   221

	DedicatedVideoStart,

   222

	DedicatedVideoStop,

   223

	DedicatedVideoMakeDirty,

   224

	DedicatedVideoMainLoop,

   225

	DedicatedVideoChangeRes,

   226

};

   227

   228

#else

   229

   230

static void *_dedicated_video_mem;

   231

   232

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

   233

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

   234

   235

	return NULL;

   236

}

   237

   238

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

   239

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

   240

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

   241

static int DedicatedVideoMainLoop() { return ML_QUIT; }

   242

   243

const HalVideoDriver _dedicated_video_driver = {

   244

	DedicatedVideoStart,

   245

	DedicatedVideoStop,

   246

	DedicatedVideoMakeDirty,

   247

	DedicatedVideoMainLoop,

   248

	DedicatedVideoChangeRes,

   249

};

   250

   251

#endif /* ENABLE_NETWORK */