1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     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

#include "sound.h"

    11

    12

/* News system

    13

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

    14

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

    15

the array elements through pointers to the elements. Once the

    16

array is full, the oldest entry (_oldest_news) is being overwritten

    17

by the newest (_latest news).

    18

    19

oldest                   current   lastest

    20

 |                          |         |

    21

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

    22

              |

    23

           forced

    24

*/

    25

    26

#define MAX_NEWS 30

    27

    28

#define INVALID_NEWS 255

    29

    30

static NewsItem _news_items[MAX_NEWS];

    31

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

    32

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

    33

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

    34

/* if the message being shown was forced by the user, its index is stored in

    35

 * _forced_news. forced_news is INVALID_NEWS otherwise.

    36

 * (Users can force messages through history or "last message") */

    37

static byte _forced_news = INVALID_NEWS;

    38

    39

static byte _total_news = 0; // total news count

    40

    41

void DrawNewsNewTrainAvail(Window *w);

    42

void DrawNewsNewRoadVehAvail(Window *w);

    43

void DrawNewsNewShipAvail(Window *w);

    44

void DrawNewsNewAircraftAvail(Window *w);

    45

void DrawNewsBankrupcy(Window *w);

    46

static void MoveToNexItem(void);

    47

    48

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    49

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    50

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    51

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    52

StringID GetNewsStringBankrupcy(NewsItem *ni);

    53

    54

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    55

	DrawNewsNewTrainAvail,    /* DNC_TRAINAVAIL */

    56

	DrawNewsNewRoadVehAvail,  /* DNC_ROADAVAIL */

    57

	DrawNewsNewShipAvail,     /* DNC_SHIPAVAIL */

    58

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    59

	DrawNewsBankrupcy,        /* DNC_BANKRUPCY */

    60

};

    61

    62

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    63

	GetNewsStringNewTrainAvail,    /* DNC_TRAINAVAIL */

    64

	GetNewsStringNewRoadVehAvail,  /* DNC_ROADAVAIL */

    65

	GetNewsStringNewShipAvail,     /* DNC_SHIPAVAIL */

    66

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    67

	GetNewsStringBankrupcy,        /* DNC_BANKRUPCY */

    68

};

    69

    70

void InitNewsItemStructs(void)

    71

{

    72

	memset(_news_items, 0, sizeof(_news_items));

    73

	_current_news = INVALID_NEWS;

    74

	_oldest_news = 0;

    75

	_latest_news = INVALID_NEWS;

    76

	_forced_news = INVALID_NEWS;

    77

	_total_news = 0;

    78

}

    79

    80

void DrawNewsBorder(const Window *w)

    81

{

    82

	int left = 0;

    83

	int right = w->width - 1;

    84

	int top = 0;

    85

	int bottom = w->height - 1;

    86

    87

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

    88

    89

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

    90

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

    91

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

    92

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

    93

    94

	DrawString(left + 2, top + 1, STR_00C6, 0);

    95

}

    96

    97

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

    98

{

    99

	switch (e->event) {

   100

	case WE_PAINT: {

   101

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

   102

		ViewPort *vp;

   103

   104

		switch (ni->display_mode) {

   105

			case NM_NORMAL:

   106

			case NM_THIN: {

   107

				DrawNewsBorder(w);

   108

   109

				DrawString(2, 1, STR_00C6, 0);

   110

   111

				SetDParam(0, ni->date);

   112

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   113

   114

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

   115

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

   116

					DrawStringMultiCenter(215, ni->display_mode == NM_NORMAL ? 76 : 56,

   117

						ni->string_id, 426);

   118

				} else {

   119

					byte bk = _display_opt;

   120

					_display_opt &= ~DO_TRANS_BUILDINGS;

   121

					DrawWindowViewport(w);

   122

					_display_opt = bk;

   123

   124

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

   125

					vp = w->viewport;

   126

					GfxFillRect(vp->left - w->left, vp->top - w->top,

   127

						vp->left - w->left + vp->width - 1, vp->top - w->top + vp->height - 1,

   128

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

   129

					);

   130

   131

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

   132

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

   133

				}

   134

				break;

   135

			}

   136

   137

			case NM_CALLBACK: {

   138

				_draw_news_callback[ni->callback](w);

   139

				break;

   140

			}

   141

   142

			default: {

   143

				DrawWindowWidgets(w);

   144

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

   145

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

   146

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

   147

				} else {

   148

					DrawWindowViewport(w);

   149

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

   150

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

   151

				}

   152

				break;

   153

			}

   154

		}

   155

	} break;

   156

   157

	case WE_CLICK: {

   158

		switch (e->click.widget) {

   159

		case 1: {

   160

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

   161

			DeleteWindow(w);

   162

			ni->duration = 0;

   163

			_forced_news = INVALID_NEWS;

   164

		} break;

   165

		case 0: {

   166

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

   167

			if (ni->flags & NF_VEHICLE) {

   168

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

   169

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

   170

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

   171

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

   172

					ScrollMainWindowToTile(ni->data_b);

   173

			}

   174

		} break;

   175

		}

   176

	} break;

   177

   178

	case WE_KEYPRESS:

   179

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

   180

			// Don't continue.

   181

			e->keypress.cont = false;

   182

			DeleteWindow(w);

   183

		}

   184

		break;

   185

   186

	case WE_TICK: {

   187

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

   188

		if (y == w->top)

   189

			return;

   190

   191

		if (w->viewport != NULL)

   192

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

   193

   194

		w->top = y;

   195

   196

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

   197

	} break;

   198

	}

   199

}

   200

   201

// returns the correct index in the array

   202

// (to deal with overflows)

   203

byte increaseIndex(byte i)

   204

{

   205

	if (i == INVALID_NEWS)

   206

		return 0;

   207

	i++;

   208

	if (i >= MAX_NEWS)

   209

		i = i % MAX_NEWS;

   210

	return i;

   211

}

   212

   213

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

   214

{

   215

	NewsItem *ni;

   216

	Window *w;

   217

   218

	if (_game_mode == GM_MENU)

   219

		return;

   220

   221

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

   222

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

   223

		MoveToNexItem();

   224

   225

	_forced_news = INVALID_NEWS;

   226

	if (_total_news < MAX_NEWS) _total_news++;

   227

   228

	// make sure our pointer isn't overflowing

   229

	_latest_news = increaseIndex(_latest_news);

   230

   231

	// overwrite oldest news entry

   232

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

   233

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

   234

   235

	// add news to _latest_news

   236

	ni = &_news_items[_latest_news];

   237

	memset(ni, 0, sizeof(*ni));

   238

   239

	ni->string_id = string;

   240

	ni->display_mode = (byte)flags;

   241

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

   242

   243

	// show this news message in color?

   244

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

   245

		ni->flags |= NF_INCOLOR;

   246

   247

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

   248

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

   249

	ni->data_a = data_a;

   250

	ni->data_b = data_b;

   251

	ni->date = _date;

   252

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

   253

   254

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   255

	if (w == NULL) return;

   256

	SetWindowDirty(w);

   257

	w->vscroll.count = _total_news;

   258

}

   259

   260

/* To add a news item with an attached validation function. This validation function

   261

 * makes sure that the news item is not outdated when the newspaper pops up. */

   262

void AddValidatedNewsItem(StringID string, uint32 flags, uint data_a, uint data_b, ValidationProc *validation)

   263

{

   264

	AddNewsItem(string, flags, data_a, data_b);

   265

	_news_items[_latest_news].isValid = validation;

   266

}

   267

   268

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

   269

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

   270

   271

static const Widget _news_type13_widgets[] = {

   272

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

   273

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

   274

{   WIDGETS_END},

   275

};

   276

   277

static WindowDesc _news_type13_desc = {

   278

	WDP_CENTER, 476, 430, 170,

   279

	WC_NEWS_WINDOW, 0,

   280

	WDF_DEF_WIDGET,

   281

	_news_type13_widgets,

   282

	NewsWindowProc

   283

};

   284

   285

static const Widget _news_type2_widgets[] = {

   286

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

   287

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

   288

{   WIDGETS_END},

   289

};

   290

   291

static WindowDesc _news_type2_desc = {

   292

	WDP_CENTER, 476, 430, 130,

   293

	WC_NEWS_WINDOW, 0,

   294

	WDF_DEF_WIDGET,

   295

	_news_type2_widgets,

   296

	NewsWindowProc

   297

};

   298

   299

static const Widget _news_type0_widgets[] = {

   300

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

   301

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

   302

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

   303

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

   304

{   WIDGETS_END},

   305

};

   306

   307

static WindowDesc _news_type0_desc = {

   308

	WDP_CENTER, 476, 280, 87,

   309

	WC_NEWS_WINDOW, 0,

   310

	WDF_DEF_WIDGET,

   311

	_news_type0_widgets,

   312

	NewsWindowProc

   313

};

   314

   315

static const SoundFx _news_sounds[] = {

   316

	SND_1D_APPLAUSE,

   317

	SND_1D_APPLAUSE,

   318

	0,

   319

	0,

   320

	0,

   321

	0,

   322

	SND_1E_OOOOH,

   323

	0,

   324

	0,

   325

	0

   326

};

   327

   328

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

   329

static void ShowNewspaper(NewsItem *ni)

   330

{

   331

	Window *w;

   332

	int sound;

   333

	int top;

   334

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

   335

	ni->duration = 555;

   336

   337

	sound = _news_sounds[ni->type];

   338

	if (sound != 0)

   339

		SndPlayFx(sound);

   340

   341

	top = _screen.height - 4;

   342

	switch (ni->display_mode) {

   343

		case NM_NORMAL:

   344

		case NM_CALLBACK: {

   345

			_news_type13_desc.top = top;

   346

			w = AllocateWindowDesc(&_news_type13_desc);

   347

			if (ni->flags & NF_VIEWPORT)

   348

				AssignWindowViewport(w, 2, 58, 0x1AA, 0x6E,

   349

					ni->data_a | (ni->flags & NF_VEHICLE ? 0x80000000 : 0), 0);

   350

			break;

   351

		}

   352

   353

		case NM_THIN: {

   354

			_news_type2_desc.top = top;

   355

			w = AllocateWindowDesc(&_news_type2_desc);

   356

			if (ni->flags & NF_VIEWPORT)

   357

				AssignWindowViewport(w, 2, 58, 0x1AA, 0x46,

   358

					ni->data_a | (ni->flags & NF_VEHICLE ? 0x80000000 : 0), 0);

   359

			break;

   360

		}

   361

   362

		default: {

   363

			_news_type0_desc.top = top;

   364

			w = AllocateWindowDesc(&_news_type0_desc);

   365

			if (ni->flags & NF_VIEWPORT)

   366

				AssignWindowViewport(w, 3, 17, 0x112, 0x2F,

   367

					ni->data_a | (ni->flags & NF_VEHICLE ? 0x80000000 : 0), 0);

   368

			break;

   369

		}

   370

	}

   371

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

   372

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   373

}

   374

   375

// show news item in the ticker

   376

static void ShowTicker(const NewsItem *ni)

   377

{

   378

	Window *w;

   379

   380

	SndPlayFx(SND_16_MORSE);

   381

	_statusbar_news_item = *ni;

   382

	w = FindWindowById(WC_STATUS_BAR, 0);

   383

	if (w != NULL)

   384

		WP(w, def_d).data_1 = 360;

   385

}

   386

   387

   388

// Are we ready to show another news item?

   389

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

   390

static bool ReadyForNextItem(void)

   391

{

   392

	const Window *w;

   393

	byte item = _forced_news == INVALID_NEWS ? _current_news : _forced_news;

   394

	NewsItem *ni;

   395

   396

	if (item >= MAX_NEWS) return true;

   397

	ni = &_news_items[item];

   398

   399

	// Ticker message

   400

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

   401

	w = FindWindowById(WC_STATUS_BAR, 0);

   402

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

   403

		return false;

   404

   405

	// Newspaper message

   406

	// Wait until duration reaches 0

   407

	if (ni->duration != 0) {

   408

		ni->duration--;

   409

		return false;

   410

	}

   411

   412

	// neither newsticker nor newspaper are running

   413

	return true;

   414

}

   415

   416

static void MoveToNexItem(void)

   417

{

   418

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   419

	_forced_news = INVALID_NEWS;

   420

   421

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

   422

	if (_current_news != _latest_news) {

   423

		NewsItem *ni;

   424

   425

		_current_news = increaseIndex(_current_news);

   426

		ni = &_news_items[_current_news];

   427

   428

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

   429

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

   430

			return;

   431

   432

		// execute the validation function to see if this item is still valid

   433

		if ( ni->isValid != NULL && !ni->isValid(ni->data_a, ni->data_b) )

   434

			return;

   435

   436

		// show newspaper or send to ticker?

   437

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

   438

			ShowTicker(ni);

   439

		else

   440

			ShowNewspaper(ni);

   441

	}

   442

}

   443

   444

void NewsLoop(void)

   445

{

   446

	// no news item yet

   447

	if (_total_news == 0) return;

   448

   449

	if (ReadyForNextItem())

   450

		MoveToNexItem();

   451

}

   452

   453

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

   454

void ShowNewsMessage(byte i)

   455

{

   456

	if (_total_news == 0) return;

   457

   458

	// Delete the news window

   459

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   460

   461

	// setup forced news item

   462

	_forced_news = i;

   463

   464

	if (_forced_news != INVALID_NEWS) {

   465

		NewsItem *ni = &_news_items[_forced_news];

   466

		ni->duration = 555;

   467

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   468

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   469

		ShowNewspaper(ni);

   470

	}

   471

}

   472

   473

void ShowLastNewsMessage(void)

   474

{

   475

	if (_forced_news == INVALID_NEWS)

   476

		ShowNewsMessage(_current_news);

   477

	else if (_forced_news != 0)

   478

		ShowNewsMessage(_forced_news - 1);

   479

	else {

   480

		if (_total_news != MAX_NEWS)

   481

			ShowNewsMessage(_latest_news);

   482

		else

   483

			ShowNewsMessage(MAX_NEWS - 1);

   484

	}

   485

}

   486

   487

   488

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

   489

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

   490

static byte getNews(byte i)

   491

{

   492

	if (i >= _total_news)

   493

		return INVALID_NEWS;