1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "strings.h"

     7

#include "table/sprites.h"

     8

#include "table/strings.h"

     9

#include "window.h"

    10

#include "gui.h"

    11

#include "viewport.h"

    12

#include "gfx.h"

    13

#include "news.h"

    14

#include "vehicle.h"

    15

#include "sound.h"

    16

#include "variables.h"

    17

    18

/* News system

    19

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

    20

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

    21

the array elements through pointers to the elements. Once the

    22

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

    23

by the newest (_latest news).

    24

    25

oldest                   current   lastest

    26

 |                          |         |

    27

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

    28

              |

    29

           forced

    30

*/

    31

    32

#define MAX_NEWS 30

    33

    34

#define INVALID_NEWS 255

    35

    36

static NewsItem _news_items[MAX_NEWS];

    37

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

    38

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

    39

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

    40

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

    41

 * _forced_news. forced_news is INVALID_NEWS otherwise.

    42

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

    43

static byte _forced_news = INVALID_NEWS;

    44

    45

static byte _total_news = 0; // total news count

    46

    47

void DrawNewsNewTrainAvail(Window *w);

    48

void DrawNewsNewRoadVehAvail(Window *w);

    49

void DrawNewsNewShipAvail(Window *w);

    50

void DrawNewsNewAircraftAvail(Window *w);

    51

void DrawNewsBankrupcy(Window *w);

    52

static void MoveToNexItem(void);

    53

    54

StringID GetNewsStringNewTrainAvail(const NewsItem *ni);

    55

StringID GetNewsStringNewRoadVehAvail(const NewsItem *ni);

    56

StringID GetNewsStringNewShipAvail(const NewsItem *ni);

    57

StringID GetNewsStringNewAircraftAvail(const NewsItem *ni);

    58

StringID GetNewsStringBankrupcy(const NewsItem *ni);

    59

    60

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    61

	DrawNewsNewTrainAvail,    /* DNC_TRAINAVAIL */

    62

	DrawNewsNewRoadVehAvail,  /* DNC_ROADAVAIL */

    63

	DrawNewsNewShipAvail,     /* DNC_SHIPAVAIL */

    64

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    65

	DrawNewsBankrupcy,        /* DNC_BANKRUPCY */

    66

};

    67

    68

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    69

	GetNewsStringNewTrainAvail,    /* DNC_TRAINAVAIL */

    70

	GetNewsStringNewRoadVehAvail,  /* DNC_ROADAVAIL */

    71

	GetNewsStringNewShipAvail,     /* DNC_SHIPAVAIL */

    72

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    73

	GetNewsStringBankrupcy,        /* DNC_BANKRUPCY */

    74

};

    75

    76

void InitNewsItemStructs(void)

    77

{

    78

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

    79

	_current_news = INVALID_NEWS;

    80

	_oldest_news = 0;

    81

	_latest_news = INVALID_NEWS;

    82

	_forced_news = INVALID_NEWS;

    83

	_total_news = 0;

    84

}

    85

    86

void DrawNewsBorder(const Window *w)

    87

{

    88

	int left = 0;

    89

	int right = w->width - 1;

    90

	int top = 0;

    91

	int bottom = w->height - 1;

    92

    93

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

    94

    95

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

    96

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

    97

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

    98

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

    99

   100

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

   101

}

   102

   103

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

   104

{

   105

	switch (e->event) {

   106

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

   107

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

   108

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

   109

	} break;

   110

   111

	case WE_PAINT: {

   112

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

   113

		ViewPort *vp;

   114

   115

		switch (ni->display_mode) {

   116

			case NM_NORMAL:

   117

			case NM_THIN: {

   118

				DrawNewsBorder(w);

   119

   120

				DrawString(2, 1, STR_00C6, 0);

   121

   122

				SetDParam(0, ni->date);

   123

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   124

   125

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

   126

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

   127

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

   128

						ni->string_id, 426);

   129

				} else {

   130

					byte bk = _display_opt;

   131

					_display_opt &= ~DO_TRANS_BUILDINGS;

   132

					DrawWindowViewport(w);

   133

					_display_opt = bk;

   134

   135

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

   136

					vp = w->viewport;

   137

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

   138

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

   139

						(ni->flags & NF_INCOLOR ? 0x322 : 0x323) | USE_COLORTABLE

   140

					);

   141

   142

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

   143

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

   144

				}

   145

				break;

   146

			}

   147

   148

			case NM_CALLBACK: {

   149

				_draw_news_callback[ni->callback](w);

   150

				break;

   151

			}

   152

   153

			default: {

   154

				DrawWindowWidgets(w);

   155

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

   156

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

   157

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

   158

				} else {

   159

					DrawWindowViewport(w);

   160

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

   161

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

   162

				}

   163

				break;

   164

			}

   165

		}

   166

	} break;

   167

   168

	case WE_CLICK: {

   169

		switch (e->click.widget) {

   170

		case 1: {

   171

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

   172

			DeleteWindow(w);

   173

			ni->duration = 0;

   174

			_forced_news = INVALID_NEWS;

   175

		} break;

   176

		case 0: {

   177

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

   178

			if (ni->flags & NF_VEHICLE) {

   179

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

   180

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

   181

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

   182

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

   183

					ScrollMainWindowToTile(ni->data_b);

   184

			}

   185

		} break;

   186

		}

   187

	} break;

   188

   189

	case WE_KEYPRESS:

   190

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

   191

			// Don't continue.

   192

			e->keypress.cont = false;

   193

			DeleteWindow(w);

   194

		}

   195

		break;

   196

   197

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

   198

		switch (e->message.msg) {

   199

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

   200

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

   201

		}

   202

		break;

   203

   204

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

   205

		int diff;

   206

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

   207

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

   208

   209

		if (w->viewport != NULL)

   210

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

   211

   212

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

   213

		w->top = y;

   214

   215

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

   216

	} break;

   217

	}

   218

}

   219

   220

// returns the correct index in the array

   221

// (to deal with overflows)

   222

static byte increaseIndex(byte i)

   223

{

   224

	if (i == INVALID_NEWS)

   225

		return 0;

   226

	i++;

   227

	if (i >= MAX_NEWS)

   228

		i = i % MAX_NEWS;

   229

	return i;

   230

}

   231

   232

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

   233

{

   234

	NewsItem *ni;

   235

	Window *w;

   236

   237

	if (_game_mode == GM_MENU)

   238

		return;

   239

   240

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

   241

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

   242

		MoveToNexItem();

   243

   244

	_forced_news = INVALID_NEWS;

   245

	if (_total_news < MAX_NEWS) _total_news++;

   246

   247

	// make sure our pointer isn't overflowing

   248

	_latest_news = increaseIndex(_latest_news);

   249

   250

	// overwrite oldest news entry

   251

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

   252

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

   253

   254

	// add news to _latest_news

   255

	ni = &_news_items[_latest_news];

   256

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

   257

   258

	ni->string_id = string;

   259

	ni->display_mode = (byte)flags;

   260

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

   261

   262

	// show this news message in color?

   263

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

   264

		ni->flags |= NF_INCOLOR;

   265

   266

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

   267

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

   268

	ni->data_a = data_a;

   269

	ni->data_b = data_b;

   270

	ni->date = _date;

   271

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

   272

   273

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   274

	if (w == NULL) return;

   275

	SetWindowDirty(w);

   276

	w->vscroll.count = _total_news;

   277

}

   278

   279

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

   280

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

   281

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

   282

{

   283

	AddNewsItem(string, flags, data_a, data_b);

   284

	_news_items[_latest_news].isValid = validation;

   285

}

   286

   287

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

   288

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

   289

   290

static const Widget _news_type13_widgets[] = {

   291

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

   292

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

   293

{   WIDGETS_END},

   294

};

   295

   296

static WindowDesc _news_type13_desc = {

   297

	WDP_CENTER, 476, 430, 170,

   298

	WC_NEWS_WINDOW, 0,

   299

	WDF_DEF_WIDGET,

   300

	_news_type13_widgets,

   301

	NewsWindowProc

   302

};

   303

   304

static const Widget _news_type2_widgets[] = {

   305

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

   306

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

   307

{   WIDGETS_END},

   308

};

   309

   310

static WindowDesc _news_type2_desc = {

   311

	WDP_CENTER, 476, 430, 130,

   312

	WC_NEWS_WINDOW, 0,

   313

	WDF_DEF_WIDGET,

   314

	_news_type2_widgets,

   315

	NewsWindowProc

   316

};

   317

   318

static const Widget _news_type0_widgets[] = {

   319

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

   320

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

   321

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

   322

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

   323

{   WIDGETS_END},

   324

};

   325

   326

static WindowDesc _news_type0_desc = {

   327

	WDP_CENTER, 476, 280, 87,

   328

	WC_NEWS_WINDOW, 0,

   329

	WDF_DEF_WIDGET,

   330

	_news_type0_widgets,

   331

	NewsWindowProc

   332

};

   333

   334

static const SoundFx _news_sounds[] = {

   335

	SND_1D_APPLAUSE,

   336

	SND_1D_APPLAUSE,

   337

	0,

   338

	0,

   339

	0,

   340

	0,

   341

	SND_1E_OOOOH,

   342

	0,

   343

	0,

   344

	0

   345

};

   346

   347

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

   348

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

   349

 * @param item the item whose value is requested

   350

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

   351

 */

   352

static inline byte GetNewsDisplayValue(byte item)

   353

{

   354

	assert(item < 10 && GB(_news_display_opt, item * 2, 2) <= 2);

   355

	return GB(_news_display_opt, item * 2, 2);

   356

}

   357

   358

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

   359

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

   360

 * @param item the item whose value is being set

   361

 * @param val new value

   362

 */

   363

static inline void SetNewsDisplayValue(byte item, byte val)

   364

{

   365

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

   366

	SB(_news_display_opt, item * 2, 2, val);

   367

}

   368

   369

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

   370

static void ShowNewspaper(NewsItem *ni)

   371

{

   372

	Window *w;

   373

	SoundFx sound;

   374

	int top;

   375

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

   376

	ni->duration = 555;

   377

   378

	sound = _news_sounds[ni->type];

   379

	if (sound != 0)

   380

		SndPlayFx(sound);

   381

   382

	top = _screen.height;

   383

	switch (ni->display_mode) {

   384

		case NM_NORMAL:

   385

		case NM_CALLBACK: {

   386

			_news_type13_desc.top = top;

   387

			w = AllocateWindowDesc(&_news_type13_desc);

   388

			if (ni->flags & NF_VIEWPORT)

   389

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

   390

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

   391

			break;

   392

		}

   393

   394

		case NM_THIN: {

   395

			_news_type2_desc.top = top;

   396

			w = AllocateWindowDesc(&_news_type2_desc);

   397

			if (ni->flags & NF_VIEWPORT)

   398

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

   399

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

   400

			break;

   401

		}

   402

   403

		default: {

   404

			_news_type0_desc.top = top;

   405

			w = AllocateWindowDesc(&_news_type0_desc);

   406

			if (ni->flags & NF_VIEWPORT)

   407

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

   408

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

   409

			break;

   410

		}

   411

	}

   412

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

   413

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   414

}

   415

   416

// show news item in the ticker

   417

static void ShowTicker(const NewsItem *ni)

   418

{

   419

	Window *w;

   420

   421

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   422

   423

	_statusbar_news_item = *ni;

   424

	w = FindWindowById(WC_STATUS_BAR, 0);

   425

	if (w != NULL)

   426

		WP(w, def_d).data_1 = 360;

   427

}

   428

   429

   430

// Are we ready to show another news item?

   431

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

   432

static bool ReadyForNextItem(void)

   433

{

   434

	const Window *w;

   435

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

   436

	NewsItem *ni;

   437

   438

	if (item >= MAX_NEWS) return true;

   439

	ni = &_news_items[item];

   440

   441

	// Ticker message

   442

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

   443

	w = FindWindowById(WC_STATUS_BAR, 0);

   444

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

   445

		return false;

   446

   447

	// Newspaper message

   448

	// Wait until duration reaches 0

   449

	if (ni->duration != 0) {

   450

		ni->duration--;

   451

		return false;

   452

	}

   453

   454

	// neither newsticker nor newspaper are running

   455

	return true;

   456

}

   457

   458

static void MoveToNexItem(void)

   459

{

   460

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   461

	_forced_news = INVALID_NEWS;

   462

   463

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

   464

	if (_current_news != _latest_news) {

   465

		NewsItem *ni;

   466

   467

		_current_news = increaseIndex(_current_news);

   468

		ni = &_news_items[_current_news];

   469

   470

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

   471

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

   472

			return;

   473

   474

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

   475

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

   476

			return;

   477

   478

  	switch (GetNewsDisplayValue(ni->type)) {

   479

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

   480

  		Window *w = FindWindowById(WC_STATUS_BAR, 0);

   481

			if (w != NULL) {

   482

				WP(w, def_d).data_2 = 91;

   483

				SetWindowDirty(w);

   484

			}

   485

  	} break;

   486

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

   487

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

   488

  			ShowTicker(ni);

   489

  			break;

   490

  		}

   491

  		/* Fallthrough */

   492

  	case 2: /* Full - show newspaper*/

   493