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"

    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 bool _iconsole_inited;

    28

static char* _iconsole_buffer[ICON_BUFFER + 1];

    29

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    31

static byte _iconsole_scroll;

    32

    33

// ** console cursor ** //

    34

static bool _icursor_state;

    35

static byte _icursor_rate;

    36

static byte _icursor_counter;

    37

    38

// ** stdlib ** //

    39

byte _stdlib_developer = 1;

    40

bool _stdlib_con_developer = false;

    41

FILE* _iconsole_output_file;

    42

    43

// ** main console cmd buffer

    44

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    45

static byte _iconsole_cmdbufferpos;

    46

    47

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

    48

/*  end of header  */

    49

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

    50

    51

static void IConsoleClearCommand(void)

    52

{

    58

	SetWindowDirty(_iconsole_win);

    59

}

    60

    62

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

    63

{

    64

	switch(e->event) {

    66

			int i = _iconsole_scroll;

    67

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

    68

			int delta = 0;

    69

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

    70

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

    71

				DoDrawString(_iconsole_buffer[i], 5,

    72

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

    73

				i--;

    74

			}

    77

			if (delta > 0) {

    78

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

    79

				delta = 0;

    80

			}

    81

    86

			break;

    87

		}

    91

			break;

    92

		case WE_DESTROY:

    93

			_iconsole_win = NULL;

    94

			_iconsole_mode = ICONSOLE_CLOSED;

    95

			break;

    96

		case WE_KEYPRESS:

    97

			e->keypress.cont = false;

    98

			switch (e->keypress.keycode) {

    99

				case WKC_UP:

   100

					IConsoleCmdBufferNavigate(+1);

   101

					SetWindowDirty(w);

   102

					break;

   103

				case WKC_DOWN:

   104

					IConsoleCmdBufferNavigate(-1);

   105

					SetWindowDirty(w);

   106

					break;

   107

				case WKC_SHIFT | WKC_PAGEUP:

   108

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

   109

						_iconsole_scroll = 0;

   110

					else

   111

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

   112

					SetWindowDirty(w);

   113

					break;

   114

				case WKC_SHIFT | WKC_PAGEDOWN:

   115

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

   116

						_iconsole_scroll = ICON_BUFFER;

   117

					else

   118

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

   119

					SetWindowDirty(w);

   120

					break;

   121

				case WKC_SHIFT | WKC_UP:

   122

					if (_iconsole_scroll <= 0)

   123

						_iconsole_scroll = 0;

   124

					else

   125

						--_iconsole_scroll;

   126

					SetWindowDirty(w);

   127

					break;

   128

				case WKC_SHIFT | WKC_DOWN:

   129

					if (_iconsole_scroll >= ICON_BUFFER)

   130

						_iconsole_scroll = ICON_BUFFER;

   131

					else

   132

						++_iconsole_scroll;

   133

					SetWindowDirty(w);

   134

					break;

   135

				case WKC_BACKQUOTE:

   136

					IConsoleSwitch();

   137

					break;

   142

   144

					IConsoleClearCommand();

   145

					break;

   146

				case WKC_CTRL | WKC_RETURN:

   148

					IConsoleResize();

   149

					MarkWholeScreenDirty();

   150

					break;

   163

					break;

   164

				default:

   166

						_iconsole_scroll = ICON_BUFFER;

   169

						SetWindowDirty(w);

   171

						e->keypress.cont = true;

   172

			break;

   173

		}

   174

	}

   175

}

   176

   189

extern const char _openttd_revision[];

   190

   191

void IConsoleInit(void)

   192

{

   193

	_iconsole_output_file = NULL;

   194

	_iconsole_color_default = 1;

   195

	_iconsole_color_error = 3;

   196

	_iconsole_color_warning = 13;

   197

	_iconsole_color_debug = 5;

   198

	_iconsole_color_commands = 2;

   199

	_iconsole_scroll = ICON_BUFFER;

   200

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   201

	_iconsole_inited = true;

   202

	_iconsole_mode = ICONSOLE_CLOSED;

   203

	_iconsole_win = NULL;

   204

	_icursor_state = false;

   205

	_icursor_rate = 5;

   206

	_icursor_counter = 0;

   207

   208

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   209

	_redirect_console_to_client = 0;

   210

#endif

   211

   212

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

   213

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

   214

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

   217

   218

	IConsoleStdLibRegister();

   219

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

   220

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

   221

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

   222

	IConsolePrint(12, "");

   223

	IConsoleClearCommand();

   224

	IConsoleCmdBufferAdd("");

   225

}

   226

   227

void IConsoleClear(void)

   228

{

   229

	uint i;

   230

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

   231

		free(_iconsole_buffer[i]);

   234

}

   235

   236

static void IConsoleWriteToLogFile(const char* string)

   237

{

   238

	if (_iconsole_output_file != NULL) {

   239

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

   240

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

   241

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

   242

	}

   243

}

   244

   245

bool CloseConsoleLogIfActive(void)

   246

{

   247

	if (_iconsole_output_file != NULL) {

   248

		IConsolePrintF(_iconsole_color_default, "file output complete");

   249

		fclose(_iconsole_output_file);

   250

		_iconsole_output_file = NULL;

   251

		return true;

   252

	}

   253

   254

	return false;

   255

}

   256

   257

void IConsoleFree(void)

   258

{

   259

	_iconsole_inited = false;

   260

	IConsoleClear();

   261

	CloseConsoleLogIfActive();

   262

}

   263

   264

void IConsoleResize(void)

   265

{

   266

   267

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   268

   269

	switch (_iconsole_mode) {

   270

		case ICONSOLE_OPENED:

   271

			_iconsole_win->height = _screen.height / 3;

   272

			_iconsole_win->width = _screen.width;

   273

			break;

   274

		case ICONSOLE_FULL:

   275

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   276

			_iconsole_win->width = _screen.width;

   277

			break;

   278

		default:

   279

			break;

   280

	}

   281

   282

	MarkWholeScreenDirty();

   283

}

   284

   285

void IConsoleSwitch(void)

   286

{

   287

	switch (_iconsole_mode) {

   288

		case ICONSOLE_CLOSED:

   289

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   290

			_iconsole_win->height = _screen.height / 3;

   291

			_iconsole_win->width = _screen.width;

   292

			_iconsole_mode = ICONSOLE_OPENED;

   293

			break;

   294

		case ICONSOLE_OPENED:

   295

			DeleteWindowById(WC_CONSOLE, 0);

   296

			_iconsole_win = NULL;

   297

			_iconsole_mode = ICONSOLE_CLOSED;

   298

			break;

   299

		case ICONSOLE_FULL:

   300

			DeleteWindowById(WC_CONSOLE, 0);

   301

			_iconsole_win = NULL;

   302

			_iconsole_mode = ICONSOLE_CLOSED;

   303

			break;

   304

	}

   305

   306

	MarkWholeScreenDirty();

   307

}

   308

   309

void IConsoleClose(void)

   310

{

   311

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   312

}

   313

   314

void IConsoleOpen(void)

   315

{

   316

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   317

}

   318

   319

void IConsoleCmdBufferAdd(const char* cmd)

   320

{

   321

	int i;

   325

	_iconsole_cmdbuffer[0] = strdup(cmd);

   326

}

   327

   328

void IConsoleCmdBufferNavigate(signed char direction)

   329

{

   330

	int i;

   331

	i = _iconsole_cmdbufferpos + direction;

   334

	if (direction > 0)

   335

		while (_iconsole_cmdbuffer[i] == NULL) {

   338

		}

   339

	if (direction < 0)

   340

		while (_iconsole_cmdbuffer[i] == NULL) {

   341

			--i;

   343

		}

   344

	_iconsole_cmdbufferpos = i;

   345

	IConsoleClearCommand();

   348

}

   349

   350

void IConsolePrint(uint16 color_code, const char* string)

   351

{

   352

	char* _ex;

   353

	char* _new;

   354

	uint16 _exc;

   355

	uint16 _newc;

   356

	char* i;

   357

	int j;

   358

   359

#ifdef ENABLE_NETWORK

   360

	if (_redirect_console_to_client != 0) {

   361

		/* Redirect the string to the client */

   362

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

   363

		return;

   364

	}

   365

#endif

   366

   367

	if (_network_dedicated) {

   368

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

   369

		IConsoleWriteToLogFile(string);

   370

		return;

   371

	}

   372

   373

	if (!_iconsole_inited) return;

   374

   375

	_newc = color_code;

   376

	_new = strdup(string);

   377

   378

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

   379

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

   380

   381

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

   382

		_ex = _iconsole_buffer[j];

   383

		_exc = _iconsole_cbuffer[j];

   384

		_iconsole_buffer[j] = _new;

   385

		_iconsole_cbuffer[j] = _newc;

   386

		_new = _ex;

   387

		_newc = _exc;

   388

	}

   389

	free(_ex);

   390

   391

	IConsoleWriteToLogFile(string);

   392

   393

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

   394

}

   395

   396

   397

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

   398

{

   399

	va_list va;

   400

	char buf[1024];

   401

	int len;

   402

   403

	va_start(va, s);

   404

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

   405

	va_end(va);

   406

   407

	IConsolePrint(color_code, buf);

   408

}

   409

   410

void IConsoleDebug(const char* string)

   411

{

   412

	if (_stdlib_developer > 1)

   413

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

   414

}

   415

   416

void IConsoleError(const char* string)

   417

{

   418

	if (_stdlib_developer > 0)

   419

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

   420

}

   421

   422

void IConsoleWarning(const char* string)

   423

{

   424

	if (_stdlib_developer > 0)

   425

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

   426

}

   427

   428

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   429

{

   430

	char* _new;

   431

	_iconsole_cmd* item;

   432

	_iconsole_cmd* item_new;

   433

	_iconsole_cmd* item_before;

   434

   435

	_new = strdup(name);

   436

   437

	item_new = malloc(sizeof(_iconsole_cmd));

   438

   439

	item_new->_next = NULL;

   440

	item_new->addr = addr;

   441

	item_new->name = _new;

   442

   443

	item_new->hook_access = NULL;

   444

	item_new->hook_after_exec = NULL;

   445

	item_new->hook_before_exec = NULL;

   446

   447

	item_before = NULL;

   448

	item = _iconsole_cmds;

   449

   450

	if (item == NULL) {

   451

		_iconsole_cmds = item_new;

   452

	} else {

   453

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

   454

			item_before = item;

   455

			item = item->_next;

   456

			}

   457

// insertion sort

   458

		if (item_before==NULL) {

   459

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

   460

				// appending

   461

				item ->_next = item_new;

   462

			} else {

   463

				// inserting as startitem

   464

				_iconsole_cmds = item_new;

   465

				item_new ->_next = item;

   466

			}

   467

		} else {

   468

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

   469

				// appending

   470

				item ->_next = item_new;

   471

			} else {

   472

				// inserting

   473

				item_new ->_next = item_before->_next;

   474

				item_before ->_next = item_new;

   475

			}

   476

		}

   477

// insertion sort end

   478

	}

   479

   480

}

   481

   482

_iconsole_cmd* IConsoleCmdGet(const char* name)

   483

{