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_CMDBUF_SIZE 20

    20

#define ICON_CMDLN_SIZE 255

    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

    26

// ** main console ** //

    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

// ** console cursor ** //

    35

static bool _icursor_state;

    36

static byte _icursor_rate;

    37

static byte _icursor_counter;

    38

    39

// ** stdlib ** //

    40

byte _stdlib_developer = 1;

    41

bool _stdlib_con_developer = false;

    42

FILE* _iconsole_output_file;

    43

    44

// ** main console cmd buffer

    45

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    46

static byte _iconsole_cmdbufferpos;

    47

    48

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

    49

/*  end of header  */

    50

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

    51

    52

static void IConsoleClearCommand(void)

    53

{

    54

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    55

	_iconsole_cmdline.length = 0;

    56

	_iconsole_cmdline.width = 0;

    57

	_iconsole_cmdline.caretpos = 0;

    58

	_iconsole_cmdline.caretxoffs = 0;

    59

	SetWindowDirty(_iconsole_win);

    60

}

    61

    62

// ** console window ** //

    63

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

    64

{

    65

	switch(e->event) {

    66

		case WE_PAINT: {

    67

			int i = _iconsole_scroll;

    68

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

    69

			int delta = 0;

    70

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

    71

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

    72

				DoDrawString(_iconsole_buffer[i], 5,

    73

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

    74

				i--;

    75

			}

    76

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

    77

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

    78

			if (delta > 0) {

    79

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

    80

				delta = 0;

    81

			}

    82

    83

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

    84

    85

			if (_iconsole_cmdline.caret)

    86

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

    87

			break;

    88

		}

    89

		case WE_MOUSELOOP:

    90

			if (HandleCaret(&_iconsole_cmdline))

    91

				SetWindowDirty(w);

    92

			break;

    93

		case WE_DESTROY:

    94

			_iconsole_win = NULL;

    95

			_iconsole_mode = ICONSOLE_CLOSED;

    96

			break;

    97

		case WE_KEYPRESS:

    98

			e->keypress.cont = false;

    99

			switch (e->keypress.keycode) {

   100

				case WKC_UP:

   101

					IConsoleCmdBufferNavigate(+1);

   102

					SetWindowDirty(w);

   103

					break;

   104

				case WKC_DOWN:

   105

					IConsoleCmdBufferNavigate(-1);

   106

					SetWindowDirty(w);

   107

					break;

   108

				case WKC_SHIFT | WKC_PAGEUP:

   109

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

   110

						_iconsole_scroll = 0;

   111

					else

   112

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

   113

					SetWindowDirty(w);

   114

					break;

   115

				case WKC_SHIFT | WKC_PAGEDOWN:

   116

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

   117

						_iconsole_scroll = ICON_BUFFER;

   118

					else

   119

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

   120

					SetWindowDirty(w);

   121

					break;

   122

				case WKC_SHIFT | WKC_UP:

   123

					if (_iconsole_scroll <= 0)

   124

						_iconsole_scroll = 0;

   125

					else

   126

						--_iconsole_scroll;

   127

					SetWindowDirty(w);

   128

					break;

   129

				case WKC_SHIFT | WKC_DOWN:

   130

					if (_iconsole_scroll >= ICON_BUFFER)

   131

						_iconsole_scroll = ICON_BUFFER;

   132

					else

   133

						++_iconsole_scroll;

   134

					SetWindowDirty(w);

   135

					break;

   136

				case WKC_BACKQUOTE:

   137

					IConsoleSwitch();

   138

					break;

   139

				case WKC_RETURN: case WKC_NUM_ENTER:

   140

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

   141

					_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   142

					IConsoleCmdBufferAdd(_iconsole_cmdline.buf);

   143

   144

					IConsoleCmdExec(_iconsole_cmdline.buf);

   145

					IConsoleClearCommand();

   146

					break;

   147

				case WKC_CTRL | WKC_RETURN:

   148

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

   149

					IConsoleResize();

   150

					MarkWholeScreenDirty();

   151

					break;

   152

				case (WKC_CTRL | 'V'):

   153

					if (InsertTextBufferClipboard(&_iconsole_cmdline))

   154

						SetWindowDirty(w);

   155

					break;

   156

				case WKC_BACKSPACE: case WKC_DELETE:

   157

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

   158

						SetWindowDirty(w);

   159

					_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   160

					break;

   161

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

   162

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

   163

						SetWindowDirty(w);

   164

					break;

   165

				default:

   166

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

   167

						_iconsole_scroll = ICON_BUFFER;

   168

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

   169

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   170

						SetWindowDirty(w);

   171

					} else

   172

						e->keypress.cont = true;

   173

			break;

   174

		}

   175

	}

   176

}

   177

   178

static const Widget _iconsole_window_widgets[] = {

   179

	{WIDGETS_END}

   180

};

   181

   182

static const WindowDesc _iconsole_window_desc = {

   183

	0, 0, 2, 2,

   184

	WC_CONSOLE, 0,

   185

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   186

	_iconsole_window_widgets,

   187

	IConsoleWndProc,

   188

};

   189

   190

extern const char _openttd_revision[];

   191

   192

void IConsoleInit(void)

   193

{

   194

	_iconsole_output_file = NULL;

   195

	_iconsole_color_default = 1;

   196

	_iconsole_color_error = 3;

   197

	_iconsole_color_warning = 13;

   198

	_iconsole_color_debug = 5;

   199

	_iconsole_color_commands = 2;

   200

	_iconsole_scroll = ICON_BUFFER;

   201

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   202

	_iconsole_inited = true;

   203

	_iconsole_mode = ICONSOLE_CLOSED;

   204

	_iconsole_win = NULL;

   205

	_icursor_state = false;

   206

	_icursor_rate = 5;

   207

	_icursor_counter = 0;

   208

   209

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   210

	_redirect_console_to_client = 0;

   211

#endif

   212

   213

	memset(_iconsole_cmdbuffer, 0, sizeof(_iconsole_cmdbuffer));

   214

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

   215

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

   216

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

   217

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE - 1;

   218

   219

	IConsoleStdLibRegister();

   220

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

   221

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

   222

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

   223

	IConsolePrint(12, "");

   224

	IConsoleClearCommand();

   225

	IConsoleCmdBufferAdd("");

   226

}

   227

   228

void IConsoleClear(void)

   229

{

   230

	uint i;

   231

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

   232

		free(_iconsole_buffer[i]);

   233

   234

	free(_iconsole_cmdline.buf);

   235

}

   236

   237

static void IConsoleWriteToLogFile(const char* string)

   238

{

   239

	if (_iconsole_output_file != NULL) {

   240

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

   241

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

   242

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

   243

	}

   244

}

   245

   246

bool CloseConsoleLogIfActive(void)

   247

{

   248

	if (_iconsole_output_file != NULL) {

   249

		IConsolePrintF(_iconsole_color_default, "file output complete");

   250

		fclose(_iconsole_output_file);

   251

		_iconsole_output_file = NULL;

   252

		return true;

   253

	}

   254

   255

	return false;

   256

}

   257

   258

void IConsoleFree(void)

   259

{

   260

	_iconsole_inited = false;

   261

	IConsoleClear();

   262

	CloseConsoleLogIfActive();

   263

}

   264

   265

void IConsoleResize(void)

   266

{

   267

   268

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   269

   270

	switch (_iconsole_mode) {

   271

		case ICONSOLE_OPENED:

   272

			_iconsole_win->height = _screen.height / 3;

   273

			_iconsole_win->width = _screen.width;

   274

			break;

   275

		case ICONSOLE_FULL:

   276

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   277

			_iconsole_win->width = _screen.width;

   278

			break;

   279

		default:

   280

			break;

   281

	}

   282

   283

	MarkWholeScreenDirty();

   284

}

   285

   286

void IConsoleSwitch(void)

   287

{

   288

	switch (_iconsole_mode) {

   289

		case ICONSOLE_CLOSED:

   290

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   291

			_iconsole_win->height = _screen.height / 3;

   292

			_iconsole_win->width = _screen.width;

   293

			_iconsole_mode = ICONSOLE_OPENED;

   295

			break;

   297

			DeleteWindowById(WC_CONSOLE, 0);

   298

			_iconsole_win = NULL;

   299

			_iconsole_mode = ICONSOLE_CLOSED;

   301

			break;

   302

	}

   303

   304

	MarkWholeScreenDirty();

   305

}

   306

   307

void IConsoleClose(void)

   308

{

   309

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   310

}

   311

   312

void IConsoleOpen(void)

   313

{

   314

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   315

}

   316

   317

void IConsoleCmdBufferAdd(const char* cmd)

   318

{

   319

	int i;

   320

	if (_iconsole_cmdbufferpos != (ICON_CMDBUF_SIZE - 1)) return;

   321

	free(_iconsole_cmdbuffer[ICON_CMDBUF_SIZE - 2]);

   322

	for (i = (ICON_CMDBUF_SIZE - 2); i > 0; i--) _iconsole_cmdbuffer[i] = _iconsole_cmdbuffer[i - 1];

   323

	_iconsole_cmdbuffer[0] = strdup(cmd);

   324

}

   325

   326

void IConsoleCmdBufferNavigate(signed char direction)

   327

{

   328

	int i;

   329

	i = _iconsole_cmdbufferpos + direction;

   330

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

   331

	if (i >= ICON_CMDBUF_SIZE) i = 0;

   332

	if (direction > 0)

   333

		while (_iconsole_cmdbuffer[i] == NULL) {

   334

			i++;

   335

			if (i >= ICON_CMDBUF_SIZE) i = 0;

   336

		}

   337

	if (direction < 0)

   338

		while (_iconsole_cmdbuffer[i] == NULL) {

   339

			--i;

   340

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

   341

		}

   342

	_iconsole_cmdbufferpos = i;

   343

	IConsoleClearCommand();

   344

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

   345

	UpdateTextBufferSize(&_iconsole_cmdline);

   346

}

   347

   348

void IConsolePrint(uint16 color_code, const char* string)

   349

{

   350

	char* _ex;

   351

	char* _new;

   352

	uint16 _exc;

   353

	uint16 _newc;

   354

	char* i;

   355

	int j;

   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

	_newc = color_code;

   374

	_new = strdup(string);

   375

   376

	for (i = _new; *i != '\0'; ++i)

   377

		if (*i < ' ') *i = ' '; /* filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   378

   379

	for (j = ICON_BUFFER; j >= 0; --j) {

   380

		_ex = _iconsole_buffer[j];

   381

		_exc = _iconsole_cbuffer[j];

   382

		_iconsole_buffer[j] = _new;

   383

		_iconsole_cbuffer[j] = _newc;

   384

		_new = _ex;

   385

		_newc = _exc;

   386

	}

   387

	free(_ex);

   388

   389

	IConsoleWriteToLogFile(string);

   390

   391

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

   392

}

   393

   394

   395

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

   396

{

   397

	va_list va;

   398

	char buf[1024];

   399

	int len;

   400

   401

	va_start(va, s);

   402

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

   403

	va_end(va);

   404

   405

	IConsolePrint(color_code, buf);

   406

}

   407

   408

void IConsoleDebug(const char* string)

   409

{

   410

	if (_stdlib_developer > 1)

   411

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

   412

}

   413

   414

void IConsoleError(const char* string)

   415

{

   416

	if (_stdlib_developer > 0)

   417

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

   418

}

   419

   420

void IConsoleWarning(const char* string)

   421

{

   422

	if (_stdlib_developer > 0)

   423

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

   424

}

   425

   426

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   427

{

   428

	char* _new;

   429

	_iconsole_cmd* item;

   430

	_iconsole_cmd* item_new;

   431

	_iconsole_cmd* item_before;

   432

   433

	_new = strdup(name);

   434

   435

	item_new = malloc(sizeof(_iconsole_cmd));

   436

   437

	item_new->_next = NULL;

   438

	item_new->addr = addr;

   439

	item_new->name = _new;

   440

   441

	item_new->hook_access = NULL;

   442

	item_new->hook_after_exec = NULL;

   443

	item_new->hook_before_exec = NULL;

   444

   445

	item_before = NULL;

   446

	item = _iconsole_cmds;

   447

   448

	if (item == NULL) {

   449

		_iconsole_cmds = item_new;

   450

	} else {

   451

		while ((item->_next != NULL) && (strcmp(item->name,item_new->name)<=0)) {

   452

			item_before = item;

   453

			item = item->_next;

   454

			}

   455

// insertion sort

   456

		if (item_before==NULL) {

   457

			if (strcmp(item->name,item_new->name)<=0) {

   458

				// appending

   459

				item ->_next = item_new;

   460

			} else {

   461

				// inserting as startitem

   462

				_iconsole_cmds = item_new;

   463

				item_new ->_next = item;

   464

			}

   465

		} else {

   466

			if (strcmp(item->name,item_new->name)<=0) {

   467

				// appending

   468

				item ->_next = item_new;

   469

			} else {

   470

				// inserting

   471

				item_new ->_next = item_before->_next;

   472

				item_before ->_next = item_new;

   473

			}

   474

		}

   475

// insertion sort end

   476

	}

   477

   478

}

   479

   480

_iconsole_cmd* IConsoleCmdGet(const char* name)

   481

{

   482

	_iconsole_cmd* item;

   483