1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "strings.h"

     5

#include "table/sprites.h"

     6

#include "table/strings.h"

     7

#include "town.h"

     8

#include "window.h"

     9

#include "gfx.h"

    10

#include "viewport.h"

    11

#include "gui.h"

    12

#include "command.h"

    13

#include "player.h"

    14

#include "network.h"

    15

    16

static const Widget _town_authority_widgets[] = {

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

{   WIDGETS_END},

    25

};

    26

    27

extern const byte _town_action_costs[8];

    28

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

    29

    30

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

    31

{

    32

	int32 avail, ref;

    33

	int i, num;

    34

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

    35

	uint buttons;

    36

    37

	if (_local_player != OWNER_SPECTATOR) {

    38

		// bribe option enabled?

    39

		if (_patches.bribe) {

    40

			// if unwanted, disable everything.

    41

			if (t->unwanted[_local_player]) {

    42

				avail_buttons = 0;

    43

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

    44

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

    45

		}

    46

    47

		// Things worth more than this are not shown

    48

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

    49

		ref = _price.build_industry >> 8;

    50

    51

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

    52

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

    53

				SETBIT(buttons, i);

    54

				num++;

    55

			}

    56

		}

    57

    58

		// Disable build statue if already built

    59

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

    60

		{

    61

			CLRBIT(buttons, 4);

    62

			num--;

    63

		}

    64

    65

	} else {

    66

		// no actions available for spectator

    67

		buttons = 0;

    68

		num = 0;

    69

	}

    70

    71

	if (nump) *nump = num;

    72

	return buttons;

    73

}

    74

    75

static int GetNthSetBit(uint32 bits, int n)

    76

{

    77

	int i = 0;

    78

	if (n >= 0) {

    79

		do {

    80

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

    81

			i++;

    82

		} while (bits>>=1);

    83

	}

    84

	return -1;

    85

}

    86

    87

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

    88

{

    89

	uint buttons;

    90

	int numact;

    91

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

    92

    93

	switch(e->event) {

    94

	case WE_PAINT:

    95

		buttons = GetMaskOfTownActions(&numact, t);

    96

		SetVScrollCount(w, numact + 1);

    97

    98

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

    99

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

   100

   101

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

   102

   103

		{

   104

			int y;

   105

			Player *p;

   106

			int r;

   107

			StringID str;

   108

   109

			SetDParam(0, w->window_number);

   110

			DrawWindowWidgets(w);

   111

   112

			DrawString(2, 15, STR_2023_TRANSPORT_COMPANY_RATINGS, 0);

   113

   114

			// Draw list of players

   115

			y = 25;

   116

			FOR_ALL_PLAYERS(p) {

   117

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

   118

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

   119

   120

					SetDParam(0, p->name_1);

   121

					SetDParam(1, p->name_2);

   122

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

   123

   124

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

   125

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

   126

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

   127

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

   128

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

   129

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

   130

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

   131

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

   132

					(str++, true);														// Outstanding

   133

   134

					/*	WARNING ugly hack!

   135

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

   136

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

   137

							that because there is another param after it.

   138

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

   139

						*/

   140

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

   141

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

   142

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

   143

   144

					DrawString(28, y, STR_2024, 0);

   145

					y+=10;

   146

				}

   147

			}

   148

		}

   149

   150

		// Draw actions list

   151

		{

   152

			int y = 107, i;

   153

			int pos = w->vscroll.pos;

   154

   155

			if (--pos < 0) {

   156

				DrawString(2, y, STR_2045_ACTIONS_AVAILABLE, 0);

   157

				y+=10;

   158

			}

   159

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

   160

				if (pos <= -5)

   161

					break;

   162

   163

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

   164

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

   165

					y += 10;

   166

				}

   167

			}

   168

		}

   169

   170

		{

   171

			int i;

   172

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

   173

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

   174

				SetDParam(0, STR_2046_SMALL_ADVERTISING_CAMPAIGN + i);

   175

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

   176

			}

   177

		}

   178

   179

		break;

   180

   181

	case WE_CLICK:

   182

		switch(e->click.widget) {

   183

		case 3: { /* listbox */

   184

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

   185

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

   186

				return;

   187

   188

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

   189

			if (y >= 0) {

   190

				WP(w,def_d).data_1 = y;

   191

				SetWindowDirty(w);

   192

			}

   193

			break;

   194

		}

   195

   196

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

   197

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

   198

			break;

   199

		}

   200

		}

   201

		break;

   202

   203

	case WE_4:

   204

		SetWindowDirty(w);

   205

		break;

   206

	}

   207

}

   208

   209

static const WindowDesc _town_authority_desc = {

   210

	-1, -1, 317, 222,

   211

	WC_TOWN_AUTHORITY,0,

   212

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   213

	_town_authority_widgets,

   214

	TownAuthorityWndProc

   215

};

   216

   217

static void ShowTownAuthorityWindow(uint town)

   218

{

   219

	Window *w;

   220

   221

	w = AllocateWindowDescFront(&_town_authority_desc, town);

   222

	if (w) {

   223

		w->vscroll.cap = 5;

   224

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

   225

	}

   226

}

   227

   228

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

   229

{

   230

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

   231

   232

	switch(e->event) {

   233

	case WE_PAINT:

   234

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

   235

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

   236

   237

		SetDParam(0, t->index);

   238

		DrawWindowWidgets(w);

   239

   240

		SetDParam(0, t->population);

   241

		SetDParam(1, t->num_houses);

   242

		DrawString(2,107,STR_2006_POPULATION,0);

   243

   244

		SetDParam(0, t->act_pass);

   245

		SetDParam(1, t->max_pass);

   246

		DrawString(2,117,STR_200D_PASSENGERS_LAST_MONTH_MAX,0);

   247

   248

		SetDParam(0, t->act_mail);

   249

		SetDParam(1, t->max_mail);

   250

		DrawString(2,127,STR_200E_MAIL_LAST_MONTH_MAX,0);

   251

   252

		DrawWindowViewport(w);

   253

		break;

   254

   255

	case WE_CLICK:

   256

		switch(e->click.widget) {

   257

		case 6: /* scroll to location */

   258

			ScrollMainWindowToTile(t->xy);

   259

			break;

   260

		case 7: /* town authority */

   261

			ShowTownAuthorityWindow(w->window_number);

   262

			break;

   263

		case 8: /* rename */

   264

			SetDParam(0, t->townnameparts);

   265

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

   266

			break;

   267

		case 9: /* expand town */

   268

			ExpandTown(t);

   269

			break;

   270

		case 10: /* delete town */

   271

			DeleteTown(t);

   272

			break;

   273

		}

   274

		break;

   275

   276

	case WE_ON_EDIT_TEXT: {

   277

		const char *b = e->edittext.str;

   278

		if (*b == 0)

   279

			return;

   280

		memcpy(_decode_parameters, b, 32);

   281

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

   282

	} break;

   283

	}

   284

}

   285

   286

   287

static const Widget _town_view_widgets[] = {

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

{   WIDGETS_END},

   298

};

   299

   300

static const WindowDesc _town_view_desc = {

   301

	-1, -1, 260, 150,

   302

	WC_TOWN_VIEW,0,

   303

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   304

	_town_view_widgets,

   305

	TownViewWndProc

   306

};

   307

   308

static const Widget _town_view_scen_widgets[] = {

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

{   WIDGETS_END},

   321

};

   322

   323

static const WindowDesc _town_view_scen_desc = {

   324

	-1, -1, 260, 150,

   325

	WC_TOWN_VIEW,0,

   326

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_STICKY_BUTTON,

   327

	_town_view_scen_widgets,

   328

	TownViewWndProc

   329

};

   330

   331

void ShowTownViewWindow(uint town)

   332

{

   333

	Window *w;

   334

	Town *t;

   335

   336

	if (_game_mode != GM_EDITOR) {

   337

		w = AllocateWindowDescFront(&_town_view_desc, town);

   338

	} else {

   339

		w = AllocateWindowDescFront(&_town_view_scen_desc, town);

   340

	}

   341

   342

	if (w) {

   343

		w->flags4 |= WF_DISABLE_VP_SCROLL;

   344

		t = GetTown(w->window_number);

   345

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

   346

	}

   347

}

   348

   349

static const Widget _town_directory_widgets[] = {

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

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

   359

{   WIDGETS_END},

   360

};

   361

   362

   363

// used to get a sorted list of the towns

   364

static uint _num_town_sort;

   365

   366

static char _bufcache[64];

   367

static uint16 _last_town_idx;

   368

   369

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

   370

{

   371

	char buf1[64];

   372

	const Town *t;

   373

	uint16 val;

   374

	int r;

   375

   376

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

   377

	SetDParam(0, t->townnameparts);

   378

	GetString(buf1, t->townnametype);

   379

   380

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

   381

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

   382

	*  times after eachother) */

   383

	val = *(const uint16*)b;

   384

	if (val != _last_town_idx) {

   385

		_last_town_idx = val;

   386

		t = GetTown(val);

   387

		SetDParam(0, t->townnameparts);

   388

		GetString(_bufcache, t->townnametype);

   389

	}

   390

   391

	r = strcmp(buf1, _bufcache);

   392

	if (_town_sort_order & 1) r = -r;

   393

	return r;

   394

}

   395

   396

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

   397

{

   398

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

   399

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

   400

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

   401

	if (_town_sort_order & 1) r = -r;

   402

	return r;

   403

}

   404

   405

static void MakeSortedTownList(void)

   406

{

   407

	Town *t;

   408

	int n = 0;

   409

   410

	/* Create array for sorting */

   411

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

   412

	if (_town_sort == NULL)

   413

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

   414

   415

	FOR_ALL_TOWNS(t)

   416

		if (t->xy)

   417

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

   418

   419

	_num_town_sort = n;

   420

   421

	_last_town_idx = 0; // used for "cache"

   422

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

   423

   424

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

   425

}

   426

   427

   428

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

   429

{

   430

	switch(e->event) {

   431

	case WE_PAINT: {

   432

   433

		if (_town_sort_dirty) {

   434

			_town_sort_dirty = false;

   435

			MakeSortedTownList();

   436

		}

   437

   438

		SetVScrollCount(w, _num_town_sort);

   439

   440

		DrawWindowWidgets(w);

   441

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

   442

   443

		{

   444

			Town *t;

   445

			int n = 0;

   446

			uint16 i = w->vscroll.pos;

   447

			int y = 28;

   448

   449

			while (i < _num_town_sort) {

   450

				t = GetTown(_town_sort[i]);

   451

   452

				assert(t->xy);

   453

   454

				SetDParam(0, t->index);

   455

				SetDParam(1, t->population);

   456

				DrawString(2, y, STR_2057, 0);

   457

   458

				y += 10;

   459

				i++;

   460

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

   461

			}

   462

			SetDParam(0, GetWorldPopulation());

   463

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

   464

		}

   465

	} break;

   466

   467

	case WE_CLICK:

   468

		switch(e->click.widget) {

   469

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

   470

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

   471

			_town_sort_dirty = true;

   472

			SetWindowDirty(w);

   473

		} break;

   474

   475

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

   476

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

   477

			_town_sort_dirty = true;

   478

			SetWindowDirty(w);

   479

		} break;

   480

   481

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

   482

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

   483

   484

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

   485

   486

			id_v += w->vscroll.pos;

   487

   488

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

   489

   490

			{

   491

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

   492

				assert(t->xy);

   493

   494

				ScrollMainWindowToTile(t->xy);

   495

			}

   496

		}	break;

   497

		}

   498

		break;

   499

   500

	case WE_4:

   501

		SetWindowDirty(w);

   502

		break;

   503

   504

	case WE_RESIZE:

   505

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

   506

		break;

   507

	}