1

/* $Id$ */

     2

     3

     4

#include "stdafx.h"

     5

#include "openttd.h"

     6

#include "gui.h"

     7

#include "window_gui.h"

     8

#include "viewport_func.h"

    10

#include "settings_type.h"

    11

#include "transparency.h"

    12

#include "strings_func.h"

    13

#include "window_func.h"

    14

#include "date_func.h"

    15

#include "vehicle_base.h"

    16

#include "sound_func.h"

    17

#include "string_func.h"

    18

#include "widgets/dropdown_func.h"

    19

    20

#include "table/sprites.h"

    21

#include "table/strings.h"

    22

    23

/** @file news_gui.cpp

    24

 *

    25

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

    26

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

    27

 * the array elements through pointers to the elements. Once the

    28

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

    29

 * by the newest (\a _latest_news).

    30

 *

    31

 * \verbatim

    32

 * oldest                   current   lastest

    33

 *  |                          |         |

    34

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

    35

 *               |

    36

 *            forced

    37

 * \endverbatim

    38

 *

    39

 * Of course by using an array we can have situations like

    40

 *

    41

 * \verbatim

    42

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

    43

 * This is where we have wrapped around the array and have

    44

 * (MAX_NEWS - O) + L news items

    45

 * \endverbatim

    46

 */

    47

    48

/** Number of news items in the FIFO queue */

    49

#define MAX_NEWS 30

    50

#define NB_WIDG_PER_SETTING 4

    51

    52

typedef byte NewsID;

    53

#define INVALID_NEWS 255

    54

    55

NewsItem _statusbar_news_item;

    56

uint32 _news_display_opt;

    57

bool _news_ticker_sound;

    58

static NewsItem _news_items[MAX_NEWS];      ///< The news FIFO queue

    59

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

    60

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

    61

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

    62

    73

/** Forced news item.

    74

 * Users can force an item by accessing the history or "last message".

    75

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

    76

 * _forced_news. Otherwise, \a _forced_news variable is INVALID_NEWS. */

    77

static NewsID _forced_news = INVALID_NEWS;

    78

    79

static byte _total_news = 0; ///< Number of news items in FIFO queue @see _news_items

    80

    83

static void MoveToNextItem();

    84

    85

StringID GetNewsStringNewVehicleAvail(const NewsItem *ni);

    86

StringID GetNewsStringBankrupcy(const NewsItem *ni);

    87

    88

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    89

	DrawNewsNewVehicleAvail,  ///< DNC_VEHICLEAVAIL

    90

	DrawNewsBankrupcy,        ///< DNC_BANKRUPCY

    91

};

    92

    93

extern GetNewsStringCallbackProc * const _get_news_string_callback[];

    94

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    95

	GetNewsStringNewVehicleAvail,  ///< DNC_VEHICLEAVAIL

    96

	GetNewsStringBankrupcy,        ///< DNC_BANKRUPCY

    97

};

    98

    99

/** Initialize the news-items data structures */

   100

void InitNewsItemStructs()

   101

{

   102

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

   103

	_current_news = INVALID_NEWS;

   104

	_oldest_news = 0;

   105

	_latest_news = INVALID_NEWS;

   106

	_forced_news = INVALID_NEWS;

   107

	_total_news = 0;

   108

}

   109

   110

void DrawNewsBorder(const Window *w)

   111

{

   112

	int left = 0;

   113

	int right = w->width - 1;

   114

	int top = 0;

   115

	int bottom = w->height - 1;

   116

   117

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

   118

   119

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

   120

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

   121

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

   122

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

   123

   124

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

   125

}

   126

   127

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

   128

{

   129

	switch (e->event) {

   134

   138

   143

   171

				}

   172

   190

			}

   191

		} break;

   192

   213

   221

   228

   233

   242

	}

   243

}

   244

   245

/**

   246

 * Return the correct index in the pseudo-fifo

   247

 * queue and deals with overflows when increasing the index

   248

 */

   249

static inline NewsID increaseIndex(NewsID i)

   250

{

   251

	assert(i != INVALID_NEWS);

   252

	return (i + 1) % MAX_NEWS;

   253

}

   254

   255

/**

   256

 * Return the correct index in the pseudo-fifo

   257

 * queue and deals with overflows when decreasing the index

   258

 */

   259

static inline NewsID decreaseIndex(NewsID i)

   260

{

   261

	assert(i != INVALID_NEWS);

   262

	return (i + MAX_NEWS - 1) % MAX_NEWS;

   263

}

   264

   265

/**

   266

 * Add a new newsitem to be shown.

   272

 * @param data_a news-specific value based on news type

   273

 * @param data_b news-specific value based on news type

   274

 *

   276

 * \a string has a special meaning.

   277

 *  - For DNC_TRAINAVAIL, DNC_ROADAVAIL, DNC_SHIPAVAIL, DNC_AIRCRAFTAVAIL messages: StringID is

   278

 *    the index of the engine that is shown

   279

 *

   280

 *  - For DNC_BANKRUPCY: bytes 0-3 of StringID contains the player that is in trouble,

   281

 *    and 4-7 contains what kind of bankrupcy message is shown.

   282

 *    @see NewsBankrupcy

   283

 *

   284

 * @see NewsMode

   286

 * @see NewsType

   287

 * @see NewsCallback

   288

 */

   290

{

   291

	NewsID l_news;

   292

   293

	if (_game_mode == GM_MENU) return;

   294

   295

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

   296

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

   297

		MoveToNextItem();

   298

   299

	if (_total_news < MAX_NEWS) _total_news++;

   300

   301

	/* Increase _latest_news. If we have no news yet, use _oldest news as an

   302

	 * index. We cannot use 0 as _oldest_news can jump around due to

   303

	 * DeleteVehicleNews */

   304

	l_news = _latest_news;

   305

	_latest_news = (_latest_news == INVALID_NEWS) ? _oldest_news : increaseIndex(_latest_news);

   306

   307

	/* If the fifo-buffer is full, overwrite the oldest entry */

   308

	if (l_news != INVALID_NEWS && _latest_news == _oldest_news) {

   309

		assert(_total_news == MAX_NEWS);

   310

		_oldest_news = increaseIndex(_oldest_news);

   311

	}

   312

   313

	/*DEBUG(misc, 0, "+cur %3d, old %2d, lat %3d, for %3d, tot %2d",

   314

	  _current_news, _oldest_news, _latest_news, _forced_news, _total_news);*/

   315

   316

	/* Add news to _latest_news */

   319

   323

   338

}

   339

   340

   341

/**

   342

 * Maximum age of news items.

   344

 * @see NewsType

   345

 */

   346

static const byte _news_items_age[NT_END] = {

   347

	60,  ///< NT_ARRIVAL_PLAYER

   348

	60,  ///< NT_ARRIVAL_OTHER

   349

	90,  ///< NT_ACCIDENT

   350

	60,  ///< NT_COMPANY_INFO

   351

	90,  ///< NT_OPENCLOSE

   352

	30,  ///< NT_ECONOMY

   353

	30,  ///< NT_INDUSTRY_PLAYER

   354

	30,  ///< NT_INDUSTRY_OTHER

   355

	30,  ///< NT_INDUSTRY_NOBODY

   356

	150, ///< NT_ADVICE

   357

	30,  ///< NT_NEW_VEHICLES

   358

	90,  ///< NT_ACCEPTANCE

   359

	180, ///< NT_SUBSIDIES

   360

	60   ///< NT_GENERAL

   361

};

   362

   363

   364

static const Widget _news_type13_widgets[] = {

   365

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

   366

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

   367

{   WIDGETS_END},

   368

};

   369

   370

static WindowDesc _news_type13_desc = {

   371

	WDP_CENTER, 476, 430, 170, 430, 170,

   372

	WC_NEWS_WINDOW, WC_NONE,

   373

	WDF_DEF_WIDGET,

   374

	_news_type13_widgets,

   375

	NewsWindowProc

   376

};

   377

   378

static const Widget _news_type2_widgets[] = {

   379

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

   380

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

   381

{   WIDGETS_END},

   382

};

   383

   384

static WindowDesc _news_type2_desc = {

   385

	WDP_CENTER, 476, 430, 130, 430, 130,

   386

	WC_NEWS_WINDOW, WC_NONE,

   387

	WDF_DEF_WIDGET,

   388

	_news_type2_widgets,

   389

	NewsWindowProc

   390

};

   391

   392

static const Widget _news_type0_widgets[] = {

   393

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

   394

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

   395

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

   396

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

   397

{   WIDGETS_END},

   398

};

   399

   400

static WindowDesc _news_type0_desc = {

   401

	WDP_CENTER, 476, 280, 87, 280, 87,

   402

	WC_NEWS_WINDOW, WC_NONE,

   403

	WDF_DEF_WIDGET,

   404

	_news_type0_widgets,

   405

	NewsWindowProc

   406

};

   407

   408

static const SoundFx _news_sounds[NT_END] = {

   409

	SND_1D_APPLAUSE,	///< NT_ARRIVAL_PLAYER

   410

	SND_1D_APPLAUSE,	///< NT_ARRIVAL_OTHER

   411

	SND_BEGIN,		///< NT_ACCIDENT

   412

	SND_BEGIN,		///< NT_COMPANY_INFO

   413

	SND_BEGIN,		///< NT_OPENCLOSE

   414

	SND_BEGIN,		///< NT_ECONOMY

   415

	SND_BEGIN,		///< NT_INDUSTRY_PLAYER

   416

	SND_BEGIN,		///< NT_INDUSTRY_OTHER

   417

	SND_BEGIN,		///< NT_INDUSTRY_NOBODY

   418

	SND_BEGIN,		///< NT_ADVICE

   419

	SND_1E_OOOOH,		///< NT_NEW_VEHICLES

   420

	SND_BEGIN,		///< NT_ACCEPTANCE

   421

	SND_BEGIN,		///< NT_SUBSIDIES

   422

	SND_BEGIN,		///< NT_GENERAL

   423

};

   424

   425

const char *_news_display_name[NT_END] = {

   426

	"arrival_player",

   427

	"arrival_other",

   428

	"accident",

   429

	"company_info",

   430

	"openclose",

   431

	"economy",

   432

	"production_player",

   433

	"production_other",

   434

	"production_nobody",

   435

	"advice",

   436

	"new_vehicles",

   437

	"acceptance",

   438

	"subsidies",

   439

	"general",

   440

};

   441

   442

/**

   443

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

   444

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

   445

 * @param item the item whose value is requested

   446

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

   447

 */

   448

static inline byte GetNewsDisplayValue(byte item)

   449

{

   450

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

   451

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

   452

}

   453

   454

/**

   455

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

   456

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

   457

 * @param item the item whose value is being set

   458

 * @param val new value

   459

 */

   460

static inline void SetNewsDisplayValue(byte item, byte val)

   461

{

   462

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

   463

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

   464

}

   465

   466

/** Open up an own newspaper window for the news item */

   467

static void ShowNewspaper(NewsItem *ni)

   468

{

   469

	Window *w;

   470

	SoundFx sound;

   471

	int top;

   472

	ni->flags &= ~NF_FORCE_BIG;

   473

	ni->duration = 555;

   474

   475

	sound = _news_sounds[ni->type];

   476

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

   477

   478

	top = _screen.height;

   479

	switch (ni->display_mode) {

   480

		case NM_NORMAL:

   481

		case NM_CALLBACK: {

   482

			_news_type13_desc.top = top;

   483

			w = AllocateWindowDesc(&_news_type13_desc);

   484

			if (ni->flags & NF_VIEWPORT)

   485

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

   486

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

   487

			break;

   488

		}