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

    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

    26

    27

// ** main console ** //

    28

static Window *_iconsole_win; // Pointer to console window

    29

static bool _iconsole_inited;

    30

static char* _iconsole_buffer[ICON_BUFFER + 1];

    31

static uint16 _iconsole_cbuffer[ICON_BUFFER + 1];

    32

static Textbuf _iconsole_cmdline;

    33

static byte _iconsole_scroll;

    34

    35

// ** stdlib ** //

    36

byte _stdlib_developer = 1;

    37

bool _stdlib_con_developer = false;

    38

FILE* _iconsole_output_file;

    39

    40

// ** main console cmd buffer

    43

    44

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

    45

/*  end of header  */

    46

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

    47

    48

static void IConsoleClearCommand(void)

    49

{

    50

	memset(_iconsole_cmdline.buf, 0, ICON_CMDLN_SIZE);

    51

	_iconsole_cmdline.length = 0;

    52

	_iconsole_cmdline.width = 0;

    53

	_iconsole_cmdline.caretpos = 0;

    54

	_iconsole_cmdline.caretxoffs = 0;

    55

	SetWindowDirty(_iconsole_win);

    56

}

    57

    60

// ** console window ** //

    61

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

    62

{

    64

		case WE_PAINT: {

    65

			int i = _iconsole_scroll;

    66

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

    67

			int delta = 0;

    68

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

    69

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

    70

				DoDrawString(_iconsole_buffer[i], 5,

    71

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

    72

				i--;

    73

			}

    74

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

    75

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

    76

			if (delta > 0) {

    77

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

    78

				delta = 0;

    79

			}

    80

    81

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

    82

    83

			if (_iconsole_cmdline.caret)

    84

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

    85

			break;

    86

		}

    87

		case WE_MOUSELOOP:

    88

			if (HandleCaret(&_iconsole_cmdline))

    89

				SetWindowDirty(w);

    90

			break;

    91

		case WE_DESTROY:

    92

			_iconsole_win = NULL;

    93

			_iconsole_mode = ICONSOLE_CLOSED;

    94

			break;

    95

		case WE_KEYPRESS:

    96

			e->keypress.cont = false;

    97

			switch (e->keypress.keycode) {

    98

				case WKC_UP:

   100

					SetWindowDirty(w);

   101

					break;

   102

				case WKC_DOWN:

   104

					SetWindowDirty(w);

   105

					break;

   106

				case WKC_SHIFT | WKC_PAGEUP:

   107

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

   108

						_iconsole_scroll = 0;

   109

					else

   110

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

   111

					SetWindowDirty(w);

   112

					break;

   113

				case WKC_SHIFT | WKC_PAGEDOWN:

   114

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

   115

						_iconsole_scroll = ICON_BUFFER;

   116

					else

   117

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

   118

					SetWindowDirty(w);

   119

					break;

   120

				case WKC_SHIFT | WKC_UP:

   121

					if (_iconsole_scroll <= 0)

   122

						_iconsole_scroll = 0;

   123

					else

   124

						--_iconsole_scroll;

   125

					SetWindowDirty(w);

   126

					break;

   127

				case WKC_SHIFT | WKC_DOWN:

   128

					if (_iconsole_scroll >= ICON_BUFFER)

   129

						_iconsole_scroll = ICON_BUFFER;

   130

					else

   131

						++_iconsole_scroll;

   132

					SetWindowDirty(w);

   133

					break;

   134

				case WKC_BACKQUOTE:

   135

					IConsoleSwitch();

   136

					break;

   137

				case WKC_RETURN: case WKC_NUM_ENTER:

   138

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

   140

   141

					IConsoleCmdExec(_iconsole_cmdline.buf);

   142

					IConsoleClearCommand();

   143

					break;

   144

				case WKC_CTRL | WKC_RETURN:

   145

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

   146

					IConsoleResize();

   147

					MarkWholeScreenDirty();

   148

					break;

   149

				case (WKC_CTRL | 'V'):

   152

						SetWindowDirty(w);

   154

					break;

   155

				case WKC_BACKSPACE: case WKC_DELETE:

   158

						SetWindowDirty(w);

   160

					break;

   161

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

   164

						SetWindowDirty(w);

   166

					break;

   167

				default:

   168

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

   169

						_iconsole_scroll = ICON_BUFFER;

   170

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

   172

						SetWindowDirty(w);

   173

					} else

   174

						e->keypress.cont = true;

   175

			break;

   176

		}

   177

	}

   178

}

   179

   180

static const Widget _iconsole_window_widgets[] = {

   181

	{WIDGETS_END}

   182

};

   183

   184

static const WindowDesc _iconsole_window_desc = {

   185

	0, 0, 2, 2,

   186

	WC_CONSOLE, 0,

   187

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   188

	_iconsole_window_widgets,

   189

	IConsoleWndProc,

   190

};

   191

   192

extern const char _openttd_revision[];

   193

   194

void IConsoleInit(void)

   195

{

   196

	_iconsole_output_file = NULL;

   197

	_iconsole_color_default = 1;

   198

	_iconsole_color_error = 3;

   199

	_iconsole_color_warning = 13;

   200

	_iconsole_color_debug = 5;

   201

	_iconsole_color_commands = 2;

   202

	_iconsole_scroll = ICON_BUFFER;

   204

	_iconsole_inited = true;

   205

	_iconsole_mode = ICONSOLE_CLOSED;

   206

	_iconsole_win = NULL;

   207

   208

#ifdef ENABLE_NETWORK /* Initialize network only variables */

   209

	_redirect_console_to_client = 0;

   210

#endif

   211

   213

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

   214

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

   215

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

   216

	_iconsole_cmdline.maxlength = ICON_CMDLN_SIZE - 1;

   217

   218

	IConsoleStdLibRegister();

   223

	IConsoleClearCommand();

   225

}

   226

   227

void IConsoleClear(void)

   228

{

   229

	uint i;

   230

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

   231

		free(_iconsole_buffer[i]);

   232

   233

	free(_iconsole_cmdline.buf);

   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

	_iconsole_win = FindWindowById(WC_CONSOLE, 0);

   267

   268

	switch (_iconsole_mode) {

   269

		case ICONSOLE_OPENED:

   270

			_iconsole_win->height = _screen.height / 3;

   271

			_iconsole_win->width = _screen.width;

   272

			break;

   273

		case ICONSOLE_FULL:

   274

			_iconsole_win->height = _screen.height - ICON_BOTTOM_BORDERWIDTH;

   275

			_iconsole_win->width = _screen.width;

   276

			break;

   277

		default:

   279

	}

   280

   281

	MarkWholeScreenDirty();

   282

}

   283

   284

void IConsoleSwitch(void)

   285

{

   286

	switch (_iconsole_mode) {

   287

		case ICONSOLE_CLOSED:

   288

			_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   289

			_iconsole_win->height = _screen.height / 3;

   290

			_iconsole_win->width = _screen.width;

   291

			_iconsole_mode = ICONSOLE_OPENED;

   293

			break;

   294

		case ICONSOLE_OPENED: case ICONSOLE_FULL:

   295

			DeleteWindowById(WC_CONSOLE, 0);

   296

			_iconsole_win = NULL;

   297

			_iconsole_mode = ICONSOLE_CLOSED;

   298

			CLRBIT(_no_scroll, SCROLL_CON);

   299

			break;

   300

	}

   301

   302

	MarkWholeScreenDirty();

   303

}

   304

   305

void IConsoleClose(void)

   306

{

   307

	if (_iconsole_mode == ICONSOLE_OPENED) IConsoleSwitch();

   308

}

   309

   310

void IConsoleOpen(void)

   311

{

   312

	if (_iconsole_mode == ICONSOLE_CLOSED) IConsoleSwitch();

   313

}

   314

   321

{

   327

}

   328

   334

{

   341

	if (direction > 0)

   349

	IConsoleClearCommand();

   353

	UpdateTextBufferSize(&_iconsole_cmdline);

   354

}

   355

   356

/**

   357

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

   358

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

   359

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

   360

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

   361

 * used as a history to print them onscreen

   362

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

   363

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

   364

 */

   365

void IConsolePrint(uint16 color_code, const char* string)

   366

{

   367

	char *i;

   368

   369

#ifdef ENABLE_NETWORK

   370

	if (_redirect_console_to_client != 0) {

   371

		/* Redirect the string to the client */

   372

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

   373

		return;

   374

	}

   375

#endif

   376

   377

	if (_network_dedicated) {

   378

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

   379

		IConsoleWriteToLogFile(string);

   380

		return;

   381

	}

   382

   383

	if (!_iconsole_inited) return;

   384

   385

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

   386

	 * to accomodate for the new command/message */

   387

	free(_iconsole_buffer[0]);

   388

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

   389

	_iconsole_buffer[ICON_BUFFER] = strdup(string);

   390

   391

	// filter out unprintable characters

   392

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

   393

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

   394

   395

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

   396

	_iconsole_cbuffer[ICON_BUFFER] = color_code;

   397

   398

	IConsoleWriteToLogFile(string);

   399

   400

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

   401

}

   402

   408

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

   409

{

   410

	va_list va;

   412

   413

	va_start(va, s);

   415

	va_end(va);

   416

   417

	IConsolePrint(color_code, buf);

   418

}

   419

   426

void IConsoleDebug(const char* string)

   427

{

   428

	if (_stdlib_developer > 1)

   429

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

   430

}

   431

   437

void IConsoleWarning(const char* string)

   438

{

   439

	if (_stdlib_developer > 0)

   440

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

   441

}

   442

   448

{

   451

   462

   463

	item_new->_next = NULL;

   464

	item_new->addr = addr;

   466

   467

	item_new->hook_access = NULL;

   468

	item_new->hook_after_exec = NULL;

   469

	item_new->hook_before_exec = NULL;

   470

   477

	item_before = NULL;

   478

	item = _iconsole_cmds;

   479