1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "table/strings.h"

     4

#include "functions.h"

     5

#include "window.h"

     6

#include "gui.h"

     7

#include "gfx.h"

     8

#include "player.h"

     9

#include "variables.h"

    10

#include "string.h"

    11

#include "hal.h"

    12

#include <stdarg.h>

    13

#include <string.h>

    14

#include "console.h"

    15

#include "network.h"

    16

#include "network_data.h"

    17

#include "network_server.h"

    18

    19

#define ICON_BUFFER 79

    20

#define ICON_HISTORY_SIZE 20

    21

#define ICON_LINE_HEIGHT 12

    22

#define ICON_RIGHT_BORDERWIDTH 10

    23

#define ICON_BOTTOM_BORDERWIDTH 12

    24

#define ICON_MAX_ALIAS_LINES 40

    25

#define ICON_TOKEN_COUNT 20

    26

    27

// ** main console ** //

    28

static Window *_iconsole_win; // Pointer to console window

    29

static bool _iconsole_inited;

    30

static char *_iconsole_buffer[ICON_BUFFER + 1];

    31

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    32

static Textbuf _iconsole_cmdline;

    33

static byte _iconsole_scroll;

    34

    35

// ** stdlib ** //

    36

byte _stdlib_developer = 1;

    37

bool _stdlib_con_developer = false;

    38

FILE *_iconsole_output_file;

    39

    40

// ** main console cmd buffer

    41

static char *_iconsole_history[ICON_HISTORY_SIZE];

    42

static byte _iconsole_historypos;

    43

    44

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

    45

/*  end of header  */

    46

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

    47

    48

static void IConsoleClearCommand(void)

    49

{

    50

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    51

	_iconsole_cmdline.length = 0;

    52

	_iconsole_cmdline.width = 0;

    53

	_iconsole_cmdline.caretpos = 0;

    54

	_iconsole_cmdline.caretxoffs = 0;

    55

	SetWindowDirty(_iconsole_win);

    56

}

    57

    58

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

    59

    60

// ** console window ** //

    61

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

    62

{

    63

	switch (e->event) {

    64

		case WE_PAINT: {

    65

			int i = _iconsole_scroll;

    66

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

    67

			int delta = 0;

    68

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

    69

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

    70

				DoDrawString(_iconsole_buffer[i], 5,

    71

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

    72

				i--;

    73

			}

    74

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

    75

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

    76

			if (delta > 0) {

    77

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

    78

				delta = 0;

    79

			}

    80

    81

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

    82

    83

			if (_iconsole_cmdline.caret)

    84

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

    85

			break;

    86

		}

    87

		case WE_MOUSELOOP:

    88

			if (HandleCaret(&_iconsole_cmdline))

    89

				SetWindowDirty(w);

    90

			break;

    91

		case WE_DESTROY:

    92

			_iconsole_win = NULL;

    93

			_iconsole_mode = ICONSOLE_CLOSED;

    94

			break;

    95

		case WE_KEYPRESS:

    96

			e->keypress.cont = false;

    97

			switch (e->keypress.keycode) {

    98

				case WKC_UP:

    99

					IConsoleHistoryNavigate(+1);

   100

					SetWindowDirty(w);

   101

					break;

   102

				case WKC_DOWN:

   103

					IConsoleHistoryNavigate(-1);

   104

					SetWindowDirty(w);

   105

					break;

   106

				case WKC_SHIFT | WKC_PAGEUP:

   107

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

   108

						_iconsole_scroll = 0;

   109

					else

   110

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

   111

					SetWindowDirty(w);

   112

					break;

   113

				case WKC_SHIFT | WKC_PAGEDOWN:

   114

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

   115

						_iconsole_scroll = ICON_BUFFER;

   116

					else

   117

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

   118

					SetWindowDirty(w);

   119

					break;

   120

				case WKC_SHIFT | WKC_UP:

   121

					if (_iconsole_scroll <= 0)

   122

						_iconsole_scroll = 0;

   123

					else

   124

						--_iconsole_scroll;

   125

					SetWindowDirty(w);

   126

					break;

   127

				case WKC_SHIFT | WKC_DOWN:

   128

					if (_iconsole_scroll >= ICON_BUFFER)

   129

						_iconsole_scroll = ICON_BUFFER;

   130

					else

   131

						++_iconsole_scroll;

   132

					SetWindowDirty(w);

   133

					break;

   134

				case WKC_BACKQUOTE:

   135

					IConsoleSwitch();

   136

					break;

   137

				case WKC_RETURN: case WKC_NUM_ENTER:

   138

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

   139

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   140

   141

					IConsoleCmdExec(_iconsole_cmdline.buf);

   142

					IConsoleClearCommand();

   143

					break;

   144

				case WKC_CTRL | WKC_RETURN:

   145

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

   146

					IConsoleResize();

   147

					MarkWholeScreenDirty();

   148

					break;

   149

				case (WKC_CTRL | 'V'):

   150

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   151

						IConsoleResetHistoryPos();

   152

						SetWindowDirty(w);

   153

					}

   154

					break;

   155

				case (WKC_CTRL | 'L'):

   156

					IConsoleCmdExec("clear");

   157

					break;

   158

				case (WKC_CTRL | 'U'):

   159

					DeleteTextBufferAll(&_iconsole_cmdline);

   160

					SetWindowDirty(w);

   161

					break;

   162

				case WKC_BACKSPACE: case WKC_DELETE:

   163

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

   164

						IConsoleResetHistoryPos();

   165

						SetWindowDirty(w);

   166

					}

   167

					break;

   168

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

   169

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

   170

						IConsoleResetHistoryPos();

   171

						SetWindowDirty(w);

   172

					}

   173

					break;

   174

				default:

   175

					if (IsValidAsciiChar(e->keypress.ascii)) {

   176

						_iconsole_scroll = ICON_BUFFER;

   177

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

   178

						IConsoleResetHistoryPos();

   179

						SetWindowDirty(w);

   180

					} else

   181

						e->keypress.cont = true;

   182

			break;

   183

		}

   184

	}

   185

}

   186

   187

static const Widget _iconsole_window_widgets[] = {

   188

	{WIDGETS_END}

   189

};

   190

   191

static const WindowDesc _iconsole_window_desc = {

   192

	0, 0, 2, 2,

   193

	WC_CONSOLE, 0,

   194

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   195

	_iconsole_window_widgets,

   196

	IConsoleWndProc,

   197

};

   198

   199

void IConsoleInit(void)

   200

{

   201

	extern const char _openttd_revision[];

   202

	_iconsole_output_file = NULL;

   203

	_icolour_def  =  1;

   204

	_icolour_err  =  3;

   205

	_icolour_warn = 13;

   206

	_icolour_dbg  =  5;

   207

	_icolour_cmd  =  2;

   208

	_iconsole_scroll = ICON_BUFFER;

   209

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   210

	_iconsole_inited = true;

   211

	_iconsole_mode = ICONSOLE_CLOSED;

   212

	_iconsole_win = NULL;

   213

   214

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   215

	_redirect_console_to_client = 0;

   216

#endif

   217

   218

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

   219

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

   220

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

   221

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

   222

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE - 1;

   223

   224

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

   225

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

   226

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

   227

	IConsolePrint(12,  "");

   228

	IConsoleStdLibRegister();

   229

	IConsoleClearCommand();

   230

	IConsoleHistoryAdd("");

   231

}

   232

   233

void IConsoleClearBuffer(void)

   234

{

   235

	uint i;

   236

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

   237

		free(_iconsole_buffer[i]);

   238

		_iconsole_buffer[i] = NULL;

   239

	}

   240

}

   241

   242

static void IConsoleClear(void)

   243

{

   244

	free(_iconsole_cmdline.buf);

   245

	IConsoleClearBuffer();

   246

}

   247

   248

static void IConsoleWriteToLogFile(const char* string)

   249

{

   250

	if (_iconsole_output_file != NULL) {

   251

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

   252

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

   253

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

   254

	}

   255

}

   256

   257

bool CloseConsoleLogIfActive(void)

   258

{

   259

	if (_iconsole_output_file != NULL) {

   260

		IConsolePrintF(_icolour_def, "file output complete");

   261

		fclose(_iconsole_output_file);

   262

		_iconsole_output_file = NULL;

   263

		return true;

   264

	}

   265

   266

	return false;

   267

}

   268

   269

void IConsoleFree(void)

   270

{

   271

	_iconsole_inited = false;

   272

	IConsoleClear();

   273

	CloseConsoleLogIfActive();

   274

}

   275

   276

void IConsoleResize(void)

   277

{

   278

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   279

   280

	switch (_iconsole_mode) {

   281

		case ICONSOLE_OPENED:

   282

			_iconsole_win->height = _screen.height / 3;

   283

			_iconsole_win->width = _screen.width;

   284

			break;

   285

		case ICONSOLE_FULL:

   286

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   287

			_iconsole_win->width = _screen.width;

   288

			break;

   289

		default: break;

   290

	}

   291

   292

	MarkWholeScreenDirty();

   293

}

   294

   295

void IConsoleSwitch(void)

   296

{

   297

	switch (_iconsole_mode) {

   298

		case ICONSOLE_CLOSED:

   299

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   300

			_iconsole_win->height = _screen.height / 3;

   301

			_iconsole_win->width = _screen.width;

   302

			_iconsole_mode = ICONSOLE_OPENED;

   303

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

   304

			break;

   305

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   306

			DeleteWindowById(WC_CONSOLE, 0);

   307

			_iconsole_win = NULL;

   308

			_iconsole_mode = ICONSOLE_CLOSED;

   309

			CLRBIT(_no_scroll, SCROLL_CON);

   310

			break;

   311

	}

   312

   313

	MarkWholeScreenDirty();

   314

}

   315

   316

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

   317

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

   318

   319

/**

   320

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

   321

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

   322

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

   323

 */

   324

void IConsoleHistoryAdd(const char *cmd)

   325

{

   326

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   327

   328

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

   329

	_iconsole_history[0] = strdup(cmd);

   330

	IConsoleResetHistoryPos();

   331

}

   332

   333

/**

   334

 * Navigate Up/Down in the history of typed commands

   335

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

   336

 */

   337

void IConsoleHistoryNavigate(signed char direction)

   338

{

   339

	int i = _iconsole_historypos + direction;

   340

   341

	// watch out for overflows, just wrap around

   342

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

   343

	if (i >= ICON_HISTORY_SIZE) i = 0;

   344

   345

	if (direction > 0)

   346

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

   347

   348

	if (direction < 0) {

   349

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

   350

	}

   351

   352

	_iconsole_historypos = i;

   353

	IConsoleClearCommand();

   354

	// copy history to 'command prompt / bash'

   355

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

   356

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

   357

	UpdateTextBufferSize(&_iconsole_cmdline);

   358

}

   359

   360

/**

   361

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

   362

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

   363

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

   364

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

   365

 * used as a history to print them onscreen

   366

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

   367

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

   368

 */

   369

void IConsolePrint(uint16 color_code, const char* string)

   370

{

   371

#ifdef ENABLE_NETWORK

   372

	if (_redirect_console_to_client != 0) {

   373

		/* Redirect the string to the client */

   374

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

   375

		return;

   376

	}

   377

#endif

   378

   379

	if (_network_dedicated) {

   380

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

   381

		IConsoleWriteToLogFile(string);

   382

		return;

   383

	}

   384

   385

	if (!_iconsole_inited) return;

   386

   387

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

   388

	 * to accomodate for the new command/message */

   389

	free(_iconsole_buffer[0]);

   390

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

   391

	_iconsole_buffer[ICON_BUFFER] = strdup(string);

   392

   393

	{ // filter out unprintable characters

   394

		char *i;

   395

		for (i = _iconsole_buffer[ICON_BUFFER]; *i != '\0'; i++)

   396

			if (!IsValidAsciiChar((byte)*i)) *i = ' ';

   397

	}

   398

   399

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

   400

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   401

   402

	IConsoleWriteToLogFile(string);

   403

   404

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

   405

}

   406

   407

/**

   408

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

   409

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

   410

 * at @IConsolePrint()

   411

 */

   412

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

   413

{

   414

	va_list va;

   415

	char buf[ICON_MAX_STREAMSIZE];

   416

   417

	va_start(va, s);

   418

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

   419

	va_end(va);

   420

   421

	IConsolePrint(color_code, buf);

   422

}

   423

   424

/**

   425

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

   426

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

   427

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

   428

 * messages to show up

   429

 */

   430

void IConsoleDebug(const char* string)

   431

{

   432

	if (_stdlib_developer > 1)

   433

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

   434

}

   435

   436

/**

   437

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

   438

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

   439

 * debugging messages to show up

   440

 */

   441

void IConsoleWarning(const char* string)

   442

{

   443

	if (_stdlib_developer > 0)

   444

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

   445

}

   446

   447

/**

   448

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

   449

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

   450

 */

   451

void IConsoleError(const char* string)

   452

{

   453

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

   454

}

   455

   456

/**

   457

 * Change a string into its number representation. Supports

   458

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

   459

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

   460

 * @param *arg the string to be converted

   461

 * @return Return true on success or false on failure

   462

 */

   463

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

   464

{

   465

	char *endptr;

   466

   467

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

   468

		*value = 1;

   469

		return true;

   470

	}

   471

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

   472

		*value = 0;

   473

		return true;

   474

	}

   475

   476

	*value = strtoul(arg, &endptr, 0);

   477

	return arg != endptr;

   478

}

   479

   480

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

   481

// * hooking code              * //