1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "strings.h"

     4

#include "table/strings.h"

     5

#include "window.h"

     6

#include "gui.h"

     7

#include "viewport.h"

     8

#include "gfx.h"

     9

#include "news.h"

    10

#include "vehicle.h"

    11

#include "sound.h"

    12

    13

/* News system

    14

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

    15

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

    16

the array elements through pointers to the elements. Once the

    17

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

    18

by the newest (_latest news).

    19

    20

oldest                   current   lastest

    21

 |                          |         |

    22

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

    23

              |

    24

           forced

    25

*/

    26

    27

#define MAX_NEWS 30

    28

    29

#define INVALID_NEWS 255

    30

    31

static NewsItem _news_items[MAX_NEWS];

    32

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

    33

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

    34

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

    35

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

    36

 * _forced_news. forced_news is INVALID_NEWS otherwise.

    37

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

    38

static byte _forced_news = INVALID_NEWS;

    39

    40

static byte _total_news = 0; // total news count

    41

    42

void DrawNewsNewTrainAvail(Window *w);

    43

void DrawNewsNewRoadVehAvail(Window *w);

    44

void DrawNewsNewShipAvail(Window *w);

    45

void DrawNewsNewAircraftAvail(Window *w);

    46

void DrawNewsBankrupcy(Window *w);

    47

static void MoveToNexItem(void);

    48

    49

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    50

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    51

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    52

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    53

StringID GetNewsStringBankrupcy(NewsItem *ni);

    54

    55

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    56

	DrawNewsNewTrainAvail,    /* DNC_TRAINAVAIL */

    57

	DrawNewsNewRoadVehAvail,  /* DNC_ROADAVAIL */

    58

	DrawNewsNewShipAvail,     /* DNC_SHIPAVAIL */

    59

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    60

	DrawNewsBankrupcy,        /* DNC_BANKRUPCY */

    61

};

    62

    63

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    64

	GetNewsStringNewTrainAvail,    /* DNC_TRAINAVAIL */

    65

	GetNewsStringNewRoadVehAvail,  /* DNC_ROADAVAIL */

    66

	GetNewsStringNewShipAvail,     /* DNC_SHIPAVAIL */

    67

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    68

	GetNewsStringBankrupcy,        /* DNC_BANKRUPCY */

    69

};

    70

    71

void InitNewsItemStructs(void)

    72

{

    73

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

    74

	_current_news = INVALID_NEWS;

    75

	_oldest_news = 0;

    76

	_latest_news = INVALID_NEWS;

    77

	_forced_news = INVALID_NEWS;

    78

	_total_news = 0;

    79

}

    80

    81

void DrawNewsBorder(const Window *w)

    82

{

    83

	int left = 0;

    84

	int right = w->width - 1;

    85

	int top = 0;

    86

	int bottom = w->height - 1;

    87

    88

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

    89

    90

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

    91

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

    92

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

    93

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

    94

    95

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

    96

}

    97

    98

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

    99

{

   100

	switch (e->event) {

   101

	case WE_PAINT: {

   102

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

   103

		ViewPort *vp;

   104

   105

		switch (ni->display_mode) {

   106

			case NM_NORMAL:

   107

			case NM_THIN: {

   108

				DrawNewsBorder(w);

   109

   110

				DrawString(2, 1, STR_00C6, 0);

   111

   112

				SetDParam(0, ni->date);

   113

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   114

   115

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

   116

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

   117

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

   118

						ni->string_id, 426);

   119

				} else {

   120

					byte bk = _display_opt;

   121

					_display_opt &= ~DO_TRANS_BUILDINGS;

   122

					DrawWindowViewport(w);

   123

					_display_opt = bk;

   124

   125

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

   126

					vp = w->viewport;

   127

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

   128

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

   129

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

   130

					);

   131

   132

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

   133

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

   134

				}

   135

				break;

   136

			}

   137

   138

			case NM_CALLBACK: {

   139

				_draw_news_callback[ni->callback](w);

   140

				break;

   141

			}

   142

   143

			default: {

   144

				DrawWindowWidgets(w);

   145

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

   146

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

   147

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

   148

				} else {

   149

					DrawWindowViewport(w);

   150

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

   151

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

   152

				}

   153

				break;

   154

			}

   155

		}

   156

	} break;

   157

   158

	case WE_CLICK: {

   159

		switch (e->click.widget) {

   160

		case 1: {

   161

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

   162

			DeleteWindow(w);

   163

			ni->duration = 0;

   164

			_forced_news = INVALID_NEWS;

   165

		} break;

   166

		case 0: {

   167

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

   168

			if (ni->flags & NF_VEHICLE) {

   169

				Vehicle *v = GetVehicle(ni->data_a);

   170

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

   171

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

   172

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

   173

					ScrollMainWindowToTile(ni->data_b);

   174

			}

   175

		} break;

   176

		}

   177

	} break;

   178

   179

	case WE_KEYPRESS:

   180

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

   181

			// Don't continue.

   182

			e->keypress.cont = false;

   183

			DeleteWindow(w);

   184

		}

   185

		break;

   186

   187

	case WE_TICK: {

   188

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

   189

		if (y == w->top)

   190

			return;

   191

   192

		if (w->viewport != NULL)

   193

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

   194

   195

		w->top = y;

   196

   197

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

   198

	} break;

   199

	}

   200

}

   201

   202

// returns the correct index in the array

   203

// (to deal with overflows)

   204

static byte increaseIndex(byte i)

   205

{

   206

	if (i == INVALID_NEWS)

   207

		return 0;

   208

	i++;

   209

	if (i >= MAX_NEWS)

   210

		i = i % MAX_NEWS;

   211

	return i;

   212

}

   213

   214

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

   215

{

   216

	NewsItem *ni;

   217

	Window *w;

   218

   219

	if (_game_mode == GM_MENU)

   220

		return;

   221

   222

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

   223

	if (_total_news==MAX_NEWS && (_oldest_news == _current_news || _oldest_news == _forced_news))

   224

		MoveToNexItem();

   225

   226

	_forced_news = INVALID_NEWS;

   227

	if (_total_news < MAX_NEWS) _total_news++;

   228

   229

	// make sure our pointer isn't overflowing

   230

	_latest_news = increaseIndex(_latest_news);

   231

   232

	// overwrite oldest news entry

   233

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

   234

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

   235

   236

	// add news to _latest_news

   237

	ni = &_news_items[_latest_news];

   238

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

   239

   240

	ni->string_id = string;

   241

	ni->display_mode = (byte)flags;

   242

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

   243

   244

	// show this news message in color?

   245

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

   246

		ni->flags |= NF_INCOLOR;

   247

   248

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

   249

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

   250

	ni->data_a = data_a;

   251

	ni->data_b = data_b;

   252

	ni->date = _date;

   253

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

   254

   255

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   256

	if (w == NULL) return;

   257

	SetWindowDirty(w);

   258

	w->vscroll.count = _total_news;

   259

}

   260

   261

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

   262

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

   263

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

   264

{

   265

	AddNewsItem(string, flags, data_a, data_b);

   266

	_news_items[_latest_news].isValid = validation;

   267

}

   268

   269

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

   270

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

   271

   272

static const Widget _news_type13_widgets[] = {

   273

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

   274

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

   275

{   WIDGETS_END},

   276

};

   277

   278

static WindowDesc _news_type13_desc = {

   279

	WDP_CENTER, 476, 430, 170,

   280

	WC_NEWS_WINDOW, 0,

   281

	WDF_DEF_WIDGET,

   282

	_news_type13_widgets,

   283

	NewsWindowProc

   284

};

   285

   286

static const Widget _news_type2_widgets[] = {

   287

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

   288

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

   289

{   WIDGETS_END},

   290

};

   291

   292

static WindowDesc _news_type2_desc = {

   293

	WDP_CENTER, 476, 430, 130,

   294

	WC_NEWS_WINDOW, 0,

   295

	WDF_DEF_WIDGET,

   296

	_news_type2_widgets,

   297

	NewsWindowProc

   298

};

   299

   300

static const Widget _news_type0_widgets[] = {

   301

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

   302

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

   303

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

   304

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

   305

{   WIDGETS_END},

   306

};

   307

   308

static WindowDesc _news_type0_desc = {

   309

	WDP_CENTER, 476, 280, 87,

   310

	WC_NEWS_WINDOW, 0,

   311

	WDF_DEF_WIDGET,

   312

	_news_type0_widgets,

   313

	NewsWindowProc

   314

};

   315

   316

static const SoundFx _news_sounds[] = {

   317

	SND_1D_APPLAUSE,

   318

	SND_1D_APPLAUSE,

   319

	0,

   320

	0,

   321

	0,

   322

	0,

   323

	SND_1E_OOOOH,

   324

	0,

   325

	0,

   326

	0

   327

};

   328

   329

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

   330

static void ShowNewspaper(NewsItem *ni)

   331

{

   332

	Window *w;

   333

	int sound;

   334

	int top;

   335

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

   336

	ni->duration = 555;

   337

   338

	sound = _news_sounds[ni->type];

   339

	if (sound != 0)

   340

		SndPlayFx(sound);

   341

   342

	top = _screen.height - 4;

   343

	switch (ni->display_mode) {

   344

		case NM_NORMAL:

   345

		case NM_CALLBACK: {

   346

			_news_type13_desc.top = top;

   347

			w = AllocateWindowDesc(&_news_type13_desc);

   348

			if (ni->flags & NF_VIEWPORT)

   349

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

   350

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

   351

			break;

   352

		}

   353

   354

		case NM_THIN: {

   355

			_news_type2_desc.top = top;

   356

			w = AllocateWindowDesc(&_news_type2_desc);

   357

			if (ni->flags & NF_VIEWPORT)

   358

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

   359

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

   360

			break;

   361

		}

   362

   363

		default: {

   364

			_news_type0_desc.top = top;

   365

			w = AllocateWindowDesc(&_news_type0_desc);

   366

			if (ni->flags & NF_VIEWPORT)

   367

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

   368

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

   369

			break;

   370

		}

   371

	}

   372

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

   373

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   374

}

   375

   376

// show news item in the ticker

   377

static void ShowTicker(const NewsItem *ni)

   378

{

   379

	Window *w;

   380

   381

	SndPlayFx(SND_16_MORSE);

   382

	_statusbar_news_item = *ni;

   383

	w = FindWindowById(WC_STATUS_BAR, 0);

   384

	if (w != NULL)

   385

		WP(w, def_d).data_1 = 360;

   386

}

   387

   388

   389

// Are we ready to show another news item?

   390

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

   391

static bool ReadyForNextItem(void)

   392

{

   393

	const Window *w;

   394

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

   395

	NewsItem *ni;

   396

   397

	if (item >= MAX_NEWS) return true;

   398

	ni = &_news_items[item];

   399

   400

	// Ticker message

   401

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

   402

	w = FindWindowById(WC_STATUS_BAR, 0);

   403

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

   404

		return false;

   405

   406

	// Newspaper message

   407

	// Wait until duration reaches 0

   408

	if (ni->duration != 0) {

   409

		ni->duration--;

   410

		return false;

   411

	}

   412

   413

	// neither newsticker nor newspaper are running

   414

	return true;

   415

}

   416

   417

static void MoveToNexItem(void)

   418

{

   419

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   420

	_forced_news = INVALID_NEWS;

   421

   422

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

   423

	if (_current_news != _latest_news) {

   424

		NewsItem *ni;

   425

   426

		_current_news = increaseIndex(_current_news);

   427

		ni = &_news_items[_current_news];

   428

   429

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

   430

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

   431

			return;

   432

   433

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

   434

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

   435

			return;

   436

   437

		// show newspaper or send to ticker?

   438

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

   439

			ShowTicker(ni);

   440

		else

   441

			ShowNewspaper(ni);

   442

	}

   443

}

   444

   445

void NewsLoop(void)

   446

{

   447

	// no news item yet

   448

	if (_total_news == 0) return;

   449

   450

	if (ReadyForNextItem())

   451

		MoveToNexItem();

   452

}

   453

   454

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

   455

static void ShowNewsMessage(byte i)

   456

{

   457

	if (_total_news == 0) return;

   458

   459

	// Delete the news window

   460

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   461

   462

	// setup forced news item

   463

	_forced_news = i;

   464

   465

	if (_forced_news != INVALID_NEWS) {

   466

		NewsItem *ni = &_news_items[_forced_news];

   467

		ni->duration = 555;

   468

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   469

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   470

		ShowNewspaper(ni);

   471

	}

   472

}

   473

   474

void ShowLastNewsMessage(void)

   475

{

   476

	if (_forced_news == INVALID_NEWS)

   477

		ShowNewsMessage(_current_news);

   478

	else if (_forced_news != 0)

   479

		ShowNewsMessage(_forced_news - 1);

   480

	else {

   481

		if (_total_news != MAX_NEWS)

   482

			ShowNewsMessage(_latest_news);

   483

		else

   484

			ShowNewsMessage(MAX_NEWS - 1);

   485

	}

   486

}

   487

   488

   489

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

   490

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

   491

static byte getNews(byte i)

   492

{

   493

	if (i >= _total_news)