1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "viewport.h"

     7

#include "gfx.h"

     8

#include "news.h"

     9

#include "vehicle.h"

    10

#include "sound.h"

    11

    12

/* News system

    13

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

    14

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

    15

the array elements through pointers to the elements. Once the

    16

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

    17

by the newest (_latest news).

    18

    19

oldest                   current   lastest

    20

 |                          |         |

    21

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

    22

              |

    23

           forced

    24

*/

    25

    29

    30

static NewsItem _news_items[MAX_NEWS];

    32

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

    38

    39

static byte _total_news = 0; // total news count

    40

    41

void DrawNewsNewTrainAvail(Window *w);

    42

void DrawNewsNewRoadVehAvail(Window *w);

    43

void DrawNewsNewShipAvail(Window *w);

    44

void DrawNewsNewAircraftAvail(Window *w);

    45

void DrawNewsBankrupcy(Window *w);

    47

    48

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    49

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    50

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    51

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    52

StringID GetNewsStringBankrupcy(NewsItem *ni);

    53

    54

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    58

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    60

};

    61

    62

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    66

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    68

};

    69

    71

{

    74

	_oldest_news = 0;

    77

	_total_news = 0;

    78

}

    79

    81

{

    82

	int left = 0;

    83

	int right = w->width - 1;

    84

	int top = 0;

    85

	int bottom = w->height - 1;

    86

    87

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

    88

    89

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

    90

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

    91

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

    92

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

    93

    94

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

    95

}

    96

    97

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

    98

{

   100

	case WE_PAINT: {

   102

		ViewPort *vp;

   103

   108

   110

   135

			}

   153

			}

   154

		}

   155

	} break;

   156

   157

	case WE_CLICK: {

   159

		case 1: {

   161

			DeleteWindow(w);

   162

			ni->duration = 0;

   164

		} break;

   165

		case 0: {

   167

			if (ni->flags & NF_VEHICLE) {

   168

				Vehicle *v = &_vehicles[ni->data_a];

   169

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

   170

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

   171

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

   172

					ScrollMainWindowToTile(ni->data_b);

   173

			}

   174

		} break;

   175

		}

   176

	} break;

   177

   178

	case WE_KEYPRESS:

   179

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

   180

			// Don't continue.

   181

			e->keypress.cont = false;

   182

			DeleteWindow(w);

   183

		}

   184

		break;

   185

   186

	case WE_TICK: {

   187

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

   188

		if (y == w->top)

   189

			return;

   190

   191

		if (w->viewport != NULL)

   192

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

   193

   194

		w->top = y;

   195

   196

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

   197

	} break;

   198

	}

   199

}

   200

   201

// returns the correct index in the array

   202

// (to deal with overflows)

   203

byte increaseIndex(byte i)

   204

{

   206

		return 0;

   207

	i++;

   209

		i = i % MAX_NEWS;

   210

	return i;

   211

}

   212

   213

   214

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

   215

{

   216

	NewsItem *ni;

   217

	Window *w;

   218

   219

	if (_game_mode == GM_MENU)

   220

		return;

   221

   222

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

   224

		MoveToNexItem();

   225

   228

   229

	// make sure our pointer isn't overflowing

   230

	_latest_news = increaseIndex(_latest_news);

   231

   232

	// overwrite oldest news entry

   234

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

   235

   236

	// add news to _latest_news

   237

	ni = &_news_items[_latest_news];

   238

   239

	ni->string_id = string;

   240

	ni->display_mode = (byte)flags;

   241

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

   242

   243

	// show this news message in color?

   244

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

   245

		ni->flags |= NF_INCOLOR;

   246

   247

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

   248

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

   249

	ni->data_a = data_a;

   250

	ni->data_b = data_b;

   251

	ni->date = _date;

   252

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

   253

   254

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   256

	SetWindowDirty(w);

   257

	w->vscroll.count = _total_news;

   258

}

   259

   260

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

   261

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

   262

   263

static const Widget _news_type13_widgets[] = {

   266

{   WIDGETS_END},

   267

};

   268

   269

static WindowDesc _news_type13_desc = {

   270

	WDP_CENTER, 476, 430, 170,

   272

	WDF_DEF_WIDGET,

   273

	_news_type13_widgets,

   274

	NewsWindowProc

   275

};

   276

   277

static const Widget _news_type2_widgets[] = {

   280

{   WIDGETS_END},

   281

};

   282

   283

static WindowDesc _news_type2_desc = {

   284

	WDP_CENTER, 476, 430, 130,

   286

	WDF_DEF_WIDGET,

   287

	_news_type2_widgets,

   288

	NewsWindowProc

   289

};

   290

   291

static const Widget _news_type0_widgets[] = {

   292

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

   293

{   WWT_CLOSEBOX,     5,     0,    10,     0,    13, STR_00C5,					STR_NULL},

   294

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

   295

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

   296

{   WIDGETS_END},

   297

};

   298

   299

static WindowDesc _news_type0_desc = {

   300

	WDP_CENTER, 476, 280, 87,

   302

	WDF_DEF_WIDGET,

   303

	_news_type0_widgets,

   304

	NewsWindowProc

   305

};

   306

   319

   320

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

   321

static void ShowNewspaper(NewsItem *ni)

   322

{

   323

	Window *w;

   324

	int sound;

   325

	int top;

   327

	ni->duration = 555;

   328

   329

	sound = _news_sounds[ni->type];

   330

	if (sound != 0)

   331

		SndPlayFx(sound);

   332

   333

	top = _screen.height - 4;

   343

		}

   352

		}

   361

		}

   362

	}

   364

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   365

}

   366

   367

// show news item in the ticker

   369

{

   370

	Window *w;

   371

   372

	SndPlayFx(20);

   373

	_statusbar_news_item = *ni;

   374

	w = FindWindowById(WC_STATUS_BAR, 0);

   377

}

   378

   379

   380

// Are we ready to show another news item?

   381

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

   383

{

   386

	NewsItem *ni;

   387

   389

	ni = &_news_items[item];

   390

   391

	// Ticker message

   392

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

   393

	w = FindWindowById(WC_STATUS_BAR, 0);

   395

		return false;

   396

   397

	// Newspaper message

   398

	// Wait until duration reaches 0

   399

	if (ni->duration != 0) {

   400

		ni->duration--;

   401

		return false;

   402

	}

   403

   404

	// neither newsticker nor newspaper are running

   405

	return true;

   406

}

   407

   409

{

   410

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   412

   413

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

   415

		NewsItem *ni;

   416

   417

		_current_news = increaseIndex(_current_news);

   418

		ni = &_news_items[_current_news];

   419

   420

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

   422

			return;

   423

   424

		// show newspaper or send to ticker?

   426

			ShowTicker(ni);

   427

		else

   428

			ShowNewspaper(ni);

   429

	}

   430

}

   431

   433

{

   434

	// no news item yet

   436

   438

		MoveToNexItem();

   439

}

   440

   441

/* Do a forced show of a specific message */

   442

void ShowNewsMessage(byte i)

   443

{

   445

   446

	// Delete the news window

   447

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   448

   449

	// setup forced news item

   450

	_forced_news = i;

   451

   453

		NewsItem *ni = &_news_items[_forced_news];

   454

		ni->duration = 555;

   455

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   456

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   457

		ShowNewspaper(ni);

   458

	}

   459

}

   460

   462

{

   464

		ShowNewsMessage(_current_news);

   467

	else {

   469

			ShowNewsMessage(_latest_news);

   470

		else

   472

	}

   473

}

   474

   475

   476

/* return news by number, with 0 being the most

   478

static byte getNews(byte i)

   479

{

   482

   484

		i = _latest_news + MAX_NEWS - i;

   485

	else

   486

		i = _latest_news - i;

   487

   489

	return i;

   490

}

   491

   492

static void GetNewsString(NewsItem *ni, byte *buffer)

   493

{

   494

	StringID str;