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>

    15

    16

// ** main console ** //

    17

static bool _iconsole_inited;

    18

static byte* _iconsole_buffer[80];

    19

static byte _iconsole_cbuffer[80];

    20

static byte _iconsole_cmdline[255];

    21

static byte _iconsole_cmdpos;

    22

static byte _iconsole_mode = ICONSOLE_CLOSED;

    23

static Window *_iconsole_win = NULL;

    24

static byte _iconsole_scroll;

    25

    26

// ** console cursor ** //

    27

static bool _icursor_state;

    28

static byte _icursor_rate;

    29

static byte _icursor_counter;

    30

    31

// ** stdlib ** //

    32

byte _stdlib_developer=1;

    33

bool _stdlib_con_developer=false;

    34

FILE * _iconsole_output_file;

    35

    36

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

    37

static byte* _iconsole_cmdbuffer[20];

    38

static byte _iconsole_cmdbufferpos;

    39

    40

// ** console window ** //

    41

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

    42

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

    43

static const WindowDesc _iconsole_window_desc = {

    44

	0, 0, 2, 2,

    45

	WC_CONSOLE,0,

    46

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

    47

	_iconsole_window_widgets,

    48

	IConsoleWndProc,

    49

};

    50

    51

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

    52

/*  end of header  */

    79

    81

{

    82

int i;

    83

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

    84

_iconsole_cmdpos=0;

    85

SetWindowDirty(_iconsole_win);

    86

}

    87

    88

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

    89

{

    90

	// only do window events with the console

    91

	w = FindWindowById(WC_CONSOLE, 0);

    92

    93

	switch(e->event) {

    94

    95

	case WE_PAINT:

    96

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

    97

		{

    98

		int i=_iconsole_scroll;

    99

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

   100

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

   101

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

   102

			i--;

   103

			}

   104

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

   105

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

   106

		}

   107

		break;

   108

   109

	case WE_TICK:

   110

   111

		_icursor_counter++;

   112

		if (_icursor_counter>_icursor_rate) {

   113

			_icursor_state=!_icursor_state;

   114

			{

   115

				int posx;

   116

				int posy;

   117

				int color;

   118

				_cur_dpi=&_screen;

   119

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

   120

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

   121

				posy=w->height-3;

   122

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

   123

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

   124

			}

   125

			_icursor_counter=0;

   126

			}

   127

		break;

   128

   129

	case WE_DESTROY:

   130

		_iconsole_win=NULL;

   131

		_iconsole_mode=ICONSOLE_CLOSED;

   132

		break;

   133

   134

	case WE_KEYPRESS:

   141

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

   142

			{

   143

			IConsoleCmdBufferNavigate(+1);

   144

			SetWindowDirty(w);

   145

			} else

   146

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

   147

			{

   148

			IConsoleCmdBufferNavigate(-1);

   149

			SetWindowDirty(w);

   150

			} else

   151

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

   152

			{

   153

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

   154

				_iconsole_scroll = 0;

   155

				} else {

   156

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

   157

				}

   158

			SetWindowDirty(w);

   159

			} else

   160

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

   161

			{

   162

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

   163

				_iconsole_scroll = 79;

   164

				} else {

   165

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

   166

				}

   167

			SetWindowDirty(w);

   168

			} else

   169

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

   170

			{

   171

			if ((_iconsole_scroll - 1)<0) {

   172

				_iconsole_scroll = 0;

   173

				} else {

   174

				_iconsole_scroll -= 1;

   175

				}

   176

			SetWindowDirty(w);

   177

			} else

   178

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

   179

			{

   180

			if ((_iconsole_scroll + 1)>79) {

   181

				_iconsole_scroll = 79;

   182

				} else {

   183

				_iconsole_scroll += 1;

   184

				}

   185

			SetWindowDirty(w);

   186

			} else

   187

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

   188

			{

   189

			IConsoleSwitch();

   190

			} else

   191

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

   192

			{

   193

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

   194

			IConsoleCmdBufferAdd(_iconsole_cmdline);

   195

			IConsoleCmdExec((byte *) _iconsole_cmdline);

   196

			IConsoleClearCommand();

   197

			} else

   198

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

   199

			{

   200

			if (_iconsole_cmdpos!=0) _iconsole_cmdpos--;

   201

			_iconsole_cmdline[_iconsole_cmdpos]=0;

   202

			SetWindowDirty(w);

   203

			_iconsole_cmdbufferpos=19;

   204

			} else

   205

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

   206

			{

   207

			_iconsole_scroll=79;

   208

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

   209

			if (_iconsole_cmdpos!=255) _iconsole_cmdpos++;

   210

			SetWindowDirty(w);

   211

			_iconsole_cmdbufferpos=19;

   212

			} else e->keypress.cont=true;

   213

		break;

   214

   215

	}

   216

}

   217

   218

void IConsoleInit()

   219

{

   220

	int i;

   221

	#if defined(WITH_REV)

   222

	extern char _openttd_revision[];

   223

	#endif

   224

	_iconsole_output_file = NULL;

   225

	_iconsole_color_default = 1;

   226

	_iconsole_color_error = 3;

   227

	_iconsole_color_warning = 13;

   228

	_iconsole_color_debug = 5;

   229

	_iconsole_color_commands = 2;

   230

	_iconsole_scroll=79;

   231

	_iconsole_cmdbufferpos=19;

   232

	_iconsole_inited=true;

   233

	_iconsole_mode=ICONSOLE_CLOSED;

   234

	_iconsole_win=NULL;

   235

	_icursor_state=false;

   236

	_icursor_rate=5;

   237

	_icursor_counter=0;

   238

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

   239

		_iconsole_cmdbuffer[i]=NULL;

   240

		}

   241

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

   242

		_iconsole_buffer[i]=NULL;

   243

		_iconsole_cbuffer[i]=0;

   244

		}

   245

	IConsoleStdLibRegister();

   246

	#if defined(WITH_REV)

   247

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

   248

	#else

   249

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

   250

	#endif

   251

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

   252

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

   253

	IConsolePrint(12,"");

   254

	IConsoleClearCommand();

   255

	IConsoleCmdBufferAdd("");

   256

}

   257

   258

void IConsoleClear()

   259

{

   260

	int i;

   261

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

   262

		free(_iconsole_buffer[i]);

   263

		}

   264

}

   265

   266

void IConsoleFree()

   267

{

   268

	_iconsole_inited=false;

   269

	IConsoleClear();

   270

	if (_iconsole_output_file!=NULL) fclose(_iconsole_output_file);

   271

}

   272

   273

void IConsoleResize()

   274

{

   275

	if (_iconsole_win!=NULL) {

   276

		_iconsole_win->height = _screen.height / 3;

   277

		_iconsole_win->width= _screen.width;

   278

	}

   279

}

   280

   281

void IConsoleSwitch()

   282

{

   283

	if (_iconsole_mode==ICONSOLE_CLOSED) {

   284

		_iconsole_win = AllocateWindowDesc(&_iconsole_window_desc);

   285

		_iconsole_win->height = _screen.height / 3;

   286

		_iconsole_win->width= _screen.width;

   287

		_iconsole_mode=ICONSOLE_OPENED;

   288

		} else

   289

	if (_iconsole_mode==ICONSOLE_OPENED) {

   290

		DeleteWindowById(WC_CONSOLE,0);

   291

		_iconsole_win=NULL;

   292

		_iconsole_mode=ICONSOLE_CLOSED;

   293

		}

   294

	MarkWholeScreenDirty();

   295

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

   296

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

   297

}

   298

   299

void IConsoleClose()

   300

{

   301

	if (_iconsole_mode==ICONSOLE_OPENED)  IConsoleSwitch();

   302

	_iconsole_mode=ICONSOLE_CLOSED;

   303

}

   304

   305

void IConsoleOpen()

   306

{

   307

	if (_iconsole_mode==ICONSOLE_CLOSED) IConsoleSwitch();

   308

}

   309

   310

void IConsoleCmdBufferAdd(const byte * cmd)

   311

{

   312

	int i;

   313

	if (_iconsole_cmdbufferpos != 19) return;

   314

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

   315

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

   316

	i=strlen(cmd);

   317

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

   318

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

   319

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

   320

	_iconsole_cmdbuffer[0][i]=0;

   321

	_iconsole_cmdbufferpos = 19;

   322

}

   323

   324

void IConsoleCmdBufferNavigate(signed char direction)

   325

{

   326

	int i;

   327

	i=_iconsole_cmdbufferpos + direction;

   328

	if (i<0) i=19;

   329

	if (i>19) i=0;

   330

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

   331

		i++;

   332

		if (i>19) i=0;

   333

		}

   334

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

   335

		i--;

   336

		if (i<0) i=19;

   337

		}

   338

	_iconsole_cmdbufferpos = i;

   339

	IConsoleClearCommand();

   340

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

   341

	_iconsole_cmdpos =strlen(_iconsole_cmdbuffer[i]);

   342

}

   343

   344

void IConsolePrint(byte color_code, const byte* string)

   345

{

   346

	byte * _ex;

   347

	byte * _new;

   348

	byte _exc;

   349

	byte _newc;

   350

	int i,j;

   351

   352

	if (!_iconsole_inited) return;

   353

   354

	_newc=color_code;

   355

	i=strlen(string);

   356

	_new=malloc(i+1);

   357

	memset(_new,0,i+1);

   358

	memcpy(_new,string,i);

   359

   360

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

   361

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

   362

		}

   363

   364

	i=79;

   365

	while (i>=0) {

   366

		_ex=_iconsole_buffer[i];

   367

		_exc=_iconsole_cbuffer[i];

   368

		_iconsole_buffer[i]=_new;

   369

		_iconsole_cbuffer[i]=_newc;

   370

		_new=_ex;

   371

		_newc=_exc;

   372

		i--;

   373

		}

   374

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

   375

   376

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

   377

}

   378

   379

   380

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

   381

{

   382

	va_list va;

   383

	char buf[1024];

   384

	int len;

   385

   386

	va_start(va, s);

   387

	len = vsprintf(buf, s, va);

   388

	va_end(va);

   389

   390

	if (_iconsole_output_file!=NULL) {

   391

		// if there is an console output file ... also print it there

   392

		fwrite((void *) &buf, len, 1, _iconsole_output_file);

   393

		buf[1023]='\n';

   394

		fwrite((void *)&buf[1023], 1, 1,_iconsole_output_file);

   395

		}

   396

   397

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

   398

}

   399

   400

void IConsoleDebug(byte* string)

   401

{

   402

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

   403

}

   404

   405

void IConsoleError(const byte* string)

   406

{

   407

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

   408

}

   409

   410

void IConsoleWarning(const byte* string)

   411

{

   412

	if (_stdlib_developer>0) IConsolePrintF(_iconsole_color_warning, "WARNING: %s", string);

   413

}

   414

   415

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

   416

{

   417

	byte * _new;

   418

	_iconsole_cmd * item;

   419

	_iconsole_cmd * item_new;

   420

	int i;

   421

   422

	i=strlen(name);

   423

	_new=malloc(i+1);

   424

	memset(_new,0,i+1);

   425

	memcpy(_new,name,i);

   426

   427

	item_new = malloc(sizeof(_iconsole_cmd));

   428

   429

	item_new->_next = NULL;

   430

	item_new->addr  = addr;

   431

	item_new->name  = _new;

   432

   433

	item_new->hook_access = NULL;

   434

	item_new->hook_after_exec = NULL;

   435

	item_new->hook_before_exec = NULL;

   436

   437

	item = _iconsole_cmds;

   438

	if (item == NULL) {

   439

		_iconsole_cmds = item_new;

   440

		} else {

   441

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

   442

		item->_next = item_new;

   443

		}

   444

}

   445

   446

_iconsole_cmd * IConsoleCmdGet(const byte * name)

   447

{

   448

	_iconsole_cmd * item;

   449

   450

	item = _iconsole_cmds;

   451

	while (item != NULL) {

   452

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

   453

		item = item->_next;

   454

		}

   455

	return NULL;

   456

}

   457

   458

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

   459

{

   460

	byte * _new;

   461

	_iconsole_var * item;

   462

	_iconsole_var * item_new;

   463

	int i;

   464

   465

	i=strlen(name)+1;

   466

	_new=malloc(i+1);

   467

	memset(_new,0,i+1);

   468

	_new[0]='*';

   469

	memcpy(_new+1,name,i);

   470

   471

	item_new = malloc(sizeof(_iconsole_var));

   472

   473

	item_new->_next = NULL;

   474

	item_new->addr  = addr;

   475

	item_new->name  = _new;

   476

	item_new->type  = type;

   477

	item_new->_malloc = false;

   478

   479

	item_new->hook_access = NULL;

   480

	item_new->hook_after_change = NULL;

   481

	item_new->hook_before_change = NULL;

   482

   483

	item = _iconsole_vars;

   484

	if (item == NULL) {

   485

		_iconsole_vars = item_new;

   486

		} else {

   487

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

   488

		item->_next = item_new;

   489

		}