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_CREATE: { /* If chatbar is open at creation time, we need to go above it */

   102

		const Window *w1 = FindWindowById(WC_SEND_NETWORK_MSG, 0);

   103

		w->message.msg = (w1 != NULL) ? w1->height : 0;

   104

	} break;

   105

   106

	case WE_PAINT: {

   107

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

   108

		ViewPort *vp;

   109

   110

		switch (ni->display_mode) {

   111

			case NM_NORMAL:

   112

			case NM_THIN: {

   113

				DrawNewsBorder(w);

   114

   115

				DrawString(2, 1, STR_00C6, 0);

   116

   117

				SetDParam(0, ni->date);

   118

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   119

   120

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

   121

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

   122

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

   123

						ni->string_id, 426);

   124

				} else {

   125

					byte bk = _display_opt;

   126

					_display_opt &= ~DO_TRANS_BUILDINGS;

   127

					DrawWindowViewport(w);

   128

					_display_opt = bk;

   129

   130

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

   131

					vp = w->viewport;

   132

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

   133

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

   134

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

   135

					);

   136

   137

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

   138

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

   139

				}

   140

				break;

   141

			}

   142

   143

			case NM_CALLBACK: {

   144

				_draw_news_callback[ni->callback](w);

   145

				break;

   146

			}

   147

   148

			default: {

   149

				DrawWindowWidgets(w);

   150

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

   151

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

   152

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

   153

				} else {

   154

					DrawWindowViewport(w);

   155

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

   156

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

   157

				}

   158

				break;

   159

			}

   160

		}

   161

	} break;

   162

   163

	case WE_CLICK: {

   164

		switch (e->click.widget) {

   165

		case 1: {

   166

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

   167

			DeleteWindow(w);

   168

			ni->duration = 0;

   169

			_forced_news = INVALID_NEWS;

   170

		} break;

   171

		case 0: {

   172

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

   173

			if (ni->flags & NF_VEHICLE) {

   174

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

   175

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

   176

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

   177

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

   178

					ScrollMainWindowToTile(ni->data_b);

   179

			}

   180

		} break;

   181

		}

   182

	} break;

   183

   184

	case WE_KEYPRESS:

   185

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

   186

			// Don't continue.

   187

			e->keypress.cont = false;

   188

			DeleteWindow(w);

   189

		}

   190

		break;

   191

   192

	case WE_MESSAGE: /* The chatbar has notified us that is was either created or closed */

   193

		switch (e->message.msg) {

   194

			case WE_CREATE: w->message.msg = e->message.wparam; break;

   195

			case WE_DESTROY: w->message.msg = 0; break;

   196

			break;

   197

		}

   198

		break;

   199

   200

	case WE_TICK: { /* Scroll up newsmessages from the bottom in steps of 4 pixels */

   201

		int diff;

   202

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

   203

		if (y == w->top) return;

   204

   205

		if (w->viewport != NULL)

   206

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

   207

   208

		diff = abs(w->top - y);

   209

		w->top = y;

   210

   211

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

   212

	} break;

   213

	}

   214

}

   215

   216

// returns the correct index in the array

   217

// (to deal with overflows)

   218

static byte increaseIndex(byte i)

   219

{

   220

	if (i == INVALID_NEWS)

   221

		return 0;

   222

	i++;

   223

	if (i >= MAX_NEWS)

   224

		i = i % MAX_NEWS;

   225

	return i;

   226

}

   227

   228

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

   229

{

   230

	NewsItem *ni;

   231

	Window *w;

   232

   233

	if (_game_mode == GM_MENU)

   234

		return;

   235

   236

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

   237

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

   238

		MoveToNexItem();

   239

   240

	_forced_news = INVALID_NEWS;

   241

	if (_total_news < MAX_NEWS) _total_news++;

   242

   243

	// make sure our pointer isn't overflowing

   244

	_latest_news = increaseIndex(_latest_news);

   245

   246

	// overwrite oldest news entry

   247

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

   248

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

   249

   250

	// add news to _latest_news

   251

	ni = &_news_items[_latest_news];

   252

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

   253

   254

	ni->string_id = string;

   255

	ni->display_mode = (byte)flags;

   256

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

   257

   258

	// show this news message in color?

   259

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

   260

		ni->flags |= NF_INCOLOR;

   261

   262

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

   263

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

   264

	ni->data_a = data_a;

   265

	ni->data_b = data_b;

   266

	ni->date = _date;

   267

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

   268

   269

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   270

	if (w == NULL) return;

   271

	SetWindowDirty(w);

   272

	w->vscroll.count = _total_news;

   273

}

   274

   275

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

   276

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

   277

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

   278

{

   279

	AddNewsItem(string, flags, data_a, data_b);

   280

	_news_items[_latest_news].isValid = validation;

   281

}

   282

   283

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

   284

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

   285

   286

static const Widget _news_type13_widgets[] = {

   287

{      WWT_PANEL,   RESIZE_NONE,    15,     0,   429,     0,   169, 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_type13_desc = {

   293

	WDP_CENTER, 476, 430, 170,

   294

	WC_NEWS_WINDOW, 0,

   295

	WDF_DEF_WIDGET,

   296

	_news_type13_widgets,

   297

	NewsWindowProc

   298

};

   299

   300

static const Widget _news_type2_widgets[] = {

   301

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

   302

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

   303

{   WIDGETS_END},

   304

};

   305

   306

static WindowDesc _news_type2_desc = {

   307

	WDP_CENTER, 476, 430, 130,

   308

	WC_NEWS_WINDOW, 0,

   309

	WDF_DEF_WIDGET,

   310

	_news_type2_widgets,

   311

	NewsWindowProc

   312

};

   313

   314

static const Widget _news_type0_widgets[] = {

   315

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

   316

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

   317

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

   318

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

   319

{   WIDGETS_END},

   320

};

   321

   322

static WindowDesc _news_type0_desc = {

   323

	WDP_CENTER, 476, 280, 87,

   324

	WC_NEWS_WINDOW, 0,

   325

	WDF_DEF_WIDGET,

   326

	_news_type0_widgets,

   327

	NewsWindowProc

   328

};

   329

   330

static const SoundFx _news_sounds[] = {

   331

	SND_1D_APPLAUSE,

   332

	SND_1D_APPLAUSE,

   333

	0,

   334

	0,

   335

	0,

   336

	0,

   337

	SND_1E_OOOOH,

   338

	0,

   339

	0,

   340

	0

   341

};

   342

   343

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

   344

static void ShowNewspaper(NewsItem *ni)

   345

{

   346

	Window *w;

   347

	int sound;

   348

	int top;

   349

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

   350

	ni->duration = 555;

   351

   352

	sound = _news_sounds[ni->type];

   353

	if (sound != 0)

   354

		SndPlayFx(sound);

   355

   356

	top = _screen.height;

   357

	switch (ni->display_mode) {

   358

		case NM_NORMAL:

   359

		case NM_CALLBACK: {

   360

			_news_type13_desc.top = top;

   361

			w = AllocateWindowDesc(&_news_type13_desc);

   362

			if (ni->flags & NF_VIEWPORT)

   363

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

   364

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

   365

			break;

   366

		}

   367

   368

		case NM_THIN: {

   369

			_news_type2_desc.top = top;

   370

			w = AllocateWindowDesc(&_news_type2_desc);

   371

			if (ni->flags & NF_VIEWPORT)

   372

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

   373

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

   374

			break;

   375

		}

   376

   377

		default: {

   378

			_news_type0_desc.top = top;

   379

			w = AllocateWindowDesc(&_news_type0_desc);

   380

			if (ni->flags & NF_VIEWPORT)

   381

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

   382

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

   383

			break;

   384

		}

   385

	}

   386

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

   387

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   388

}

   389

   390

// show news item in the ticker

   391

static void ShowTicker(const NewsItem *ni)

   392

{

   393

	Window *w;

   394

   395

	SndPlayFx(SND_16_MORSE);

   396

	_statusbar_news_item = *ni;

   397

	w = FindWindowById(WC_STATUS_BAR, 0);

   398

	if (w != NULL)

   399

		WP(w, def_d).data_1 = 360;

   400

}

   401

   402

   403

// Are we ready to show another news item?

   404

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

   405

static bool ReadyForNextItem(void)

   406

{

   407

	const Window *w;

   408

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

   409

	NewsItem *ni;

   410

   411

	if (item >= MAX_NEWS) return true;

   412

	ni = &_news_items[item];

   413

   414

	// Ticker message

   415

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

   416

	w = FindWindowById(WC_STATUS_BAR, 0);

   417

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

   418

		return false;

   419

   420

	// Newspaper message

   421

	// Wait until duration reaches 0

   422

	if (ni->duration != 0) {

   423

		ni->duration--;

   424

		return false;

   425

	}

   426

   427

	// neither newsticker nor newspaper are running

   428

	return true;

   429

}

   430

   431

static void MoveToNexItem(void)

   432

{

   433

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   434

	_forced_news = INVALID_NEWS;

   435

   436

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

   437

	if (_current_news != _latest_news) {

   438

		NewsItem *ni;

   439

   440

		_current_news = increaseIndex(_current_news);

   441

		ni = &_news_items[_current_news];

   442

   443

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

   444

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

   445

			return;

   446

   447

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

   448

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

   449

			return;

   450

   451

		// show newspaper or send to ticker?

   452

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

   453

			ShowTicker(ni);

   454

		else

   455

			ShowNewspaper(ni);

   456

	}

   457

}

   458

   459

void NewsLoop(void)

   460

{

   461

	// no news item yet

   462

	if (_total_news == 0) return;

   463

   464

	if (ReadyForNextItem())

   465

		MoveToNexItem();

   466

}

   467

   468

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

   469

static void ShowNewsMessage(byte i)

   470

{

   471

	if (_total_news == 0) return;

   472

   473

	// Delete the news window

   474

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   475

   476

	// setup forced news item

   477

	_forced_news = i;

   478

   479

	if (_forced_news != INVALID_NEWS) {

   480

		NewsItem *ni = &_news_items[_forced_news];

   481

		ni->duration = 555;

   482

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   483

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   484

		ShowNewspaper(ni);

   485

	}

   486

}

   487

   488

void ShowLastNewsMessage(void)

   489

{

   490

	if (_forced_news == INVALID_NEWS)

   491

		ShowNewsMessage(_current_news);

   492

	else if (_forced_news != 0)

   493

		ShowNewsMessage(_forced_news - 1);