1

/* -------------------- dont cross this line --------------------- */

     2

#include "stdafx.h"

     3

#include "ttd.h"

     4

#include "console.h"

     5

#include "engine.h"

     6

#include "functions.h"

     7

#include "variables.h"

     8

#include "network_data.h"

     9

#include "network_client.h"

    10

#include "network_server.h"

    11

#include "command.h"

    12

#include "settings.h"

    13

    14

    15

// ** scriptfile handling ** //

    16

static FILE * _script_file;

    17

static bool _script_running;

    18

    19

// ** console command / variable defines ** //

    20

    21

#define DEF_CONSOLE_CMD(yyyy) static _iconsole_var * yyyy(byte argc, char* argv[], byte argt[])

    22

#define DEF_CONSOLE_CMD_HOOK(yyyy) static bool yyyy(_iconsole_cmd * hookcmd)

    23

#define DEF_CONSOLE_VAR_HOOK(yyyy) static bool yyyy(_iconsole_var * hookvar)

    24

    25

    26

// ** supporting functions ** //

    27

    28

static uint32 GetArgumentInteger(const char* arg)

    29

{

    30

	uint32 result;

    31

	sscanf(arg, "%u", &result);

    32

    33

	if (result == 0 && arg[0] == '0' && arg[1] == 'x')

    34

		sscanf(arg, "%x", &result);

    35

    36

	return result;

    37

}

    38

    39

/* **************************** */

    40

/* variable and command hooks   */

    41

/* **************************** */

    42

    43

#ifdef ENABLE_NETWORK

    44

    45

DEF_CONSOLE_CMD_HOOK(ConCmdHookNoNetwork)

    46

{

    47

	if (_networking) {

    48

		IConsoleError("This command is forbidden in multiplayer.");

    49

		return false;

    50

	}

    51

	return true;

    52

}

    53

    54

DEF_CONSOLE_VAR_HOOK(ConVarHookNoNetClient)

    55

{

    56

	if (!_network_available) {

    57

		IConsoleError("You can not use this command because there is no network available.");

    58

		return false;

    59

	}

    60

	if (!_network_server) {

    61

		IConsoleError("This variable only makes sense for a network server.");

    62

		return false;

    63

	}

    64

	return true;

    65

}

    66

    67

DEF_CONSOLE_CMD_HOOK(ConCmdHookNoNetClient)

    68

{

    69

	if (!_network_available) {

    70

		IConsoleError("You can not use this command because there is no network available.");

    71

		return false;

    72

	}

    73

	if (!_network_server) {

    74

		IConsoleError("This command is only available for a network server.");

    75

		return false;

    76

	}

    77

	return true;

    78

}

    79

    80

DEF_CONSOLE_CMD_HOOK(ConCmdHookNoNetServer)

    81

{

    82

	if (!_network_available) {

    83

		IConsoleError("You can not use this command because there is no network available.");

    84

		return false;

    85

	}

    86

	if (_network_server) {

    87

		IConsoleError("You can not use this command because you are a network-server.");

    88

		return false;

    89

	}

    90

	return true;

    91

}

    92

    93

DEF_CONSOLE_CMD_HOOK(ConCmdHookNeedNetwork)

    94

{

    95

	if (!_network_available) {

    96

		IConsoleError("You can not use this command because there is no network available.");

    97

		return false;

    98

	}

    99

	if (!_networking) {

   100

		IConsoleError("Not connected. Multiplayer only command.");

   101

		return false;

   102

	}

   103

	return true;

   104

}

   105

   106

#endif /* ENABLE_NETWORK */

   107

   108

/* **************************** */

   109

/* reset commands               */

   110

/* **************************** */

   111

   112

DEF_CONSOLE_CMD(ConResetEngines)

   113

{

   114

	StartupEngines();

   115

	return 0;

   116

}

   117

   118

#ifdef _DEBUG

   119

DEF_CONSOLE_CMD(ConResetTile)

   120

{

   121

	if (argc == 2) {

   122

		TileIndex tile = (TileIndex)GetArgumentInteger(argv[1]);

   123

		DoClearSquare(tile);

   124

	}

   125

   126

	return 0;

   127

}

   128

#endif

   129

   130

DEF_CONSOLE_CMD(ConScrollToTile)

   131

{

   132

	if (argc == 2) {

   133

		TileIndex tile = (TileIndex)GetArgumentInteger(argv[1]);

   134

		ScrollMainWindowToTile(tile);

   135

	}

   136

   137

	return 0;

   138

}

   139

   140

   141

// ********************************* //

   142

// * Network Core Console Commands * //

   143

// ********************************* //

   144

#ifdef ENABLE_NETWORK

   145

   146

DEF_CONSOLE_CMD(ConStatus)

   147

{

   148

	const char *status;

   149

	int lag;

   150

	const ClientState *cs;

   151

	const NetworkClientInfo *ci;

   152

	FOR_ALL_CLIENTS(cs) {

   153

		lag = NetworkCalculateLag(cs);

   154

		ci = DEREF_CLIENT_INFO(cs);

   155

   156

		switch (cs->status) {

   157

			case STATUS_INACTIVE:

   158

				status = "inactive";

   159

				break;

   160

			case STATUS_AUTH:

   161

				status = "authorized";

   162

				break;

   163

			case STATUS_MAP:

   164

				status = "loading map";

   165

				break;

   166

			case STATUS_DONE_MAP:

   167

				status = "done map";

   168

				break;

   169

			case STATUS_PRE_ACTIVE:

   170

				status = "ready";

   171

				break;

   172

			case STATUS_ACTIVE:

   173

				status = "active";

   174

				break;

   175

			default:

   176

				status = "unknown";

   177

				break;

   178

		}

   179

		IConsolePrintF(8, "Client #%d/%s  status: %s  frame-lag: %d  play-as: %d  unique-id: %s",

   180

			cs->index, ci->client_name, status, lag, ci->client_playas, ci->unique_id);

   181

	}

   182

   183

	return NULL;

   184

}

   185

   186

DEF_CONSOLE_CMD(ConKick)

   187

{

   188

	NetworkClientInfo *ci;

   189

   190

	if (argc == 2) {

   191

		uint32 index = atoi(argv[1]);

   192

		if (index == NETWORK_SERVER_INDEX) {

   193

			IConsolePrint(_iconsole_color_default, "Silly boy, you can not kick yourself!");

   194

			return NULL;

   195

		}

   196

		if (index == 0) {

   197

			IConsoleError("Invalid Client-ID");

   198

			return NULL;

   199

		}

   200

   201

		ci = NetworkFindClientInfoFromIndex(index);

   202

   203

		if (ci != NULL) {

   204

			SEND_COMMAND(PACKET_SERVER_ERROR)(NetworkFindClientStateFromIndex(index), NETWORK_ERROR_KICKED);

   205

			return NULL;

   206

		} else {

   207

			IConsoleError("Client-ID not found");

   208

			return NULL;

   209

		}

   210

	}

   211

   212

	IConsolePrint(_iconsole_color_default, "Unknown usage. Usage: kick <client-id>. For client-ids, see 'clients'.");

   213

   214

	return NULL;

   215

}

   216

   217

DEF_CONSOLE_CMD(ConNetworkClients)

   218

{

   219

	NetworkClientInfo *ci;

   220

	for (ci = _network_client_info; ci != &_network_client_info[MAX_CLIENT_INFO]; ci++) {

   221

		if (ci->client_index != NETWORK_EMPTY_INDEX) {

   222

			IConsolePrintF(8,"Client #%d   name: %s  play-as: %d", ci->client_index, ci->client_name, ci->client_playas);

   223

		}

   224

	}

   225

   226

	return NULL;

   227

}

   228

   229

DEF_CONSOLE_CMD(ConNetworkConnect)

   230

{

   231

	char* ip;

   232

	const byte *port = NULL;

   233

	const byte *player = NULL;

   234

	uint16 rport;

   235

   236

	if (argc<2) return NULL;

   237

   238

	if (_networking) {

   239

		// We are in network-mode, first close it!

   240

		NetworkDisconnect();

   241

	}

   242

   243

	ip = argv[1];

   244

	rport = NETWORK_DEFAULT_PORT;

   245

   246

	ParseConnectionString(&player, &port, ip);

   247

   248

	IConsolePrintF(_iconsole_color_default, "Connecting to %s...", ip);

   249

	if (player != NULL) {

   250

		_network_playas = atoi(player);

   251

		IConsolePrintF(_iconsole_color_default, "    player-no: %s", player);

   252

	}

   253

	if (port != NULL) {

   254

		rport = atoi(port);

   255

		IConsolePrintF(_iconsole_color_default, "    port: %s", port);

   256

	}

   257

   258

	NetworkClientConnectGame(ip, rport);

   259

   260

	return NULL;

   261

}

   262

   263

#endif /* ENABLE_NETWORK */

   264

   265

/* ******************************** */

   266

/*   script file console commands   */

   267

/* ******************************** */

   268

   269

DEF_CONSOLE_CMD(ConExec)

   270

{

   271

	char cmd[1024];

   272

	bool doerror;

   273

   274

	if (argc<2) return NULL;

   275

   276

	doerror = true;

   277

	_script_file = fopen(argv[1], "r");

   278

   279

	if (_script_file == NULL) {

   280

		if (argc>2) if (atoi(argv[2])==0) doerror=false;

   281

		if (doerror) IConsoleError("script file not found");

   282

		return NULL;

   283

		}

   284

   285

	_script_running = true;

   286

   287

	fgets(cmd, sizeof(cmd), _script_file);

   288

	while (!feof(_script_file) && _script_running) {

   289

		strtok(cmd, "\r\n#");

   290

		if (strlen(cmd) > 0 && cmd[0] != '#')

   291

			IConsoleCmdExec(cmd);

   292

		fgets(cmd, sizeof(cmd), _script_file);

   293

	}

   294

   295

	_script_running = false;

   296

	fclose(_script_file);

   297

	return NULL;

   298

}

   299

   300

DEF_CONSOLE_CMD(ConReturn)

   301

{

   302

	_script_running = false;

   303

	return NULL;

   304

}

   305

   306

/* **************************** */

   307

/*   default console commands   */

   308

/* **************************** */

   309

   310

DEF_CONSOLE_CMD(ConScript)

   311

{

   312

	extern FILE* _iconsole_output_file;

   313

	if (_iconsole_output_file != NULL) {

   314

		IConsolePrintF(_iconsole_color_default, "file output complete");

   315

		fclose(_iconsole_output_file);

   316

	} else {

   317

		if (argc < 2) return NULL;

   318

		IConsolePrintF(_iconsole_color_default, "file output started to: %s",

   319

			argv[1]);

   320

		_iconsole_output_file = fopen(argv[1], "ab");

   321

		if (_iconsole_output_file == NULL) IConsoleError("could not open file");

   322

	}

   323

	return NULL;

   324

}

   325

   326

   327

DEF_CONSOLE_CMD(ConEcho)

   328

{

   329

	if (argc < 2) return NULL;

   330

	IConsolePrint(_iconsole_color_default, argv[1]);

   331

	return NULL;

   332

}

   333

   334

DEF_CONSOLE_CMD(ConEchoC)

   335

{

   336

	if (argc < 3) return NULL;

   337

	IConsolePrint(atoi(argv[1]), argv[2]);

   338

	return NULL;

   339

}

   340

   341

extern void SwitchMode(int new_mode);

   342

   343

DEF_CONSOLE_CMD(ConNewGame)

   344

{

   345

	_docommand_recursive = 0;

   346

   347

	_random_seeds[0][0] = Random();

   348

	_random_seeds[0][1] = InteractiveRandom();

   349

   350

	SwitchMode(SM_NEWGAME);

   351

	return NULL;

   352

}

   353

   354

DEF_CONSOLE_CMD(ConPrintF)

   355

{

   356

	if (argc < 3) return NULL;

   357

	IConsolePrintF(_iconsole_color_default, argv[1] , argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18], argv[19]); /* XXX ugh... */

   358

	return NULL;

   359

}

   360

   361

DEF_CONSOLE_CMD(ConPrintFC)

   362

{

   363

	if (argc < 3) return NULL;

   364

	IConsolePrintF(atoi(argv[1]), argv[2] , argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18], argv[19]); /* XXX ugh... */

   365

	return NULL;

   366

}

   367

   368

DEF_CONSOLE_CMD(ConAlias)

   369

{

   370

	if (argc < 3) return NULL;

   371

	IConsoleAliasRegister(argv[1],argv[2]);

   372

	return NULL;

   373

}

   374

   375

DEF_CONSOLE_CMD(ConScreenShot)

   376

{

   377

	if (argc < 2) {

   378

		_make_screenshot = 1;

   379

	} else {

   380

		if (strcmp(argv[1], "big") == 0)

   381

			_make_screenshot=2;

   382

		if (strcmp(argv[1], "no_con") == 0) {

   383

			IConsoleClose();

   384

			_make_screenshot = 1;

   385

		}

   386

	}

   387

	return NULL;

   388

}

   389

   390

DEF_CONSOLE_CMD(ConInfoVar)

   391

{

   392

	if (argc < 2) return NULL;

   393

	if (argt[1] != ICONSOLE_VAR_REFERENCE) {

   394

		IConsoleError("first argument has to be a variable reference");

   395

	} else {

   396

		_iconsole_var* item;

   397

		item = (_iconsole_var*)argv[1];

   398

		IConsolePrintF(_iconsole_color_default, "var_name: %s", item->name);

   399

		IConsolePrintF(_iconsole_color_default, "var_type: %i", item->type);

   400

		IConsolePrintF(_iconsole_color_default, "var_addr: %i", item->data.addr);

   401

		if (item->_malloc)

   402

			IConsolePrintF(_iconsole_color_default, "var_malloc: internal");

   403

		else

   404

			IConsolePrintF(_iconsole_color_default, "var_malloc: external");

   405

		if (item->hook_access) IConsoleWarning("var_access hooked");

   406

		if (item->hook_before_change) IConsoleWarning("var_before_change hooked");

   407

		if (item->hook_after_change) IConsoleWarning("var_after_change hooked");

   408

	}

   409

	return NULL;

   410

}

   411

   412

   413

DEF_CONSOLE_CMD(ConInfoCmd)

   414

{

   415

	if (argc < 2) return NULL;

   416

	if (argt[1] != ICONSOLE_VAR_UNKNOWN) {

   417

		IConsoleError("first argument has to be a command name");

   418

	} else {

   419

		_iconsole_cmd* item;

   420

		item = IConsoleCmdGet(argv[1]);

   421

		if (item == NULL) {

   422

			IConsoleError("the given command was not found");

   423

			return NULL;

   424

		}

   425

		IConsolePrintF(_iconsole_color_default, "cmd_name: %s", item->name);

   426

		IConsolePrintF(_iconsole_color_default, "cmd_addr: %i", item->addr);

   427

		if (item->hook_access) IConsoleWarning("cmd_access hooked");

   428

		if (item->hook_before_exec) IConsoleWarning("cmd_before_exec hooked");

   429

		if (item->hook_after_exec) IConsoleWarning("cmd_after_exec hooked");

   430

	}

   431

	return NULL;

   432

}

   433

   434

DEF_CONSOLE_CMD(ConDebugLevel)

   435

{

   436

	if (argc < 2) return NULL;

   437

	SetDebugString(argv[1]);

   438

	return NULL;

   439

}

   440

   441

DEF_CONSOLE_CMD(ConExit)

   442

{

   443

	_exit_game = true;

   444

	return NULL;

   445

}

   446

   447

DEF_CONSOLE_CMD(ConHelp)

   448

{

   449

	IConsolePrint(13, " -- console help -- ");

   450

	IConsolePrint( 1, " variables: [command to list them: list_vars]");

   451

	IConsolePrint( 1, " temp_string = \"my little \"");

   452

	IConsolePrint( 1, "");

   453

	IConsolePrint( 1, " commands: [command to list them: list_cmds]");

   454

	IConsolePrint( 1, " [command] [\"string argument with spaces\"] [argument 2] ...");

   455

	IConsolePrint( 1, " printf \"%s world\" temp_string");

   456

	IConsolePrint( 1, "");

   457

	IConsolePrint( 1, " command/variable returning a value into an variable:");

   458

	IConsolePrint( 1, " temp_uint16 << random");

   459

	IConsolePrint( 1, " temp_uint16 << temp_uint16_2");

   460

	IConsolePrint( 1, "");

   461

	return NULL;

   462

}

   463

   464

DEF_CONSOLE_CMD(ConRandom)

   465

{

   466

	_iconsole_var* result;

   467

	result = IConsoleVarAlloc(ICONSOLE_VAR_UINT16);

   468

	IConsoleVarSetValue(result, rand());

   469

	return result;

   470

}

   471

   472

DEF_CONSOLE_CMD(ConListCommands)

   473

{

   474

	const _iconsole_cmd* item;

   475

	size_t l = 0;

   476

   477

	if (argv[1] != NULL) l = strlen(argv[1]);

   478

   479

	for (item = _iconsole_cmds; item != NULL; item = item->_next)

   480

		if (argv[1] == NULL || strncmp(item->name, argv[1], l) == 0)

   481

			IConsolePrintF(_iconsole_color_default, "%s", item->name);

   482

   483

	return NULL;

   484

}

   485

   486

DEF_CONSOLE_CMD(ConListVariables)

   487

{