1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "viewport.h"

     7

#include "gfx.h"

     8

#include "news.h"

     9

#include "vehicle.h"

    10

    11

/* News system

    12

News system is realized as a FIFO queue (in an array)

    13

The positions in the queue can't be rearranged, we only access

    14

the array elements through pointers to the elements. Once the

    16

by the newest (_latest news).

    17

    18

oldest                   current   lastest

    19

 |                          |         |

    20

[O------------F-------------C---------L           ]

    21

              |

    22

           forced

    23

*/

    24

    25

# define MAX_NEWS 30

    26

    27

static NewsItem _news_items[MAX_NEWS];

    28

static byte _current_news = 255; // points to news item that should be shown next

    29

static byte _oldest_news = 0;    // points to first item in fifo queue

    30

static byte _latest_news = 255;  // points to last item in fifo queue

    32

																 //forced_news is 255 otherwise. (Users can force messages through history or "last message")

    33

    34

static byte _total_news = 0; // total news count

    35

    36

void DrawNewsNewTrainAvail(Window *w);

    37

void DrawNewsNewRoadVehAvail(Window *w);

    38

void DrawNewsNewShipAvail(Window *w);

    39

void DrawNewsNewAircraftAvail(Window *w);

    40

void DrawNewsBankrupcy(Window *w);

    41

static void MoveToNexItem();

    42

    43

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    44

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    45

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    46

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    47

StringID GetNewsStringBankrupcy(NewsItem *ni);

    48

    49

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    50

	DrawNewsNewTrainAvail, /* DNC_TRAINAVAIL */

    51

	DrawNewsNewRoadVehAvail, /* DNC_ROADAVAIL */

    52

	DrawNewsNewShipAvail, /* DNC_SHIPAVAIL */

    53

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    54

	DrawNewsBankrupcy, /* DNC_BANKRUPCY */

    55

};

    56

    57

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    58

	GetNewsStringNewTrainAvail, /* DNC_TRAINAVAIL */

    59

	GetNewsStringNewRoadVehAvail, /* DNC_ROADAVAIL */

    60

	GetNewsStringNewShipAvail, /* DNC_SHIPAVAIL */

    61

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    62

	GetNewsStringBankrupcy, /* DNC_BANKRUPCY */

    63

};

    64

    65

void InitNewsItemStructs()

    66

{

    67

	memset(_news_items, 0, sizeof(NewsItem)*MAX_NEWS);

    68

	_current_news = 255;

    69

	_oldest_news = 0;

    70

	_latest_news = 255;

    71

	_forced_news = 255;

    72

	_total_news = 0;

    73

}

    74

    75

void DrawNewsBorder(Window *w)

    76

{

    77

	int left = 0;

    78

	int right = w->width - 1;

    79

	int top = 0;

    80

	int bottom = w->height - 1;

    81

    82

	GfxFillRect(left, top, right, bottom, 0xF);

    84

	GfxFillRect(left, top, left, bottom, 0xD7);

    85

	GfxFillRect(right, top, right, bottom, 0xD7);

    86

	GfxFillRect(left, top, right, top, 0xD7);

    87

	GfxFillRect(left, bottom, right, bottom, 0xD7);

    90

}

    91

    92

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

    93

{

    94

	switch(e->event) {

    95

	case WE_PAINT: {

    96

		NewsItem *ni = WP(w,news_d).ni;

    97

		ViewPort *vp;

    98

    99

		if (ni->display_mode == NM_NORMAL || ni->display_mode == NM_THIN) {

   100

			DrawNewsBorder(w);

   101

   102

			DrawString(2, 1, STR_00C6, 0);

   103

   104

			SET_DPARAM16(0, ni->date);

   105

			DrawStringRightAligned(428, 1, STR_01FF, 0);

   106

   107

			if (!(ni->flags & NF_VIEWPORT)) {

   108

				COPY_IN_DPARAM(0, ni->params, lengthof(ni->params));

   109

				DrawStringMultiCenter(215, ni->display_mode == NM_NORMAL ? 76 : 56, ni->string_id, 426);

   110

			} else {

   111

				byte bk = _display_opt;

   112

				_display_opt |= DO_TRANS_BUILDINGS;

   113

				DrawWindowViewport(w);

   114

				_display_opt = bk;

   115

   116

				/* Shade the viewport into gray, or color*/

   117

				vp = w->viewport;

   119

					ni->flags & NF_INCOLOR ? 0x4322:0x4323

   120

				);

   121

   122

				COPY_IN_DPARAM(0, ni->params, lengthof(ni->params));

   123

				DrawStringMultiCenter((w->width>>1), 20, ni->string_id, 428);

   124

			}

   125

		} else if (ni->display_mode == NM_CALLBACK) {

   126

			_draw_news_callback[ni->callback](w);

   127

		} else {

   128

			DrawWindowWidgets(w);

   129

			if (!(ni->flags & NF_VIEWPORT)) {

   130

				COPY_IN_DPARAM(0, ni->params, lengthof(ni->params));

   131

				DrawStringMultiCenter(140,38, ni->string_id, 276);

   132

			} else {

   133

				DrawWindowViewport(w);

   134

				COPY_IN_DPARAM(0, ni->params, lengthof(ni->params));

   135

				DrawStringMultiCenter((w->width>>1), w->height - 16, ni->string_id, 276);

   136

			}

   137

		}

   138

	} break;

   139

   140

	case WE_CLICK: {

   141

		switch(e->click.widget) {

   142

		case 1: {

   143

			NewsItem *ni = WP(w,news_d).ni;

   144

			DeleteWindow(w);

   145

			ni->duration = 0;

   146

			if(_forced_news!=255) _forced_news = 255;

   147

		} break;

   148

		case 0: {

   149

			NewsItem *ni = WP(w,news_d).ni;

   150

			if (ni->flags & NF_VEHICLE) {

   151

				Vehicle *v = &_vehicles[ni->data_a];

   152

				ScrollMainWindowTo(v->x_pos, v->y_pos);

   153

			} else if (ni->flags & NF_TILE) {

   154

				if (!ScrollMainWindowToTile(ni->data_a) && ni->data_b != 0)

   155

					ScrollMainWindowToTile(ni->data_b);

   156

			}

   157

		} break;

   158

		}

   159

	} break;

   160

   161

	case WE_KEYPRESS:

   162

		if (e->keypress.keycode == WKC_SPACE) {

   163

			// Don't continue.

   164

			e->keypress.cont = false;

   165

			DeleteWindow(w);

   166

		}

   167

		break;

   168

   169

	case WE_TICK: {

   170

		int y = max(w->top - 4, _screen.height - w->height);

   171

		if (y == w->top)

   172

			return;

   173

   174

		if (w->viewport != NULL)

   175

			w->viewport->top += y - w->top;

   176

   177

		w->top = y;

   178

   179

		SetDirtyBlocks(w->left, w->top, w->left + w->width, w->top + w->height + 4);

   180

	} break;

   181

	}

   182

}

   183

   184

// returns the correct index in the array

   185

// (to deal with overflows)

   186

byte increaseIndex(byte i)

   187

{

   188

	if(i==255)

   189

		return 0;

   190

	i++;

   191

	if(i >= MAX_NEWS)

   192

		i = i % MAX_NEWS;

   193

	return i;

   194

}

   195

   196

   197

void AddNewsItem(StringID string, uint32 flags, uint data_a, uint data_b)

   198

{

   199

	NewsItem *ni;

   200

	Window *w;

   201

   202

	if (_game_mode == GM_MENU)

   203

		return;

   204

   205

	// check the rare case that the oldest (to be overwritten) news item is open

   206

	if(_oldest_news == _current_news || _oldest_news == _forced_news)

   207

		MoveToNexItem();

   208

   209

	_forced_news = 255;

   210

	if(_total_news < MAX_NEWS) _total_news++;

   212

	// make sure our pointer isn't overflowing

   213

	_latest_news = increaseIndex(_latest_news);

   214

   215

	// overwrite oldest news entry

   216

	if( _oldest_news == _latest_news && _news_items[_oldest_news].string_id != 0)

   217

		_oldest_news = increaseIndex(_oldest_news); // but make sure we're not overflowing here

   218

   219

	// add news to _latest_news

   220

	ni = &_news_items[_latest_news];

   221

   222

	ni->string_id = string;

   223

	ni->display_mode = (byte)flags;

   224

	ni->flags = (byte)(flags >> 8) | NF_NOEXPIRE;

   225

   226

	// show this news message in color?

   227

	if (_date >= ConvertIntDate(_patches.colored_news_date))

   228

		ni->flags |= NF_INCOLOR;

   229

   230

	ni->type = (byte)(flags >> 16);

   231

	ni->callback = (byte)(flags >> 24);

   232

	ni->data_a = data_a;

   233

	ni->data_b = data_b;

   234

	ni->date = _date;

   235

	COPY_OUT_DPARAM(ni->params, 0, lengthof(ni->params));

   236

   237

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   238

	if(w==NULL) return;

   239

	SetWindowDirty(w);

   240

	w->vscroll.count = _total_news;

   241

}

   242

   243

// don't show item if it's older than x days

   244

static const byte _news_items_age[] = {60, 60, 90, 60, 90, 30, 150, 30, 90, 180};

   245

   246

static const Widget _news_type13_widgets[] = {

   247

{      WWT_PANEL,    15,     0,   429,     0,   169, 0x0,	STR_NULL},

   248

{      WWT_PANEL,    15,     0,    10,     0,    11, 0x0,	STR_NULL},

   249

{   WIDGETS_END},

   250

};

   251

   252

static WindowDesc _news_type13_desc = {

   253

	WDP_CENTER, 476, 430, 170,

   254

	WC_NEWS_WINDOW,0,

   255

	WDF_DEF_WIDGET,

   256

	_news_type13_widgets,

   257

	NewsWindowProc

   258

};

   259

   260

static const Widget _news_type2_widgets[] = {

   261

{      WWT_PANEL,    15,     0,   429,     0,   129, 0x0,	STR_NULL},

   262

{      WWT_PANEL,    15,     0,    10,     0,    11, 0x0,	STR_NULL},

   263

{   WIDGETS_END},

   264

};

   265

   266

static WindowDesc _news_type2_desc = {

   267

	WDP_CENTER, 476, 430, 130,

   268

	WC_NEWS_WINDOW,0,

   269

	WDF_DEF_WIDGET,

   270

	_news_type2_widgets,

   271

	NewsWindowProc

   272

};

   273

   274

static const Widget _news_type0_widgets[] = {

   275

{      WWT_PANEL,     5,     0,   279,    14,    86, 0x0,								STR_NULL},

   276

{   WWT_CLOSEBOX,     5,     0,    10,     0,    13, STR_00C5,					STR_NULL},

   277

{    WWT_CAPTION,     5,    11,   279,     0,    13, STR_012C_MESSAGE,	STR_NULL},

   278

{          WWT_6,     5,     2,   277,    16,    64, 0x0,								STR_NULL},

   279

{   WIDGETS_END},

   280

};

   281

   282

static WindowDesc _news_type0_desc = {

   283

	WDP_CENTER, 476, 280, 87,

   284

	WC_NEWS_WINDOW,0,

   285

	WDF_DEF_WIDGET,

   286

	_news_type0_widgets,

   287

	NewsWindowProc

   288

};

   289

   290

static byte _news_sounds[] = { 27, 27, 0, 0, 0, 0, 28, 0, 0, 0 };

   291

   292

// open up an own newspaper window for the news item

   293

static void ShowNewspaper(NewsItem *ni)

   294

{

   295

	Window *w;

   296

	int sound;

   297

	int top;

   298

	ni->flags &= ~(NF_NOEXPIRE|NF_FORCE_BIG);

   299

	ni->duration = 555;

   300

   301

	sound = _news_sounds[ni->type];

   302

	if (sound != 0)

   303

		SndPlayFx(sound);

   304

   305

	top = _screen.height - 4;

   306

	if (ni->display_mode == NM_NORMAL || ni->display_mode == NM_CALLBACK) {

   307

		_news_type13_desc.top = top;

   308

		w = AllocateWindowDesc(&_news_type13_desc);

   309

		if (ni->flags & NF_VIEWPORT) {

   310

			AssignWindowViewport(w, 2, 58, 0x1AA, 0x6E, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   311

		}

   312

	} else if (ni->display_mode == NM_THIN) {

   313

		_news_type2_desc.top = top;

   314

		w = AllocateWindowDesc(&_news_type2_desc);

   315

		if (ni->flags & NF_VIEWPORT) {

   316

			AssignWindowViewport(w, 2, 58, 0x1AA, 0x46, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   317

		}

   318

	} else {

   319

		_news_type0_desc.top = top;

   320

		w = AllocateWindowDesc(&_news_type0_desc);

   321

		if (ni->flags & NF_VIEWPORT) {

   322

			AssignWindowViewport(w, 3, 17, 0x112, 0x2F, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   323

		}

   324

	}

   325

	WP(w,news_d).ni = &_news_items[(_forced_news==255)?_current_news:_forced_news];

   326

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   327

}

   328

   329

// show news item in the ticker

   330

static void ShowTicker(NewsItem *ni)

   331

{

   332

	Window *w;

   333

   334

	SndPlayFx(20);

   335

	_statusbar_news_item = *ni;

   336

	w = FindWindowById(WC_STATUS_BAR, 0);

   337

	if (w != 0)

   338

		WP(w,def_d).data_1 = 360;

   339

}

   340

   341

   342

// Are we ready to show another news item?

   343

// Only if nothing is in the newsticker and no newspaper is displayed

   344

static bool ReadyForNextItem()

   345

{

   346

	Window *w;

   347

	byte item = (_forced_news==255)?_current_news:_forced_news;

   348

	NewsItem *ni;

   349

   350

	if(item>=MAX_NEWS) return true;

   351

	ni = &_news_items[item];

   352

   353

	// Ticker message

   354

	// Check if the status bar message is still being displayed?

   355

	w = FindWindowById(WC_STATUS_BAR, 0);

   356

	if (w != NULL && WP(w,def_d).data_1 > -1280)

   357

	{

   358

		return false;

   359

	}

   360

   361

	// Newspaper message

   362

	// Wait until duration reaches 0

   363

	if (ni->duration != 0) {

   364

		ni->duration--;

   365

		return false;

   366

	}

   367

   368

	// neither newsticker nor newspaper are running

   369

	return true;

   370

}

   371

   372

static void MoveToNexItem()

   373

{

   374

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   375

	_forced_news = 255;

   376

   377

	// if we're not at the last item, than move on

   378

	if(_current_news != _latest_news)

   379

	{

   380

		NewsItem *ni;

   381

   382

		_current_news = increaseIndex(_current_news);

   383

		ni = &_news_items[_current_news];

   384

   385

		// check the date, don't show too old items

   386

		if(_date - _news_items_age[ni->type] > ni->date)

   387

			return;

   388

   389

		// show newspaper or send to ticker?

   390

		if(!HASBIT(_news_display_opt, ni->type) && !(ni->flags&NF_FORCE_BIG))

   391

			ShowTicker(ni);

   392

		else

   393

			ShowNewspaper(ni);

   394

	}

   395

}

   396

   397

void NewsLoop()

   398

{

   399

	// no news item yet

   400

	if(_total_news==0) return;

   401

   402

	if( ReadyForNextItem() )

   403

		MoveToNexItem();

   404

}

   405

   406

/* Do a forced show of a specific message */

   407

void ShowNewsMessage(byte i)

   408

{

   409

	if(_total_news==0) return;

   410

   411

	// Delete the news window

   412

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   413

   414

	// setup forced news item

   415

	_forced_news = i;

   416

   417

	if(_forced_news!=255)

   418

	{

   419

		NewsItem *ni = &_news_items[_forced_news];

   420

		ni->duration = 555;

   421

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   422

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   423

		ShowNewspaper(ni);

   424

	}

   425

}

   426

   427

void ShowLastNewsMessage()

   428

{

   429

	if(_forced_news==255)

   430

		ShowNewsMessage(_current_news);

   431

	else if(_forced_news!=0)

   432

		ShowNewsMessage(_forced_news-1);

   433

	else {

   435

			ShowNewsMessage(_latest_news);

   436

		else

   437

			ShowNewsMessage(MAX_NEWS-1);

   438

	}

   439

}

   440

   441

   442

/* return news by number, with 0 being the most

   443

recent news. Returns 255 if end of queue reached. */

   444

static byte getNews(byte i)

   445

{

   447

		return 255;

   448

   449

	if(_latest_news < i)

   450

		i = _latest_news + MAX_NEWS - i;

   451

	else

   452

		i = _latest_news - i;

   453

   454

	i = i % MAX_NEWS;

   455

	return i;

   456

}

   457

   458

static void GetNewsString(NewsItem *ni, byte *buffer)

   459

{

   460

	StringID str;

   461

	byte *s, *d;

   463

	if (ni->display_mode == 3) {

   464

		str = _get_news_string_callback[ni->callback](ni);

   465

	} else {

   466

		COPY_IN_DPARAM(0, ni->params, lengthof(ni->params));

   468

	}

   469

   470

	GetString(str_buffr, str);

   471

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   473

	s = str_buffr;

   474

	d = buffer;

   475

   476

	for(;;s++) {

   477

		// cut strings that are too long

   478

		if(s >= str_buffr + 55) {

   479

			d[0] = d[1] = d[2] = '.';

   480

			d+=3;

   481

			*d = 0;

   482

			break;

   483

		}

   484

   485

		if (*s == 0) {

   486

			*d = 0;

   487

			break;

   488

		} else if (*s == 13) {

   489

			d[0] = d[1] = d[2] = d[3] = ' ';

   490

			d+=4;

   491

		} else if (*s >= ' ' && (*s < 0x88 || *s >= 0x99)) {

   492

			*d++ = *s;

   493

		}

   494

	}

   495

}

   496

   497

   498

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

   499

{

   500

	switch(e->event) {

   501

	case WE_PAINT: {

   502

		byte buffer[256];

   503

		int y=19;