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_018B_CLOSE_WINDOW},

   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) 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) WP(w, def_d).data_1 = 360;

   425

}

   426

   427

   428

// Are we ready to show another news item?

   429

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

   430

static bool ReadyForNextItem(void)

   431

{

   432

	const Window *w;

   433

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

   434

	NewsItem *ni;

   435

   436

	if (item >= MAX_NEWS) return true;

   437

	ni = &_news_items[item];

   438

   439

	// Ticker message

   440

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

   441

	w = FindWindowById(WC_STATUS_BAR, 0);

   442

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

   443

   444

	// Newspaper message

   445

	// Wait until duration reaches 0

   446

	if (ni->duration != 0) {

   447

		ni->duration--;

   448

		return false;

   449

	}

   450

   451

	// neither newsticker nor newspaper are running

   452

	return true;

   453

}

   454

   455

static void MoveToNexItem(void)

   456

{

   457

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   458

	_forced_news = INVALID_NEWS;

   459

   460

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

   461

	if (_current_news != _latest_news) {

   462

		NewsItem *ni;

   463

   464

		_current_news = increaseIndex(_current_news);

   465

		ni = &_news_items[_current_news];

   466

   467

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

   468

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

   469

   470

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

   471

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

   472

   473

		switch (GetNewsDisplayValue(ni->type)) {

   474

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

   475

			Window* w = FindWindowById(WC_STATUS_BAR, 0);

   476

   477

			if (w != NULL) {

   478

				WP(w, def_d).data_2 = 91;

   479

				SetWindowDirty(w);

   480

			}

   481

			break;

   482

		}

   483

   484

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

   485

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

   486

				ShowTicker(ni);

   487

				break;

   488

			}

   489

			/* Fallthrough */

   490

   491

		case 2: /* Full - show newspaper*/

   492

			ShowNewspaper(ni);