1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "town.h"

     6

#include "window.h"

     7

#include "gfx.h"

     8

#include "viewport.h"

     9

#include "gui.h"

    10

#include "command.h"

    11

#include "player.h"

    12

#include "network.h"

    13

    14

static const Widget _town_authority_widgets[] = {

    15

{    WWT_TEXTBTN,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5,				STR_018B_CLOSE_WINDOW},

    16

{    WWT_CAPTION,   RESIZE_NONE,    13,    11,   316,     0,    13, STR_2022_LOCAL_AUTHORITY, STR_018C_WINDOW_TITLE_DRAG_THIS},

    17

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   316,    14,   105, 0x0,							STR_NULL},

    18

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   306,   106,   157, 0x0,							STR_2043_LIST_OF_THINGS_TO_DO_AT},

    19

{  WWT_SCROLLBAR,   RESIZE_NONE,    13,   305,   316,   106,   157, 0x0,							STR_0190_SCROLL_BAR_SCROLLS_LIST},

    20

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   316,   158,   209, 0x0,							STR_NULL},

    21

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,     0,   316,   210,   221, STR_2042_DO_IT,	STR_2044_CARRY_OUT_THE_HIGHLIGHTED},

    22

{   WIDGETS_END},

    23

};

    24

    25

extern const byte _town_action_costs[8];

    26

extern void DrawPlayerIcon(int p, int x, int y);

    27

    28

static uint GetMaskOfTownActions(int *nump, Town *t)

    29

{

    30

	int32 avail, ref;

    31

	int i, num;

    32

	uint avail_buttons = 0x7F; // by default all buttons except bribe are enabled.

    33

	uint buttons;

    34

    35

	if (_local_player != OWNER_SPECTATOR) {

    36

		// bribe option enabled?

    37

		if (_patches.bribe) {

    38

			// if unwanted, disable everything.

    39

			if (t->unwanted[_local_player]) {

    40

				avail_buttons = 0;

    41

			} else if (t->ratings[_local_player] < 600)

    42

				avail_buttons |= (1 << 7); // only bribe if less than excellent

    43

		}

    44

    45

		// Things worth more than this are not shown

    46

		avail = DEREF_PLAYER(_local_player)->player_money + _price.station_value * 200;

    47

		ref = _price.build_industry >> 8;

    48

    49

		for(i=0,buttons=0,num=0; i != lengthof(_town_action_costs); i++,avail_buttons>>=1) {

    50

			if (avail_buttons&1 && avail >= _town_action_costs[i] * ref) {

    51

				SETBIT(buttons, i);

    52

				num++;

    53

			}

    54

		}

    55

    56

		// Disable build statue if already built

    57

		if(HASBIT(t->statues, _local_player))

    58

		{

    59

			CLRBIT(buttons, 4);

    60

			num--;

    61

		}

    62

    63

	} else {

    64

		// no actions available for spectator

    65

		buttons = 0;

    66

		num = 0;

    67

	}

    68

    69

	if (nump) *nump = num;

    70

	return buttons;

    71

}

    72

    73

static int GetNthSetBit(uint32 bits, int n)

    74

{

    75

	int i = 0;

    76

	if (n >= 0) {

    77

		do {

    78

			if (bits&1 && --n < 0) return i;

    79

			i++;

    80

		} while (bits>>=1);

    81

	}

    82

	return -1;

    83

}

    84

    85

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

    86

{

    87

	uint buttons;

    88

	int numact;

    89

	Town *t = GetTown(w->window_number);

    90

    91

	switch(e->event) {

    92

	case WE_PAINT:

    93

		buttons = GetMaskOfTownActions(&numact, t);

    94

		SetVScrollCount(w, numact + 1);

    95

    96

		if (WP(w,def_d).data_1 != -1 && !HASBIT(buttons, WP(w,def_d).data_1))

    97

			WP(w,def_d).data_1 = -1;

    98

    99

		w->disabled_state = (WP(w,def_d).data_1 == -1) ? (1 << 6) : 0;

   100

   101

		{

   102

			int y;

   103

			Player *p;

   104

			int r;

   105

			StringID str;

   106

   107

			SetDParam(0, w->window_number);

   108

			DrawWindowWidgets(w);

   109

   110

			DrawString(2, 15, STR_2023_TRANSPORT_COMPANY_RATINGS, 0);

   111

   112

			// Draw list of players

   113

			y = 25;

   114

			FOR_ALL_PLAYERS(p) {

   115

				if (p->is_active && (HASBIT(t->have_ratings, p->index) || t->exclusivity==p->index)) {

   116

					DrawPlayerIcon(p->index, 2, y);

   117

   118

					SetDParam(0, p->name_1);

   119

					SetDParam(1, p->name_2);

   120

					SetDParam(2, GetPlayerNameString(p->index, 3));

   121

   122

					r = t->ratings[p->index];

   123

					(str = STR_3035_APPALLING, r <= RATING_APPALLING) ||	// Apalling

   124

					(str++, r <= RATING_VERYPOOR) ||											// Very Poor

   125

					(str++, r <= RATING_POOR) ||												// Poor

   126

					(str++, r <= RATING_MEDIOCRE) ||											// Mediocore

   127

					(str++, r <= RATING_GOOD) ||											// Good

   128

					(str++, r <= RATING_VERYGOOD) ||											// Very Good

   129

					(str++, r <= RATING_EXCELLENT) ||											// Excellent

   130

					(str++, true);														// Outstanding

   131

   132

					/*	WARNING ugly hack!

   133

							GetPlayerNameString sets up (Player #) if the player is human in an extra DPARAM16

   134

							It seems that if player is non-human, nothing is set up, so param is 0. GetString doesn't like

   135

							that because there is another param after it.

   136

							So we'll just shift the rating one back if player is AI and all is fine

   137

						*/

   138

					SetDParam((IS_HUMAN_PLAYER(p->index) ? 4 : 3), str);

   139

					if (t->exclusivity == p->index) // red icon for player with exclusive rights

   140

						DrawSprite((SPR_BLOT) | 0x30b8000, 18, y);

   141

   142

					DrawString(28, y, STR_2024, 0);

   143

					y+=10;

   144

				}

   145

			}

   146

		}

   147

   148

		// Draw actions list

   149

		{

   150

			int y = 107, i;

   151

			int pos = w->vscroll.pos;

   152

   153

			if (--pos < 0) {

   154

				DrawString(2, y, STR_2045_ACTIONS_AVAILABLE, 0);

   155

				y+=10;

   156

			}

   157

			for(i=0; buttons; i++,buttons>>=1) {

   158

				if (pos <= -5)

   159

					break;

   160

   161

				if (buttons&1 && --pos < 0) {

   162

					DrawString(3, y, STR_2046_SMALL_ADVERTISING_CAMPAIGN + i, 6);

   163

					y += 10;

   164

				}

   165

			}

   166

		}

   167

   168

		{

   169

			int i;

   170

			if ((i=WP(w,def_d).data_1) != -1) {

   171

				SetDParam(1, (_price.build_industry >> 8) * _town_action_costs[i]);

   172

				SetDParam(0, STR_2046_SMALL_ADVERTISING_CAMPAIGN + i);

   173

				DrawStringMultiLine(2, 159, STR_204D_INITIATE_A_SMALL_LOCAL + i, 313);

   174

			}

   175

		}

   176

   177

		break;

   178

   179

	case WE_CLICK:

   180

		switch(e->click.widget) {

   181

		case 3: { /* listbox */

   182

			int y = (e->click.pt.y - 0x6B) / 10;

   183

			if (!IS_INT_INSIDE(y, 0, 5))

   184

				return;

   185

   186

			y = GetNthSetBit(GetMaskOfTownActions(NULL, t), y + w->vscroll.pos - 1);

   187

			if (y >= 0) {

   188

				WP(w,def_d).data_1 = y;

   189

				SetWindowDirty(w);

   190

			}

   191

			break;

   192

		}

   193

   194

		case 6: { /* carry out the action */

   195

			DoCommandP(t->xy, w->window_number, WP(w,def_d).data_1, NULL, CMD_DO_TOWN_ACTION | CMD_MSG(STR_2054_CAN_T_DO_THIS));

   196

			break;

   197

		}

   198

		}

   199

		break;

   200

   201

	case WE_4:

   202

		SetWindowDirty(w);

   203

		break;

   204

	}

   205

}

   206

   207

static const WindowDesc _town_authority_desc = {

   208

	-1, -1, 317, 222,

   209

	WC_TOWN_AUTHORITY,0,

   210

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   211

	_town_authority_widgets,

   212

	TownAuthorityWndProc

   213

};

   214

   215

static void ShowTownAuthorityWindow(uint town)

   216

{

   217

	Window *w;

   218

   219

	w = AllocateWindowDescFront(&_town_authority_desc, town);

   220

	if (w) {

   221

		w->vscroll.cap = 5;

   222

		WP(w,def_d).data_1 = -1;

   223

	}

   224

}

   225

   226

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

   227

{

   228

	Town *t = GetTown(w->window_number);

   229

   230

	switch(e->event) {

   231

	case WE_PAINT:

   232

		// disable renaming town in network games if you are not the server

   233

		if (_networking && !_network_server) SETBIT(w->disabled_state, 8);

   234

   235

		SetDParam(0, t->index);

   236

		DrawWindowWidgets(w);

   237

   238

		SetDParam(0, t->population);

   239

		SetDParam(1, t->num_houses);

   240

		DrawString(2,107,STR_2006_POPULATION,0);

   241

   242

		SetDParam(0, t->act_pass);

   243

		SetDParam(1, t->max_pass);

   244

		DrawString(2,117,STR_200D_PASSENGERS_LAST_MONTH_MAX,0);

   245

   246

		SetDParam(0, t->act_mail);

   247

		SetDParam(1, t->max_mail);

   248

		DrawString(2,127,STR_200E_MAIL_LAST_MONTH_MAX,0);

   249

   250

		DrawWindowViewport(w);

   251

		break;

   252

   253

	case WE_CLICK:

   254

		switch(e->click.widget) {

   255

		case 6: /* scroll to location */

   256

			ScrollMainWindowToTile(t->xy);

   257

			break;

   258

		case 7: /* town authority */

   259

			ShowTownAuthorityWindow(w->window_number);

   260

			break;

   261

		case 8: /* rename */

   262

			SetDParam(0, t->townnameparts);

   263

			ShowQueryString(t->townnametype, STR_2007_RENAME_TOWN, 31, 130, w->window_class, w->window_number);

   264

			break;

   265

		case 9: /* expand town */

   266

			ExpandTown(t);

   267

			break;

   268

		case 10: /* delete town */

   269

			DeleteTown(t);

   270

			break;

   271

		}

   272

		break;

   273

   274

	case WE_ON_EDIT_TEXT: {

   275

		byte *b = e->edittext.str;

   276

		if (*b == 0)

   277

			return;

   278

		memcpy(_decode_parameters, b, 32);

   279

		DoCommandP(0, w->window_number, 0, NULL, CMD_RENAME_TOWN | CMD_MSG(STR_2008_CAN_T_RENAME_TOWN));

   280

	} break;

   281

	}

   282

}

   283

   284

   285

static const Widget _town_view_widgets[] = {

   286

{    WWT_TEXTBTN,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   287

{    WWT_CAPTION,   RESIZE_NONE,    13,    11,   247,     0,    13, STR_2005, STR_018C_WINDOW_TITLE_DRAG_THIS},

   288

{  WWT_STICKYBOX,   RESIZE_NONE,    13,   248,   259,     0,    13, 0x0,      STR_STICKY_BUTTON},

   289

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   259,    14,   105, 0x0,      STR_NULL},

   290

{          WWT_6,   RESIZE_NONE,    13,     2,   257,    16,   103, 0x0,      STR_NULL},

   291

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   259,   106,   137, 0x0,      STR_NULL},

   292

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,     0,    85,   138,   149, STR_00E4_LOCATION,				STR_200B_CENTER_THE_MAIN_VIEW_ON},

   293

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,    86,   171,   138,   149, STR_2020_LOCAL_AUTHORITY,STR_2021_SHOW_INFORMATION_ON_LOCAL},

   294

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,   172,   259,   138,   149, STR_0130_RENAME,					STR_200C_CHANGE_TOWN_NAME},

   295

{   WIDGETS_END},

   296

};

   297

   298

static const WindowDesc _town_view_desc = {

   299

	-1, -1, 260, 150,

   300

	WC_TOWN_VIEW,0,

   301

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   302

	_town_view_widgets,

   303

	TownViewWndProc

   304

};

   305

   306

static const Widget _town_view_scen_widgets[] = {

   307

{    WWT_TEXTBTN,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5,					STR_018B_CLOSE_WINDOW},

   308

{    WWT_CAPTION,   RESIZE_NONE,    13,    11,   172,     0,    13, STR_2005,					STR_018C_WINDOW_TITLE_DRAG_THIS},

   309

{  WWT_STICKYBOX,   RESIZE_NONE,    13,   248,   259,     0,    13, 0x0,               STR_STICKY_BUTTON},

   310

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   259,    14,   105, 0x0,								STR_NULL},

   311

{          WWT_6,   RESIZE_NONE,    13,     2,   257,    16,   103, 0x0,								STR_NULL},

   312

{     WWT_IMGBTN,   RESIZE_NONE,    13,     0,   259,   106,   137, 0x0,								STR_NULL},

   313

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,     0,    85,   138,   149, STR_00E4_LOCATION,	STR_200B_CENTER_THE_MAIN_VIEW_ON},

   314

{      WWT_EMPTY,   RESIZE_NONE,     0,     0,     0,     0,     0, 0x0,								STR_NULL},

   315

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,   173,   247,     0,    13, STR_0130_RENAME,		STR_200C_CHANGE_TOWN_NAME},

   316

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,    86,   171,   138,   149, STR_023C_EXPAND,		STR_023B_INCREASE_SIZE_OF_TOWN},

   317

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,   172,   259,   138,   149, STR_0290_DELETE,		STR_0291_DELETE_THIS_TOWN_COMPLETELY},

   318

{   WIDGETS_END},

   319

};

   320

   321

static const WindowDesc _town_view_scen_desc = {

   322

	-1, -1, 260, 150,

   323

	WC_TOWN_VIEW,0,

   324

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   325

	_town_view_scen_widgets,

   326

	TownViewWndProc

   327

};

   328

   329

void ShowTownViewWindow(uint town)

   330

{

   331

	Window *w;

   332

	Town *t;

   333

   334

	if (_game_mode != GM_EDITOR) {

   335

		w = AllocateWindowDescFront(&_town_view_desc, town);

   336

	} else {

   337

		w = AllocateWindowDescFront(&_town_view_scen_desc, town);

   338

	}

   339

   340

	if (w) {

   341

		w->flags4 |= WF_DISABLE_VP_SCROLL;

   342

		t = GetTown(w->window_number);

   343

		AssignWindowViewport(w, 3, 17, 0xFE, 0x56, t->xy, 1);

   344

	}

   345

}

   346

   347

static const Widget _town_directory_widgets[] = {

   348

{    WWT_TEXTBTN,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5,								STR_018B_CLOSE_WINDOW},

   349

{    WWT_CAPTION,   RESIZE_NONE,    13,    11,   195,     0,    13, STR_2000_TOWNS,					STR_018C_WINDOW_TITLE_DRAG_THIS},

   350

{  WWT_STICKYBOX,   RESIZE_NONE,    13,   196,   207,     0,    13, 0x0,										STR_STICKY_BUTTON},

   351

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,     0,    98,    14,    25, STR_SORT_BY_NAME,				STR_SORT_ORDER_TIP},

   352

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    13,    99,   195,    14,    25, STR_SORT_BY_POPULATION,	STR_SORT_ORDER_TIP},

   353

{     WWT_IMGBTN, RESIZE_BOTTOM,    13,     0,   195,    26,   189, 0x0,										STR_200A_TOWN_NAMES_CLICK_ON_NAME},

   354

{  WWT_SCROLLBAR, RESIZE_BOTTOM,    13,   196,   207,    14,   189, 0x0,										STR_0190_SCROLL_BAR_SCROLLS_LIST},

   355

{    WWT_PANEL,   	RESIZE_TB,    	13,  		0,   195,    190,  201, 0x0,				STR_NULL},

   356

{  WWT_RESIZEBOX,     RESIZE_TB,    13,   196,   207,   190,   201, 0x0,										STR_RESIZE_BUTTON},

   357

{   WIDGETS_END},

   358

};

   359

   360

   361

// used to get a sorted list of the towns

   362

static uint _num_town_sort;

   363

   364

static char _bufcache[64];

   365

static uint16 _last_town_idx;

   366

   367

static int CDECL TownNameSorter(const void *a, const void *b)

   368

{

   369

	char buf1[64];

   370

	const Town *t;

   371

	uint16 val;

   372

	int r;

   373

   374

	t = GetTown(*(const uint16*)a);

   375

	SetDParam(0, t->townnameparts);

   376

	GetString(buf1, t->townnametype);

   377

   378

	/* If 'b' is the same town as in the last round, use the cached value

   379

	 *  We do this to speed stuff up ('b' is called with the same value a lot of

   380

	*  times after eachother) */

   381

	val = *(const uint16*)b;

   382

	if (val != _last_town_idx) {

   383

		_last_town_idx = val;

   384

		t = GetTown(val);

   385

		SetDParam(0, t->townnameparts);

   386

		GetString(_bufcache, t->townnametype);

   387

	}

   388

   389

	r = strcmp(buf1, _bufcache);

   390

	if (_town_sort_order & 1) r = -r;

   391

	return r;

   392

}

   393

   394

static int CDECL TownPopSorter(const void *a, const void *b)

   395

{

   396

	const Town *ta = GetTown(*(const uint16*)a);

   397

	const Town *tb = GetTown(*(const uint16*)b);

   398

	int r = ta->population - tb->population;

   399

	if (_town_sort_order & 1) r = -r;

   400

	return r;

   401

}

   402

   403

static void MakeSortedTownList(void)

   404

{

   405

	Town *t;

   406

	int n = 0;

   407

   408

	/* Create array for sorting */

   409

	_town_sort = realloc(_town_sort, GetTownPoolSize() * sizeof(_town_sort[0]));

   410

	if (_town_sort == NULL)

   411

		error("Could not allocate memory for the town-sorting-list");

   412

   413

	FOR_ALL_TOWNS(t)

   414

		if (t->xy)

   415

			_town_sort[n++] = t->index;

   416

   417

	_num_town_sort = n;

   418

   419

	_last_town_idx = 0; // used for "cache"

   420

	qsort(_town_sort, n, sizeof(_town_sort[0]), _town_sort_order & 2 ? TownPopSorter : TownNameSorter);

   421

   422

	DEBUG(misc, 1) ("Resorting Towns list...");

   423

}

   424

   425

   426

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

   427

{

   428

	switch(e->event) {

   429

	case WE_PAINT: {

   430

   431

		if (_town_sort_dirty) {

   432

			_town_sort_dirty = false;

   433

			MakeSortedTownList();

   434

		}

   435

   436

		SetVScrollCount(w, _num_town_sort);

   437

   438

		DrawWindowWidgets(w);

   439

		DoDrawString(_town_sort_order & 1 ? "\xAA" : "\xA0", (_town_sort_order <= 1) ? 88 : 187, 15, 0x10);

   440

   441

		{

   442

			Town *t;

   443

			int n = 0;

   444

			uint16 i = w->vscroll.pos;

   445

			int y = 28;

   446

   447

			while (i < _num_town_sort) {

   448

				t = GetTown(_town_sort[i]);

   449

   450

				assert(t->xy);

   451

   452

				SetDParam(0, t->index);

   453

				SetDParam(1, t->population);

   454

				DrawString(2, y, STR_2057, 0);

   455

   456

				y += 10;

   457

				i++;

   458

				if (++n == w->vscroll.cap) { break;} // max number of towns in 1 window

   459

			}

   460

			SetDParam(0, GetWorldPopulation());

   461

			DrawString(3, w->height - 12 + 2, STR_TOWN_POPULATION, 0);

   462

		}

   463

	} break;

   464

   465

	case WE_CLICK:

   466

		switch(e->click.widget) {

   467

		case 3: { /* Sort by Name ascending/descending */

   468

			_town_sort_order = (_town_sort_order == 0) ? 1 : 0;

   469

			_town_sort_dirty = true;

   470

			SetWindowDirty(w);

   471

		} break;

   472

   473

		case 4: { /* Sort by Population ascending/descending */

   474

			_town_sort_order = (_town_sort_order == 2) ? 3 : 2;

   475

			_town_sort_dirty = true;

   476

			SetWindowDirty(w);

   477

		} break;

   478

   479

		case 5: { /* Click on Town Matrix */

   480

			uint16 id_v = (e->click.pt.y - 28) / 10;

   481

   482

			if (id_v >= w->vscroll.cap) { return;} // click out of bounds

   483

   484

			id_v += w->vscroll.pos;

   485

   486

			if (id_v >= _num_town_sort) { return;} // click out of town bounds

   487

   488

			{

   489

				Town *t = GetTown(_town_sort[id_v]);

   490

				assert(t->xy);

   491

   492

				ScrollMainWindowToTile(t->xy);

   493

			}

   494

		}	break;

   495

		}

   496

		break;

   497

   498

	case WE_4:

   499

		SetWindowDirty(w);

   500

		break;

   501

   502

	case WE_RESIZE:

   503

		w->vscroll.cap += e->sizing.diff.y / 10;

   504

		break;

   505

	}

   506

}

   507