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 && ((_news_display_opt >> (item * 2)) & 0x3) <= 2);

   355

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

   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

	item *= 2;

   367

	CLRBIT(_news_display_opt, item);

   368

	CLRBIT(_news_display_opt, item + 1);

   369

	_news_display_opt |= val << item;

   370

}

   371

   372

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

   373

static void ShowNewspaper(NewsItem *ni)

   374

{

   375

	Window *w;

   376

	int sound;

   377

	int top;

   378

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

   379

	ni->duration = 555;

   380

   381

	sound = _news_sounds[ni->type];

   382

	if (sound != 0)

   383

		SndPlayFx(sound);

   384

   385

	top = _screen.height;

   386

	switch (ni->display_mode) {

   387

		case NM_NORMAL:

   388

		case NM_CALLBACK: {

   389

			_news_type13_desc.top = top;

   390

			w = AllocateWindowDesc(&_news_type13_desc);

   391

			if (ni->flags & NF_VIEWPORT)

   392

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

   393

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

   394

			break;

   395

		}

   396

   397

		case NM_THIN: {

   398

			_news_type2_desc.top = top;

   399

			w = AllocateWindowDesc(&_news_type2_desc);

   400

			if (ni->flags & NF_VIEWPORT)

   401

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

   402

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

   403

			break;

   404

		}

   405

   406

		default: {

   407

			_news_type0_desc.top = top;

   408

			w = AllocateWindowDesc(&_news_type0_desc);

   409

			if (ni->flags & NF_VIEWPORT)

   410

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

   411

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

   412

			break;

   413

		}

   414

	}

   415

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

   416

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   417

}

   418

   419

// show news item in the ticker

   420

static void ShowTicker(const NewsItem *ni)

   421

{

   422

	Window *w;

   423

   424

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   425

   426

	_statusbar_news_item = *ni;

   427

	w = FindWindowById(WC_STATUS_BAR, 0);

   428

	if (w != NULL)

   429

		WP(w, def_d).data_1 = 360;

   430

}

   431

   432

   433

// Are we ready to show another news item?

   434

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

   435

static bool ReadyForNextItem(void)

   436

{

   437

	const Window *w;

   438

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

   439

	NewsItem *ni;

   440

   441

	if (item >= MAX_NEWS) return true;

   442

	ni = &_news_items[item];

   443

   444

	// Ticker message

   445

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

   446

	w = FindWindowById(WC_STATUS_BAR, 0);

   447

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

   448

		return false;

   449

   450

	// Newspaper message

   451

	// Wait until duration reaches 0

   452

	if (ni->duration != 0) {

   453

		ni->duration--;

   454

		return false;

   455

	}

   456

   457

	// neither newsticker nor newspaper are running

   458

	return true;

   459

}

   460

   461

static void MoveToNexItem(void)

   462

{

   463

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   464

	_forced_news = INVALID_NEWS;

   465

   466

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

   467

	if (_current_news != _latest_news) {

   468

		NewsItem *ni;

   469

   470

		_current_news = increaseIndex(_current_news);

   471

		ni = &_news_items[_current_news];

   472

   473

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

   474

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

   475

			return;

   476

   477

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

   478

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

   479

			return;

   480

   481

  	switch (GetNewsDisplayValue(ni->type)) {

   482

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

   483

  		Window *w = FindWindowById(WC_STATUS_BAR, 0);

   484

			if (w != NULL) {

   485

				WP(w, def_d).data_2 = 91;

   486

				SetWindowDirty(w);

   487

			}

   488

  	} break;

   489

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

   490

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

   491

  			ShowTicker(ni);

   492

  			break;

   493

  		}