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

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

   279

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

   280

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

   281

{

   282

	AddNewsItem(string, flags, data_a, data_b);

   283

	_news_items[_latest_news].isValid = validation;

   284

}

   285

   286

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

   287

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

   288

   289

static const Widget _news_type13_widgets[] = {

   290

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

   291

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

   292

{   WIDGETS_END},

   293

};

   294

   295

static WindowDesc _news_type13_desc = {

   296

	WDP_CENTER, 476, 430, 170,

   297

	WC_NEWS_WINDOW, 0,

   298

	WDF_DEF_WIDGET,

   299

	_news_type13_widgets,

   300

	NewsWindowProc

   301

};

   302

   303

static const Widget _news_type2_widgets[] = {

   304

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

   305

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

   306

{   WIDGETS_END},

   307

};

   308

   309

static WindowDesc _news_type2_desc = {

   310

	WDP_CENTER, 476, 430, 130,

   311

	WC_NEWS_WINDOW, 0,

   312

	WDF_DEF_WIDGET,

   313

	_news_type2_widgets,

   314

	NewsWindowProc

   315

};

   316

   317

static const Widget _news_type0_widgets[] = {

   318

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

   319

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

   320

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

   321

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

   322

{   WIDGETS_END},

   323

};

   324

   325

static WindowDesc _news_type0_desc = {

   326

	WDP_CENTER, 476, 280, 87,

   327

	WC_NEWS_WINDOW, 0,

   328

	WDF_DEF_WIDGET,

   329

	_news_type0_widgets,

   330

	NewsWindowProc

   331

};

   332

   333

static const SoundFx _news_sounds[] = {

   334

	SND_1D_APPLAUSE,

   335

	SND_1D_APPLAUSE,

   336

	0,

   337

	0,

   338

	0,

   339

	0,

   340

	SND_1E_OOOOH,

   341

	0,

   342

	0,

   343

	0

   344

};

   345

   346

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

   347

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

   348

 * @param item the item whose value is requested

   349

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

   350

 */

   351

static inline byte GetNewsDisplayValue(byte item)

   352

{

   353

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

   354

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

   355

}

   356

   357

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

   358

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

   359

 * @param item the item whose value is being set

   360

 * @param val new value

   361

 */

   362

static inline void SetNewsDisplayValue(byte item, byte val)

   363

{

   364

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

   365

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

   366

}

   367

   368

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

   369

static void ShowNewspaper(NewsItem *ni)

   370

{

   371

	Window *w;

   372

	SoundFx sound;

   373

	int top;

   374

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

   375

	ni->duration = 555;

   376

   377

	sound = _news_sounds[ni->type];

   378

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

   379

   380

	top = _screen.height;

   381

	switch (ni->display_mode) {

   382

		case NM_NORMAL:

   383

		case NM_CALLBACK: {

   384

			_news_type13_desc.top = top;

   385

			w = AllocateWindowDesc(&_news_type13_desc);

   386

			if (ni->flags & NF_VIEWPORT)

   387

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

   388

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

   389

			break;

   390

		}

   391

   392

		case NM_THIN: {

   393

			_news_type2_desc.top = top;

   394

			w = AllocateWindowDesc(&_news_type2_desc);

   395

			if (ni->flags & NF_VIEWPORT)

   396

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

   397

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

   398

			break;

   399

		}

   400

   401

		default: {

   402

			_news_type0_desc.top = top;

   403

			w = AllocateWindowDesc(&_news_type0_desc);

   404

			if (ni->flags & NF_VIEWPORT)

   405

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

   406

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

   407

			break;

   408

		}

   409

	}

   410

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

   411

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   412

}

   413

   414

// show news item in the ticker

   415

static void ShowTicker(const NewsItem *ni)

   416

{

   417

	Window *w;

   418

   419

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   420

   421

	_statusbar_news_item = *ni;

   422

	w = FindWindowById(WC_STATUS_BAR, 0);

   423

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

   424

}

   425

   426

   427

// Are we ready to show another news item?

   428

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

   429

static bool ReadyForNextItem(void)

   430

{

   431

	const Window *w;

   432

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

   433

	NewsItem *ni;

   434

   435

	if (item >= MAX_NEWS) return true;

   436

	ni = &_news_items[item];

   437

   438

	// Ticker message

   439

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

   440

	w = FindWindowById(WC_STATUS_BAR, 0);

   441

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

   442

   443

	// Newspaper message

   444

	// Wait until duration reaches 0

   445

	if (ni->duration != 0) {

   446

		ni->duration--;

   447

		return false;

   448

	}

   449

   450

	// neither newsticker nor newspaper are running

   451

	return true;

   452

}

   453

   454

static void MoveToNexItem(void)

   455

{

   456

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   457

	_forced_news = INVALID_NEWS;

   458

   459

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

   460

	if (_current_news != _latest_news) {

   461

		NewsItem *ni;

   462

   463

		_current_news = increaseIndex(_current_news);

   464

		ni = &_news_items[_current_news];

   465

   466

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

   467

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

   468

   469

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

   470

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

   471

   472

		switch (GetNewsDisplayValue(ni->type)) {

   473

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

   474

			Window* w = FindWindowById(WC_STATUS_BAR, 0);

   475

   476

			if (w != NULL) {

   477

				WP(w, def_d).data_2 = 91;

   478

				SetWindowDirty(w);

   479

			}

   480

			break;

   481

		}

   482

   483

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

   484

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

   485

				ShowTicker(ni);

   486

				break;

   487

			}

   488

			/* Fallthrough */

   489

   490

		case 2: /* Full - show newspaper*/

   491

			ShowNewspaper(ni);

   492

			break;