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 "viewport.h"

    11

#include "gfx.h"

    12

#include "news.h"

    13

#include "vehicle.h"

    14

#include "sound.h"

    15

#include "variables.h"

    16

    17

/* News system

    18

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

    19

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

    20

the array elements through pointers to the elements. Once the

    21

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

    22

by the newest (_latest news).

    23

    24

oldest                   current   lastest

    25

 |                          |         |

    26

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

    27

              |

    28

           forced

    29

*/

    30

    31

#define MAX_NEWS 30

    32

    33

#define INVALID_NEWS 255

    34

    35

static NewsItem _news_items[MAX_NEWS];

    36

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

    37

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

    38

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

    39

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

    40

 * _forced_news. forced_news is INVALID_NEWS otherwise.

    41

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

    42

static byte _forced_news = INVALID_NEWS;

    43

    44

static byte _total_news = 0; // total news count

    45

    46

void DrawNewsNewTrainAvail(Window *w);

    47

void DrawNewsNewRoadVehAvail(Window *w);

    48

void DrawNewsNewShipAvail(Window *w);

    49

void DrawNewsNewAircraftAvail(Window *w);

    50

void DrawNewsBankrupcy(Window *w);

    51

static void MoveToNexItem(void);

    52

    53

StringID GetNewsStringNewTrainAvail(const NewsItem *ni);

    54

StringID GetNewsStringNewRoadVehAvail(const NewsItem *ni);

    55

StringID GetNewsStringNewShipAvail(const NewsItem *ni);

    56

StringID GetNewsStringNewAircraftAvail(const NewsItem *ni);

    57

StringID GetNewsStringBankrupcy(const NewsItem *ni);

    58

    59

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    60

	DrawNewsNewTrainAvail,    /* DNC_TRAINAVAIL */

    61

	DrawNewsNewRoadVehAvail,  /* DNC_ROADAVAIL */

    62

	DrawNewsNewShipAvail,     /* DNC_SHIPAVAIL */

    63

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    64

	DrawNewsBankrupcy,        /* DNC_BANKRUPCY */

    65

};

    66

    67

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    68

	GetNewsStringNewTrainAvail,    /* DNC_TRAINAVAIL */

    69

	GetNewsStringNewRoadVehAvail,  /* DNC_ROADAVAIL */

    70

	GetNewsStringNewShipAvail,     /* DNC_SHIPAVAIL */

    71

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    72

	GetNewsStringBankrupcy,        /* DNC_BANKRUPCY */

    73

};

    74

    75

void InitNewsItemStructs(void)

    76

{

    77

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

    78

	_current_news = INVALID_NEWS;

    79

	_oldest_news = 0;

    80

	_latest_news = INVALID_NEWS;

    81

	_forced_news = INVALID_NEWS;

    82

	_total_news = 0;

    83

}

    84

    85

void DrawNewsBorder(const Window *w)

    86

{

    87

	int left = 0;

    88

	int right = w->width - 1;

    89

	int top = 0;

    90

	int bottom = w->height - 1;

    91

    92

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

    93

    94

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

    95

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

    96

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

    97

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

    98

    99

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

   100

}

   101

   102

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

   103

{

   104

	switch (e->event) {

   105

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

   106

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

   107

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

   108

	} break;

   109

   110

	case WE_PAINT: {

   111

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

   112

		ViewPort *vp;

   113

   114

		switch (ni->display_mode) {

   115

			case NM_NORMAL:

   116

			case NM_THIN: {

   117

				DrawNewsBorder(w);

   118

   119

				DrawString(2, 1, STR_00C6, 0);

   120

   121

				SetDParam(0, ni->date);

   122

				DrawStringRightAligned(428, 1, STR_01FF, 0);

   123

   124

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

   125

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

   126

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

   127

						ni->string_id, 426);

   128

				} else {

   129

					byte bk = _display_opt;

   130

					_display_opt &= ~DO_TRANS_BUILDINGS;

   131

					DrawWindowViewport(w);

   132

					_display_opt = bk;

   133

   134

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

   135

					vp = w->viewport;

   136

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

   137

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

   138

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

   139

					);

   140

   141

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

   142

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

   143

				}

   144

				break;

   145

			}

   146

   147

			case NM_CALLBACK: {

   148

				_draw_news_callback[ni->callback](w);

   149

				break;

   150

			}

   151

   152

			default: {

   153

				DrawWindowWidgets(w);

   154

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

   155

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

   156

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

   157

				} else {

   158

					DrawWindowViewport(w);

   159

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

   160

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

   161

				}

   162

				break;

   163

			}

   164

		}

   165

	} break;

   166

   167

	case WE_CLICK: {

   168

		switch (e->click.widget) {

   169

		case 1: {

   170

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

   171

			DeleteWindow(w);

   172

			ni->duration = 0;

   173

			_forced_news = INVALID_NEWS;

   174

		} break;

   175

		case 0: {

   176

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

   177

			if (ni->flags & NF_VEHICLE) {

   178

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

   179

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

   180

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

   181

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

   182

					ScrollMainWindowToTile(ni->data_b);

   183

			}

   184

		} break;

   185

		}

   186

	} break;

   187

   188

	case WE_KEYPRESS:

   189

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

   190

			// Don't continue.

   191

			e->keypress.cont = false;

   192

			DeleteWindow(w);

   193

		}

   194

		break;

   195

   196

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

   197

		switch (e->message.msg) {

   198

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

   199

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

   200

		}

   201

		break;

   202

   203

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

   204

		int diff;

   205

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

   206

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

   207

   208

		if (w->viewport != NULL)

   209

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

   210

   211

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

   212

		w->top = y;

   213

   214

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

   215

	} break;

   216

	}

   217

}

   218

   219

// returns the correct index in the array

   220

// (to deal with overflows)

   221

static byte increaseIndex(byte i)

   222

{

   223

	if (i == INVALID_NEWS)

   224

		return 0;

   225

	i++;

   226

	if (i >= MAX_NEWS)

   227

		i = i % MAX_NEWS;

   228

	return i;

   229

}

   230

   231

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

   232

{

   233

	NewsItem *ni;

   234

	Window *w;

   235

   236

	if (_game_mode == GM_MENU)

   237

		return;

   238

   239

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

   240

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

   241

		MoveToNexItem();

   242

   243

	_forced_news = INVALID_NEWS;

   244

	if (_total_news < MAX_NEWS) _total_news++;

   245

   246

	// make sure our pointer isn't overflowing

   247

	_latest_news = increaseIndex(_latest_news);

   248

   249

	// overwrite oldest news entry

   250

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

   251

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

   252

   253

	// add news to _latest_news

   254

	ni = &_news_items[_latest_news];

   255

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

   256

   257

	ni->string_id = string;

   258

	ni->display_mode = (byte)flags;

   259

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

   260

   261

	// show this news message in color?

   262

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

   263

		ni->flags |= NF_INCOLOR;

   264

   265

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

   266

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

   267

	ni->data_a = data_a;

   268

	ni->data_b = data_b;

   269

	ni->date = _date;

   270

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

   271

   272

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   273

	if (w == NULL) return;

   274

	SetWindowDirty(w);

   275

	w->vscroll.count = _total_news;

   276

}

   277

   278

   279

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

   280

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

   281

   282

static const Widget _news_type13_widgets[] = {

   283

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

   284

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

   285

{   WIDGETS_END},

   286

};

   287

   288

static WindowDesc _news_type13_desc = {

   289

	WDP_CENTER, 476, 430, 170,

   290

	WC_NEWS_WINDOW, 0,

   291

	WDF_DEF_WIDGET,

   292

	_news_type13_widgets,

   293

	NewsWindowProc

   294

};

   295

   296

static const Widget _news_type2_widgets[] = {

   297

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

   298

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

   299

{   WIDGETS_END},

   300

};

   301

   302

static WindowDesc _news_type2_desc = {

   303

	WDP_CENTER, 476, 430, 130,

   304

	WC_NEWS_WINDOW, 0,

   305

	WDF_DEF_WIDGET,

   306

	_news_type2_widgets,

   307

	NewsWindowProc

   308

};

   309

   310

static const Widget _news_type0_widgets[] = {

   311

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

   312

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

   313

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

   314

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

   315

{   WIDGETS_END},

   316

};

   317

   318

static WindowDesc _news_type0_desc = {

   319

	WDP_CENTER, 476, 280, 87,

   320

	WC_NEWS_WINDOW, 0,

   321

	WDF_DEF_WIDGET,

   322

	_news_type0_widgets,

   323

	NewsWindowProc

   324

};

   325

   326

static const SoundFx _news_sounds[] = {

   327

	SND_1D_APPLAUSE,

   328

	SND_1D_APPLAUSE,

   329

	0,

   330

	0,

   331

	0,

   332

	0,

   333

	SND_1E_OOOOH,

   334

	0,

   335

	0,

   336

	0

   337

};

   338

   339

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

   340

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

   341

 * @param item the item whose value is requested

   342

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

   343

 */

   344

static inline byte GetNewsDisplayValue(byte item)

   345

{

   346

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

   347

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

   348

}

   349

   350

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

   351

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

   352

 * @param item the item whose value is being set

   353

 * @param val new value

   354

 */

   355

static inline void SetNewsDisplayValue(byte item, byte val)

   356

{

   357

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

   358

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

   359

}

   360

   361

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

   362

static void ShowNewspaper(NewsItem *ni)

   363

{

   364

	Window *w;

   365

	SoundFx sound;

   366

	int top;

   367

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

   368

	ni->duration = 555;

   369

   370

	sound = _news_sounds[ni->type];

   371

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

   372

   373

	top = _screen.height;

   374

	switch (ni->display_mode) {

   375

		case NM_NORMAL:

   376

		case NM_CALLBACK: {

   377

			_news_type13_desc.top = top;

   378

			w = AllocateWindowDesc(&_news_type13_desc);

   379

			if (ni->flags & NF_VIEWPORT)

   380

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

   381

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

   382

			break;

   383

		}

   384

   385

		case NM_THIN: {

   386

			_news_type2_desc.top = top;

   387

			w = AllocateWindowDesc(&_news_type2_desc);

   388

			if (ni->flags & NF_VIEWPORT)

   389

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

   390

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

   391

			break;

   392

		}

   393

   394

		default: {

   395

			_news_type0_desc.top = top;

   396

			w = AllocateWindowDesc(&_news_type0_desc);

   397

			if (ni->flags & NF_VIEWPORT)

   398

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

   399

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

   400

			break;

   401

		}

   402

	}

   403

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

   404

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   405

}

   406

   407

// show news item in the ticker

   408

static void ShowTicker(const NewsItem *ni)

   409

{

   410

	Window *w;

   411

   412

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   413

   414

	_statusbar_news_item = *ni;

   415

	w = FindWindowById(WC_STATUS_BAR, 0);

   416

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

   417

}

   418

   419

   420

// Are we ready to show another news item?

   421

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

   422

static bool ReadyForNextItem(void)

   423

{

   424

	const Window *w;

   425

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

   426

	NewsItem *ni;

   427

   428

	if (item >= MAX_NEWS) return true;

   429

	ni = &_news_items[item];

   430

   431

	// Ticker message

   432

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

   433

	w = FindWindowById(WC_STATUS_BAR, 0);

   434

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

   435

   436

	// Newspaper message

   437

	// Wait until duration reaches 0

   438

	if (ni->duration != 0) {

   439

		ni->duration--;

   440

		return false;

   441

	}

   442

   443

	// neither newsticker nor newspaper are running

   444

	return true;

   445

}

   446

   447

static void MoveToNexItem(void)

   448

{

   449

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   450

	_forced_news = INVALID_NEWS;

   451

   452

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

   453

	if (_current_news != _latest_news) {

   454

		NewsItem *ni;

   455

   456

		_current_news = increaseIndex(_current_news);

   457

		ni = &_news_items[_current_news];

   458

   459

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

   460

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

   461

   462

		switch (GetNewsDisplayValue(ni->type)) {

   463

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

   464

			Window* w = FindWindowById(WC_STATUS_BAR, 0);

   465

   466

			if (w != NULL) {

   467

				WP(w, def_d).data_2 = 91;

   468

				SetWindowDirty(w);

   469

			}

   470

			break;

   471

		}

   472

   473

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

   474

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

   475

				ShowTicker(ni);

   476

				break;

   477

			}

   478

			/* Fallthrough */

   479

   480

		case 2: /* Full - show newspaper*/

   481

			ShowNewspaper(ni);

   482

			break;

   483

		}

   484

	}

   485

}

   486

   487

void NewsLoop(void)

   488

{

   489

	// no news item yet

   490

	if (_total_news == 0) return;

   491

   492

	if (ReadyForNextItem()) MoveToNexItem();