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;

    20

static byte _iconsole_color_default = 1;

    21

static byte _iconsole_color_error = 3;

    22

static byte _iconsole_color_debug = 5;

    23

static byte _iconsole_color_commands = 2;

    24

static Window *_iconsole_win = NULL;

    25

static byte _iconsole_scroll;

    26

    27

// ** console cursor ** //

    28

static bool _icursor_state;

    29

static byte _icursor_rate;

    30

static byte _icursor_counter;

    31

    32

// ** console window ** //

    33

    34

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

    35

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

    36

static const WindowDesc _iconsole_window_desc = {

    37

	0, 0, 2, 2,

    38

	WC_CONSOLE,0,

    39

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    40

	_iconsole_window_widgets,

    41

	IConsoleWndProc,

    42

};

    43

    44

// ** console parser ** //

    45

    46

static _iconsole_cmd * _iconsole_cmds; // list of registred commands

    47

static _iconsole_var * _iconsole_vars; // list of registred vars

    48

    49

// ** console std lib ** // 

    50

static byte _stdlib_developer=1;

    51

static void IConsoleStdLibRegister();

    52

    53

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

    54

/*  end of header  */

    55

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

    56

    57

void IConsoleClearCommand()

    58

{

    59

int i;

    60

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

    61

_iconsole_cmdpos=0;

    62

SetWindowDirty(_iconsole_win);

    63

}

    64

    65

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

    66

{

    67

	switch(e->event) {

    68

    69

	case WE_PAINT:

    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

		if (_iconsole_mode==ICONSOLE_OPENING) {

    86

			_iconsole_mode=ICONSOLE_OPENED;

    87

			}

    88

    89

		_icursor_counter++;

    90

		if (_icursor_counter>_icursor_rate) {

    91

			_icursor_state=!_icursor_state;

    92

			{

    93

				int posx;

    94

				int posy;

    95

				int color;

    96

				_cur_dpi=&_screen;

    97

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

    98

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

    99

				posy=w->height-3;

   100

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

   101

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

   102

			}

   103

			_icursor_counter=0;			

   104

			}

   105

		break;

   106

   107

	case WE_KEYPRESS:

   108

		e->keypress.cont=false;

   109

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

   110

			{

   111

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

   112

				_iconsole_scroll = 0;

   113

				} else {

   114

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

   115

				}

   116

			SetWindowDirty(w);

   117

			} else

   118

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

   119

			{

   120

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

   121

				_iconsole_scroll = 79;

   122

				} else {

   123

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

   124

				}

   125

			SetWindowDirty(w);

   126

			} else

   127

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

   128

			{

   129

			if ((_iconsole_scroll - 1)<0) {

   130

				_iconsole_scroll = 0;

   131

				} else {

   132

				_iconsole_scroll -= 1;

   133

				}

   134

			SetWindowDirty(w);

   135

			} else

   136

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

   137

			{

   138

			if ((_iconsole_scroll + 1)>79) {

   139

				_iconsole_scroll = 79;

   140

				} else {

   141

				_iconsole_scroll += 1;

   142

				}

   143

			SetWindowDirty(w);

   144

			} else

   145

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

   146

			{

   147

			IConsoleSwitch();

   148

			} else

   149

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

   150

			{

   151

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

   152

			IConsoleCmdExec((byte *) _iconsole_cmdline);

   153

			IConsoleClearCommand();

   154

			} else

   155

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

   156

			{

   157

			if (_iconsole_cmdpos!=0) _iconsole_cmdpos--;

   158

			_iconsole_cmdline[_iconsole_cmdpos]=0;

   159

			SetWindowDirty(w);

   160

			} else

   161

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

   162

			{

   163

			_iconsole_scroll=79;

   164

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

   165

			if (_iconsole_cmdpos!=255) _iconsole_cmdpos++;	

   166

			SetWindowDirty(w);

   167

			} else e->keypress.cont=true;	

   168

		break;

   169

   170

	}

   171

}

   172

   173

void IConsoleInit()

   174

{

   175

int i;

   176

#if defined(WITH_REV)

   177

extern char _openttd_revision[];

   178

#endif

   179

_iconsole_scroll=79;

   180

_iconsole_inited=true;

   181

_iconsole_mode=ICONSOLE_CLOSED;

   182

_iconsole_win=NULL;

   183

_icursor_state=false;

   184

_icursor_rate=5;

   185

_icursor_counter=0;

   186

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

   187

IConsoleStdLibRegister();

   188

#if defined(WITH_REV)

   189

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

   190

#else

   191

IConsolePrint(13,"OpenTTD Game Console");	

   192

#endif

   193

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

   194

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

   195

IConsolePrint(12,"");

   196

IConsoleClearCommand();

   197

}

   198

   199

void IConsoleClear()

   200

{

   201

int i;

   202

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

   203

	free(_iconsole_buffer[i]);

   204

	}

   205

}

   206

   207

void IConsoleFree()

   208

{

   209

_iconsole_inited=false;

   210

IConsoleClear();

   211

}

   212

   213

void IConsoleResize() {

   214

	if (_iconsole_win!=NULL) {

   215

		_iconsole_win->height = _screen.height / 3;

   216

		_iconsole_win->width= _screen.width;

   217

	}

   218

}

   219

   220

void IConsoleSwitch()

   221

{

   222

	if (_iconsole_mode==ICONSOLE_CLOSED) {

   223

		_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   224

		_iconsole_win->height = _screen.height / 3;

   225

		_iconsole_win->width= _screen.width;

   226

		_iconsole_mode=ICONSOLE_OPENING;

   227

		} else

   228

	if (_iconsole_mode==ICONSOLE_OPENED) {

   229

		DeleteWindow(_iconsole_win);

   230

		_iconsole_win=NULL;

   231

		_iconsole_mode=ICONSOLE_CLOSED;

   232

		}

   233

	MarkWholeScreenDirty();

   234

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

   235

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

   236

}

   237

   238

void IConsoleClose() {

   239

if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();

   240

}

   241

   242

void IConsoleOpen() {

   243

if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();

   244

}

   245

   246

void IConsolePrint(byte color_code, byte* string)

   247

{

   248

byte * _ex;

   249

byte * _new;

   250

byte _exc;

   251

byte _newc;

   252

int i,j;

   253

   254

if (!_iconsole_inited) return;

   255

   256

_newc=color_code;

   257

   258

i=strlen((char *)string);

   259

_new=malloc(i+1);

   260

memset(_new,0,i+1);

   261

memcpy(_new,string,i);

   262

   263

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

   264

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

   265

	}

   266

   267

i=79;

   268

while (i>=0) {

   269

	_ex=_iconsole_buffer[i];

   270

	_exc=_iconsole_cbuffer[i];

   271

	_iconsole_buffer[i]=_new;

   272

	_iconsole_cbuffer[i]=_newc;

   273

	_new=_ex;

   274

	_newc=_exc;

   275

	i--;

   276

	}

   277

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

   278

   279

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

   280

}

   281

   282

   283

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

   284

{

   285

	va_list va;

   286

	char buf[1024];

   287

	va_start(va, s);

   288

	vsprintf(buf, s, va);

   289

	va_end(va);

   290

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

   291

}

   292

   293

void IConsoleDebug(byte* string) {

   294

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

   295

}

   296

   297

void IConsoleError(byte* string) {

   298

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

   299

}

   300

   301

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

   302

byte * _new;

   303

_iconsole_cmd * item;

   304

_iconsole_cmd * item_new;

   305

int i;

   306

   307

	i=strlen((char *)name);

   308

	_new=malloc(i+1);

   309

	memset(_new,0,i+1);

   310

	memcpy(_new,name,i);

   311

   312

item_new = malloc(sizeof(_iconsole_cmd));

   313

   314

item_new->_next = NULL;

   315

item_new->addr  = addr;

   316

item_new->name  = _new;

   317

   318

item = _iconsole_cmds;

   319

if (item == NULL) {

   320

	_iconsole_cmds = item_new;

   321

	} else {

   322

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

   323

	item->_next = item_new;

   324

	}

   325

}

   326

   327

void* IConsoleCmdGetAddr(byte * name) {

   328

_iconsole_cmd * item;

   329

   330

item = _iconsole_cmds;

   331

while (item != NULL) { 

   332

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

   333

	item = item->_next;

   334

	}

   335

return NULL;

   336

}

   337

   338

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

   339

byte * _new;

   340

_iconsole_var * item;

   341

_iconsole_var * item_new;

   342

int i;

   343

   344

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

   345

	_new=malloc(i+1);

   346

	memset(_new,0,i+1);

   347

	_new[0]='*';

   348

	memcpy(_new+1,name,i);

   349

   350

item_new = malloc(sizeof(_iconsole_var));

   351

   352

item_new->_next = NULL;

   353

item_new->addr  = addr;

   354

item_new->name  = _new;

   355

item_new->type  = type;

   356

item_new->_malloc = false;

   357

   358

item = _iconsole_vars;

   359

if (item == NULL) {

   360

	_iconsole_vars = item_new;

   361

	} else {

   362

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

   363

	item->_next = item_new;

   364

	}

   365

}

   366

   367

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

   368

byte * _new;

   369

_iconsole_var * item;

   370

_iconsole_var * item_new;

   371

int i;

   372

   373

item_new = var;

   374

   375

// dont allow to build variable rings

   376

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

   377

   378

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

   379

	_new=malloc(i+1);

   380

	memset(_new,0,i+1);

   381

	_new[0]='*';

   382

	memcpy(_new+1,name,i);

   383

   384

item_new->name  = _new;

   385

   386

item = _iconsole_vars;

   387

if (item == NULL) {

   388

	_iconsole_vars = item_new;

   389

	} else {

   390

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

   391

	item->_next = item_new;

   392

	}

   393

}

   394

   395

   396

_iconsole_var * IConsoleVarGet(byte * name) {

   397

_iconsole_var * item;

   398

   399

item = _iconsole_vars;

   400

while (item != NULL) { 

   401

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

   402

	item = item->_next;

   403

	}

   404

return NULL;

   405

}

   406

   407

_iconsole_var * IConsoleVarAlloc(byte type) {

   408

_iconsole_var * item;

   409

item=malloc(sizeof(_iconsole_var));

   410

item->_next = NULL;

   411

item->name  = "";

   412

item->type  = type;

   413

switch (item->type) {

   414

		case ICONSOLE_VAR_BOOLEAN:

   415

				{

   416

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

   417

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

   418

				item->_malloc=true;

   419

				}

   420

				break;

   421

		case ICONSOLE_VAR_BYTE:

   422

				{

   423

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

   424

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

   425

				item->_malloc=true;

   426

				}

   427

				break;

   428

		case ICONSOLE_VAR_UINT16:

   429

				{

   430

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

   431

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

   432

				item->_malloc=true;

   433

				}

   434

				break;

   435

		case ICONSOLE_VAR_UINT32:

   436

				{

   437

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

   438

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

   439

				item->_malloc=true;

   440

				}

   441

				break;

   442

		case ICONSOLE_VAR_INT16:

   443

				{

   444

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

   445

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

   446

				item->_malloc=true;

   447

				}

   448

				break;

   449

		case ICONSOLE_VAR_INT32:

   450

				{

   451

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

   452

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

   453

				item->_malloc=true;

   454

				}

   455

				break;

   456

		default:

   457

				item->addr  = NULL;

   458

				item->_malloc = false;

   459

				break;

   460

		}

   461

return item;

   462

}

   463

   464

   465

void IConsoleVarFree(_iconsole_var * var) {

   466

if (var ->_malloc) {

   467

	free(var ->addr);

   468

	}

   469

free(var);

   470

}

   471

   472

void IConsoleVarSetString(_iconsole_var * var, byte * string) {

   473

int l;

   474

   475

if (var->_malloc) {

   476

	free(var->addr);

   477

	}

   478

   479

l=strlen((char *) string);

   480

var->addr=malloc(l+1);

   481

var->_malloc=true;

   482

memset(var->addr,0,l);

   483

memcpy((void *) var->addr,(void *) string, l);

   484

((byte *)var->addr)[l]=0;

   485

}

   486

   487

void IConsoleVarSetValue(_iconsole_var * var, int value) {

   488

switch (var->type) {

   489

		case ICONSOLE_VAR_BOOLEAN:

   490

				{

   491

				(*(bool *)var->addr)=(value!=0);

   492

				}

   493

				break;

   494

		case ICONSOLE_VAR_BYTE:

   495

				{

   496

				(*(byte *)var->addr)=value;