1

/* $Id$ */

     2

     3

/** @file console.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "functions.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "gfx.h"

    12

#include "player.h"

    13

#include "variables.h"

    14

#include "string.h"

    15

#include <stdarg.h>

    16

#include <string.h>

    17

#include "console.h"

    18

#include "helpers.hpp"

    19

#include "network/network.h"

    20

#include "network/network_data.h"

    21

#include "network/network_server.h"

    22

    23

#define ICON_BUFFER 79

    24

#define ICON_HISTORY_SIZE 20

    25

#define ICON_LINE_HEIGHT 12

    26

#define ICON_RIGHT_BORDERWIDTH 10

    27

#define ICON_BOTTOM_BORDERWIDTH 12

    28

#define ICON_MAX_ALIAS_LINES 40

    29

#define ICON_TOKEN_COUNT 20

    30

    31

/* ** main console ** */

    32

static char *_iconsole_buffer[ICON_BUFFER + 1];

    33

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    34

static Textbuf _iconsole_cmdline;

    35

    36

/* ** stdlib ** */

    37

byte _stdlib_developer = 1;

    38

bool _stdlib_con_developer = false;

    39

FILE *_iconsole_output_file;

    40

    41

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

    42

static char *_iconsole_history[ICON_HISTORY_SIZE];

    43

static byte _iconsole_historypos;

    44

    45

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

    46

 *  end of header  *

    47

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

    48

    49

static void IConsoleClearCommand()

    50

{

    51

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    52

	_iconsole_cmdline.length = 0;

    53

	_iconsole_cmdline.width = 0;

    54

	_iconsole_cmdline.caretpos = 0;

    55

	_iconsole_cmdline.caretxoffs = 0;

    56

	BaseWindow::SetDirtyById(WC_CONSOLE, 0);

    57

}

    58

    59

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

    60

    61

    62

static void IConsoleHistoryAdd(const char *cmd);

    63

static void IConsoleHistoryNavigate(int direction);

    64

    65

/* ** console window ** */

    66

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

    67

{

    68

	static byte iconsole_scroll = ICON_BUFFER;

    69

    70

	switch (e->event) {

    71

		case WE_PAINT: {

    72

			int i = iconsole_scroll;

    73

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

    74

			int delta = 0;

    75

			GfxFillRect(w->Left(), w->Top(), w->Width(), w->Height() - 1, 0);

    76

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

    77

				DoDrawString(_iconsole_buffer[i], 5,

    78

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

    79

				i--;

    80

			}

    81

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

    82

			delta = w->Width() - 10 - _iconsole_cmdline.width - ICON_RIGHT_BORDERWIDTH;

    83

			if (delta > 0) {

    84

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

    85

				delta = 0;

    86

			}

    87

    88

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

    89

    90

			if (_iconsole_cmdline.caret)

    91

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

    92

			break;

    93

		}

    94

		case WE_MOUSELOOP:

    95

			if (HandleCaret(&_iconsole_cmdline))

    96

				w->SetDirty();

    97

			break;

    98

		case WE_DESTROY:

    99

			_iconsole_mode = ICONSOLE_CLOSED;

   100

			break;

   101

		case WE_KEYPRESS:

   102

			e->we.keypress.cont = false;

   103

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

   104

				case WKC_UP:

   105

					IConsoleHistoryNavigate(+1);

   106

					w->SetDirty();

   107

					break;

   108

				case WKC_DOWN:

   109

					IConsoleHistoryNavigate(-1);

   110

					w->SetDirty();

   111

					break;

   112

				case WKC_SHIFT | WKC_PAGEUP:

   113

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

   114

						iconsole_scroll = 0;

   115

					} else {

   116

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

   117

					}

   118

					w->SetDirty();

   119

					break;

   120

				case WKC_SHIFT | WKC_PAGEDOWN:

   121

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

   122

						iconsole_scroll = ICON_BUFFER;

   123

					} else {

   124

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

   125

					}

   126

					w->SetDirty();

   127

					break;

   128

				case WKC_SHIFT | WKC_UP:

   129

					if (iconsole_scroll <= 0) {

   130

						iconsole_scroll = 0;

   131

					} else {

   132

						--iconsole_scroll;

   133

					}

   134

					w->SetDirty();

   135

					break;

   136

				case WKC_SHIFT | WKC_DOWN:

   137

					if (iconsole_scroll >= ICON_BUFFER) {

   138

						iconsole_scroll = ICON_BUFFER;

   139

					} else {

   140

						++iconsole_scroll;

   141

					}

   142

					w->SetDirty();

   143

					break;

   144

				case WKC_BACKQUOTE:

   145

					IConsoleSwitch();

   146

					break;

   147

				case WKC_RETURN: case WKC_NUM_ENTER:

   148

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

   149

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   150

   151

					IConsoleCmdExec(_iconsole_cmdline.buf);

   152

					IConsoleClearCommand();

   153

					break;

   154

				case WKC_CTRL | WKC_RETURN:

   155

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

   156

					IConsoleResize(w);

   157

					MarkWholeScreenDirty();

   158

					break;

   159

				case (WKC_CTRL | 'V'):

   160

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   161

						IConsoleResetHistoryPos();

   162

						w->SetDirty();

   163

					}

   164

					break;

   165

				case (WKC_CTRL | 'L'):

   166

					IConsoleCmdExec("clear");

   167

					break;

   168

				case (WKC_CTRL | 'U'):

   169

					DeleteTextBufferAll(&_iconsole_cmdline);

   170

					w->SetDirty();

   171

					break;

   172

				case WKC_BACKSPACE: case WKC_DELETE:

   173

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

   174

						IConsoleResetHistoryPos();

   175

						w->SetDirty();

   176

					}

   177

					break;

   178

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

   179

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

   180

						IConsoleResetHistoryPos();

   181

						w->SetDirty();

   182

					}

   183

					break;

   184

				default:

   185

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

   186

						iconsole_scroll = ICON_BUFFER;

   187

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

   188

						IConsoleResetHistoryPos();

   189

						w->SetDirty();

   190

					} else {

   191

						e->we.keypress.cont = true;

   192

					}

   193

			break;

   194

		}

   195

	}

   196

}

   197

   198

static const OldWidget _iconsole_window_widgets[] = {

   199

	{WIDGETS_END}

   200

};

   201

   202

static const WindowDesc _iconsole_window_desc = {

   203

	0, 0, 2, 2,

   204

	WC_CONSOLE, WC_NONE,

   205

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   206

	_iconsole_window_widgets,

   207

	IConsoleWndProc,

   208

};

   209

   210

void IConsoleInit()

   211

{

   212

	extern const char _openttd_revision[];

   213

	_iconsole_output_file = NULL;

   214

	_icolour_def  =  1;

   215

	_icolour_err  =  3;

   216

	_icolour_warn = 13;

   217

	_icolour_dbg  =  5;

   218

	_icolour_cmd  =  2;

   219

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   220

	_iconsole_mode = ICONSOLE_CLOSED;

   221

   222

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   223

	_redirect_console_to_client = 0;

   224

#endif

   225

   226

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

   227

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

   228

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

   229

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

   230

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE;

   231

   232

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

   233

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

   234

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

   235

	IConsolePrint(12,  "");

   236

	IConsoleStdLibRegister();

   237

	IConsoleClearCommand();

   238

	IConsoleHistoryAdd("");

   239

}

   240

   241

void IConsoleClearBuffer()

   242

{

   243

	uint i;

   244

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

   245

		free(_iconsole_buffer[i]);

   246

		_iconsole_buffer[i] = NULL;

   247

	}

   248

}

   249

   250

static void IConsoleClear()

   251

{

   252

	free(_iconsole_cmdline.buf);

   253

	IConsoleClearBuffer();

   254

}

   255

   256

static void IConsoleWriteToLogFile(const char *string)

   257

{

   258

	if (_iconsole_output_file != NULL) {

   259

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

   260

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

   261

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

   262

	}

   263

}

   264

   265

bool CloseConsoleLogIfActive()

   266

{

   267

	if (_iconsole_output_file != NULL) {

   268

		IConsolePrintF(_icolour_def, "file output complete");

   269

		fclose(_iconsole_output_file);

   270

		_iconsole_output_file = NULL;

   271

		return true;

   272

	}

   273

   274

	return false;

   275

}

   276

   277

void IConsoleFree()

   278

{

   279

	IConsoleClear();

   280

	CloseConsoleLogIfActive();

   281

}

   282

   283

void IConsoleResize(BaseWindow *w)

   284

{

   285

	switch (_iconsole_mode) {

   286

		case ICONSOLE_OPENED:

   287

			w->SetSize(Point(_screen.width, _screen.height / 3));

   288

			break;

   289

		case ICONSOLE_FULL:

   290

			w->SetSize(Point(_screen.width, _screen.height - ICON_BOTTOM_BORDERWIDTH));

   291

			break;

   292

		default: return;

   293

	}

   294

   295

	MarkWholeScreenDirty();

   296

}

   297

   298

void IConsoleSwitch()

   299

{

   300

	switch (_iconsole_mode) {

   301

		case ICONSOLE_CLOSED: {

   302

			BaseWindow *w = BaseWindow::Allocate(&_iconsole_window_desc);

   303

			w->SetSize(Point(_screen.width, _screen.height / 3));

   304

			_iconsole_mode = ICONSOLE_OPENED;

   305

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

   306

		} break;

   307

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   308

			DeleteWindowById(WC_CONSOLE, 0);

   309

			_iconsole_mode = ICONSOLE_CLOSED;

   310

			CLRBIT(_no_scroll, SCROLL_CON);

   311

			break;

   312

	}

   313

   314

	MarkWholeScreenDirty();

   315

}

   316

   317

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

   318

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

   319

   320

/**

   321

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

   322

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

   323

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

   324

 */

   325

static void IConsoleHistoryAdd(const char *cmd)

   326

{

   327

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   328

   329

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

   330

	_iconsole_history[0] = strdup(cmd);

   331

	IConsoleResetHistoryPos();

   332

}

   333

   334

/**

   335

 * Navigate Up/Down in the history of typed commands

   336

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

   337

 */

   338

static void IConsoleHistoryNavigate(int direction)

   339

{

   340

	int i = _iconsole_historypos + direction;

   341

   342

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

   343

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

   344

	if (i >= ICON_HISTORY_SIZE) i = 0;

   345

   346

	if (direction > 0)

   347

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

   348

   349

	if (direction < 0) {

   350

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

   351

	}

   352

   353

	_iconsole_historypos = i;

   354

	IConsoleClearCommand();

   355

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

   356

	assert(_iconsole_history[i] != NULL && IS_INT_INSIDE(i, 0, ICON_HISTORY_SIZE));

   357

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

   358

	UpdateTextBufferSize(&_iconsole_cmdline);

   359

}

   360

   361

/**

   362

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

   363

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

   364

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

   365

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

   366

 * used as a history to print them onscreen

   367

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

   368

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

   369

 */

   370

void IConsolePrint(uint16 color_code, const char *string)

   371

{

   372

	char *str;

   373

#ifdef ENABLE_NETWORK

   374

	if (_redirect_console_to_client != 0) {

   375

		/* Redirect the string to the client */

   376

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

   377

		return;

   378

	}

   379

#endif

   380

   381

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

   382

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

   383

	str = strdup(string);

   384

	str_strip_colours(str);

   385

	str_validate(str);

   386

   387

	if (_network_dedicated) {

   388

		printf("%s\n", str);

   389

		IConsoleWriteToLogFile(str);

   390

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

   391

		return;

   392

	}

   393

   394

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

   395

	 * to accomodate for the new command/message */

   396

	free(_iconsole_buffer[0]);

   397

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

   398

	_iconsole_buffer[ICON_BUFFER] = str;

   399

   400

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

   401

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   402

   403

	IConsoleWriteToLogFile(_iconsole_buffer[ICON_BUFFER]);

   404

   405

	BaseWindow::SetDirtyById(WC_CONSOLE, 0);

   406

}

   407

   408

/**

   409

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

   410

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

   411

 * at IConsolePrint()

   412

 */

   413

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

   414

{

   415

	va_list va;

   416

	char buf[ICON_MAX_STREAMSIZE];

   417

   418

	va_start(va, s);

   419

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

   420

	va_end(va);

   421

   422

	IConsolePrint(color_code, buf);

   423

}

   424

   425

/**

   426

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

   427

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

   428

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

   429

 * messages to show up

   430

 * @param dbg debugging category

   431

 * @param string debugging message

   432

 */

   433

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

   434

{

   435

	if (_stdlib_developer > 1)

   436

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

   437

}

   438

   439

/**

   440

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

   441

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

   442

 * debugging messages to show up

   443

 */

   444

void IConsoleWarning(const char *string)

   445

{

   446

	if (_stdlib_developer > 0)

   447

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

   448

}

   449

   450

/**

   451

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

   452

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

   453

 */

   454

void IConsoleError(const char *string)

   455

{

   456

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

   457

}

   458

   459

/**

   460

 * Change a string into its number representation. Supports

   461

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

   462

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

   463

 * @param *arg the string to be converted

   464

 * @return Return true on success or false on failure

   465

 */

   466

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

   467

{

   468

	char *endptr;

   469

   470

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

   471

		*value = 1;

   472

		return true;

   473

	}

   474

	if (strcmp(arg, "off") == 0 || strcmp(arg, "false") == 0) {

   475

		*value = 0;

   476

		return true;

   477

	}

   478