1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "strings.h"

     4

#include "table/sprites.h"

     5

#include "table/strings.h"

     6

#include "window.h"

     7

#include "gui.h"

     8

#include "viewport.h"

     9

#include "gfx.h"

    10

#include "news.h"

    11

#include "vehicle.h"

    12

#include "sound.h"

    13

    14

/* News system

    15

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

    16

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

    17

the array elements through pointers to the elements. Once the

    18

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

    19

by the newest (_latest news).

    20

    21

oldest                   current   lastest

    22

 |                          |         |

    23

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

    24

              |

    25

           forced

    26

*/

    27

    28

#define MAX_NEWS 30

    29

    30

#define INVALID_NEWS 255

    31

    32

static NewsItem _news_items[MAX_NEWS];

    33

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

    34

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

    35

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

    36

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

    37

 * _forced_news. forced_news is INVALID_NEWS otherwise.

    38

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

    39

static byte _forced_news = INVALID_NEWS;

    40

    41

static byte _total_news = 0; // total news count

    42

    43

void DrawNewsNewTrainAvail(Window *w);

    44

void DrawNewsNewRoadVehAvail(Window *w);

    45

void DrawNewsNewShipAvail(Window *w);

    46

void DrawNewsNewAircraftAvail(Window *w);

    47

void DrawNewsBankrupcy(Window *w);

    48

static void MoveToNexItem(void);

    49

    50

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    51

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    52

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    53

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    54

StringID GetNewsStringBankrupcy(NewsItem *ni);

    55

    56

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    57

	DrawNewsNewTrainAvail,    /* DNC_TRAINAVAIL */

    58

	DrawNewsNewRoadVehAvail,  /* DNC_ROADAVAIL */

    59

	DrawNewsNewShipAvail,     /* DNC_SHIPAVAIL */

    60

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    61

	DrawNewsBankrupcy,        /* DNC_BANKRUPCY */

    62

};

    63

    64

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    65

	GetNewsStringNewTrainAvail,    /* DNC_TRAINAVAIL */

    66

	GetNewsStringNewRoadVehAvail,  /* DNC_ROADAVAIL */

    67

	GetNewsStringNewShipAvail,     /* DNC_SHIPAVAIL */

    68

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    69

	GetNewsStringBankrupcy,        /* DNC_BANKRUPCY */

    70

};

    71

    72

void InitNewsItemStructs(void)

    73

{

    74

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

    75

	_current_news = INVALID_NEWS;

    76

	_oldest_news = 0;

    77

	_latest_news = INVALID_NEWS;

    78

	_forced_news = INVALID_NEWS;

    79

	_total_news = 0;

    80

}

    81

    82

void DrawNewsBorder(const Window *w)

    83

{

    84

	int left = 0;

    85

	int right = w->width - 1;

    86

	int top = 0;

    87

	int bottom = w->height - 1;

    88

    89

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

    90

    91

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

    92

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

    93

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

    94

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

    95

    96

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

    97

}

    98

    99

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

   100

{

   101

	switch (e->event) {

   102

	case WE_CREATE: { /* If chatbar is open at creation time, we need to go above it */

   103

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

   104

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

   105

	} break;

   106

   107

	case WE_PAINT: {

   108

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

   109

		ViewPort *vp;

   110

   111

		switch (ni->display_mode) {

   112

			case NM_NORMAL:

   113

			case NM_THIN: {

   114

				DrawNewsBorder(w);

   115

   116

				DrawString(2, 1, STR_00C6, 0);

   117

   118

				SetDParam(0, ni->date);

   119

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   120

   121

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

   122

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

   123

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

   124

						ni->string_id, 426);

   125

				} else {

   126

					byte bk = _display_opt;

   127

					_display_opt &= ~DO_TRANS_BUILDINGS;

   128

					DrawWindowViewport(w);

   129

					_display_opt = bk;

   130

   131

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

   132

					vp = w->viewport;

   133

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

   134

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

   135

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

   136

					);

   137

   138

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

   139

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

   140

				}

   141

				break;

   142

			}

   143

   144

			case NM_CALLBACK: {

   145

				_draw_news_callback[ni->callback](w);

   146

				break;

   147

			}

   148

   149

			default: {

   150

				DrawWindowWidgets(w);

   151

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

   152

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

   153

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

   154

				} else {

   155

					DrawWindowViewport(w);

   156

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

   157

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

   158

				}

   159

				break;

   160

			}

   161

		}

   162

	} break;

   163

   164

	case WE_CLICK: {

   165

		switch (e->click.widget) {

   166

		case 1: {

   167

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

   168

			DeleteWindow(w);

   169

			ni->duration = 0;

   170

			_forced_news = INVALID_NEWS;

   171

		} break;

   172

		case 0: {

   173

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

   174

			if (ni->flags & NF_VEHICLE) {

   175

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

   176

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

   177

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

   178

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

   179

					ScrollMainWindowToTile(ni->data_b);

   180

			}

   181

		} break;

   182

		}

   183

	} break;

   184

   185

	case WE_KEYPRESS:

   186

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

   187

			// Don't continue.

   188

			e->keypress.cont = false;

   189

			DeleteWindow(w);

   190

		}

   191

		break;

   192

   193

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

   194

		switch (e->message.msg) {

   195

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

   196

			case WE_DESTROY: w->message.msg = 0; 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

/** Get the value of an item of the news-display settings. This is

   344

 * a little tricky since on/off/summary must use 2 bits to store the value

   345

 * @param item the item whose value is requested

   346

 * @return return the found value which is between 0-2

   347

 */

   348

static inline byte GetNewsDisplayValue(byte item)

   349

{

   350

	assert(item < 10 && ((_news_display_opt >> (item * 2)) & 0x3) <= 2);

   351

	return (_news_display_opt >> (item * 2)) & 0x3;

   352

}

   353

   354

/** Set the value of an item in the news-display settings. This is

   355

 * a little tricky since on/off/summary must use 2 bits to store the value

   356

 * @param item the item whose value is being set

   357

 * @param val new value

   358

 */

   359

static inline void SetNewsDisplayValue(byte item, byte val)

   360

{

   361

	assert(item < 10 && val <= 2);

   362

	item *= 2;

   363

	CLRBIT(_news_display_opt, item);

   364

	CLRBIT(_news_display_opt, item + 1);

   365

	_news_display_opt |= val << item;

   366

}

   367

   368

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

   369

static void ShowNewspaper(NewsItem *ni)

   370

{

   371

	Window *w;

   372

	int sound;

   373

	int top;

   374

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

   375

	ni->duration = 555;

   376

   377

	sound = _news_sounds[ni->type];

   378

	if (sound != 0)

   379

		SndPlayFx(sound);

   380

   381

	top = _screen.height;

   382

	switch (ni->display_mode) {

   383

		case NM_NORMAL:

   384

		case NM_CALLBACK: {

   385

			_news_type13_desc.top = top;

   386

			w = AllocateWindowDesc(&_news_type13_desc);

   387

			if (ni->flags & NF_VIEWPORT)

   388

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

   389

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

   390

			break;

   391

		}

   392

   393

		case NM_THIN: {

   394

			_news_type2_desc.top = top;

   395

			w = AllocateWindowDesc(&_news_type2_desc);

   396

			if (ni->flags & NF_VIEWPORT)

   397

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

   398

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

   399

			break;

   400

		}

   401

   402

		default: {

   403

			_news_type0_desc.top = top;

   404

			w = AllocateWindowDesc(&_news_type0_desc);

   405

			if (ni->flags & NF_VIEWPORT)

   406

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

   407

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

   408

			break;

   409

		}

   410

	}

   411

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

   412

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   413

}

   414

   415

// show news item in the ticker

   416

static void ShowTicker(const NewsItem *ni)

   417

{

   418

	Window *w;

   419

   420

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   421

   422

	_statusbar_news_item = *ni;

   423

	w = FindWindowById(WC_STATUS_BAR, 0);

   424

	if (w != NULL)

   425

		WP(w, def_d).data_1 = 360;

   426

}

   427

   428

   429

// Are we ready to show another news item?

   430

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

   431

static bool ReadyForNextItem(void)

   432

{

   433

	const Window *w;

   434

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

   435

	NewsItem *ni;

   436

   437

	if (item >= MAX_NEWS) return true;

   438

	ni = &_news_items[item];

   439

   440

	// Ticker message

   441

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

   442

	w = FindWindowById(WC_STATUS_BAR, 0);

   443

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

   444

		return false;

   445

   446

	// Newspaper message

   447

	// Wait until duration reaches 0

   448

	if (ni->duration != 0) {

   449

		ni->duration--;

   450

		return false;

   451

	}

   452

   453

	// neither newsticker nor newspaper are running

   454

	return true;

   455

}

   456

   457

static void MoveToNexItem(void)

   458

{

   459

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   460

	_forced_news = INVALID_NEWS;

   461

   462

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

   463

	if (_current_news != _latest_news) {

   464

		NewsItem *ni;

   465

   466

		_current_news = increaseIndex(_current_news);

   467

		ni = &_news_items[_current_news];

   468

   469

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

   470

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

   471

			return;

   472

   473

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

   474

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

   475

			return;

   476

   477

  	switch (GetNewsDisplayValue(ni->type)) {

   478

  	case 0: { /* Off - show nothing only a small reminder in the status bar */

   479

  		Window *w = FindWindowById(WC_STATUS_BAR, 0);

   480

			if (w != NULL) {

   481

				WP(w, def_d).data_2 = 91;

   482

				SetWindowDirty(w);

   483

			}

   484

  	} break;

   485

  	case 1: /* Summary - show ticker, but if forced big, cascade to full */

   486

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

   487

  			ShowTicker(ni);

   488

  			break;

   489

  		}

   490

  		/* Fallthrough */

   491

  	case 2: /* Full - show newspaper*/

   492

  		ShowNewspaper(ni);

   493

  		break;

   494

  	}