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 "network.h"

    17

#include "network_data.h"

    18

#include "network_server.h"

    19

    20

#define ICON_BUFFER 79

    21

#define ICON_HISTORY_SIZE 20

    22

#define ICON_LINE_HEIGHT 12

    23

#define ICON_RIGHT_BORDERWIDTH 10

    24

#define ICON_BOTTOM_BORDERWIDTH 12

    25

#define ICON_MAX_ALIAS_LINES 40

    26

#define ICON_TOKEN_COUNT 20

    27

    28

// ** main console ** //

    29

static Window *_iconsole_win; // Pointer to console window

    30

static bool _iconsole_inited;

    31

static char *_iconsole_buffer[ICON_BUFFER + 1];

    32

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    33

static Textbuf _iconsole_cmdline;

    34

static byte _iconsole_scroll;

    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(void)

    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

	SetWindowDirty(_iconsole_win);

    57

}

    58

    59

static inline void IConsoleResetHistoryPos(void) {_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(Window *w, WindowEvent *e)

    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_win = NULL;

    98

			_iconsole_mode = ICONSOLE_CLOSED;

    99

			break;

   100

		case WE_KEYPRESS:

   101

			e->keypress.cont = false;

   102

			switch (e->keypress.keycode) {

   103

				case WKC_UP:

   104

					IConsoleHistoryNavigate(+1);

   105

					SetWindowDirty(w);

   106

					break;

   107

				case WKC_DOWN:

   108

					IConsoleHistoryNavigate(-1);

   109

					SetWindowDirty(w);

   110

					break;

   111

				case WKC_SHIFT | WKC_PAGEUP:

   112

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

   113

						_iconsole_scroll = 0;

   114

					} else {

   115

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

   116

					}

   117

					SetWindowDirty(w);

   118

					break;

   119

				case WKC_SHIFT | WKC_PAGEDOWN:

   120

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

   121

						_iconsole_scroll = ICON_BUFFER;

   122

					} else {

   123

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

   124

					}

   125

					SetWindowDirty(w);

   126

					break;

   127

				case WKC_SHIFT | WKC_UP:

   128

					if (_iconsole_scroll <= 0) {

   129

						_iconsole_scroll = 0;

   130

					} else {

   131

						--_iconsole_scroll;

   132

					}

   133

					SetWindowDirty(w);

   134

					break;

   135

				case WKC_SHIFT | WKC_DOWN:

   136

					if (_iconsole_scroll >= ICON_BUFFER) {

   137

						_iconsole_scroll = ICON_BUFFER;

   138

					} else {

   139

						++_iconsole_scroll;

   140

					}

   141

					SetWindowDirty(w);

   142

					break;

   143

				case WKC_BACKQUOTE:

   144

					IConsoleSwitch();

   145

					break;

   146

				case WKC_RETURN: case WKC_NUM_ENTER:

   147

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

   148

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   149

   150

					IConsoleCmdExec(_iconsole_cmdline.buf);

   151

					IConsoleClearCommand();

   152

					break;

   153

				case WKC_CTRL | WKC_RETURN:

   154

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

   155

					IConsoleResize();

   156

					MarkWholeScreenDirty();

   157

					break;

   158

				case (WKC_CTRL | 'V'):

   159

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   160

						IConsoleResetHistoryPos();

   161

						SetWindowDirty(w);

   162

					}

   163

					break;

   164

				case (WKC_CTRL | 'L'):

   165

					IConsoleCmdExec("clear");

   166

					break;

   167

				case (WKC_CTRL | 'U'):

   168

					DeleteTextBufferAll(&_iconsole_cmdline);

   169

					SetWindowDirty(w);

   170

					break;

   171

				case WKC_BACKSPACE: case WKC_DELETE:

   172

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

   173

						IConsoleResetHistoryPos();

   174

						SetWindowDirty(w);

   175

					}

   176

					break;

   177

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

   178

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

   179

						IConsoleResetHistoryPos();

   180

						SetWindowDirty(w);

   181

					}

   182

					break;

   183

				default:

   185

						_iconsole_scroll = ICON_BUFFER;

   186

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

   187

						IConsoleResetHistoryPos();

   188

						SetWindowDirty(w);

   189

					} else {

   190

						e->keypress.cont = true;

   191

					}

   192

			break;

   193

		}

   194

	}

   195

}

   196

   197

static const Widget _iconsole_window_widgets[] = {

   198

	{WIDGETS_END}

   199

};

   200

   201

static const WindowDesc _iconsole_window_desc = {

   202

	0, 0, 2, 2,

   203

	WC_CONSOLE, 0,

   204

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   205

	_iconsole_window_widgets,

   206

	IConsoleWndProc,

   207

};

   208

   209

void IConsoleInit(void)

   210

{

   211

	extern const char _openttd_revision[];

   212

	_iconsole_output_file = NULL;

   213

	_icolour_def  =  1;

   214

	_icolour_err  =  3;

   215

	_icolour_warn = 13;

   216

	_icolour_dbg  =  5;

   217

	_icolour_cmd  =  2;

   218

	_iconsole_scroll = ICON_BUFFER;

   219

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   220

	_iconsole_inited = true;

   221

	_iconsole_mode = ICONSOLE_CLOSED;

   222

	_iconsole_win = NULL;

   223

   224

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   225

	_redirect_console_to_client = 0;

   226

#endif

   227

   228

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

   229

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

   230

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

   231

	_iconsole_cmdline.buf = calloc(ICON_CMDLN_SIZE, sizeof(*_iconsole_cmdline.buf)); // create buffer and zero it

   232

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE;

   233

   234

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

   235

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

   236

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

   237

	IConsolePrint(12,  "");

   238

	IConsoleStdLibRegister();

   239

	IConsoleClearCommand();

   240

	IConsoleHistoryAdd("");

   241

}

   242

   243

void IConsoleClearBuffer(void)

   244

{

   245

	uint i;

   246

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

   247

		free(_iconsole_buffer[i]);

   248

		_iconsole_buffer[i] = NULL;

   249

	}

   250

}

   251

   252

static void IConsoleClear(void)

   253

{

   254

	free(_iconsole_cmdline.buf);

   255

	IConsoleClearBuffer();

   256

}

   257

   258

static void IConsoleWriteToLogFile(const char *string)

   259

{

   260

	if (_iconsole_output_file != NULL) {

   261

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

   262

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

   263

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

   264

	}

   265

}

   266

   267

bool CloseConsoleLogIfActive(void)

   268

{

   269

	if (_iconsole_output_file != NULL) {

   270

		IConsolePrintF(_icolour_def, "file output complete");

   271

		fclose(_iconsole_output_file);

   272

		_iconsole_output_file = NULL;

   273

		return true;

   274

	}

   275

   276

	return false;

   277

}

   278

   279

void IConsoleFree(void)

   280

{

   281

	_iconsole_inited = false;

   282

	IConsoleClear();

   283

	CloseConsoleLogIfActive();

   284

}

   285

   286

void IConsoleResize(void)

   287

{

   288

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   289

   290

	switch (_iconsole_mode) {

   291

		case ICONSOLE_OPENED:

   292

			_iconsole_win->height = _screen.height / 3;

   293

			_iconsole_win->width = _screen.width;

   294

			break;

   295

		case ICONSOLE_FULL:

   296

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   297

			_iconsole_win->width = _screen.width;

   298

			break;

   299

		default: break;

   300

	}

   301

   302

	MarkWholeScreenDirty();

   303

}

   304

   305

void IConsoleSwitch(void)

   306

{

   307

	switch (_iconsole_mode) {

   308

		case ICONSOLE_CLOSED:

   309

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   310

			_iconsole_win->height = _screen.height / 3;

   311

			_iconsole_win->width = _screen.width;

   312

			_iconsole_mode = ICONSOLE_OPENED;

   313

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

   314

			break;

   315

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   316

			DeleteWindowById(WC_CONSOLE, 0);

   317

			_iconsole_win = NULL;

   318

			_iconsole_mode = ICONSOLE_CLOSED;

   319

			CLRBIT(_no_scroll, SCROLL_CON);

   320

			break;

   321

	}

   322

   323

	MarkWholeScreenDirty();

   324

}

   325

   326

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

   327

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

   328

   329

/**

   330

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

   331

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

   332

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

   333

 */

   334

static void IConsoleHistoryAdd(const char *cmd)

   335

{

   336

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   337

   338

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

   339

	_iconsole_history[0] = strdup(cmd);

   340

	IConsoleResetHistoryPos();

   341

}

   342

   343

/**

   344

 * Navigate Up/Down in the history of typed commands

   345

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

   346

 */

   347

static void IConsoleHistoryNavigate(int direction)

   348

{

   349

	int i = _iconsole_historypos + direction;

   350

   351

	// watch out for overflows, just wrap around

   352

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

   353

	if (i >= ICON_HISTORY_SIZE) i = 0;

   354

   355

	if (direction > 0)

   356

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

   357

   358

	if (direction < 0) {

   359

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

   360

	}

   361

   362

	_iconsole_historypos = i;

   363

	IConsoleClearCommand();

   364

	// copy history to 'command prompt / bash'

   365

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

   366

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

   367

	UpdateTextBufferSize(&_iconsole_cmdline);

   368

}

   369

   370

/**

   371

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

   372

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

   373

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

   374

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

   375

 * used as a history to print them onscreen

   376

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

   377

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

   378

 */

   379

void IConsolePrint(uint16 color_code, const char *string)

   380

{

   381

#ifdef ENABLE_NETWORK

   382

	if (_redirect_console_to_client != 0) {

   383

		/* Redirect the string to the client */

   384

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

   385

		return;

   386

	}

   387

#endif

   388

   389

	if (_network_dedicated) {

   390

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

   391

		IConsoleWriteToLogFile(string);

   392

		return;

   393

	}

   394

   395

	if (!_iconsole_inited) return;

   396

   397

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

   398

	 * to accomodate for the new command/message */

   399

	free(_iconsole_buffer[0]);

   400

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

   401

	_iconsole_buffer[ICON_BUFFER] = strdup(string);

   402

   403

	str_validate(_iconsole_buffer[ICON_BUFFER]);

   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(string);

   409

   410

	if (_iconsole_win != NULL) SetWindowDirty(_iconsole_win);

   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.c. You need at least a level 2 (developer) for debugging

   434

 * messages to show up

   435

 */

   436

void IConsoleDebug(const char *string)

   437

{

   438

	if (_stdlib_developer > 1)

   439

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

   440

}

   441

   442

/**

   443

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

   444

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

   445

 * debugging messages to show up

   446

 */

   447

void IConsoleWarning(const char *string)

   448

{

   449

	if (_stdlib_developer > 0)

   450

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

   451

}

   452

   453

/**

   454

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

   455

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

   456

 */

   457

void IConsoleError(const char *string)

   458

{

   459

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

   460

}

   461

   462

/**

   463

 * Change a string into its number representation. Supports

   464

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

   465

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

   466

 * @param *arg the string to be converted

   467

 * @return Return true on success or false on failure

   468

 */

   469

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

   470

{

   471

	char *endptr;

   472

   473

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

   474

		*value = 1;

   475

		return true;

   476

	}

   477

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

   478

		*value = 0;

   479

		return true;

   480

	}