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) return 0;

   225

	i++;

   226

	if (i >= MAX_NEWS) i = i % MAX_NEWS;

   227

	return i;

   228

}

   229

   230

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

   231

{

   232

	NewsItem *ni;

   233

	Window *w;

   234

   235

	if (_game_mode == GM_MENU) return;

   236

   237

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

   238

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

   239

		MoveToNexItem();

   240

   241

	_forced_news = INVALID_NEWS;

   242

	if (_total_news < MAX_NEWS) _total_news++;

   243

   244

	// make sure our pointer isn't overflowing

   245

	_latest_news = increaseIndex(_latest_news);

   246

   247

	// overwrite oldest news entry

   248

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

   249

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

   250

   251

	// add news to _latest_news

   252

	ni = &_news_items[_latest_news];

   253

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

   254

   255

	ni->string_id = string;

   256

	ni->display_mode = (byte)flags;

   257

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

   258

   259

	// show this news message in color?

   260

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

   261

		ni->flags |= NF_INCOLOR;

   262

   263

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

   264

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

   265

	ni->data_a = data_a;

   266

	ni->data_b = data_b;

   267

	ni->date = _date;

   268

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

   269

   270

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   271

	if (w == NULL) return;

   272

	SetWindowDirty(w);

   273

	w->vscroll.count = _total_news;

   274

}

   275

   276

   277

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

   278

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

   279

   280

static const Widget _news_type13_widgets[] = {

   281

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

   282

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

   283

{   WIDGETS_END},

   284

};

   285

   286

static WindowDesc _news_type13_desc = {

   287

	WDP_CENTER, 476, 430, 170,

   288

	WC_NEWS_WINDOW, 0,

   289

	WDF_DEF_WIDGET,

   290

	_news_type13_widgets,

   291

	NewsWindowProc

   292

};

   293

   294

static const Widget _news_type2_widgets[] = {

   295

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

   296

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

   297

{   WIDGETS_END},

   298

};

   299

   300

static WindowDesc _news_type2_desc = {

   301

	WDP_CENTER, 476, 430, 130,

   302

	WC_NEWS_WINDOW, 0,

   303

	WDF_DEF_WIDGET,

   304

	_news_type2_widgets,

   305

	NewsWindowProc

   306

};

   307

   308

static const Widget _news_type0_widgets[] = {

   309

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

   310

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

   311

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

   312

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

   313

{   WIDGETS_END},

   314

};

   315

   316

static WindowDesc _news_type0_desc = {

   317

	WDP_CENTER, 476, 280, 87,

   318

	WC_NEWS_WINDOW, 0,

   319

	WDF_DEF_WIDGET,

   320

	_news_type0_widgets,

   321

	NewsWindowProc

   322

};

   323

   324

static const SoundFx _news_sounds[] = {

   325

	SND_1D_APPLAUSE,

   326

	SND_1D_APPLAUSE,

   327

	0,

   328

	0,

   329

	0,

   330

	0,

   331

	SND_1E_OOOOH,

   332

	0,

   333

	0,

   334

	0

   335

};

   336

   337

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

   338

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

   339

 * @param item the item whose value is requested

   340

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

   341

 */

   342

static inline byte GetNewsDisplayValue(byte item)

   343

{

   344

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

   345

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

   346

}

   347

   348

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

   349

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

   350

 * @param item the item whose value is being set

   351

 * @param val new value

   352

 */

   353

static inline void SetNewsDisplayValue(byte item, byte val)

   354

{

   355

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

   356

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

   357

}

   358

   359

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

   360

static void ShowNewspaper(NewsItem *ni)

   361

{

   362

	Window *w;

   363

	SoundFx sound;

   364

	int top;

   365

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

   366

	ni->duration = 555;

   367

   368

	sound = _news_sounds[ni->type];

   369

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

   370

   371

	top = _screen.height;

   372

	switch (ni->display_mode) {

   373

		case NM_NORMAL:

   374

		case NM_CALLBACK: {

   375

			_news_type13_desc.top = top;

   376

			w = AllocateWindowDesc(&_news_type13_desc);

   377

			if (ni->flags & NF_VIEWPORT)

   378

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

   379

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

   380

			break;

   381

		}

   382

   383

		case NM_THIN: {

   384

			_news_type2_desc.top = top;

   385

			w = AllocateWindowDesc(&_news_type2_desc);

   386

			if (ni->flags & NF_VIEWPORT)

   387

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

   388

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

   389

			break;

   390

		}

   391

   392

		default: {

   393

			_news_type0_desc.top = top;

   394

			w = AllocateWindowDesc(&_news_type0_desc);

   395

			if (ni->flags & NF_VIEWPORT)

   396

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

   397

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

   398

			break;

   399

		}

   400

	}

   401

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

   402

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   403

}

   404

   405

// show news item in the ticker

   406

static void ShowTicker(const NewsItem *ni)

   407

{

   408

	Window *w;

   409

   410

	if (_news_ticker_sound) SndPlayFx(SND_16_MORSE);

   411

   412

	_statusbar_news_item = *ni;

   413

	w = FindWindowById(WC_STATUS_BAR, 0);

   414

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

   415

}

   416

   417

   418

// Are we ready to show another news item?

   419

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

   420

static bool ReadyForNextItem(void)

   421

{

   422

	const Window *w;

   423

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

   424

	NewsItem *ni;

   425

   426

	if (item >= MAX_NEWS) return true;

   427

	ni = &_news_items[item];

   428

   429

	// Ticker message

   430

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

   431

	w = FindWindowById(WC_STATUS_BAR, 0);

   432

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

   433

   434

	// Newspaper message

   435

	// Wait until duration reaches 0

   436

	if (ni->duration != 0) {

   437

		ni->duration--;

   438

		return false;

   439

	}

   440

   441

	// neither newsticker nor newspaper are running

   442

	return true;

   443

}

   444

   445

static void MoveToNexItem(void)

   446

{

   447

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   448

	_forced_news = INVALID_NEWS;

   449

   450

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

   451

	if (_current_news != _latest_news) {

   452

		NewsItem *ni;

   453

   454

		_current_news = increaseIndex(_current_news);

   455

		ni = &_news_items[_current_news];

   456

   457

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

   458

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

   459

   460

		switch (GetNewsDisplayValue(ni->type)) {

   461

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

   462

			Window *w = FindWindowById(WC_STATUS_BAR, 0);

   463

   464

			if (w != NULL) {

   465

				WP(w, def_d).data_2 = 91;

   466

				SetWindowDirty(w);

   467

			}

   468

			break;

   469

		}

   470

   471

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

   472

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

   473

				ShowTicker(ni);

   474

				break;

   475

			}

   476

			/* Fallthrough */

   477

   478

		case 2: /* Full - show newspaper*/

   479

			ShowNewspaper(ni);

   480

			break;

   481

		}

   482

	}

   483

}

   484

   485

void NewsLoop(void)

   486

{

   487

	// no news item yet

   488

	if (_total_news == 0) return;

   489

   490

	if (ReadyForNextItem()) MoveToNexItem();

   491

}