1

/* $Id$ */

     2

     3

/** @file console.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "gui.h"

    11

#include "player.h"

    12

#include "variables.h"

    13

#include <stdarg.h>

    14

#include <string.h>

    15

#include "console.h"

    16

#include "network/network.h"

    17

#include "network/network_data.h"

    18

#include "network/network_server.h"

    23

    24

#define ICON_BUFFER 79

    25

#define ICON_HISTORY_SIZE 20

    26

#define ICON_LINE_HEIGHT 12

    27

#define ICON_RIGHT_BORDERWIDTH 10

    28

#define ICON_BOTTOM_BORDERWIDTH 12

    29

#define ICON_MAX_ALIAS_LINES 40

    30

#define ICON_TOKEN_COUNT 20

    31

    32

/* ** main console ** */

    33

static char *_iconsole_buffer[ICON_BUFFER + 1];

    34

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    35

static Textbuf _iconsole_cmdline;

    36

    37

/* ** stdlib ** */

    38

byte _stdlib_developer = 1;

    39

bool _stdlib_con_developer = false;

    40

FILE *_iconsole_output_file;

    41

    42

/* ** main console cmd buffer ** */

    43

static char *_iconsole_history[ICON_HISTORY_SIZE];

    44

static byte _iconsole_historypos;

    45

    46

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

    47

 *  end of header  *

    48

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

    49

    50

static void IConsoleClearCommand()

    51

{

    52

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    53

	_iconsole_cmdline.length = 0;

    54

	_iconsole_cmdline.width = 0;

    55

	_iconsole_cmdline.caretpos = 0;

    56

	_iconsole_cmdline.caretxoffs = 0;

    57

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

    58

}

    59

    60

static inline void IConsoleResetHistoryPos() {_iconsole_historypos = ICON_HISTORY_SIZE - 1;}

    61

    62

    63

static void IConsoleHistoryAdd(const char *cmd);

    64

static void IConsoleHistoryNavigate(int direction);

    65

    66

/* ** console window ** */

    67

static void IConsoleWndProc(Window *w, WindowEvent *e)

    68

{

    69

	static byte iconsole_scroll = ICON_BUFFER;

    70

    71

	switch (e->event) {

    72

		case WE_PAINT: {

    73

			int i = iconsole_scroll;

    74

			int max = (w->height / ICON_LINE_HEIGHT) - 1;

    75

			int delta = 0;

    76

			GfxFillRect(w->left, w->top, w->width, w->height - 1, 0);

    77

			while ((i > 0) && (i > iconsole_scroll - max) && (_iconsole_buffer[i] != NULL)) {

    78

				DoDrawString(_iconsole_buffer[i], 5,

    79

					w->height - (iconsole_scroll + 2 - i) * ICON_LINE_HEIGHT, _iconsole_cbuffer[i]);

    80

				i--;

    81

			}

    82

			/* If the text is longer than the window, don't show the starting ']' */

    83

			delta = w->width - 10 - _iconsole_cmdline.width - ICON_RIGHT_BORDERWIDTH;

    84

			if (delta > 0) {

    85

				DoDrawString("]", 5, w->height - ICON_LINE_HEIGHT, _icolour_cmd);

    86

				delta = 0;

    87

			}

    88

    89

			DoDrawString(_iconsole_cmdline.buf, 10 + delta, w->height - ICON_LINE_HEIGHT, _icolour_cmd);

    90

    91

			if (_iconsole_cmdline.caret)

    92

				DoDrawString("_", 10 + delta + _iconsole_cmdline.caretxoffs, w->height - ICON_LINE_HEIGHT, TC_WHITE);

    93

			break;

    94

		}

    95

		case WE_MOUSELOOP:

    96

			if (HandleCaret(&_iconsole_cmdline))

    97

				SetWindowDirty(w);

    98

			break;

    99

		case WE_DESTROY:

   100

			_iconsole_mode = ICONSOLE_CLOSED;

   101

			break;

   102

		case WE_KEYPRESS:

   103

			e->we.keypress.cont = false;

   104

			switch (e->we.keypress.keycode) {

   105

				case WKC_UP:

   106

					IConsoleHistoryNavigate(+1);

   107

					SetWindowDirty(w);

   108

					break;

   109

				case WKC_DOWN:

   110

					IConsoleHistoryNavigate(-1);

   111

					SetWindowDirty(w);

   112

					break;

   113

				case WKC_SHIFT | WKC_PAGEUP:

   114

					if (iconsole_scroll - (w->height / ICON_LINE_HEIGHT) - 1 < 0) {

   115

						iconsole_scroll = 0;

   116

					} else {

   117

						iconsole_scroll -= (w->height / ICON_LINE_HEIGHT) - 1;

   118

					}

   119

					SetWindowDirty(w);

   120

					break;

   121

				case WKC_SHIFT | WKC_PAGEDOWN:

   122

					if (iconsole_scroll + (w->height / ICON_LINE_HEIGHT) - 1 > ICON_BUFFER) {

   123

						iconsole_scroll = ICON_BUFFER;

   124

					} else {

   125

						iconsole_scroll += (w->height / ICON_LINE_HEIGHT) - 1;

   126

					}

   127

					SetWindowDirty(w);

   128

					break;

   129

				case WKC_SHIFT | WKC_UP:

   130

					if (iconsole_scroll <= 0) {

   131

						iconsole_scroll = 0;

   132

					} else {

   133

						--iconsole_scroll;

   134

					}

   135

					SetWindowDirty(w);

   136

					break;

   137

				case WKC_SHIFT | WKC_DOWN:

   138

					if (iconsole_scroll >= ICON_BUFFER) {

   139

						iconsole_scroll = ICON_BUFFER;

   140

					} else {

   141

						++iconsole_scroll;

   142

					}

   143

					SetWindowDirty(w);

   144

					break;

   145

				case WKC_BACKQUOTE:

   146

					IConsoleSwitch();

   147

					break;

   148

				case WKC_RETURN: case WKC_NUM_ENTER:

   149

					IConsolePrintF(_icolour_cmd, "] %s", _iconsole_cmdline.buf);

   150

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   151

   152

					IConsoleCmdExec(_iconsole_cmdline.buf);

   153

					IConsoleClearCommand();

   154

					break;

   155

				case WKC_CTRL | WKC_RETURN:

   156

					_iconsole_mode = (_iconsole_mode == ICONSOLE_FULL) ? ICONSOLE_OPENED : ICONSOLE_FULL;

   157

					IConsoleResize(w);

   158

					MarkWholeScreenDirty();

   159

					break;

   160

				case (WKC_CTRL | 'V'):

   161

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   162

						IConsoleResetHistoryPos();

   163

						SetWindowDirty(w);

   164

					}

   165

					break;

   166

				case (WKC_CTRL | 'L'):

   167

					IConsoleCmdExec("clear");

   168

					break;

   169

				case (WKC_CTRL | 'U'):

   170

					DeleteTextBufferAll(&_iconsole_cmdline);

   171

					SetWindowDirty(w);

   172

					break;

   173

				case WKC_BACKSPACE: case WKC_DELETE:

   174

					if (DeleteTextBufferChar(&_iconsole_cmdline, e->we.keypress.keycode)) {

   175

						IConsoleResetHistoryPos();

   176

						SetWindowDirty(w);

   177

					}

   178

					break;

   179

				case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME:

   180

					if (MoveTextBufferPos(&_iconsole_cmdline, e->we.keypress.keycode)) {

   181

						IConsoleResetHistoryPos();

   182

						SetWindowDirty(w);

   183

					}

   184

					break;

   185

				default:

   186

					if (IsValidChar(e->we.keypress.key, CS_ALPHANUMERAL)) {

   187

						iconsole_scroll = ICON_BUFFER;

   188

						InsertTextBufferChar(&_iconsole_cmdline, e->we.keypress.key);

   189

						IConsoleResetHistoryPos();

   190

						SetWindowDirty(w);

   191

					} else {

   192

						e->we.keypress.cont = true;

   193

					}

   194

			break;

   195

		}

   196

	}

   197

}

   198

   199

static const Widget _iconsole_window_widgets[] = {

   200

	{WIDGETS_END}

   201

};

   202

   203

static const WindowDesc _iconsole_window_desc = {

   204

	0, 0, 2, 2, 2, 2,

   205

	WC_CONSOLE, WC_NONE,

   206

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   207

	_iconsole_window_widgets,

   208

	IConsoleWndProc,

   209

};

   210

   211

void IConsoleInit()

   212

{

   213

	extern const char _openttd_revision[];

   214

	_iconsole_output_file = NULL;

   215

	_icolour_def  =  1;

   216

	_icolour_err  =  3;

   217

	_icolour_warn = 13;

   218

	_icolour_dbg  =  5;

   219

	_icolour_cmd  = TC_GOLD;

   220

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   221

	_iconsole_mode = ICONSOLE_CLOSED;

   222

   223

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   224

	_redirect_console_to_client = 0;

   225

#endif

   226

   227

	memset(_iconsole_history, 0, sizeof(_iconsole_history));

   228

	memset(_iconsole_buffer, 0, sizeof(_iconsole_buffer));

   229

	memset(_iconsole_cbuffer, 0, sizeof(_iconsole_cbuffer));

   230

	_iconsole_cmdline.buf = CallocT<char>(ICON_CMDLN_SIZE); // create buffer and zero it

   231

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE;

   232

   233

	IConsolePrintF(13, "OpenTTD Game Console Revision 7 - %s", _openttd_revision);

   234

	IConsolePrint(12,  "------------------------------------");

   235

	IConsolePrint(12,  "use \"help\" for more information");

   236

	IConsolePrint(12,  "");

   237

	IConsoleStdLibRegister();

   238

	IConsoleClearCommand();

   239

	IConsoleHistoryAdd("");

   240

}

   241

   242

void IConsoleClearBuffer()

   243

{

   244

	uint i;

   245

	for (i = 0; i <= ICON_BUFFER; i++) {

   246

		free(_iconsole_buffer[i]);

   247

		_iconsole_buffer[i] = NULL;

   248

	}

   249

}

   250

   251

static void IConsoleClear()

   252

{

   253

	free(_iconsole_cmdline.buf);

   254

	IConsoleClearBuffer();

   255

}

   256

   257

static void IConsoleWriteToLogFile(const char *string)

   258

{

   259

	if (_iconsole_output_file != NULL) {

   260

		/* if there is an console output file ... also print it there */

   261

		fwrite(string, strlen(string), 1, _iconsole_output_file);

   262

		fwrite("\n", 1, 1, _iconsole_output_file);

   263

	}

   264

}

   265

   266

bool CloseConsoleLogIfActive()

   267

{

   268

	if (_iconsole_output_file != NULL) {

   269

		IConsolePrintF(_icolour_def, "file output complete");

   270

		fclose(_iconsole_output_file);

   271

		_iconsole_output_file = NULL;

   272

		return true;

   273

	}

   274

   275

	return false;

   276

}

   277

   278

void IConsoleFree()

   279

{

   280

	IConsoleClear();

   281

	CloseConsoleLogIfActive();

   282

}

   283

   284

void IConsoleResize(Window *w)

   285

{

   286

	switch (_iconsole_mode) {

   287

		case ICONSOLE_OPENED:

   288

			w->height = _screen.height / 3;

   289

			w->width = _screen.width;

   290

			break;

   291

		case ICONSOLE_FULL:

   292

			w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   293

			w->width = _screen.width;

   294

			break;

   295

		default: return;

   296

	}

   297

   298

	MarkWholeScreenDirty();

   299

}

   300

   301

void IConsoleSwitch()

   302

{

   303

	switch (_iconsole_mode) {

   304

		case ICONSOLE_CLOSED: {

   305

			Window *w = AllocateWindowDesc(&_iconsole_window_desc);

   306

			w->height = _screen.height / 3;

   307

			w->width = _screen.width;

   308

			_iconsole_mode = ICONSOLE_OPENED;

   309

			SetBit(_no_scroll, SCROLL_CON); // override cursor arrows; the gamefield will not scroll

   310

		} break;

   311

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   312

			DeleteWindowById(WC_CONSOLE, 0);

   313

			_iconsole_mode = ICONSOLE_CLOSED;

   314

			ClrBit(_no_scroll, SCROLL_CON);

   315

			break;

   316

	}

   317

   318

	MarkWholeScreenDirty();

   319

}

   320

   321

void IConsoleClose() {if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();}

   322

void IConsoleOpen()  {if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();}

   323

   324

/**

   325

 * Add the entered line into the history so you can look it back

   326

 * scroll, etc. Put it to the beginning as it is the latest text

   327

 * @param cmd Text to be entered into the 'history'

   328

 */

   329

static void IConsoleHistoryAdd(const char *cmd)

   330

{

   331

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   332

   333

	memmove(&_iconsole_history[1], &_iconsole_history[0], sizeof(_iconsole_history[0]) * (ICON_HISTORY_SIZE - 1));

   334

	_iconsole_history[0] = strdup(cmd);

   335

	IConsoleResetHistoryPos();

   336

}

   337

   338

/**

   339

 * Navigate Up/Down in the history of typed commands

   340

 * @param direction Go further back in history (+1), go to recently typed commands (-1)

   341

 */

   342

static void IConsoleHistoryNavigate(int direction)

   343

{

   344

	int i = _iconsole_historypos + direction;

   345

   346

	/* watch out for overflows, just wrap around */

   347

	if (i < 0) i = ICON_HISTORY_SIZE - 1;

   348

	if (i >= ICON_HISTORY_SIZE) i = 0;

   349

   350

	if (direction > 0)

   351

		if (_iconsole_history[i] == NULL) i = 0;

   352

   353

	if (direction < 0) {

   354

		while (i > 0 && _iconsole_history[i] == NULL) i--;

   355

	}

   356

   357

	_iconsole_historypos = i;

   358

	IConsoleClearCommand();

   359

	/* copy history to 'command prompt / bash' */

   361

	ttd_strlcpy(_iconsole_cmdline.buf, _iconsole_history[i], _iconsole_cmdline.maxlength);

   362

	UpdateTextBufferSize(&_iconsole_cmdline);

   363

}

   364

   365

/**

   366

 * Handle the printing of text entered into the console or redirected there

   367

 * by any other means. Text can be redirected to other players in a network game

   368

 * as well as to a logfile. If the network server is a dedicated server, all activities

   369

 * are also logged. All lines to print are added to a temporary buffer which can be

   370

 * used as a history to print them onscreen

   371

 * @param color_code the colour of the command. Red in case of errors, etc.

   372

 * @param string the message entered or output on the console (notice, error, etc.)

   373

 */

   374

void IConsolePrint(uint16 color_code, const char *string)

   375

{

   376

	char *str;

   377

#ifdef ENABLE_NETWORK

   378

	if (_redirect_console_to_client != 0) {

   379

		/* Redirect the string to the client */

   380

		SEND_COMMAND(PACKET_SERVER_RCON)(NetworkFindClientStateFromIndex(_redirect_console_to_client), color_code, string);

   381

		return;

   382

	}

   383

#endif

   384

   385

	/* Create a copy of the string, strip if of colours and invalid

   386

	 * characters and (when applicable) assign it to the console buffer */

   387

	str = strdup(string);

   388

	str_strip_colours(str);

   389

	str_validate(str);

   390

   391

	if (_network_dedicated) {

   392

		fprintf(stdout, "%s\n", str);

   393

		fflush(stdout);

   394

		IConsoleWriteToLogFile(str);

   395

		free(str); // free duplicated string since it's not used anymore

   396

		return;

   397

	}

   398

   399

	/* move up all the strings in the buffer one place and do the same for colour

   400

	 * to accomodate for the new command/message */

   401

	free(_iconsole_buffer[0]);

   402

	memmove(&_iconsole_buffer[0], &_iconsole_buffer[1], sizeof(_iconsole_buffer[0]) * ICON_BUFFER);

   403

	_iconsole_buffer[ICON_BUFFER] = str;

   404

   405

	memmove(&_iconsole_cbuffer[0], &_iconsole_cbuffer[1], sizeof(_iconsole_cbuffer[0]) * ICON_BUFFER);

   406

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   407

   408

	IConsoleWriteToLogFile(_iconsole_buffer[ICON_BUFFER]);

   409

   410

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   411

}

   412

   413

/**

   414

 * Handle the printing of text entered into the console or redirected there

   415

 * by any other means. Uses printf() style format, for more information look

   416

 * at IConsolePrint()

   417

 */

   418

void CDECL IConsolePrintF(uint16 color_code, const char *s, ...)

   419

{

   420

	va_list va;

   421

	char buf[ICON_MAX_STREAMSIZE];

   422

   423

	va_start(va, s);

   424

	vsnprintf(buf, sizeof(buf), s, va);

   425

	va_end(va);

   426

   427

	IConsolePrint(color_code, buf);

   428

}

   429

   430

/**

   431

 * It is possible to print debugging information to the console,

   432

 * which is achieved by using this function. Can only be used by

   433

 * debug() in debug.cpp. You need at least a level 2 (developer) for debugging

   434

 * messages to show up

   435

 * @param dbg debugging category

   436

 * @param string debugging message

   437

 */

   438

void IConsoleDebug(const char *dbg, const char *string)

   439

{

   440

	if (_stdlib_developer > 1)

   441

		IConsolePrintF(_icolour_dbg, "dbg: [%s] %s", dbg, string);

   442

}

   443

   444

/**

   445

 * It is possible to print warnings to the console. These are mostly

   446

 * errors or mishaps, but non-fatal. You need at least a level 1 (developer) for

   447

 * debugging messages to show up

   448

 */

   449

void IConsoleWarning(const char *string)

   450

{

   451

	if (_stdlib_developer > 0)

   452

		IConsolePrintF(_icolour_warn, "WARNING: %s", string);

   453

}

   454

   455

/**

   456

 * It is possible to print error information to the console. This can include

   457

 * game errors, or errors in general you would want the user to notice

   458

 */

   459

void IConsoleError(const char *string)

   460

{

   461

	IConsolePrintF(_icolour_err, "ERROR: %s", string);

   462

}

   463

   464

/**

   465

 * Change a string into its number representation. Supports

   466

 * decimal and hexadecimal numbers as well as 'on'/'off' 'true'/'false'

   467

 * @param *value the variable a successful conversion will be put in

   468

 * @param *arg the string to be converted

   469

 * @return Return true on success or false on failure

   470

 */

   471

bool GetArgumentInteger(uint32 *value, const char *arg)

   472

{

   473

	char *endptr;

   474

   475

	if (strcmp(arg, "on") == 0 || strcmp(arg, "true") == 0) {

   476

		*value = 1;

   477

		return true;

   478

	}