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 ** //

    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_cmdbuffer[ICON_CMDBUF_SIZE];

    41

static byte _iconsole_cmdbufferpos;

    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

// ** console window ** //

    58

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

    59

{

    60

	switch(e->event) {

    61

		case WE_PAINT: {

    62

			int i = _iconsole_scroll;

    63

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

    64

			int delta = 0;

    65

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

    66

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

    67

				DoDrawString(_iconsole_buffer[i], 5,

    68

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

    69

				i--;

    70

			}

    71

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

    72

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

    73

			if (delta > 0) {

    74

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

    75

				delta = 0;

    76

			}

    77

    78

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

    79

    80

			if (_iconsole_cmdline.caret)

    81

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

    82

			break;

    83

		}

    84

		case WE_MOUSELOOP:

    85

			if (HandleCaret(&_iconsole_cmdline))

    86

				SetWindowDirty(w);

    87

			break;

    88

		case WE_DESTROY:

    89

			_iconsole_win = NULL;

    90

			_iconsole_mode = ICONSOLE_CLOSED;

    91

			break;

    92

		case WE_KEYPRESS:

    93

			e->keypress.cont = false;

    94

			switch (e->keypress.keycode) {

    95

				case WKC_UP:

    96

					IConsoleCmdBufferNavigate(+1);

    97

					SetWindowDirty(w);

    98

					break;

    99

				case WKC_DOWN:

   100

					IConsoleCmdBufferNavigate(-1);

   101

					SetWindowDirty(w);

   102

					break;

   103

				case WKC_SHIFT | WKC_PAGEUP:

   104

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

   105

						_iconsole_scroll = 0;

   106

					else

   107

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

   108

					SetWindowDirty(w);

   109

					break;

   110

				case WKC_SHIFT | WKC_PAGEDOWN:

   111

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

   112

						_iconsole_scroll = ICON_BUFFER;

   113

					else

   114

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

   115

					SetWindowDirty(w);

   116

					break;

   117

				case WKC_SHIFT | WKC_UP:

   118

					if (_iconsole_scroll <= 0)

   119

						_iconsole_scroll = 0;

   120

					else

   121

						--_iconsole_scroll;

   122

					SetWindowDirty(w);

   123

					break;

   124

				case WKC_SHIFT | WKC_DOWN:

   125

					if (_iconsole_scroll >= ICON_BUFFER)

   126

						_iconsole_scroll = ICON_BUFFER;

   127

					else

   128

						++_iconsole_scroll;

   129

					SetWindowDirty(w);

   130

					break;

   131

				case WKC_BACKQUOTE:

   132

					IConsoleSwitch();

   133

					break;

   134

				case WKC_RETURN: case WKC_NUM_ENTER:

   135

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

   136

					_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   137

					IConsoleCmdBufferAdd(_iconsole_cmdline.buf);

   138

   139

					IConsoleCmdExec(_iconsole_cmdline.buf);

   140

					IConsoleClearCommand();

   141

					break;

   142

				case WKC_CTRL | WKC_RETURN:

   143

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

   144

					IConsoleResize();

   145

					MarkWholeScreenDirty();

   146

					break;

   147

				case (WKC_CTRL | 'V'):

   148

					if (InsertTextBufferClipboard(&_iconsole_cmdline))

   149

						SetWindowDirty(w);

   150

					break;

   151

				case WKC_BACKSPACE: case WKC_DELETE:

   152

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

   153

						SetWindowDirty(w);

   154

					_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   155

					break;

   156

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

   157

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

   158

						SetWindowDirty(w);

   159

					break;

   160

				default:

   161

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

   162

						_iconsole_scroll = ICON_BUFFER;

   163

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

   164

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   165

						SetWindowDirty(w);

   166

					} else

   167

						e->keypress.cont = true;

   168

			break;

   169

		}

   170

	}

   171

}

   172

   173

static const Widget _iconsole_window_widgets[] = {

   174

	{WIDGETS_END}

   175

};

   176

   177

static const WindowDesc _iconsole_window_desc = {

   178

	0, 0, 2, 2,

   179

	WC_CONSOLE, 0,

   180

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   181

	_iconsole_window_widgets,

   182

	IConsoleWndProc,

   183

};

   184

   185

extern const char _openttd_revision[];

   186

   187

void IConsoleInit(void)

   188

{

   189

	_iconsole_output_file = NULL;

   190

	_iconsole_color_default = 1;

   191

	_iconsole_color_error = 3;

   192

	_iconsole_color_warning = 13;

   193

	_iconsole_color_debug = 5;

   194

	_iconsole_color_commands = 2;

   195

	_iconsole_scroll = ICON_BUFFER;

   196

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   197

	_iconsole_inited = true;

   198

	_iconsole_mode = ICONSOLE_CLOSED;

   199

	_iconsole_win = NULL;

   200

   201

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   202

	_redirect_console_to_client = 0;

   203

#endif

   204

   205

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

   206

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

   207

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

   208

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

   209

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE - 1;

   210

   211

	IConsoleStdLibRegister();

   212

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

   213

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

   214

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

   215

	IConsolePrint(12, "");

   216

	IConsoleClearCommand();

   217

	IConsoleCmdBufferAdd("");

   218

}

   219

   220

void IConsoleClear(void)

   221

{

   222

	uint i;

   223

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

   224

		free(_iconsole_buffer[i]);

   225

   226

	free(_iconsole_cmdline.buf);

   227

}

   228

   229

static void IConsoleWriteToLogFile(const char* string)

   230

{

   231

	if (_iconsole_output_file != NULL) {

   232

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

   233

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

   234

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

   235

	}

   236

}

   237

   238

bool CloseConsoleLogIfActive(void)

   239

{

   240

	if (_iconsole_output_file != NULL) {

   241

		IConsolePrintF(_iconsole_color_default, "file output complete");

   242

		fclose(_iconsole_output_file);

   243

		_iconsole_output_file = NULL;

   244

		return true;

   245

	}

   246

   247

	return false;

   248

}

   249

   250

void IConsoleFree(void)

   251

{

   252

	_iconsole_inited = false;

   253

	IConsoleClear();

   254

	CloseConsoleLogIfActive();

   255

}

   256

   257

void IConsoleResize(void)

   258

{

   259

   260

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   261

   262

	switch (_iconsole_mode) {

   263

		case ICONSOLE_OPENED:

   264

			_iconsole_win->height = _screen.height / 3;

   265

			_iconsole_win->width = _screen.width;

   266

			break;

   267

		case ICONSOLE_FULL:

   268

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   269

			_iconsole_win->width = _screen.width;

   270

			break;

   271

		default:

   272

			break;

   273

	}

   274

   275

	MarkWholeScreenDirty();

   276

}

   277

   278

void IConsoleSwitch(void)

   279

{

   280

	switch (_iconsole_mode) {

   281

		case ICONSOLE_CLOSED:

   282

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   283

			_iconsole_win->height = _screen.height / 3;

   284

			_iconsole_win->width = _screen.width;

   285

			_iconsole_mode = ICONSOLE_OPENED;

   286

			SETBIT(_no_scroll, SCROLL_CON);

   287

			break;

   288

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   289

			DeleteWindowById(WC_CONSOLE, 0);

   290

			_iconsole_win = NULL;

   291

			_iconsole_mode = ICONSOLE_CLOSED;

   292

			CLRBIT(_no_scroll, SCROLL_CON);

   293

			break;

   294

	}

   295

   296

	MarkWholeScreenDirty();

   297

}

   298

   299

void IConsoleClose(void)

   300

{

   301

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   302

}

   303

   304

void IConsoleOpen(void)

   305

{

   306

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   307

}

   308

   309

void IConsoleCmdBufferAdd(const char* cmd)

   310

{

   311

	int i;

   312

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

   313

	free(_iconsole_cmdbuffer[ICON_CMDBUF_SIZE - 2]);

   314

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

   315

	_iconsole_cmdbuffer[0] = strdup(cmd);

   316

}

   317

   318

void IConsoleCmdBufferNavigate(signed char direction)

   319

{

   320

	int i;

   321

	i = _iconsole_cmdbufferpos + direction;

   322

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

   323

	if (i >= ICON_CMDBUF_SIZE) i = 0;

   324

	if (direction > 0)

   325

		while (_iconsole_cmdbuffer[i] == NULL) {

   326

			i++;

   327

			if (i >= ICON_CMDBUF_SIZE) i = 0;

   328

		}

   329

	if (direction < 0)

   330

		while (_iconsole_cmdbuffer[i] == NULL) {

   331

			--i;

   332

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

   333

		}

   334

	_iconsole_cmdbufferpos = i;

   335

	IConsoleClearCommand();

   336

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

   337

	UpdateTextBufferSize(&_iconsole_cmdline);

   338

}

   339

   340

/**

   341

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

   342

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

   343

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

   344

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

   345

 * used as a history to print them onscreen

   346

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

   347

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

   348

 */

   349

void IConsolePrint(uint16 color_code, const char* string)

   350

{

   351

	char *i;

   352

   353

#ifdef ENABLE_NETWORK

   354

	if (_redirect_console_to_client != 0) {

   355

		/* Redirect the string to the client */

   356

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

   357

		return;

   358

	}

   359

#endif

   360

   361

	if (_network_dedicated) {

   362

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

   363

		IConsoleWriteToLogFile(string);

   364

		return;

   365

	}

   366

   367

	if (!_iconsole_inited) return;

   368

   369

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

   370

	 * to accomodate for the new command/message */

   371

	free(_iconsole_buffer[0]);

   372

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

   373

	_iconsole_buffer[ICON_BUFFER] = strdup(string);

   374

   375

	// filter out unprintable characters

   376

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

   377

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

   378

   379

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

   380

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   381

   382

	IConsoleWriteToLogFile(string);

   383

   384

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

   385

}

   386

   387

   388

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

   389

{

   390

	va_list va;

   391

	char buf[1024];

   392

	int len;

   393

   394

	va_start(va, s);

   395

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

   396

	va_end(va);

   397

   398

	IConsolePrint(color_code, buf);

   399

}

   400

   401

void IConsoleDebug(const char* string)

   402

{

   403

	if (_stdlib_developer > 1)

   404

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

   405

}

   406

   407

void IConsoleError(const char* string)

   408

{

   409

	if (_stdlib_developer > 0)

   410

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

   411

}

   412

   413

void IConsoleWarning(const char* string)

   414

{

   415

	if (_stdlib_developer > 0)

   416

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

   417

}

   418

   419

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   420

{

   421

	char* _new;

   422

	_iconsole_cmd* item;

   423

	_iconsole_cmd* item_new;

   424

	_iconsole_cmd* item_before;

   425

   426

	_new = strdup(name);

   427

   428

	item_new = malloc(sizeof(_iconsole_cmd));

   429

   430

	item_new->_next = NULL;

   431

	item_new->addr = addr;

   432

	item_new->name = _new;

   433

   434

	item_new->hook_access = NULL;

   435

	item_new->hook_after_exec = NULL;

   436

	item_new->hook_before_exec = NULL;

   437

   438

	item_before = NULL;

   439

	item = _iconsole_cmds;

   440

   441

	if (item == NULL) {

   442

		_iconsole_cmds = item_new;

   443

	} else {

   444

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

   445

			item_before = item;

   446

			item = item->_next;

   447

			}

   448

// insertion sort

   449

		if (item_before==NULL) {

   450

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

   451

				// appending

   452

				item ->_next = item_new;

   453

			} else {

   454

				// inserting as startitem

   455

				_iconsole_cmds = item_new;

   456

				item_new ->_next = item;

   457

			}

   458

		} else {

   459

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

   460

				// appending

   461

				item ->_next = item_new;

   462

			} else {

   463

				// inserting

   464

				item_new ->_next = item_before->_next;

   465

				item_before ->_next = item_new;

   466

			}

   467

		}

   468

// insertion sort end

   469

	}

   470

   471

}

   472

   473

_iconsole_cmd* IConsoleCmdGet(const char* name)

   474

{

   475

	_iconsole_cmd* item;

   476

   477

	item = _iconsole_cmds;

   478

	while (item != NULL) {

   479

		if (strcmp(item->name, name) == 0) return item;

   480

		item = item->_next;

   481

	}

   482

	return NULL;