1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "table/strings.h"

     6

#include "functions.h"

     7

#include "window.h"

     8

#include "gui.h"

     9

#include "gfx.h"

    10

#include "player.h"

    11

#include "variables.h"

    12

#include "string.h"

    13

#include <stdarg.h>

    14

#include <string.h>

    15

#include "console.h"

    16

#include "helpers.hpp"

    17

#include "network/network.h"

    18

#include "network/network_data.h"

    19

#include "network/network_server.h"

    20

    21

#define ICON_BUFFER 79

    22

#define ICON_HISTORY_SIZE 20

    23

#define ICON_LINE_HEIGHT 12

    24

#define ICON_RIGHT_BORDERWIDTH 10

    25

#define ICON_BOTTOM_BORDERWIDTH 12

    26

#define ICON_MAX_ALIAS_LINES 40

    27

#define ICON_TOKEN_COUNT 20

    28

    29

// ** main console ** //

    30

static char *_iconsole_buffer[ICON_BUFFER + 1];

    31

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    32

static Textbuf _iconsole_cmdline;

    33

    34

// ** stdlib ** //

    35

byte _stdlib_developer = 1;

    36

bool _stdlib_con_developer = false;

    37

FILE *_iconsole_output_file;

    38

    39

// ** main console cmd buffer

    40

static char *_iconsole_history[ICON_HISTORY_SIZE];

    41

static byte _iconsole_historypos;

    42

    43

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

    44

/*  end of header  */

    45

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

    46

    47

static void IConsoleClearCommand(void)

    48

{

    49

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    50

	_iconsole_cmdline.length = 0;

    51

	_iconsole_cmdline.width = 0;

    52

	_iconsole_cmdline.caretpos = 0;

    53

	_iconsole_cmdline.caretxoffs = 0;

    54

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

    55

}

    56

    57

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

    58

    59

    60

static void IConsoleHistoryAdd(const char *cmd);

    61

static void IConsoleHistoryNavigate(int direction);

    62

    63

// ** console window ** //

    64

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

    65

{

    66

	static byte iconsole_scroll = ICON_BUFFER;

    67

    68

	switch (e->event) {

    69

		case WE_PAINT: {

    70

			int i = iconsole_scroll;

    71

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

    72

			int delta = 0;

    73

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

    74

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

    75

				DoDrawString(_iconsole_buffer[i], 5,

    76

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

    77

				i--;

    78

			}

    79

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

    80

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

    81

			if (delta > 0) {

    82

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

    83

				delta = 0;

    84

			}

    85

    86

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

    87

    88

			if (_iconsole_cmdline.caret)

    89

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

    90

			break;

    91

		}

    92

		case WE_MOUSELOOP:

    93

			if (HandleCaret(&_iconsole_cmdline))

    94

				SetWindowDirty(w);

    95

			break;

    96

		case WE_DESTROY:

    97

			_iconsole_mode = ICONSOLE_CLOSED;

    98

			break;

    99

		case WE_KEYPRESS:

   100

			e->we.keypress.cont = false;

   101

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

   102

				case WKC_UP:

   103

					IConsoleHistoryNavigate(+1);

   104

					SetWindowDirty(w);

   105

					break;

   106

				case WKC_DOWN:

   107

					IConsoleHistoryNavigate(-1);

   108

					SetWindowDirty(w);

   109

					break;

   110

				case WKC_SHIFT | WKC_PAGEUP:

   111

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

   112

						iconsole_scroll = 0;

   113

					} else {

   114

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

   115

					}

   116

					SetWindowDirty(w);

   117

					break;

   118

				case WKC_SHIFT | WKC_PAGEDOWN:

   119

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

   120

						iconsole_scroll = ICON_BUFFER;

   121

					} else {

   122

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

   123

					}

   124

					SetWindowDirty(w);

   125

					break;

   126

				case WKC_SHIFT | WKC_UP:

   127

					if (iconsole_scroll <= 0) {

   128

						iconsole_scroll = 0;

   129

					} else {

   130

						--iconsole_scroll;

   131

					}

   132

					SetWindowDirty(w);

   133

					break;

   134

				case WKC_SHIFT | WKC_DOWN:

   135

					if (iconsole_scroll >= ICON_BUFFER) {

   136

						iconsole_scroll = ICON_BUFFER;

   137

					} else {

   138

						++iconsole_scroll;

   139

					}

   140

					SetWindowDirty(w);

   141

					break;

   142

				case WKC_BACKQUOTE:

   143

					IConsoleSwitch();

   144

					break;

   145

				case WKC_RETURN: case WKC_NUM_ENTER:

   146

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

   147

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   148

   149

					IConsoleCmdExec(_iconsole_cmdline.buf);

   150

					IConsoleClearCommand();

   151

					break;

   152

				case WKC_CTRL | WKC_RETURN:

   153

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

   154

					IConsoleResize(w);

   155

					MarkWholeScreenDirty();

   156

					break;

   157

				case (WKC_CTRL | 'V'):

   158

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   159

						IConsoleResetHistoryPos();

   160

						SetWindowDirty(w);

   161

					}

   162

					break;

   163

				case (WKC_CTRL | 'L'):

   164

					IConsoleCmdExec("clear");

   165

					break;

   166

				case (WKC_CTRL | 'U'):

   167

					DeleteTextBufferAll(&_iconsole_cmdline);

   168

					SetWindowDirty(w);

   169

					break;

   170

				case WKC_BACKSPACE: case WKC_DELETE:

   171

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

   172

						IConsoleResetHistoryPos();

   173

						SetWindowDirty(w);

   174

					}

   175

					break;

   176

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

   177

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

   178

						IConsoleResetHistoryPos();

   179

						SetWindowDirty(w);

   180

					}

   181

					break;

   182

				default:

   183

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

   184

						iconsole_scroll = ICON_BUFFER;

   185

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

   186

						IConsoleResetHistoryPos();

   187

						SetWindowDirty(w);

   188

					} else {

   189

						e->we.keypress.cont = true;

   190

					}

   191

			break;

   192

		}

   193

	}

   194

}

   195

   196

static const Widget _iconsole_window_widgets[] = {

   197

	{WIDGETS_END}

   198

};

   199

   200

static const WindowDesc _iconsole_window_desc = {

   201

	0, 0, 2, 2,

   202

	WC_CONSOLE, 0,

   203

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   204

	_iconsole_window_widgets,

   205

	IConsoleWndProc,

   206

};

   207

   208

void IConsoleInit(void)

   209

{

   210

	extern const char _openttd_revision[];

   211

	_iconsole_output_file = NULL;

   212

	_icolour_def  =  1;

   213

	_icolour_err  =  3;

   214

	_icolour_warn = 13;

   215

	_icolour_dbg  =  5;

   216

	_icolour_cmd  =  2;

   217

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   218

	_iconsole_mode = ICONSOLE_CLOSED;

   219

   220

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   221

	_redirect_console_to_client = 0;

   222

#endif

   223

   224

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

   225

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

   226

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

   227

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

   228

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE;

   229

   230

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

   231

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

   232

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

   233

	IConsolePrint(12,  "");

   234

	IConsoleStdLibRegister();

   235

	IConsoleClearCommand();

   236

	IConsoleHistoryAdd("");

   237

}

   238

   239

void IConsoleClearBuffer(void)

   240

{

   241

	uint i;

   242

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

   243

		free(_iconsole_buffer[i]);

   244

		_iconsole_buffer[i] = NULL;

   245

	}

   246

}

   247

   248

static void IConsoleClear(void)

   249

{

   250

	free(_iconsole_cmdline.buf);

   251

	IConsoleClearBuffer();

   252

}

   253

   254

static void IConsoleWriteToLogFile(const char *string)

   255

{

   256

	if (_iconsole_output_file != NULL) {

   257

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

   258

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

   259

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

   260

	}

   261

}

   262

   263

bool CloseConsoleLogIfActive(void)

   264

{

   265

	if (_iconsole_output_file != NULL) {

   266

		IConsolePrintF(_icolour_def, "file output complete");

   267

		fclose(_iconsole_output_file);

   268

		_iconsole_output_file = NULL;

   269

		return true;

   270

	}

   271

   272

	return false;

   273

}

   274

   275

void IConsoleFree(void)

   276

{

   277

	IConsoleClear();

   278

	CloseConsoleLogIfActive();

   279

}

   280

   281

void IConsoleResize(Window *w)

   282

{

   283

	switch (_iconsole_mode) {

   284

		case ICONSOLE_OPENED:

   285

			w->height = _screen.height / 3;

   286

			w->width = _screen.width;

   287

			break;

   288

		case ICONSOLE_FULL:

   289

			w->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   290

			w->width = _screen.width;

   291

			break;

   292

		default: return;

   293

	}

   294

   295

	MarkWholeScreenDirty();

   296

}

   297

   298

void IConsoleSwitch(void)

   299

{

   300

	switch (_iconsole_mode) {

   301

		case ICONSOLE_CLOSED: {

   302

			Window *w = AllocateWindowDesc(&_iconsole_window_desc);

   303

			w->height = _screen.height / 3;

   304

			w->width = _screen.width;

   305

			_iconsole_mode = ICONSOLE_OPENED;

   306

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

   307

		} break;

   308

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   309

			DeleteWindowById(WC_CONSOLE, 0);

   310

			_iconsole_mode = ICONSOLE_CLOSED;

   311

			CLRBIT(_no_scroll, SCROLL_CON);

   312

			break;

   313

	}

   314

   315

	MarkWholeScreenDirty();

   316

}

   317

   318

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

   319

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

   320

   321

/**

   322

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

   323

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

   324

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

   325

 */

   326

static void IConsoleHistoryAdd(const char *cmd)

   327

{

   328

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   329

   330

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

   331

	_iconsole_history[0] = strdup(cmd);

   332

	IConsoleResetHistoryPos();

   333

}

   334

   335

/**

   336

 * Navigate Up/Down in the history of typed commands

   337

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

   338

 */

   339

static void IConsoleHistoryNavigate(int direction)

   340

{

   341

	int i = _iconsole_historypos + direction;

   342

   343

	// watch out for overflows, just wrap around

   344

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

   345

	if (i >= ICON_HISTORY_SIZE) i = 0;

   346

   347

	if (direction > 0)

   348

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

   349

   350

	if (direction < 0) {

   351

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

   352

	}

   353

   354

	_iconsole_historypos = i;

   355

	IConsoleClearCommand();

   356

	// copy history to 'command prompt / bash'

   357

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

   358

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

   359

	UpdateTextBufferSize(&_iconsole_cmdline);

   360

}

   361

   362

/**

   363

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

   364

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

   365

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

   366

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

   367

 * used as a history to print them onscreen

   368

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

   369

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

   370

 */

   371

void IConsolePrint(uint16 color_code, const char *string)

   372

{

   373

	char *str;

   374

#ifdef ENABLE_NETWORK

   375

	if (_redirect_console_to_client != 0) {

   376

		/* Redirect the string to the client */

   377

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

   378

		return;

   379

	}

   380

#endif

   381

   382

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

   383

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

   384

	str = strdup(string);

   385

	str_strip_colours(str);

   386

	str_validate(str);

   387

   388

	if (_network_dedicated) {

   389

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

   390

		IConsoleWriteToLogFile(str);

   391

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

   392

		return;

   393

	}

   394

   395

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

   396

	 * to accomodate for the new command/message */

   397

	free(_iconsole_buffer[0]);

   398

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

   399

	_iconsole_buffer[ICON_BUFFER] = str;

   400

   401

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

   402

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   403

   404

	IConsoleWriteToLogFile(_iconsole_buffer[ICON_BUFFER]);

   405

   406

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

   407

}

   408

   409

/**

   410

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

   411

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

   412

 * at @IConsolePrint()

   413

 */

   414

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

   415

{

   416

	va_list va;

   417

	char buf[ICON_MAX_STREAMSIZE];

   418

   419

	va_start(va, s);

   420

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

   421

	va_end(va);

   422

   423

	IConsolePrint(color_code, buf);

   424

}

   425

   426

/**

   427

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

   428

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

   429

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

   430

 * messages to show up

   431

 * @param dbg debugging category

   432

 * @param string debugging message

   433

 */

   434

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

   435

{

   436

	if (_stdlib_developer > 1)

   437

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

   438

}

   439

   440

/**

   441

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

   442

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

   443

 * debugging messages to show up

   444

 */

   445

void IConsoleWarning(const char *string)

   446

{

   447

	if (_stdlib_developer > 0)

   448

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

   449

}

   450

   451

/**

   452

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

   453

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

   454

 */

   455

void IConsoleError(const char *string)

   456

{

   457

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

   458

}

   459

   460

/**

   461

 * Change a string into its number representation. Supports

   462

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

   463

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

   464

 * @param *arg the string to be converted

   465

 * @return Return true on success or false on failure

   466

 */

   467

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

   468

{

   469

	char *endptr;

   470

   471

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

   472

		*value = 1;

   473

		return true;

   474

	}

   475

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

   476

		*value = 0;

   477

		return true;

   478

	}

   479