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 byte _iconsole_scroll;

    36

    37

// ** console cursor ** //

    38

static bool _icursor_state;

    39

static byte _icursor_rate;

    40

static byte _icursor_counter;

    41

    42

// ** stdlib ** //

    43

byte _stdlib_developer = 1;

    44

bool _stdlib_con_developer = false;

    45

FILE* _iconsole_output_file;

    46

    47

// ** main console cmd buffer

    48

static char* _iconsole_cmdbuffer[ICON_CMDBUF_SIZE];

    49

static byte _iconsole_cmdbufferpos;

    50

    51

// ** console window ** //

    52

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

    53

static const Widget _iconsole_window_widgets[] = {

    54

	{WIDGETS_END}

    55

};

    56

static const WindowDesc _iconsole_window_desc = {

    57

	0, 0, 2, 2,

    58

	WC_CONSOLE, 0,

    59

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    60

	_iconsole_window_widgets,

    61

	IConsoleWndProc,

    62

};

    63

    64

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

    65

/*  end of header  */

    66

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

    67

    68

static void IConsoleAppendClipboard(void)

    69

{

    70

#ifdef WIN32

    71

	if (IsClipboardFormatAvailable(CF_TEXT)) {

    72

		const char* data;

    73

		HGLOBAL cbuf;

    74

    75

		OpenClipboard(NULL);

    76

		cbuf = GetClipboardData(CF_TEXT);

    77

		data = GlobalLock(cbuf);

    78

    79

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

    80

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

    81

			_iconsole_cmdline[_iconsole_cmdpos++] = *data;

    82

    83

		GlobalUnlock(cbuf);

    84

		CloseClipboard();

    85

	}

    86

#endif

    87

}

    88

    89

static void IConsoleClearCommand(void)

    90

{

    91

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

    92

	_iconsole_cmdpos = 0;

    93

	SetWindowDirty(_iconsole_win);

    94

}

    95

    96

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

    97

{

    98

	switch(e->event) {

    99

		case WE_PAINT:

   100

		{

   101

			int i = _iconsole_scroll;

   102

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

   103

			int delta = 0;

   104

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

   105

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

   106

				DoDrawString(_iconsole_buffer[i], 5,

   107

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

   108

				i--;

   109

			}

   110

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

   111

			if (delta > 0) {

   112

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

   113

				delta = 0;

   114

			}

   115

   116

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

   117

			break;

   118

		}

   119

		case WE_TICK:

   120

			_icursor_counter++;

   121

			if (_icursor_counter > _icursor_rate) {

   122

				int posx;

   123

				int posy;

   124

				int delta;

   125

   126

				_icursor_state = !_icursor_state;

   127

   128

				_cur_dpi = &_screen;

   129

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

   130

				if (delta > 0)

   131

					delta = 0;

   132

				posx = 10 + GetStringWidth(_iconsole_cmdline) + delta;

   133

				posy = w->height - 3;

   134

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

   135

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

   136

				_icursor_counter = 0;

   137

			}

   138

			break;

   139

		case WE_DESTROY:

   140

			_iconsole_win = NULL;

   141

			_iconsole_mode = ICONSOLE_CLOSED;

   142

			break;

   143

		case WE_KEYPRESS:

   144

		{

   145

			e->keypress.cont = false;

   146

			switch (e->keypress.keycode) {

   147

				case WKC_CTRL | 'V':

   148

					IConsoleAppendClipboard();

   149

					SetWindowDirty(w);

   150

					break;

   151

				case WKC_UP:

   152

					IConsoleCmdBufferNavigate(+1);

   153

					SetWindowDirty(w);

   154

					break;

   155

				case WKC_DOWN:

   156

					IConsoleCmdBufferNavigate(-1);

   157

					SetWindowDirty(w);

   158

					break;

   159

				case WKC_SHIFT | WKC_PAGEUP:

   160

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

   161

						_iconsole_scroll = 0;

   162

					else

   163

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

   164

					SetWindowDirty(w);

   165

					break;

   166

				case WKC_SHIFT | WKC_PAGEDOWN:

   167

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

   168

						_iconsole_scroll = ICON_BUFFER;

   169

					else

   170

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

   171

					SetWindowDirty(w);

   172

					break;

   173

				case WKC_SHIFT | WKC_UP:

   174

					if (_iconsole_scroll <= 0)

   175

						_iconsole_scroll = 0;

   176

					else

   177

						--_iconsole_scroll;

   178

					SetWindowDirty(w);

   179

					break;

   180

				case WKC_SHIFT | WKC_DOWN:

   181

					if (_iconsole_scroll >= ICON_BUFFER)

   182

						_iconsole_scroll = ICON_BUFFER;

   183

					else

   184

						++_iconsole_scroll;

   185

					SetWindowDirty(w);

   186

					break;

   187

				case WKC_BACKQUOTE:

   188

					IConsoleSwitch();

   189

					break;

   190

				case WKC_RETURN:

   191

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

   192

					_iconsole_cmdbufferpos = 19;

   193

					IConsoleCmdBufferAdd(_iconsole_cmdline);

   194

   195

					IConsoleCmdExec(_iconsole_cmdline);

   196

					IConsoleClearCommand();

   197

					break;

   198

				case WKC_CTRL | WKC_RETURN:

   199

					if (_iconsole_mode == ICONSOLE_FULL) {

   200

						_iconsole_mode = ICONSOLE_OPENED;

   201

					} else {

   202

						_iconsole_mode = ICONSOLE_FULL;

   203

					}

   204

					IConsoleResize();

   205

					MarkWholeScreenDirty();

   206

					break;

   207

				case WKC_BACKSPACE:

   208

					if (_iconsole_cmdpos != 0) _iconsole_cmdpos--;

   209

					_iconsole_cmdline[_iconsole_cmdpos] = 0;

   210

					SetWindowDirty(w);

   211

					_iconsole_cmdbufferpos = 19;

   212

					break;

   213

				default:

   214

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

   215

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

   216

						_iconsole_scroll = ICON_BUFFER;

   217

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

   218

						if (_iconsole_cmdpos != lengthof(_iconsole_cmdline))

   219

							_iconsole_cmdpos++;

   220

						SetWindowDirty(w);

   221

						_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   222

					}

   223

					else

   224

						e->keypress.cont = true;

   225

			}

   226

			break;

   227

		}

   228

	}

   229

}

   230

   231

extern const char _openttd_revision[];

   232

   233

void IConsoleInit(void)

   234

{

   235

	_iconsole_output_file = NULL;

   236

	_iconsole_color_default = 1;

   237

	_iconsole_color_error = 3;

   238

	_iconsole_color_warning = 13;

   239

	_iconsole_color_debug = 5;

   240

	_iconsole_color_commands = 2;

   241

	_iconsole_scroll = ICON_BUFFER;

   242

	_iconsole_cmdbufferpos = ICON_CMDBUF_SIZE - 1;

   243

	_iconsole_inited = true;

   244

	_iconsole_mode = ICONSOLE_CLOSED;

   245

	_iconsole_win = NULL;

   246

	_icursor_state = false;

   247

	_icursor_rate = 5;

   248

	_icursor_counter = 0;

   249

   250

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   251

	_redirect_console_to_client = 0;

   252

#endif

   253

   254

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

   255

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

   256

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

   257

   258

	IConsoleStdLibRegister();

   259

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

   260

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

   261

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

   262

	IConsolePrint(12, "");

   263

	IConsoleClearCommand();

   264

	IConsoleCmdBufferAdd("");

   265

}

   266

   267

void IConsoleClear(void)

   268

{

   269

	uint i;

   270

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

   271

		free(_iconsole_buffer[i]);

   272

}

   273

   274

static void IConsoleWriteToLogFile(const char* string)

   275

{

   276

	if (_iconsole_output_file != NULL) {

   277

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

   278

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

   279

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

   280

	}

   281

}

   282

   283

bool CloseConsoleLogIfActive(void)

   284

{

   285

	if (_iconsole_output_file != NULL) {

   286

		IConsolePrintF(_iconsole_color_default, "file output complete");

   287

		fclose(_iconsole_output_file);

   288

		_iconsole_output_file = NULL;

   289

		return true;

   290

	}

   291

   292

	return false;

   293

}

   294

   295

void IConsoleFree(void)

   296

{

   297

	_iconsole_inited = false;

   298

	IConsoleClear();

   299

	CloseConsoleLogIfActive();

   300

}

   301

   302

void IConsoleResize(void)

   303

{

   304

   305

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   306

   307

	switch (_iconsole_mode) {

   308

		case ICONSOLE_OPENED:

   309

			_iconsole_win->height = _screen.height / 3;

   310

			_iconsole_win->width = _screen.width;

   311

			break;

   312

		case ICONSOLE_FULL:

   313

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   314

			_iconsole_win->width = _screen.width;

   315

			break;

   316

		default:

   317

			break;

   318

	}

   319

   320

	MarkWholeScreenDirty();

   321

}

   322

   323

void IConsoleSwitch(void)

   324

{

   325

	switch (_iconsole_mode) {

   326

		case ICONSOLE_CLOSED:

   327

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   328

			_iconsole_win->height = _screen.height / 3;

   329

			_iconsole_win->width = _screen.width;

   330

			_iconsole_mode = ICONSOLE_OPENED;

   331

			break;

   332

		case ICONSOLE_OPENED:

   333

			DeleteWindowById(WC_CONSOLE, 0);

   334

			_iconsole_win = NULL;

   335

			_iconsole_mode = ICONSOLE_CLOSED;

   336

			break;

   337

		case ICONSOLE_FULL:

   338

			DeleteWindowById(WC_CONSOLE, 0);

   339

			_iconsole_win = NULL;

   340

			_iconsole_mode = ICONSOLE_CLOSED;

   341

			break;

   342

	}

   343

   344

	MarkWholeScreenDirty();

   345

}

   346

   347

void IConsoleClose(void)

   348

{

   349

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   350

}

   351

   352

void IConsoleOpen(void)

   353

{

   354

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   355

}

   356

   357

void IConsoleCmdBufferAdd(const char* cmd)

   358

{

   359

	int i;

   360

	if (_iconsole_cmdbufferpos != 19) return;

   361

	free(_iconsole_cmdbuffer[18]);

   362

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

   363

	_iconsole_cmdbuffer[0] = strdup(cmd);

   364

}

   365

   366

void IConsoleCmdBufferNavigate(signed char direction)

   367

{

   368

	int i;

   369

	i = _iconsole_cmdbufferpos + direction;

   370

	if (i < 0) i = 19;

   371

	if (i > 19) i = 0;

   372

	if (direction > 0)

   373

		while (_iconsole_cmdbuffer[i] == NULL) {

   374

			++i;

   375

			if (i > 19) i = 0;

   376

		}

   377

	if (direction < 0)

   378

		while (_iconsole_cmdbuffer[i] == NULL) {

   379

			--i;

   380

			if (i < 0) i = 19;

   381

		}

   382

	_iconsole_cmdbufferpos = i;

   383

	IConsoleClearCommand();

   384

	memcpy(_iconsole_cmdline, _iconsole_cmdbuffer[i],

   385

		strlen(_iconsole_cmdbuffer[i]));

   386

	_iconsole_cmdpos = strlen(_iconsole_cmdbuffer[i]);

   387

}

   388

   389

void IConsolePrint(uint16 color_code, const char* string)

   390

{

   391

	char* _ex;

   392

	char* _new;

   393

	uint16 _exc;

   394

	uint16 _newc;

   395

	char* i;

   396

	int j;

   397

   398

#ifdef ENABLE_NETWORK

   399

	if (_redirect_console_to_client != 0) {

   400

		/* Redirect the string to the client */

   401

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

   402

		return;

   403

	}

   404

#endif

   405

   406

	if (_network_dedicated) {

   407

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

   408

		IConsoleWriteToLogFile(string);

   409

		return;

   410

	}

   411

   412

	if (!_iconsole_inited) return;

   413

   414

	_newc = color_code;

   415

	_new = strdup(string);

   416

   417

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

   418

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

   419

   420

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

   421

		_ex = _iconsole_buffer[j];

   422

		_exc = _iconsole_cbuffer[j];

   423

		_iconsole_buffer[j] = _new;

   424

		_iconsole_cbuffer[j] = _newc;

   425

		_new = _ex;

   426

		_newc = _exc;

   427

	}

   428

	free(_ex);

   429

   430

	IConsoleWriteToLogFile(string);

   431

   432

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

   433

}

   434

   435

   436

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

   437

{

   438

	va_list va;

   439

	char buf[1024];

   440

	int len;

   441

   442

	va_start(va, s);

   443

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

   444

	va_end(va);

   445

   446

	IConsolePrint(color_code, buf);

   447

}

   448

   449

void IConsoleDebug(const char* string)

   450

{

   451

	if (_stdlib_developer > 1)

   452

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

   453

}

   454

   455

void IConsoleError(const char* string)

   456

{

   457

	if (_stdlib_developer > 0)

   458

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

   459

}

   460

   461

void IConsoleWarning(const char* string)

   462

{

   463

	if (_stdlib_developer > 0)

   464

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

   465

}

   466

   467

void IConsoleCmdRegister(const char* name, _iconsole_cmd_addr addr)

   468

{

   469

	char* _new;

   470

	_iconsole_cmd* item;

   471

	_iconsole_cmd* item_new;

   472

	_iconsole_cmd* item_before;

   473

   474

	_new = strdup(name);

   475

   476

	item_new = malloc(sizeof(_iconsole_cmd));

   477

   478

	item_new->_next = NULL;

   479

	item_new->addr = addr;

   480

	item_new->name = _new;

   481

   482

	item_new->hook_access = NULL;

   483

	item_new->hook_after_exec = NULL;