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

{

    69

	switch(e->event) {

    70

    71

	case WE_PAINT:

    72

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

    73

		{

    74

		int i=_iconsole_scroll;

    75

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

    76

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

    77

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

    78

			i--;

    79

			}

    80

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

    81

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

    82

		}

    83

		break;

    84

    85

	case WE_TICK:

    86

    87

		_icursor_counter++;

    88

		if (_icursor_counter>_icursor_rate) {

    89

			_icursor_state=!_icursor_state;

    90

			{

    91

				int posx;

    92

				int posy;

    93

				int color;

    94

				_cur_dpi=&_screen;

    95

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

    96

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

    97

				posy=w->height-3;

    98

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

    99

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

   100

			}

   101

			_icursor_counter=0;

   102

			}

   103

		break;

   104

   105

	case WE_DESTROY:

   106

		_iconsole_win=NULL;

   107

		_iconsole_mode=ICONSOLE_CLOSED;

   108

		break;

   109

   110

	case WE_KEYPRESS:

   111

		e->keypress.cont=false;

   112

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

   113

			{

   114

			IConsoleCmdBufferNavigate(+1);

   115

			SetWindowDirty(w);

   116

			} else

   117

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

   118

			{

   119

			IConsoleCmdBufferNavigate(-1);

   120

			SetWindowDirty(w);

   121

			} else

   122

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

   123

			{

   124

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

   125

				_iconsole_scroll = 0;

   126

				} else {

   127

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

   128

				}

   129

			SetWindowDirty(w);

   130

			} else

   131

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

   132

			{

   133

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

   134

				_iconsole_scroll = 79;

   135

				} else {

   136

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

   137

				}

   138

			SetWindowDirty(w);

   139

			} else

   140

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

   141

			{

   142

			if ((_iconsole_scroll - 1)<0) {

   143

				_iconsole_scroll = 0;

   144

				} else {

   145

				_iconsole_scroll -= 1;

   146

				}

   147

			SetWindowDirty(w);

   148

			} else

   149

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

   150

			{

   151

			if ((_iconsole_scroll + 1)>79) {

   152

				_iconsole_scroll = 79;

   153

				} else {

   154

				_iconsole_scroll += 1;

   155

				}

   156

			SetWindowDirty(w);

   157

			} else

   158

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

   159

			{

   160

			IConsoleSwitch();

   161

			} else

   162

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

   163

			{

   164

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

   165

			IConsoleCmdBufferAdd(_iconsole_cmdline);

   166

			IConsoleCmdExec((byte *) _iconsole_cmdline);

   167

			IConsoleClearCommand();

   168

			} else

   169

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

   170

			{

   171

			if (_iconsole_cmdpos!=0) _iconsole_cmdpos--;

   172

			_iconsole_cmdline[_iconsole_cmdpos]=0;

   173

			SetWindowDirty(w);

   174

			_iconsole_cmdbufferpos=19;

   175

			} else

   176

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

   177

			{

   178

			_iconsole_scroll=79;

   179

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

   180

			if (_iconsole_cmdpos!=255) _iconsole_cmdpos++;

   181

			SetWindowDirty(w);

   182

			_iconsole_cmdbufferpos=19;

   183

			} else e->keypress.cont=true;

   184

		break;

   185

   186

	}

   187

}

   188

   189

void IConsoleInit()

   190

{

   191

int i;

   192

#if defined(WITH_REV)

   193

extern char _openttd_revision[];

   194

#endif

   195

_iconsole_color_default = 1;

   196

_iconsole_color_error = 3;

   197

_iconsole_color_debug = 5;

   198

_iconsole_color_commands = 2;

   199

_iconsole_scroll=79;

   200

_iconsole_cmdbufferpos=19;

   201

_iconsole_inited=true;

   202

_iconsole_mode=ICONSOLE_CLOSED;

   203

_iconsole_win=NULL;

   204

_icursor_state=false;

   205

_icursor_rate=5;

   206

_icursor_counter=0;

   207

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

   208

	_iconsole_cmdbuffer[i]=NULL;

   209

	}

   210

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

   211

	_iconsole_buffer[i]=NULL;

   212

	_iconsole_cbuffer[i]=0;

   213

	}

   214

IConsoleStdLibRegister();

   215

#if defined(WITH_REV)

   216

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

   217

#else

   218

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

   219

#endif

   220

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

   221

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

   222

IConsolePrint(12,"");

   223

IConsoleClearCommand();

   224

IConsoleCmdBufferAdd("");

   225

}

   226

   227

void IConsoleClear()

   228

{

   229

int i;

   230

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

   231

	free(_iconsole_buffer[i]);

   232

	}

   233

}

   234

   235

void IConsoleFree()

   236

{

   237

_iconsole_inited=false;

   238

IConsoleClear();

   239

}

   240

   241

void IConsoleResize() {

   242

	if (_iconsole_win!=NULL) {

   243

		_iconsole_win->height = _screen.height / 3;

   244

		_iconsole_win->width= _screen.width;

   245

	}

   246

}

   247

   248

void IConsoleSwitch()

   249

{

   250

	if (_iconsole_mode==ICONSOLE_CLOSED) {

   251

		_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   252

		_iconsole_win->height = _screen.height / 3;

   253

		_iconsole_win->width= _screen.width;

   254

		_iconsole_mode=ICONSOLE_OPENED;

   255

		} else

   256

	if (_iconsole_mode==ICONSOLE_OPENED) {

   258

		_iconsole_win=NULL;

   259

		_iconsole_mode=ICONSOLE_CLOSED;

   260

		}

   261

	MarkWholeScreenDirty();

   262

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

   263

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

   264

}

   265

   266

void IConsoleClose() {

   267

if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();

   268

_iconsole_mode=ICONSOLE_CLOSED;

   269

}

   270

   271

void IConsoleOpen() {

   272

if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();

   273

}

   274

   275

void IConsoleCmdBufferAdd(byte * cmd) {

   276

int i;

   277

if (_iconsole_cmdbufferpos != 19) return;

   278

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

   279

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

   280

i=strlen((char *)cmd);

   281

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

   282

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

   283

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

   284

_iconsole_cmdbuffer[0][i]=0;

   285

_iconsole_cmdbufferpos = 19;

   286

}

   287

   288

void IConsoleCmdBufferNavigate(signed char direction) {

   289

int i;

   290

i=_iconsole_cmdbufferpos + direction;

   291

if (i<0) i=19;

   292

if (i>19) i=0;

   293

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

   294

	i++;

   295

	if (i>19) i=0;

   296

	}

   297

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

   298

	i--;

   299

	if (i<0) i=19;

   300

	}

   301

_iconsole_cmdbufferpos = i;

   302

IConsoleClearCommand();

   303

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

   304

_iconsole_cmdpos =strlen(_iconsole_cmdbuffer[i]);

   305

}

   306

   307

void IConsolePrint(byte color_code, byte* string)

   308

{

   309

byte * _ex;

   310

byte * _new;

   311

byte _exc;

   312

byte _newc;

   313

int i,j;

   314

   315

if (!_iconsole_inited) return;

   316

   317

_newc=color_code;

   318

i=strlen((char *)string);

   319

_new=malloc(i+1);

   320

memset(_new,0,i+1);

   321

memcpy(_new,string,i);

   322

   323

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

   324

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

   325

	}

   326

   327

i=79;

   328

while (i>=0) {

   329

	_ex=_iconsole_buffer[i];

   330

	_exc=_iconsole_cbuffer[i];

   331

	_iconsole_buffer[i]=_new;

   332

	_iconsole_cbuffer[i]=_newc;

   333

	_new=_ex;

   334

	_newc=_exc;

   335

	i--;

   336

	}

   337

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

   338

   339

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

   340

}

   341

   342

   343

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

   344

{

   345

	va_list va;

   346

	char buf[1024];

   347

	va_start(va, s);

   348

	vsprintf(buf, s, va);

   349

	va_end(va);

   350

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

   351

}

   352

   353

void IConsoleDebug(byte* string) {

   354

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

   355

}

   356

   357

void IConsoleError(byte* string) {

   358

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

   359

}

   360

   361

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

   362

byte * _new;

   363

_iconsole_cmd * item;

   364

_iconsole_cmd * item_new;

   365

int i;

   366

   367

	i=strlen((char *)name);

   368

	_new=malloc(i+1);

   369

	memset(_new,0,i+1);

   370

	memcpy(_new,name,i);

   371

   372

item_new = malloc(sizeof(_iconsole_cmd));

   373

   374

item_new->_next = NULL;

   375

item_new->addr  = addr;

   376

item_new->name  = _new;

   377

   378

item = _iconsole_cmds;

   379

if (item == NULL) {

   380

	_iconsole_cmds = item_new;

   381

	} else {

   382

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

   383

	item->_next = item_new;

   384

	}

   385

}

   386

   387

void* IConsoleCmdGetAddr(byte * name) {

   388

_iconsole_cmd * item;

   389

   390

item = _iconsole_cmds;

   391

while (item != NULL) {

   392

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

   393

	item = item->_next;

   394

	}

   395

return NULL;

   396

}

   397

   398

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

   399

byte * _new;

   400

_iconsole_var * item;

   401

_iconsole_var * item_new;

   402

int i;

   403

   404

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

   405

	_new=malloc(i+1);

   406

	memset(_new,0,i+1);

   407

	_new[0]='*';

   408

	memcpy(_new+1,name,i);

   409

   410

item_new = malloc(sizeof(_iconsole_var));

   411

   412

item_new->_next = NULL;

   413

item_new->addr  = addr;

   414

item_new->name  = _new;

   415

item_new->type  = type;

   416

item_new->_malloc = false;

   417

   418

item = _iconsole_vars;

   419

if (item == NULL) {

   420

	_iconsole_vars = item_new;

   421

	} else {

   422

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

   423

	item->_next = item_new;

   424

	}

   425

}

   426

   427

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

   428

byte * _new;

   429

_iconsole_var * item;

   430

_iconsole_var * item_new;

   431

int i;

   432

   433

item_new = var;

   434

   435

// dont allow to build variable rings

   436

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

   437

   438

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

   439

	_new=malloc(i+1);

   440

	memset(_new,0,i+1);

   441

	_new[0]='*';

   442

	memcpy(_new+1,name,i);

   443

   444

item_new->name  = _new;

   445

   446

item = _iconsole_vars;

   447

if (item == NULL) {

   448

	_iconsole_vars = item_new;

   449

	} else {

   450

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

   451

	item->_next = item_new;

   452

	}

   453

}

   454

   455

   456

_iconsole_var * IConsoleVarGet(byte * name) {

   457

_iconsole_var * item;

   458

   459

item = _iconsole_vars;

   460

while (item != NULL) {

   461

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

   462

	item = item->_next;

   463

	}

   464

return NULL;

   465

}

   466

   467

_iconsole_var * IConsoleVarAlloc(byte type) {

   468

_iconsole_var * item;

   469

item=malloc(sizeof(_iconsole_var));

   470

item->_next = NULL;

   471

item->name  = "";

   472

item->type  = type;

   473

switch (item->type) {

   474

		case ICONSOLE_VAR_BOOLEAN:

   475

				{

   476

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

   477

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

   478

				item->_malloc=true;

   479

				}

   480

				break;

   481

		case ICONSOLE_VAR_BYTE:

   482

				{

   483

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

   484

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

   485

				item->_malloc=true;

   486

				}

   487

				break;

   488

		case ICONSOLE_VAR_UINT16:

   489

				{

   490

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

   491

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

   492

				item->_malloc=true;