1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "gfx.h"

     7

#include "player.h"

     8

#include "variables.h"

     9

#include "string.h"

    10

#include "hal.h"

    11

#include <stdarg.h>

    12

#include <string.h>

    13

#include "console.h"

    14

#include "network.h"

    15

#include "network_data.h"

    16

#include "network_server.h"

    17

    18

#define ICON_BUFFER 79

    19

#define ICON_HISTORY_SIZE 20

    20

#define ICON_LINE_HEIGHT 12

    21

#define ICON_RIGHT_BORDERWIDTH 10

    22

#define ICON_BOTTOM_BORDERWIDTH 12

    23

#define ICON_MAX_ALIAS_LINES 40

    24

#define ICON_TOKEN_COUNT 20

    25

    26

// ** main console ** //

    27

static Window *_iconsole_win; // Pointer to console window

    28

static bool _iconsole_inited;

    29

static char *_iconsole_buffer[ICON_BUFFER + 1];

    30

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    31

static Textbuf _iconsole_cmdline;

    32

static byte _iconsole_scroll;

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

    55

}

    56

    57

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

    58

    59

// ** console window ** //

    60

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

    61

{

    62

	switch (e->event) {

    63

		case WE_PAINT: {

    64

			int i = _iconsole_scroll;

    65

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

    66

			int delta = 0;

    67

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

    68

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

    69

				DoDrawString(_iconsole_buffer[i], 5,

    70

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

    71

				i--;

    72

			}

    73

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

    74

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

    75

			if (delta > 0) {

    77

				delta = 0;

    78

			}

    79

    81

    82

			if (_iconsole_cmdline.caret)

    83

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

    84

			break;

    85

		}

    86

		case WE_MOUSELOOP:

    87

			if (HandleCaret(&_iconsole_cmdline))

    88

				SetWindowDirty(w);

    89

			break;

    90

		case WE_DESTROY:

    91

			_iconsole_win = NULL;

    92

			_iconsole_mode = ICONSOLE_CLOSED;

    93

			break;

    94

		case WE_KEYPRESS:

    95

			e->keypress.cont = false;

    96

			switch (e->keypress.keycode) {

    97

				case WKC_UP:

    98

					IConsoleHistoryNavigate(+1);

    99

					SetWindowDirty(w);

   100

					break;

   101

				case WKC_DOWN:

   102

					IConsoleHistoryNavigate(-1);

   103

					SetWindowDirty(w);

   104

					break;

   105

				case WKC_SHIFT | WKC_PAGEUP:

   106

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

   107

						_iconsole_scroll = 0;

   108

					else

   109

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

   110

					SetWindowDirty(w);

   111

					break;

   112

				case WKC_SHIFT | WKC_PAGEDOWN:

   113

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

   114

						_iconsole_scroll = ICON_BUFFER;

   115

					else

   116

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

   117

					SetWindowDirty(w);

   118

					break;

   119

				case WKC_SHIFT | WKC_UP:

   120

					if (_iconsole_scroll <= 0)

   121

						_iconsole_scroll = 0;

   122

					else

   123

						--_iconsole_scroll;

   124

					SetWindowDirty(w);

   125

					break;

   126

				case WKC_SHIFT | WKC_DOWN:

   127

					if (_iconsole_scroll >= ICON_BUFFER)

   128

						_iconsole_scroll = ICON_BUFFER;

   129

					else

   130

						++_iconsole_scroll;

   131

					SetWindowDirty(w);

   132

					break;

   133

				case WKC_BACKQUOTE:

   134

					IConsoleSwitch();

   135

					break;

   136

				case WKC_RETURN: case WKC_NUM_ENTER:

   138

					IConsoleHistoryAdd(_iconsole_cmdline.buf);

   139

   140

					IConsoleCmdExec(_iconsole_cmdline.buf);

   141

					IConsoleClearCommand();

   142

					break;

   143

				case WKC_CTRL | WKC_RETURN:

   144

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

   145

					IConsoleResize();

   146

					MarkWholeScreenDirty();

   147

					break;

   148

				case (WKC_CTRL | 'V'):

   149

					if (InsertTextBufferClipboard(&_iconsole_cmdline)) {

   150

						IConsoleResetHistoryPos();

   151

						SetWindowDirty(w);

   152

					}

   153

					break;

   154

				case WKC_BACKSPACE: case WKC_DELETE:

   155

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

   156

						IConsoleResetHistoryPos();

   157

						SetWindowDirty(w);

   158

					}

   159

					break;

   160

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

   161

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

   162

						IConsoleResetHistoryPos();

   163

						SetWindowDirty(w);

   164

					}

   165

					break;

   166

				default:

   167

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

   168

						_iconsole_scroll = ICON_BUFFER;

   169

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

   170

						IConsoleResetHistoryPos();

   171

						SetWindowDirty(w);

   172

					} else

   173

						e->keypress.cont = true;

   174

			break;

   175

		}

   176

	}

   177

}

   178

   179

static const Widget _iconsole_window_widgets[] = {

   180

	{WIDGETS_END}

   181

};

   182

   183

static const WindowDesc _iconsole_window_desc = {

   184

	0, 0, 2, 2,

   185

	WC_CONSOLE, 0,

   186

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   187

	_iconsole_window_widgets,

   188

	IConsoleWndProc,

   189

};

   190

   191

void IConsoleInit(void)

   192

{

   193

	extern const char _openttd_revision[];

   194

	_iconsole_output_file = NULL;

   200

	_iconsole_scroll = ICON_BUFFER;

   201

	_iconsole_historypos = ICON_HISTORY_SIZE - 1;

   202

	_iconsole_inited = true;

   203

	_iconsole_mode = ICONSOLE_CLOSED;

   204

	_iconsole_win = NULL;

   205

   206

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   207

	_redirect_console_to_client = 0;

   208

#endif

   209

   210

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

   211

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

   212

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

   213

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

   214

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE - 1;

   215

   216

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

   217

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

   218

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

   219

	IConsolePrint(12,  "");

   220

	IConsoleStdLibRegister();

   221

	IConsoleClearCommand();

   222

	IConsoleHistoryAdd("");

   223

}

   224

   225

void IConsoleClear(void)

   226

{

   227

	uint i;

   228

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

   229

		free(_iconsole_buffer[i]);

   230

   231

	free(_iconsole_cmdline.buf);

   232

}

   233

   234

static void IConsoleWriteToLogFile(const char* string)

   235

{

   236

	if (_iconsole_output_file != NULL) {

   237

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

   238

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

   239

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

   240

	}

   241

}

   242

   243

bool CloseConsoleLogIfActive(void)

   244

{

   245

	if (_iconsole_output_file != NULL) {

   247

		fclose(_iconsole_output_file);

   248

		_iconsole_output_file = NULL;

   249

		return true;

   250

	}

   251

   252

	return false;

   253

}

   254

   255

void IConsoleFree(void)

   256

{

   257

	_iconsole_inited = false;

   258

	IConsoleClear();

   259

	CloseConsoleLogIfActive();

   260

}

   261

   262

void IConsoleResize(void)

   263

{

   264

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   265

   266

	switch (_iconsole_mode) {

   267

		case ICONSOLE_OPENED:

   268

			_iconsole_win->height = _screen.height / 3;

   269

			_iconsole_win->width = _screen.width;

   270

			break;

   271

		case ICONSOLE_FULL:

   272

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   273

			_iconsole_win->width = _screen.width;

   274

			break;

   275

		default: break;

   276

	}

   277

   278

	MarkWholeScreenDirty();

   279

}

   280

   281

void IConsoleSwitch(void)

   282

{

   283

	switch (_iconsole_mode) {

   284

		case ICONSOLE_CLOSED:

   285

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   286

			_iconsole_win->height = _screen.height / 3;

   287

			_iconsole_win->width = _screen.width;

   288

			_iconsole_mode = ICONSOLE_OPENED;

   289

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

   290

			break;

   291

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   292

			DeleteWindowById(WC_CONSOLE, 0);

   293

			_iconsole_win = NULL;

   294

			_iconsole_mode = ICONSOLE_CLOSED;

   295

			CLRBIT(_no_scroll, SCROLL_CON);

   296

			break;

   297

	}

   298

   299

	MarkWholeScreenDirty();

   300

}

   301

   302

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

   303

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

   304

   305

/**

   306

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

   307

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

   308

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

   309

 */

   310

void IConsoleHistoryAdd(const char *cmd)

   311

{

   312

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

   313

   314

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

   315

	_iconsole_history[0] = strdup(cmd);

   316

	IConsoleResetHistoryPos();

   317

}

   318

   319

/**

   320

 * Navigate Up/Down in the history of typed commands

   321

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

   322

 */

   323

void IConsoleHistoryNavigate(signed char direction)

   324

{

   325

	int i = _iconsole_historypos + direction;

   326

   327

	// watch out for overflows, just wrap around

   328

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

   329

	if (i >= ICON_HISTORY_SIZE) i = 0;

   330

   331

	if (direction > 0)

   332

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

   333

   334

	if (direction < 0) {

   335

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

   336

	}

   337

   338

	_iconsole_historypos = i;

   339

	IConsoleClearCommand();

   340

	// copy history to 'command prompt / bash'

   341

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

   342

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

   343

	UpdateTextBufferSize(&_iconsole_cmdline);

   344

}

   345

   346

/**

   347

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

   348

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

   349

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

   350

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

   351

 * used as a history to print them onscreen

   352

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

   353

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

   354

 */

   355

void IConsolePrint(uint16 color_code, const char* string)

   356

{

   357

#ifdef ENABLE_NETWORK

   358

	if (_redirect_console_to_client != 0) {

   359

		/* Redirect the string to the client */

   360

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

   361

		return;

   362

	}

   363

#endif

   364

   365

	if (_network_dedicated) {

   366

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

   367

		IConsoleWriteToLogFile(string);

   368

		return;

   369

	}

   370

   371

	if (!_iconsole_inited) return;

   372

   373

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

   374

	 * to accomodate for the new command/message */

   375

	free(_iconsole_buffer[0]);

   376

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

   377

	_iconsole_buffer[ICON_BUFFER] = strdup(string);

   378

   379

	{ // filter out unprintable characters

   380

		char *i;

   381

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

   382

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

   383

	}

   384

   385

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

   386

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   387

   388

	IConsoleWriteToLogFile(string);

   389

   390

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

   391

}

   392

   393

/**

   394

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

   395

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

   396

 * at @IConsolePrint()

   397

 */

   398

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

   399

{

   400

	va_list va;

   401

	char buf[ICON_MAX_STREAMSIZE];

   402

   403

	va_start(va, s);

   404

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

   405

	va_end(va);

   406

   407

	IConsolePrint(color_code, buf);

   408

}

   409

   410

/**

   411

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

   412

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

   413

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

   414

 * messages to show up

   415

 */

   416

void IConsoleDebug(const char* string)

   417

{

   418

	if (_stdlib_developer > 1)

   420

}

   421

   422

/**

   423

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

   424

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

   425

 * debugging messages to show up

   426

 */

   427

void IConsoleWarning(const char* string)

   428

{

   429

	if (_stdlib_developer > 0)

   431

}

   432

   433

/**

   434

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

   435

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

   436

 */

   437

void IConsoleError(const char* string)

   438

{

   440

}

   441

   442

/**

   443

 * Change a string into its number representation. Supports

   444

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

   445

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

   446

 * @param *arg the string to be converted

   447

 * @return Return true on success or false on failure

   448

 */

   449

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

   450

{

   451

	char *endptr;

   452

   453

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

   454

		*value = 1;

   455

		return true;

   456

	}

   457

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

   458

		*value = 0;

   459

		return true;

   460

	}

   461

   462

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

   463

	return (arg == endptr) ? false : true;

   464

}

   465

   466

/**

   467

 * Perhaps ugly macro, but this saves us the trouble of writing the same function

   468

 * three types, just with different variables. Yes, templates would be handy. It was

   469

 * either this define or an even more ugly void* magic function

   470

 */

   471

#define IConsoleAddSorted(_base, item_new, IConsoleType, type)                      \

   472

{                                                                                   \

   473

	IConsoleType *item, *item_before;                                                 \

   474

	/* first command */                                                               \

   475

	if (_base == NULL) {                                                              \

   476

		_base = item_new;                                                               \

   477

		return;                                                                         \

   478

	}                                                                                 \

   479

                                                                                    \

   480

	item_before = NULL;                                                               \

   481

	item = _base;                                                                     \

   482

                                                                                    \