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

   280

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

   281

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

   282

   283

static const Widget _news_type13_widgets[] = {

   284

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

   285

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

   286

{   WIDGETS_END},

   287

};

   288

   289

static WindowDesc _news_type13_desc = {

   290

	WDP_CENTER, 476, 430, 170,

   291

	WC_NEWS_WINDOW, 0,

   292

	WDF_DEF_WIDGET,

   293

	_news_type13_widgets,

   294

	NewsWindowProc

   295

};

   296

   297

static const Widget _news_type2_widgets[] = {

   298

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

   299

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

   300

{   WIDGETS_END},

   301

};

   302

   303

static WindowDesc _news_type2_desc = {

   304

	WDP_CENTER, 476, 430, 130,

   305

	WC_NEWS_WINDOW, 0,

   306

	WDF_DEF_WIDGET,

   307

	_news_type2_widgets,

   308

	NewsWindowProc

   309

};

   310

   311

static const Widget _news_type0_widgets[] = {

   312

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

   313

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

   314

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

   315

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

   316

{   WIDGETS_END},

   317

};

   318

   319

static WindowDesc _news_type0_desc = {

   320

	WDP_CENTER, 476, 280, 87,

   321

	WC_NEWS_WINDOW, 0,

   322

	WDF_DEF_WIDGET,

   323

	_news_type0_widgets,

   324

	NewsWindowProc

   325

};

   326

   327

static const SoundFx _news_sounds[] = {

   328

	SND_1D_APPLAUSE,

   329

	SND_1D_APPLAUSE,

   330

	0,

   331

	0,

   332

	0,

   333

	0,

   334

	SND_1E_OOOOH,

   335

	0,

   336

	0,

   337

	0

   338

};

   339

   340

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

   341

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

   342

 * @param item the item whose value is requested

   343

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

   344

 */

   345

static inline byte GetNewsDisplayValue(byte item)

   346

{

   347

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

   348

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

   349

}

   350

   351

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

   352

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

   353

 * @param item the item whose value is being set

   354

 * @param val new value

   355

 */

   356

static inline void SetNewsDisplayValue(byte item, byte val)

   357

{

   358

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

   359

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

   360

}

   361

   362

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

   363

static void ShowNewspaper(NewsItem *ni)

   364

{

   365

	Window *w;

   366

	SoundFx sound;

   367

	int top;

   368

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

   369

	ni->duration = 555;

   370

   371

	sound = _news_sounds[ni->type];

   372

	if (sound != 0) SndPlayFx(sound);

   373

   374

	top = _screen.height;

   375

	switch (ni->display_mode) {

   376

		case NM_NORMAL:

   377

		case NM_CALLBACK: {

   378

			_news_type13_desc.top = top;

   379

			w = AllocateWindowDesc(&_news_type13_desc);

   380

			if (ni->flags & NF_VIEWPORT)

   381

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

   382

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

   383

			break;

   384

		}

   385

   386

		case NM_THIN: {

   387

			_news_type2_desc.top = top;

   388

			w = AllocateWindowDesc(&_news_type2_desc);

   389

			if (ni->flags & NF_VIEWPORT)

   390

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

   391

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

   392

			break;

   393

		}

   394

   395

		default: {

   396

			_news_type0_desc.top = top;

   397

			w = AllocateWindowDesc(&_news_type0_desc);

   398

			if (ni->flags & NF_VIEWPORT)

   399

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

   400

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

   401

			break;

   402

		}

   403

	}

   404

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

   405

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   406

}

   407

   408

// show news item in the ticker

   409

static void ShowTicker(const NewsItem *ni)

   410

{

   411

	Window *w;

   412

   413

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   414

   415

	_statusbar_news_item = *ni;

   416

	w = FindWindowById(WC_STATUS_BAR, 0);

   417

	if (w != NULL) WP(w, def_d).data_1 = 360;

   418

}

   419

   420

   421

// Are we ready to show another news item?

   422

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

   423

static bool ReadyForNextItem(void)

   424

{

   425

	const Window *w;

   426

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

   427

	NewsItem *ni;

   428

   429

	if (item >= MAX_NEWS) return true;

   430

	ni = &_news_items[item];

   431

   432

	// Ticker message

   433

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

   434

	w = FindWindowById(WC_STATUS_BAR, 0);

   435

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

   436

   437

	// Newspaper message

   438

	// Wait until duration reaches 0

   439

	if (ni->duration != 0) {

   440

		ni->duration--;

   441

		return false;

   442

	}

   443

   444

	// neither newsticker nor newspaper are running

   445

	return true;

   446

}

   447

   448

static void MoveToNexItem(void)

   449

{

   450

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   451

	_forced_news = INVALID_NEWS;

   452

   453

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

   454

	if (_current_news != _latest_news) {

   455

		NewsItem *ni;

   456

   457

		_current_news = increaseIndex(_current_news);

   458

		ni = &_news_items[_current_news];

   459

   460

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

   461

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

   462

   463

		switch (GetNewsDisplayValue(ni->type)) {

   464

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

   465

			Window* w = FindWindowById(WC_STATUS_BAR, 0);

   466

   467

			if (w != NULL) {

   468

				WP(w, def_d).data_2 = 91;

   469

				SetWindowDirty(w);

   470

			}

   471

			break;

   472

		}

   473

   474

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

   475

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

   476

				ShowTicker(ni);

   477

				break;

   478

			}

   479

			/* Fallthrough */

   480

   481

		case 2: /* Full - show newspaper*/

   482

			ShowNewspaper(ni);

   483

			break;

   484

		}

   485

	}

   486

}

   487

   488

void NewsLoop(void)

   489

{

   490

	// no news item yet

   491

	if (_total_news == 0) return;

   492