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 "hal.h"

    10

#include <stdarg.h>

    11

#include <string.h>

    12

#include "console.h"

    13

#include "network.h"

    14

#include "network_data.h"

    15

#include "network_server.h"

    16

    17

#ifdef WIN32

    18

#include <windows.h>

    19

#endif

    20

    21

#define ICON_BUFFER 79

    22

#define ICON_CMDBUF_SIZE 20

    23

#define ICON_CMDLN_SIZE 255

    24

#define ICON_LINE_HEIGHT 12

    25

#define ICON_RIGHT_BORDERWIDTH 10

    26

#define ICON_BOTTOM_BORDERWIDTH 12

    27

#define ICON_MAX_ALIAS_LINES 40

    28

    29

// ** main console ** //

    30

static bool _iconsole_inited;

    31

static char* _iconsole_buffer[ICON_BUFFER + 1];

    32

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    33

static char _iconsole_cmdline[ICON_CMDLN_SIZE];

    34

static byte _iconsole_cmdpos;

    35

static Window* _iconsole_win = NULL;

    36

static byte _iconsole_scroll;

    37

    38

// ** console cursor ** //

    39

static bool _icursor_state;

    40

static byte _icursor_rate;

    41

static byte _icursor_counter;

    42

    43

// ** stdlib ** //

    44

byte _stdlib_developer = 1;

    45

bool _stdlib_con_developer = false;

    46

FILE* _iconsole_output_file;

    47

    48

// ** main console cmd buffer

    49

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    50

static byte _iconsole_cmdbufferpos;

    51

    52

// ** console window ** //

    53

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

    54

static const Widget _iconsole_window_widgets[] = {

    55

	{WIDGETS_END}

    56

};

    57

static const WindowDesc _iconsole_window_desc = {

    58

	0, 0, 2, 2,

    59

	WC_CONSOLE, 0,

    60

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    61

	_iconsole_window_widgets,

    62

	IConsoleWndProc,

    63

};

    64

    65

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

    66

/*  end of header  */

    67

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

    68

    69

static void IConsoleAppendClipboard(void)

    70

{

    71

#ifdef WIN32

    72

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    73

		const char* data;

    74

		HGLOBAL cbuf;

    75

    76

		OpenClipboard(NULL);

    77

		cbuf = GetClipboardData(CF_TEXT);

    78

		data = GlobalLock(cbuf);

    79

    80

		/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

    81

		for (; (IS_INT_INSIDE(*data, ' ', 256)) && (_iconsole_cmdpos < lengthof(_iconsole_cmdline) - 1); ++data)

    82

			_iconsole_cmdline[_iconsole_cmdpos++] = *data;

    83

    84

		GlobalUnlock(cbuf);

    85

		CloseClipboard();

    86

	}

    87

#endif

    88

}

    89

    90

static void IConsoleClearCommand(void)

    91

{

    92

	memset(_iconsole_cmdline, 0, sizeof(_iconsole_cmdline));

    93

	_iconsole_cmdpos = 0;

    94

	SetWindowDirty(_iconsole_win);

    95

}

    96

    97

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

    98

{

    99

	switch(e->event) {

   100

		case WE_PAINT:

   101

		{

   102

			int i = _iconsole_scroll;

   103

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

   104

			int delta = 0;

   105

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

   106

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

   107

				DoDrawString(_iconsole_buffer[i], 5,

   108

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

   109

				i--;

   110

			}

   111

			delta = w->width - 10 - GetStringWidth(_iconsole_cmdline) - ICON_RIGHT_BORDERWIDTH;

   112

			if (delta > 0) {

   113

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

   114

				delta = 0;

   115

			}

   116

   117

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

   118

			break;

   119

		}

   120

		case WE_TICK:

   121

			_icursor_counter++;

   122

			if (_icursor_counter > _icursor_rate) {

   123

				int posx;

   124

				int posy;

   125

				int delta;

   126

   127

				_icursor_state = !_icursor_state;

   128

   129

				_cur_dpi = &_screen;

   130

				delta = w->width - 10 - GetStringWidth(_iconsole_cmdline) - ICON_RIGHT_BORDERWIDTH;

   131

				if (delta > 0)

   132

					delta = 0;

   133

				posx = 10 + GetStringWidth(_iconsole_cmdline) + delta;

   134

				posy = w->height - 3;

   135

				GfxFillRect(posx, posy, posx + 5, posy + 1, _icursor_state ? 14 : 0);

   136

				_video_driver->make_dirty(posx, posy, 5, 1);

   137

				_icursor_counter = 0;

   138

			}

   139

			break;

   140

		case WE_DESTROY:

   141

			_iconsole_win = NULL;

   142

			_iconsole_mode = ICONSOLE_CLOSED;

   143

			break;

   144

		case WE_KEYPRESS:

   145

		{

   146

			e->keypress.cont = false;

   147

			switch (e->keypress.keycode) {

   148

				case WKC_CTRL | 'V':

   149

					IConsoleAppendClipboard();

   150

					SetWindowDirty(w);

   151

					break;

   152

				case WKC_UP:

   153

					IConsoleCmdBufferNavigate(+1);

   154

					SetWindowDirty(w);

   155

					break;

   156

				case WKC_DOWN:

   157

					IConsoleCmdBufferNavigate(-1);

   158

					SetWindowDirty(w);

   159

					break;

   160

				case WKC_SHIFT | WKC_PAGEUP:

   161

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

   162

						_iconsole_scroll = 0;

   163

					else

   164

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

   165

					SetWindowDirty(w);

   166

					break;

   167

				case WKC_SHIFT | WKC_PAGEDOWN:

   168

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

   169

						_iconsole_scroll = ICON_BUFFER;

   170

					else

   171

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

   172

					SetWindowDirty(w);

   173

					break;

   174

				case WKC_SHIFT | WKC_UP:

   175

					if (_iconsole_scroll <= 0)

   176

						_iconsole_scroll = 0;

   177

					else

   178

						--_iconsole_scroll;

   179

					SetWindowDirty(w);

   180

					break;

   181

				case WKC_SHIFT | WKC_DOWN:

   182

					if (_iconsole_scroll >= ICON_BUFFER)

   183

						_iconsole_scroll = ICON_BUFFER;

   184

					else

   185

						++_iconsole_scroll;

   186

					SetWindowDirty(w);

   187

					break;

   188

				case WKC_BACKQUOTE:

   189

					IConsoleSwitch();

   190

					break;

   191

				case WKC_RETURN:

   192

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

   193

					_iconsole_cmdbufferpos = 19;

   194

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   195

   197

					IConsoleClearCommand();

   198

					break;

   199

				case WKC_CTRL | WKC_RETURN:

   200

					if (_iconsole_mode == ICONSOLE_FULL) {

   201

						_iconsole_mode = ICONSOLE_OPENED;

   202

					} else {

   203

						_iconsole_mode = ICONSOLE_FULL;

   204

					}

   205

					IConsoleResize();

   206

					MarkWholeScreenDirty();

   207

					break;

   208

				case WKC_BACKSPACE:

   209

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   210

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   211

					SetWindowDirty(w);

   212

					_iconsole_cmdbufferpos = 19;

   213

					break;

   214

				default:

   215

					/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   216

					if (IS_INT_INSIDE(e->keypress.ascii, ' ', 256)) {

   217

						_iconsole_scroll = ICON_BUFFER;

   218

						_iconsole_cmdline[_iconsole_cmdpos] = e->keypress.ascii;

   219

						if (_iconsole_cmdpos != lengthof(_iconsole_cmdline))

   220

							_iconsole_cmdpos++;

   221

						SetWindowDirty(w);

   222

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   223

					}

   224

					else

   225

						e->keypress.cont = true;

   226

			}

   227

			break;

   228

		}

   229

	}

   230

}

   231

   232

extern const char _openttd_revision[];

   233

   234

void IConsoleInit(void)

   235

{

   236

	uint i;

   237

	_iconsole_output_file = NULL;

   238

	_iconsole_color_default = 1;

   239

	_iconsole_color_error = 3;

   240

	_iconsole_color_warning = 13;

   241

	_iconsole_color_debug = 5;

   242

	_iconsole_color_commands = 2;

   243

	_iconsole_scroll = ICON_BUFFER;

   244

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   245

	_iconsole_inited = true;

   246

	_iconsole_mode = ICONSOLE_CLOSED;

   247

	_iconsole_win = NULL;

   248

	_icursor_state = false;

   249

	_icursor_rate = 5;

   250

	_icursor_counter = 0;

   251

	for (i = 0; i < lengthof(_iconsole_cmdbuffer); i++)

   252

		_iconsole_cmdbuffer[i] = NULL;

   253

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

   254

		_iconsole_buffer[i] = NULL;

   255

		_iconsole_cbuffer[i] = 0;

   256

	}

   257

	IConsoleStdLibRegister();

   258

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

   259

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

   260

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

   261

	IConsolePrint(12, "");

   262

	IConsoleClearCommand();

   263

	IConsoleCmdBufferAdd("");

   264

}

   265

   266

void IConsoleClear(void)

   267

{

   268

	uint i;

   269

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

   270

		free(_iconsole_buffer[i]);

   271

}

   272

   293

void IConsoleFree(void)

   294

{

   295

	_iconsole_inited = false;

   296

	IConsoleClear();

   298

}

   299

   300

void IConsoleResize(void)

   301

{

   302

   303

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   304

   305

	switch (_iconsole_mode) {

   306

		case ICONSOLE_OPENED:

   307

			_iconsole_win->height = _screen.height / 3;

   308

			_iconsole_win->width = _screen.width;

   309

			break;

   310

		case ICONSOLE_FULL:

   311

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   312

			_iconsole_win->width = _screen.width;

   313

			break;

   314

		default:

   315

			break;

   316

	}

   317

   318

	MarkWholeScreenDirty();

   319

}

   320

   321

void IConsoleSwitch(void)

   322

{

   323

	switch (_iconsole_mode) {

   324

		case ICONSOLE_CLOSED:

   325

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   326

			_iconsole_win->height = _screen.height / 3;

   327

			_iconsole_win->width = _screen.width;

   328

			_iconsole_mode = ICONSOLE_OPENED;

   329

			break;

   330

		case ICONSOLE_OPENED:

   331

			DeleteWindowById(WC_CONSOLE, 0);

   332

			_iconsole_win = NULL;

   333

			_iconsole_mode = ICONSOLE_CLOSED;

   334

			break;

   335

		case ICONSOLE_FULL:

   336

			DeleteWindowById(WC_CONSOLE, 0);

   337

			_iconsole_win = NULL;

   338

			_iconsole_mode = ICONSOLE_CLOSED;

   339

			break;

   340

	}

   341

   342

	MarkWholeScreenDirty();

   343

}

   344

   345

void IConsoleClose(void)

   346

{

   347

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   348

}

   349

   350

void IConsoleOpen(void)

   351

{

   352

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   353

}

   354

   355

void IConsoleCmdBufferAdd(const char* cmd)

   356

{

   357

	int i;

   358

	if (_iconsole_cmdbufferpos != 19) return;

   359

	free(_iconsole_cmdbuffer[18]);

   360

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

   361

	_iconsole_cmdbuffer[0] = strdup(cmd);

   362

}

   363

   364

void IConsoleCmdBufferNavigate(signed char direction)

   365

{

   366

	int i;

   367

	i = _iconsole_cmdbufferpos + direction;

   368

	if (i < 0) i = 19;

   369

	if (i > 19) i = 0;

   370

	if (direction > 0)

   371

		while (_iconsole_cmdbuffer[i] == NULL) {

   372

			++i;

   373

			if (i > 19) i = 0;

   374

		}

   375

	if (direction < 0)

   376

		while (_iconsole_cmdbuffer[i] == NULL) {

   377

			--i;

   378

			if (i < 0) i = 19;

   379

		}

   380

	_iconsole_cmdbufferpos = i;

   381

	IConsoleClearCommand();

   382

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   383

		strlen(_iconsole_cmdbuffer[i]));

   384

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   385

}

   386

   387

void IConsolePrint(uint16 color_code, const char* string)

   388

{

   389

	char* _ex;

   390

	char* _new;

   391

	uint16 _exc;

   392

	uint16 _newc;

   393

	char* i;

   394

	int j;

   395

   396

	if (_redirect_console_to_client != 0) {

   397

		/* Redirect the string to the client */

   398

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

   399

		return;

   400

	}

   401

   402

	if (_network_dedicated) {

   403

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

   405

		return;

   406

	}

   407

   408

	if (!_iconsole_inited) return;

   409

   410

	_newc = color_code;

   411

	_new = strdup(string);

   412

   413

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

   414

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

   415

   416

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

   417

		_ex = _iconsole_buffer[j];

   418

		_exc = _iconsole_cbuffer[j];

   419

		_iconsole_buffer[j] = _new;

   420

		_iconsole_cbuffer[j] = _newc;

   421

		_new = _ex;

   422

		_newc = _exc;

   423

	}

   424

	free(_ex);

   425

   427

   428

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

   429

}

   430

   431

   432

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

   433

{

   434

	va_list va;

   435

	char buf[1024];

   436

	int len;

   437

   438

	va_start(va, s);

   439

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

   440

	va_end(va);

   441

   442

	IConsolePrint(color_code, buf);

   443

}

   444

   445

void IConsoleDebug(const char* string)

   446

{

   447

	if (_stdlib_developer > 1)

   448

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

   449

}

   450

   451

void IConsoleError(const char* string)

   452

{

   453

	if (_stdlib_developer > 0)

   454

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

   455

}

   456

   457

void IConsoleWarning(const char* string)

   458

{

   459

	if (_stdlib_developer > 0)

   460

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

   461

}

   462

   463

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   464

{

   465

	char* _new;

   466

	_iconsole_cmd* item;

   467

	_iconsole_cmd* item_new;

   468

	_iconsole_cmd* item_before;

   469

   470

	_new = strdup(name);

   471

   472

	item_new = malloc(sizeof(_iconsole_cmd));

   473

   474

	item_new->_next = NULL;

   475

	item_new->addr = addr;

   476

	item_new->name = _new;

   477

   478

	item_new->hook_access = NULL;

   479

	item_new->hook_after_exec = NULL;

   480

	item_new->hook_before_exec = NULL;

   481

   482

	item_before = NULL;

   483

	item = _iconsole_cmds;