1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "window.h"

     4

#include "gui.h"

     5

#include "gfx.h"

     6

#include "player.h"

     7

#include "variables.h"

     8

#include "hal.h"

     9

#include <stdarg.h>

    10

#include "console.h"

    11

    12

    13

// ** main console ** //

    14

static bool _iconsole_inited;

    15

static byte* _iconsole_buffer[80];

    16

static byte _iconsole_cbuffer[80];

    17

static byte _iconsole_cmdline[255];

    18

static byte _iconsole_cmdpos;

    19

static byte _iconsole_mode = ICONSOLE_CLOSED;

    20

static Window *_iconsole_win = NULL;

    21

static byte _iconsole_scroll;

    22

    27

// ** console cursor ** //

    28

static bool _icursor_state;

    29

static byte _icursor_rate;

    30

static byte _icursor_counter;

    31

    32

// ** console window ** //

    33

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

    34

static const Widget _iconsole_window_widgets[] = {{WWT_LAST}};

    35

static const WindowDesc _iconsole_window_desc = {

    36

	0, 0, 2, 2,

    37

	WC_CONSOLE,0,

    38

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    39

	_iconsole_window_widgets,

    40

	IConsoleWndProc,

    41

};

    42

    43

// ** console parser ** //

    44

static _iconsole_cmd * _iconsole_cmds; // list of registred commands

    45

static _iconsole_var * _iconsole_vars; // list of registred vars

    46

    47

// ** console std lib ** // 

    48

static byte _stdlib_developer=1;

    50

static void IConsoleStdLibRegister();

    51

    52

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

    53

/*  end of header  */

    54

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

    55

    56

void IConsoleClearCommand()

    57

{

    58

int i;

    59

for (i=0; i<255; i++) _iconsole_cmdline[i]=0;

    60

_iconsole_cmdpos=0;

    61

SetWindowDirty(_iconsole_win);

    62

}

    63

    64

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

    65

{

    66

	switch(e->event) {

    67

    68

	case WE_PAINT:

    69

    70

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

    71

		{

    72

		int i=_iconsole_scroll;

    73

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

    74

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

    75

			DoDrawString(_iconsole_buffer[i],5,w->height-(((_iconsole_scroll+2)-i)*12),_iconsole_cbuffer[i]);

    76

			i--;

    77

			}

    78

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

    79

		DoDrawString((char *)&_iconsole_cmdline,10,w->height-12,_iconsole_color_commands);

    80

		}

    81

		break;

    82

    83

	case WE_TICK:

    84

    85

		_icursor_counter++;

    86

		if (_icursor_counter>_icursor_rate) {

    87

			_icursor_state=!_icursor_state;

    88

			{

    89

				int posx;

    90

				int posy;

    91

				int color;

    92

				_cur_dpi=&_screen;

    93

				if (_icursor_state) color=14; else color=0;

    94

				posx=10+GetStringWidth((char *)&_iconsole_cmdline);

    95

				posy=w->height-3;

    96

				GfxFillRect(posx,posy,posx+5,posy+1,color);

    97

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

    98

			}

    99

			_icursor_counter=0;			

   100

			}

   101

		break;

   102

   103

	case WE_KEYPRESS:

   104

		e->keypress.cont=false;

   116

			{

   117

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

   118

				_iconsole_scroll = 0;

   119

				} else {

   120

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

   121

				}

   122

			SetWindowDirty(w);

   123

			} else

   125

			{

   126

			if ((_iconsole_scroll + ((w->height/12)-1))>79) {

   127

				_iconsole_scroll = 79;

   128

				} else {

   129

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

   130

				}

   131

			SetWindowDirty(w);

   132

			} else

   134

			{

   135

			if ((_iconsole_scroll - 1)<0) {

   136

				_iconsole_scroll = 0;

   137

				} else {

   138

				_iconsole_scroll -= 1;

   139

				}

   140

			SetWindowDirty(w);

   141

			} else

   143

			{

   144

			if ((_iconsole_scroll + 1)>79) {

   145

				_iconsole_scroll = 79;

   146

				} else {

   147

				_iconsole_scroll += 1;

   148

				}

   149

			SetWindowDirty(w);

   150

			} else

   151

		if (e->keypress.keycode == WKC_BACKQUOTE)

   152

			{

   153

			IConsoleSwitch();

   154

			} else

   155

		if (e->keypress.keycode == WKC_RETURN) 

   156

			{

   157

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

   159

			IConsoleCmdExec((byte *) _iconsole_cmdline);

   160

			IConsoleClearCommand();

   161

			} else

   162

		if (e->keypress.keycode == WKC_BACKSPACE) 

   163

			{

   164

			if (_iconsole_cmdpos!=0) _iconsole_cmdpos--;

   165

			_iconsole_cmdline[_iconsole_cmdpos]=0;

   166

			SetWindowDirty(w);

   168

			} else

   169

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

   170

			{

   171

			_iconsole_scroll=79;

   172

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

   173

			if (_iconsole_cmdpos!=255) _iconsole_cmdpos++;	

   174

			SetWindowDirty(w);

   176

			} else e->keypress.cont=true;	

   177

		break;

   178

   179

	}

   180

}

   181

   182

void IConsoleInit()

   183

{

   184

int i;

   185

#if defined(WITH_REV)

   186

extern char _openttd_revision[];

   187

#endif

   192

_iconsole_scroll=79;

   194

_iconsole_inited=true;

   195

_iconsole_mode=ICONSOLE_CLOSED;

   196

_iconsole_win=NULL;

   197

_icursor_state=false;

   198

_icursor_rate=5;

   199

_icursor_counter=0;

   207

IConsoleStdLibRegister();

   208

#if defined(WITH_REV)

   210

#else

   212

#endif

   213

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

   214

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

   215

IConsolePrint(12,"");

   216

IConsoleClearCommand();

   218

}

   219

   220

void IConsoleClear()

   221

{

   222

int i;

   223

for (i=0;i<80;i++) if (_iconsole_buffer[i]!=NULL) {

   224

	free(_iconsole_buffer[i]);

   225

	}

   226

}

   227

   228

void IConsoleFree()

   229

{

   230

_iconsole_inited=false;

   231

IConsoleClear();

   232

}

   233

   234

void IConsoleResize() {

   235

	if (_iconsole_win!=NULL) {

   236

		_iconsole_win->height = _screen.height / 3;

   237

		_iconsole_win->width= _screen.width;

   238

	}

   239

}

   240

   241

void IConsoleSwitch()

   242

{

   243

	if (_iconsole_mode==ICONSOLE_CLOSED) {

   244

		_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   245

		_iconsole_win->height = _screen.height / 3;

   246

		_iconsole_win->width= _screen.width;

   247

		_iconsole_mode=ICONSOLE_OPENED;

   248

		} else

   249

	if (_iconsole_mode==ICONSOLE_OPENED) {

   250

		DeleteWindow(_iconsole_win);

   251

		_iconsole_win=NULL;

   252

		_iconsole_mode=ICONSOLE_CLOSED;

   253

		}

   254

	MarkWholeScreenDirty();

   255

	MarkAllViewportsDirty(0,0,_screen.width,_screen.height);

   256

	_video_driver->make_dirty(0,0,_screen.width,_screen.height);

   257

}

   258

   259

void IConsoleClose() {

   260

if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();

   261

_iconsole_mode=ICONSOLE_CLOSED;

   262

}

   263

   264

void IConsoleOpen() {

   265

if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();

   266

}

   267

   300

void IConsolePrint(byte color_code, byte* string)

   301

{

   302

byte * _ex;

   303

byte * _new;

   304

byte _exc;

   305

byte _newc;

   306

int i,j;

   307

   308

if (!_iconsole_inited) return;

   309

   310

_newc=color_code;

   311

i=strlen((char *)string);

   312

_new=malloc(i+1);

   313

memset(_new,0,i+1);

   314

memcpy(_new,string,i);

   315

   316

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

   317

	if (_new[j]<0x1F) _new[j]=0x20;

   318

	}

   319

   320

i=79;

   321

while (i>=0) {

   322

	_ex=_iconsole_buffer[i];

   323

	_exc=_iconsole_cbuffer[i];

   324

	_iconsole_buffer[i]=_new;

   325

	_iconsole_cbuffer[i]=_newc;

   326

	_new=_ex;

   327

	_newc=_exc;

   328

	i--;

   329

	}

   330

if (_ex!=NULL) free(_ex);

   331

   332

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

   333

}

   334

   335

   336

void IConsolePrintF(byte color_code, const char *s, ...)

   337

{

   338

	va_list va;

   339

	char buf[1024];

   340

	va_start(va, s);

   341

	vsprintf(buf, s, va);

   342

	va_end(va);

   343

	IConsolePrint(color_code, (byte *) &buf);

   344

}

   345

   346

void IConsoleDebug(byte* string) {

   347

if (_stdlib_developer>1) IConsolePrintF(_iconsole_color_debug, "DEBUG: %s", string);

   348

}

   349

   350

void IConsoleError(byte* string) {

   351

if (_stdlib_developer>0) IConsolePrintF(_iconsole_color_error, "ERROR: %s", string);

   352

}

   353

   354

void IConsoleCmdRegister(byte * name, void * addr) {

   355

byte * _new;

   356

_iconsole_cmd * item;

   357

_iconsole_cmd * item_new;

   358

int i;

   359

   360

	i=strlen((char *)name);

   361

	_new=malloc(i+1);

   362

	memset(_new,0,i+1);

   363

	memcpy(_new,name,i);

   364

   365

item_new = malloc(sizeof(_iconsole_cmd));

   366

   367

item_new->_next = NULL;

   368

item_new->addr  = addr;

   369

item_new->name  = _new;

   370

   371

item = _iconsole_cmds;

   372

if (item == NULL) {

   373

	_iconsole_cmds = item_new;

   374

	} else {

   375

	while (item->_next != NULL) { item = item->_next; };

   376

	item->_next = item_new;

   377

	}

   378

}

   379

   380

void* IConsoleCmdGetAddr(byte * name) {

   381

_iconsole_cmd * item;

   382

   383

item = _iconsole_cmds;

   384

while (item != NULL) { 

   385

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

   386

	item = item->_next;

   387

	}

   388

return NULL;

   389

}

   390

   391

void IConsoleVarRegister(byte * name, void * addr, byte type) {

   392

byte * _new;

   393

_iconsole_var * item;

   394

_iconsole_var * item_new;

   395

int i;

   396

   397

	i=strlen((char *)name)+1;

   398

	_new=malloc(i+1);

   399

	memset(_new,0,i+1);

   400

	_new[0]='*';

   401

	memcpy(_new+1,name,i);

   402

   403

item_new = malloc(sizeof(_iconsole_var));

   404

   405

item_new->_next = NULL;

   406

item_new->addr  = addr;

   407

item_new->name  = _new;

   408

item_new->type  = type;

   409

item_new->_malloc = false;

   410

   411

item = _iconsole_vars;

   412

if (item == NULL) {

   413

	_iconsole_vars = item_new;

   414

	} else {

   415

	while (item->_next != NULL) { item = item->_next; };

   416

	item->_next = item_new;

   417

	}

   418

}

   419

   420

void IConsoleVarInsert(_iconsole_var * var, byte * name) {

   421

byte * _new;

   422

_iconsole_var * item;

   423

_iconsole_var * item_new;

   424

int i;

   425

   426

item_new = var;

   427

   428

// dont allow to build variable rings

   429

if (item_new->_next != NULL) return;

   430

   431

	i=strlen((char *)name)+1;

   432

	_new=malloc(i+1);

   433

	memset(_new,0,i+1);

   434

	_new[0]='*';

   435

	memcpy(_new+1,name,i);

   436

   437

item_new->name  = _new;

   438

   439

item = _iconsole_vars;

   440

if (item == NULL) {

   441

	_iconsole_vars = item_new;

   442

	} else {

   443

	while (item->_next != NULL) { item = item->_next; };

   444

	item->_next = item_new;

   445

	}

   446

}

   447

   448

   449

_iconsole_var * IConsoleVarGet(byte * name) {

   450

_iconsole_var * item;

   451

   452

item = _iconsole_vars;

   453

while (item != NULL) { 

   454

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

   455

	item = item->_next;

   456

	}

   457

return NULL;

   458

}

   459

   460

_iconsole_var * IConsoleVarAlloc(byte type) {

   461

_iconsole_var * item;

   462

item=malloc(sizeof(_iconsole_var));

   463

item->_next = NULL;

   464

item->name  = "";

   465

item->type  = type;

   466

switch (item->type) {

   467

		case ICONSOLE_VAR_BOOLEAN:

   468

				{

   469

				item->addr=malloc(sizeof(bool));

   470

				memset(item->addr,0,sizeof(bool));

   471

				item->_malloc=true;

   472

				}

   473

				break;

   474

		case ICONSOLE_VAR_BYTE:

   475

				{

   476

				item->addr=malloc(sizeof(byte));

   477

				memset(item->addr,0,sizeof(byte));

   478

				item->_malloc=true;

   479

				}

   480

				break;

   481

		case ICONSOLE_VAR_UINT16:

   482

				{

   483

				item->addr=malloc(sizeof(unsigned short));

   484

				memset(item->addr,0,sizeof(unsigned short));

   485

				item->_malloc=true;

   486

				}

   487

				break;

   488

		case ICONSOLE_VAR_UINT32:

   489

				{

   490

				item->addr=malloc(sizeof(unsigned int));

   491

				memset(item->addr,0,sizeof(unsigned int));

   492

				item->_malloc=true;

   493

				}

   494

				break;