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

    23

// ** main console cmd buffer ** // sign_de: especialy for Celestar :D

    24

static byte* _iconsole_cmdbuffer[20];

    25

static byte _iconsole_cmdbufferpos;

    26

    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[] = {{WIDGETS_END}};

    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;

    49

static bool _stdlib_con_developer=false;

    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_DESTROY:

   104

		_iconsole_win=NULL;

   105

		_iconsole_mode=ICONSOLE_CLOSED;

   106

		break;

   107

   108

	case WE_KEYPRESS:

   109

		e->keypress.cont=false;

   110

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

   111

			{

   112

			IConsoleCmdBufferNavigate(+1);

   113

			SetWindowDirty(w);

   114

			} else

   115

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

   116

			{

   117

			IConsoleCmdBufferNavigate(-1);

   118

			SetWindowDirty(w);

   119

			} else

   120

		if (e->keypress.keycode == (WKC_SHIFT | WKC_PAGEUP))

   121

			{

   122

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

   123

				_iconsole_scroll = 0;

   124

				} else {

   125

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

   126

				}

   127

			SetWindowDirty(w);

   128

			} else

   129

		if (e->keypress.keycode == (WKC_SHIFT | WKC_PAGEDOWN))

   130

			{

   131

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

   132

				_iconsole_scroll = 79;

   133

				} else {

   134

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

   135

				}

   136

			SetWindowDirty(w);

   137

			} else

   138

		if (e->keypress.keycode == (WKC_SHIFT | WKC_UP))

   139

			{

   140

			if ((_iconsole_scroll - 1)<0) {

   141

				_iconsole_scroll = 0;

   142

				} else {

   143

				_iconsole_scroll -= 1;

   144

				}

   145

			SetWindowDirty(w);

   146

			} else

   147

		if (e->keypress.keycode == (WKC_SHIFT | WKC_DOWN))

   148

			{

   149

			if ((_iconsole_scroll + 1)>79) {

   150

				_iconsole_scroll = 79;

   151

				} else {

   152

				_iconsole_scroll += 1;

   153

				}

   154

			SetWindowDirty(w);

   155

			} else

   156

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

   157

			{

   158

			IConsoleSwitch();

   159

			} else

   160

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

   161

			{

   162

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

   163

			IConsoleCmdBufferAdd(_iconsole_cmdline);

   164

			IConsoleCmdExec((byte *) _iconsole_cmdline);

   165

			IConsoleClearCommand();

   166

			} else

   167

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

   168

			{

   169

			if (_iconsole_cmdpos!=0) _iconsole_cmdpos--;

   170

			_iconsole_cmdline[_iconsole_cmdpos]=0;

   171

			SetWindowDirty(w);

   172

			_iconsole_cmdbufferpos=19;

   173

			} else

   174

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

   175

			{

   176

			_iconsole_scroll=79;

   177

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

   178

			if (_iconsole_cmdpos!=255) _iconsole_cmdpos++;	

   179

			SetWindowDirty(w);

   180

			_iconsole_cmdbufferpos=19;

   181

			} else e->keypress.cont=true;	

   182

		break;

   183

   184

	}

   185

}

   186

   187

void IConsoleInit()

   188

{

   189

int i;

   190

#if defined(WITH_REV)

   191

extern char _openttd_revision[];

   192

#endif

   193

_iconsole_color_default = 1;

   194

_iconsole_color_error = 3;

   195

_iconsole_color_debug = 5;

   196

_iconsole_color_commands = 2;

   197

_iconsole_scroll=79;

   198

_iconsole_cmdbufferpos=19;

   199

_iconsole_inited=true;

   200

_iconsole_mode=ICONSOLE_CLOSED;

   201

_iconsole_win=NULL;

   202

_icursor_state=false;

   203

_icursor_rate=5;

   204

_icursor_counter=0;

   205

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

   206

	_iconsole_cmdbuffer[i]=NULL;

   207

	}

   208

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

   209

	_iconsole_buffer[i]=NULL;

   210

	_iconsole_cbuffer[i]=0;

   211

	}

   212

IConsoleStdLibRegister();

   213

#if defined(WITH_REV)

   214

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

   215

#else

   216

IConsolePrint(13,"OpenTTD Game Console Revision 3");	

   217

#endif

   218

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

   219

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

   220

IConsolePrint(12,"");

   221

IConsoleClearCommand();

   222

IConsoleCmdBufferAdd("");

   223

}

   224

   225

void IConsoleClear()

   226

{

   227

int i;

   228

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

   229

	free(_iconsole_buffer[i]);

   230

	}

   231

}

   232

   233

void IConsoleFree()

   234

{

   235

_iconsole_inited=false;

   236

IConsoleClear();

   237

}

   238

   239

void IConsoleResize() {

   240

	if (_iconsole_win!=NULL) {

   241

		_iconsole_win->height = _screen.height / 3;

   242

		_iconsole_win->width= _screen.width;

   243

	}

   244

}

   245

   246

void IConsoleSwitch()

   247

{

   248

	if (_iconsole_mode==ICONSOLE_CLOSED) {

   249

		_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   250

		_iconsole_win->height = _screen.height / 3;

   251

		_iconsole_win->width= _screen.width;

   252

		_iconsole_mode=ICONSOLE_OPENED;

   253

		} else

   254

	if (_iconsole_mode==ICONSOLE_OPENED) {

   255

		DeleteWindow(_iconsole_win);

   256

		_iconsole_win=NULL;

   257

		_iconsole_mode=ICONSOLE_CLOSED;

   258

		}

   259

	MarkWholeScreenDirty();

   260

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

   261

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

   262

}

   263

   264

void IConsoleClose() {

   265

if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();

   266

_iconsole_mode=ICONSOLE_CLOSED;

   267

}

   268

   269

void IConsoleOpen() {

   270

if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();

   271

}

   272

   273

void IConsoleCmdBufferAdd(byte * cmd) {

   274

int i;

   275

if (_iconsole_cmdbufferpos != 19) return;

   276

if (_iconsole_cmdbuffer[18]!=NULL) free(_iconsole_cmdbuffer[18]);

   277

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

   278

i=strlen((char *)cmd);

   279

_iconsole_cmdbuffer[0]=malloc(i+1);

   280

memset(((void *)_iconsole_cmdbuffer[0]),0,i+1);

   281

memcpy(((void *)_iconsole_cmdbuffer[0]),(void *)cmd,i);

   282

_iconsole_cmdbuffer[0][i]=0;

   283

_iconsole_cmdbufferpos = 19;

   284

}

   285

   286

void IConsoleCmdBufferNavigate(signed char direction) {

   287

int i;

   288

i=_iconsole_cmdbufferpos + direction;

   289

if (i<0) i=19;

   290

if (i>19) i=0;

   291

if (direction>0) while (_iconsole_cmdbuffer[i]==NULL) {

   292

	i++;

   293

	if (i>19) i=0;

   294

	}

   295

if (direction<0) while (_iconsole_cmdbuffer[i]==NULL) {

   296

	i--;

   297

	if (i<0) i=19;

   298

	}

   299

_iconsole_cmdbufferpos = i;

   300

IConsoleClearCommand();

   301

memcpy((void *)_iconsole_cmdline,(void *)_iconsole_cmdbuffer[i],strlen(_iconsole_cmdbuffer[i]));

   302

_iconsole_cmdpos =strlen(_iconsole_cmdbuffer[i]);

   303

}

   304

   305

void IConsolePrint(byte color_code, byte* string)

   306

{

   307

byte * _ex;

   308

byte * _new;

   309

byte _exc;

   310

byte _newc;

   311

int i,j;

   312

   313

if (!_iconsole_inited) return;

   314

   315

_newc=color_code;

   316

i=strlen((char *)string);

   317

_new=malloc(i+1);

   318

memset(_new,0,i+1);

   319

memcpy(_new,string,i);

   320

   321

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

   322

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

   323

	}

   324

   325

i=79;

   326

while (i>=0) {

   327

	_ex=_iconsole_buffer[i];

   328

	_exc=_iconsole_cbuffer[i];

   329

	_iconsole_buffer[i]=_new;

   330

	_iconsole_cbuffer[i]=_newc;

   331

	_new=_ex;

   332

	_newc=_exc;

   333

	i--;

   334

	}

   335

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

   336

   337

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

   338

}

   339

   340

   341

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

   342

{

   343

	va_list va;

   344

	char buf[1024];

   345

	va_start(va, s);

   346

	vsprintf(buf, s, va);

   347

	va_end(va);

   348

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

   349

}

   350

   351

void IConsoleDebug(byte* string) {

   352

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

   353

}

   354

   355

void IConsoleError(byte* string) {

   356

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

   357

}

   358

   359

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

   360

byte * _new;

   361

_iconsole_cmd * item;

   362

_iconsole_cmd * item_new;

   363

int i;

   364

   365

	i=strlen((char *)name);

   366

	_new=malloc(i+1);

   367

	memset(_new,0,i+1);

   368

	memcpy(_new,name,i);

   369

   370

item_new = malloc(sizeof(_iconsole_cmd));

   371

   372

item_new->_next = NULL;

   373

item_new->addr  = addr;

   374

item_new->name  = _new;

   375

   376

item = _iconsole_cmds;

   377

if (item == NULL) {

   378

	_iconsole_cmds = item_new;

   379

	} else {

   380

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

   381

	item->_next = item_new;

   382

	}

   383

}

   384

   385

void* IConsoleCmdGetAddr(byte * name) {

   386

_iconsole_cmd * item;

   387

   388

item = _iconsole_cmds;

   389

while (item != NULL) { 

   390

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

   391

	item = item->_next;

   392

	}

   393

return NULL;

   394

}

   395

   396

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

   397

byte * _new;

   398

_iconsole_var * item;

   399

_iconsole_var * item_new;

   400

int i;

   401

   402

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

   403

	_new=malloc(i+1);

   404

	memset(_new,0,i+1);

   405

	_new[0]='*';

   406

	memcpy(_new+1,name,i);

   407

   408

item_new = malloc(sizeof(_iconsole_var));

   409

   410

item_new->_next = NULL;

   411

item_new->addr  = addr;

   412

item_new->name  = _new;

   413

item_new->type  = type;

   414

item_new->_malloc = false;

   415

   416

item = _iconsole_vars;

   417

if (item == NULL) {

   418

	_iconsole_vars = item_new;

   419

	} else {

   420

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

   421

	item->_next = item_new;

   422

	}

   423

}

   424

   425

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

   426

byte * _new;

   427

_iconsole_var * item;

   428

_iconsole_var * item_new;

   429

int i;

   430

   431

item_new = var;

   432

   433

// dont allow to build variable rings

   434

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

   435

   436

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

   437

	_new=malloc(i+1);

   438

	memset(_new,0,i+1);

   439

	_new[0]='*';

   440

	memcpy(_new+1,name,i);

   441

   442

item_new->name  = _new;

   443

   444

item = _iconsole_vars;

   445

if (item == NULL) {

   446

	_iconsole_vars = item_new;

   447

	} else {

   448

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

   449

	item->_next = item_new;

   450

	}

   451

}

   452

   453

   454

_iconsole_var * IConsoleVarGet(byte * name) {

   455

_iconsole_var * item;

   456

   457

item = _iconsole_vars;

   458

while (item != NULL) { 

   459

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

   460

	item = item->_next;

   461

	}

   462

return NULL;

   463

}

   464

   465

_iconsole_var * IConsoleVarAlloc(byte type) {

   466

_iconsole_var * item;

   467

item=malloc(sizeof(_iconsole_var));

   468

item->_next = NULL;

   469

item->name  = "";

   470

item->type  = type;

   471

switch (item->type) {

   472

		case ICONSOLE_VAR_BOOLEAN:

   473

				{

   474

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

   475

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

   476

				item->_malloc=true;

   477

				}

   478

				break;

   479

		case ICONSOLE_VAR_BYTE:

   480

				{

   481

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

   482

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

   483

				item->_malloc=true;

   484

				}

   485

				break;

   486

		case ICONSOLE_VAR_UINT16:

   487

				{

   488

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

   489

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

   490

				item->_malloc=true;

   491

				}

   492

				break;

   493

		case ICONSOLE_VAR_UINT32: