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

    11

/* News system

    12

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

    13

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

    14

the array elements through pointers to the elements. Once the

    15

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

    16

by the newest (_latest news).

    17

    18

oldest                   current   lastest

    19

 |                          |         |

    20

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

    21

              |

    22

           forced

    23

*/

    24

    25

# define MAX_NEWS 30

    26

    27

static NewsItem _news_items[MAX_NEWS];

    28

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

    29

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

    30

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

    31

static byte _forced_news = 255;  // points to a forced-to-be-shown item (255 for none)

    32

    33

static byte _total_news = 0; // total news count

    34

    35

void DrawNewsNewTrainAvail(Window *w);

    36

void DrawNewsNewRoadVehAvail(Window *w);

    37

void DrawNewsNewShipAvail(Window *w);

    38

void DrawNewsNewAircraftAvail(Window *w);

    39

void DrawNewsBankrupcy(Window *w);

    40

    41

StringID GetNewsStringNewTrainAvail(NewsItem *ni);

    42

StringID GetNewsStringNewRoadVehAvail(NewsItem *ni);

    43

StringID GetNewsStringNewShipAvail(NewsItem *ni);

    44

StringID GetNewsStringNewAircraftAvail(NewsItem *ni);

    45

StringID GetNewsStringBankrupcy(NewsItem *ni);

    46

    47

static DrawNewsCallbackProc * const _draw_news_callback[] = {

    48

	DrawNewsNewTrainAvail, /* DNC_TRAINAVAIL */

    49

	DrawNewsNewRoadVehAvail, /* DNC_ROADAVAIL */

    50

	DrawNewsNewShipAvail, /* DNC_SHIPAVAIL */

    51

	DrawNewsNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    52

	DrawNewsBankrupcy, /* DNC_BANKRUPCY */

    53

};

    54

    55

GetNewsStringCallbackProc * const _get_news_string_callback[] = {

    56

	GetNewsStringNewTrainAvail, /* DNC_TRAINAVAIL */

    57

	GetNewsStringNewRoadVehAvail, /* DNC_ROADAVAIL */

    58

	GetNewsStringNewShipAvail, /* DNC_SHIPAVAIL */

    59

	GetNewsStringNewAircraftAvail, /* DNC_AIRCRAFTAVAIL */

    60

	GetNewsStringBankrupcy, /* DNC_BANKRUPCY */

    61

};

    62

    63

void InitNewsItemStructs()

    64

{

    65

	memset(_news_items, 0, sizeof(NewsItem)*MAX_NEWS);

    66

	_current_news = 255;

    67

	_oldest_news = 0;

    68

	_latest_news = 255;

    69

	_forced_news = 255;

    70

	_total_news = 0;

    71

}

    72

    73

void DrawNewsBorder(Window *w)

    74

{

    75

	int left = 0;

    76

	int right = w->width - 1;

    77

	int top = 0;

    78

	int bottom = w->height - 1;

    79

    80

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

    81

    82

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

    83

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

    84

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

    85

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

    86

    87

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

    88

}

    89

    90

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

    91

{

    92

	switch(e->event) {

    93

	case WE_PAINT: {

    94

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

    95

		ViewPort *vp;

    96

    97

		if (ni->display_mode == NM_NORMAL || ni->display_mode == NM_THIN) {

    98

			DrawNewsBorder(w);

    99

   100

			DrawString(2, 1, STR_00C6, 0);

   101

   102

			SET_DPARAM16(0, ni->date);

   103

			DrawStringRightAligned(428, 1, STR_01FF, 0);

   104

   105

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

   106

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

   107

				DrawStringMultiCenter(215, ni->display_mode == NM_NORMAL ? 76 : 56, ni->string_id, 426);

   108

			} else {

   109

				byte bk = _display_opt;

   110

				_display_opt |= DO_TRANS_BUILDINGS;

   111

				DrawWindowViewport(w);

   112

				_display_opt = bk;

   113

   114

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

   115

				vp = w->viewport;

   116

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

   117

					ni->flags & NF_INCOLOR ? 0x4322:0x4323

   118

				);

   119

   120

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

   121

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

   122

			}

   123

		} else if (ni->display_mode == NM_CALLBACK) {

   124

			_draw_news_callback[ni->callback](w);

   125

		} else {

   126

			DrawWindowWidgets(w);

   127

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

   128

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

   129

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

   130

			} else {

   131

				DrawWindowViewport(w);

   132

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

   133

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

   134

			}

   135

		}

   136

	} break;

   137

   138

	case WE_CLICK: {

   139

		switch(e->click.widget) {

   140

		case 1: {

   141

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

   142

			DeleteWindow(w);

   143

			ni->duration = 0;

   144

			if(_forced_news!=255) _forced_news = 255;

   145

		} break;

   146

		case 0: {

   147

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

   148

			if (ni->flags & NF_VEHICLE) {

   149

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

   150

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

   151

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

   152

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

   153

					ScrollMainWindowToTile(ni->data_b);

   154

			}

   155

		} break;

   156

		}

   157

	} break;

   158

   159

	case WE_KEYPRESS:

   160

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

   161

			// Don't continue.

   162

			e->keypress.cont = false;

   163

			DeleteWindow(w);

   164

		}

   165

		break;

   166

   167

	case WE_TICK: {

   168

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

   169

		if (y == w->top)

   170

			return;

   171

   172

		if (w->viewport != NULL)

   173

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

   174

   175

		w->top = y;

   176

   177

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

   178

	} break;

   179

	}

   180

}

   181

   182

// returns the correct index in the array

   183

// (to deal with overflows)

   184

byte increaseIndex(byte i)

   185

{

   186

	if(i==255)

   187

		return 0;

   188

	i++;

   189

	if(i >= MAX_NEWS)

   190

		i = i % MAX_NEWS;

   191

	return i;

   192

}

   193

   194

   195

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

   196

{

   197

	NewsItem *ni;

   198

	Window *w;

   199

   200

	if (_game_mode == GM_MENU)

   201

		return;

   202

   203

	_forced_news = 255;

   204

	if(_total_news < MAX_NEWS) _total_news++;

   205

   206

	// make sure our pointer isn't overflowing

   207

	_latest_news = increaseIndex(_latest_news);

   208

   209

	// overwrite oldest news entry

   210

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

   211

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

   212

   213

	// add news to _latest_news

   214

	ni = &_news_items[_latest_news];

   215

   216

	ni->string_id = string;

   217

	ni->display_mode = (byte)flags;

   218

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

   219

   220

	// show this news message in color?

   221

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

   222

		ni->flags |= NF_INCOLOR;

   223

   224

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

   225

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

   226

	ni->data_a = data_a;

   227

	ni->data_b = data_b;

   228

	ni->date = _date;

   229

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

   230

   231

	w = FindWindowById(WC_MESSAGE_HISTORY, 0);

   232

	if(w==NULL) return;

   233

	SetWindowDirty(w);

   234

	w->vscroll.count = _total_news;

   235

}

   236

   237

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

   238

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

   239

   240

static const Widget _news_type13_widgets[] = {

   241

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

   242

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

   243

{      WWT_LAST},

   244

};

   245

   246

static WindowDesc _news_type13_desc = {

   247

	WDP_CENTER, 476, 430, 170,

   248

	WC_NEWS_WINDOW,0,

   249

	WDF_DEF_WIDGET,

   250

	_news_type13_widgets,

   251

	NewsWindowProc

   252

};

   253

   254

static const Widget _news_type2_widgets[] = {

   255

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

   256

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

   257

{      WWT_LAST},

   258

};

   259

   260

static WindowDesc _news_type2_desc = {

   261

	WDP_CENTER, 476, 430, 130,

   262

	WC_NEWS_WINDOW,0,

   263

	WDF_DEF_WIDGET,

   264

	_news_type2_widgets,

   265

	NewsWindowProc

   266

};

   267

   268

static const Widget _news_type0_widgets[] = {

   269

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

   270

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

   271

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

   272

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

   273

{      WWT_LAST},

   274

};

   275

   276

static WindowDesc _news_type0_desc = {

   277

	WDP_CENTER, 476, 280, 87,

   278

	WC_NEWS_WINDOW,0,

   279

	WDF_DEF_WIDGET,

   280

	_news_type0_widgets,

   281

	NewsWindowProc

   282

};

   283

   284

static byte _news_sounds[] = { 27, 27, 0, 0, 0, 0, 28, 0, 0, 0 };

   285

   286

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

   287

static void ShowNewspaper(NewsItem *ni)

   288

{

   289

	Window *w;

   290

	int sound;

   291

	int top;

   292

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

   293

	ni->duration = 555;

   294

   295

	sound = _news_sounds[ni->type];

   296

	if (sound != 0)

   297

		SndPlayFx(sound);

   298

   299

	top = _screen.height - 4;

   300

	if (ni->display_mode == NM_NORMAL || ni->display_mode == NM_CALLBACK) {

   301

		_news_type13_desc.top = top;

   302

		w = AllocateWindowDesc(&_news_type13_desc);

   303

		if (ni->flags & NF_VIEWPORT) {

   304

			AssignWindowViewport(w, 2, 58, 0x1AA, 0x6E, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   305

		}

   306

	} else if (ni->display_mode == NM_THIN) {

   307

		_news_type2_desc.top = top;

   308

		w = AllocateWindowDesc(&_news_type2_desc);

   309

		if (ni->flags & NF_VIEWPORT) {

   310

			AssignWindowViewport(w, 2, 58, 0x1AA, 0x46, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   311

		}

   312

	} else {

   313

		_news_type0_desc.top = top;

   314

		w = AllocateWindowDesc(&_news_type0_desc);

   315

		if (ni->flags & NF_VIEWPORT) {

   316

			AssignWindowViewport(w, 3, 17, 0x112, 0x2F, ni->data_a | ((ni->flags&NF_VEHICLE) ? 0x80000000 : 0), 0);

   317

		}

   318

	}

   319

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

   320

	w->flags4 |= WF_DISABLE_VP_SCROLL;

   321

}

   322

   323

// show news item in the ticker

   324

static void ShowTicker(NewsItem *ni)

   325

{

   326

	Window *w;

   327

   328

	SndPlayFx(20);

   329

	_statusbar_news_item = *ni;

   330

	w = FindWindowById(WC_STATUS_BAR, 0);

   331

	if (w != 0)

   332

		WP(w,def_d).data_1 = 360;

   333

}

   334

   335

   336

// Are we ready to show another news item?

   337

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

   338

static bool ReadyForNextItem()

   339

{

   340

	Window *w;

   341

	byte item = (_forced_news==255)?_current_news:_forced_news;

   342

	NewsItem *ni;

   343

   345

	ni = &_news_items[item];

   346

   347

	// Ticker message

   348

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

   349

	w = FindWindowById(WC_STATUS_BAR, 0);

   350

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

   351

	{

   352

		return false;

   353

	}

   354

   355

	// Newspaper message

   356

	// Wait until duration reaches 0

   357

	if (ni->duration != 0) {

   358

		ni->duration--;

   359

		return false;

   360

	}

   361

   362

	// neither newsticker nor newspaper are running

   363

	return true;

   364

}

   365

   366

static void MoveToNexItem()

   367

{

   368

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   369

   370

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

   371

	if(_current_news != _latest_news)

   372

	{

   373

		NewsItem *ni;

   374

   375

		_current_news = increaseIndex(_current_news);

   376

		ni = &_news_items[_current_news];

   377

   378

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

   379

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

   380

			return;

   381

   382

		// show newspaper or send to ticker?

   383

		if(!HASBIT(_news_display_opt, ni->type) && !(ni->flags&NF_FORCE_BIG))

   384

			ShowTicker(ni);

   385

		else

   386

			ShowNewspaper(ni);

   387

	}

   388

}

   389

   390

void NewsLoop()

   391

{

   392

	// no news item yet

   393

	if(_total_news==0) return;

   394

   395

	if( ReadyForNextItem() )

   396

		MoveToNexItem();

   397

}

   398

   399

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

   400

void ShowNewsMessage(byte i)

   401

{

   402

	if(_total_news==0) return;

   403

   404

	// Delete the news window

   405

	DeleteWindowById(WC_NEWS_WINDOW, 0);

   406

   407

	// setup forced news item

   408

	_forced_news = i;

   409

   410

	if(_forced_news!=255)

   411

	{

   412

		NewsItem *ni = &_news_items[_forced_news];

   413

		ni->duration = 555;

   414

		ni->flags |= NF_NOEXPIRE | NF_FORCE_BIG;

   415

		DeleteWindowById(WC_NEWS_WINDOW, 0);

   416

		ShowNewspaper(ni);

   417

	}

   418

}

   419

   420

void ShowLastNewsMessage()

   421

{

   422

	if(_forced_news==255)

   423

		ShowNewsMessage(_current_news);

   424

	else if(_forced_news!=0)

   425

		ShowNewsMessage(_forced_news-1);

   426

	else {

   427

		if(_total_news != MAX_NEWS) 

   428

			ShowNewsMessage(_latest_news);

   429

		else

   430

			ShowNewsMessage(MAX_NEWS-1);

   431

	}

   432

}

   433

   434

   435

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

   436

recent news. Returns 255 if end of queue reached. */

   437

static byte getNews(byte i)

   438

{

   439

	if(i>=_total_news) 

   440

		return 255;

   441

   442

	if(_latest_news < i)

   443

		i = _latest_news + MAX_NEWS - i;

   444

	else

   445

		i = _latest_news - i;

   446

   447

	i = i % MAX_NEWS;

   448

	return i;

   449

}

   450

   451

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

   452

{

   453

	StringID str;

   454

	byte *s, *d;

   455

   456

	if (ni->display_mode == 3) {

   457

		str = _get_news_string_callback[ni->callback](ni);

   458

	} else {

   459

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

   460

		str = ni->string_id;	

   461

	}

   462

   463

	GetString(str_buffr, str);

   464

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   465

   466

	s = str_buffr;

   467

	d = buffer;

   468

   469

	for(;;s++) {

   470

		// cut strings that are too long

   471

		if(s >= str_buffr + 55) {

   472

			d[0] = d[1] = d[2] = '.';

   473

			d+=3;

   474

			*d = 0;

   475

			break;

   476

		}

   477

   478

		if (*s == 0) {

   479

			*d = 0;

   480

			break;

   481

		} else if (*s == 13) {

   482

			d[0] = d[1] = d[2] = d[3] = ' ';

   483

			d+=4;

   484

		} else if (*s >= ' ' && (*s < 0x88 || *s >= 0x99)) {

   485

			*d++ = *s;

   486

		}

   487

	}

   488

}

   489

   490

   491

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

   492

{

   493

	switch(e->event) {

   494

	case WE_PAINT: {

   495

		byte buffer[256];

   496

		int y=19;

   497

		byte p, show;

   498

		NewsItem *ni;

   499

   500

		DrawWindowWidgets(w);

   501

   502

		if(_total_news==0) break;

   503

		show = min(_total_news, 10);

   504

   505

		for(p=w->vscroll.pos; p<w->vscroll.pos+show; p++)

   506

		{