1

/* $Id$ */

     2

     3

#ifndef TOWN_H

     4

#define TOWN_H

     5

     6

#include "oldpool.h"

     7

#include "player.h"

     8

#include "economy_new.h"

    11

    12

enum {

    75

};

    76

    77

struct Town : EconomicObject {

    78

	TileIndex xy;

    79

    80

	// Current population of people and amount of houses.

    81

	uint16 num_houses;

    82

	uint32 population;

    83

    84

	// Town name

    85

	uint16 townnametype;

    86

	uint32 townnameparts;

    87

    88

	// NOSAVE: Location of name sign, UpdateTownVirtCoord updates this.

    89

	ViewportSign sign;

    90

    91

	// Makes sure we don't build certain house types twice.

    92

	// bit 0 = Building funds received

    93

	// bit 1 = CHURCH

    94

	// bit 2 = STADIUM

    95

	byte flags12;

    96

    97

	// Which players have a statue?

    98

	byte statues;

    99

   100

	// Player ratings as well as a mask that determines which players have a rating.

   101

	byte have_ratings;

   102

	uint8 unwanted[MAX_PLAYERS]; // how many months companies aren't wanted by towns (bribe)

   103

	PlayerByte exclusivity;        // which player has exslusivity

   104

	uint8 exclusive_counter;     // months till the exclusivity expires

   105

	int16 ratings[MAX_PLAYERS];

   106

   107

	// Maximum amount of passengers and mail that can be transported.

   108

	uint32 max_pass;

   109

	uint32 max_mail;

   110

	uint32 new_max_pass;

   111

	uint32 new_max_mail;

   112

	uint32 act_pass;

   113

	uint32 act_mail;

   114

	uint32 new_act_pass;

   115

	uint32 new_act_mail;

   116

   117

	// Amount of passengers that were transported.

   118

	byte pct_pass_transported;

   119

	byte pct_mail_transported;

   120

   121

	// Amount of food and paper that was transported. Actually a bit mask would be enough.

   122

	uint16 act_food;

   123

	uint16 act_water;

   124

	uint16 new_act_food;

   125

	uint16 new_act_water;

   126

   127

	// Time until we rebuild a house.

   128

	byte time_until_rebuild;

   129

   130

	// When to grow town next time.

   131

	byte grow_counter;

   132

	byte growth_rate;

   133

   134

	// Fund buildings program in action?

   135

	byte fund_buildings_months;

   136

   137

	// Fund road reconstruction in action?

   138

	byte road_build_months;

   139

   140

	// Index in town array

   141

	TownID index;

   142

   143

	// NOSAVE: UpdateTownRadius updates this given the house count.

   144

	uint16 radius[5];

   145

   149

	/**

   150

	 * Sets the economic activity level of a town

   151

	 * @param level The activity level

   152

	 */

   153

	/* virtual */

   154

	template <typename T>

   155

	void SetActivity(T level)

   156

	{

   157

		DEBUG(eco, 7, "Setting EAL of town %d [0x%x] to %f", index, xy, (double)level);

   158

		m_activity_level = level;

   159

	}

   160

   161

	byte GetWealthLevel() const

   162

	{

   163

		FixedT<int32, 16> level = GetActivity() * 10;

   164

		if (level <  7) return 0;

   165

		if (level <  9) return 1;

   166

		if (level < 12) return 2;

   167

		if (level < 15) return 3;

   168

		return 4;

   169

	}

   170

   171

	/**

   172

	 * Adjusts the activity level of a town dependent

   173

	 * on player performance. Towns with a high share of

   174

	 * transported passengers are increasing the EAL, those

   175

	 * with a low share of transported passengers will

   176

	 * see a reduction in activity. In order to not wreck

   177

	 * new games (where no or almost no towns) are connected

   178

	 * and thus have zero transported passengers, These

   179

	 * will be untouched.

   180

	 * @pre Must be called BEFORE UpdateAmounts

   181

	 */

   182

	void UpdateActivity()

   183

	{

   184

		if (new_act_pass == 0 && act_pass == 0) {

   185

			DEBUG(eco, 7, "Town is not connected, bailing out");

   186

			return;

   187

		}

   188

   189

		static const FixedT<int, 12> max_activity_change   (1, 400);

   190

		static const FixedT<int, 12> min_activity_change = -max_activity_change;

   191

		FixedT<int, 12>              activity_change       (1, 200);

   192

   193

		activity_change *= act_pass;

   194

		activity_change /= max_pass;

   195

		activity_change -= max_activity_change;

   196

		DEBUG(eco, 6, "Raw EAL change for town at 0x%x is %f", xy, (double)activity_change);

   197

   198

		if (activity_change > max_activity_change) activity_change = max_activity_change;

   199

		if (activity_change < min_activity_change) activity_change = min_activity_change;

   200

   201

		this->SetActivity(this->GetActivity() + activity_change);

   202

   203

		DEBUG(eco, 5, "Modifying EAL for town at 0x%x by %f to %f", xy, (double)activity_change, (double)this->GetActivity());

   204

	}

   205

};

   206

   244

uint32 GetWorldPopulation();

   245

   246

void UpdateTownVirtCoord(Town *t);

   247

void InitializeTown();

   248

void ShowTownViewWindow(TownID town);

   249

void ExpandTown(Town *t);

   250

Town *CreateRandomTown(uint attempts, uint size_mode);

   251

   252

enum {

   253

	ROAD_REMOVE = 0,

   254

	UNMOVEABLE_REMOVE = 1,

   255

	TUNNELBRIDGE_REMOVE = 1,

   256

	INDUSTRY_REMOVE = 2

   257

};

   258

   259

enum {

   260

	// These refer to the maximums, so Appalling is -1000 to -400

   261

	// MAXIMUM RATINGS BOUNDARIES

   262

	RATING_MINIMUM     = -1000,

   263

	RATING_APPALLING   =  -400,

   264

	RATING_VERYPOOR    =  -200,

   265

	RATING_POOR        =     0,

   266

	RATING_MEDIOCRE    =   200,

   267

	RATING_GOOD        =   400,

   268

	RATING_VERYGOOD    =   600,

   269

	RATING_EXCELLENT   =   800,

   270

	RATING_OUTSTANDING =  1000,         // OUTSTANDING

   271

   272

	RATING_MAXIMUM = RATING_OUTSTANDING,

   273

   274

	// RATINGS AFFECTING NUMBERS

   275

	RATING_TREE_DOWN_STEP = -35,

   276

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   277

	RATING_TREE_UP_STEP   = 7,

   278

	RATING_TREE_MAXIMUM   = 220,

   279

   280

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   281

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   282

   283

	RATING_INDUSTRY_DOWN_STEP = -1500,

   284

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   285

   286

	RATING_ROAD_DOWN_STEP = -50,

   287

	RATING_ROAD_MINIMUM   = -100,

   288

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   289

   290

	RATING_BRIBE_UP_STEP = 200,

   291

	RATING_BRIBE_MAXIMUM = 800,

   292

	RATING_BRIBE_DOWN_TO = -50        // XXX SHOULD BE SOMETHING LOWER?

   293

};

   294

   295

enum {

   296

/* This is the base "normal" number of towns on the 8x8 map, when

   297

 * one town should get grown per tick. The other numbers of towns

   298

 * are then scaled based on that. */

   299

	TOWN_GROWTH_FREQUENCY = 23,

   300

/* Simple value that indicates the house has reached final stage of construction*/

   301

	TOWN_HOUSE_COMPLETED  =  3,

   302

};

   303

   304

/* This enum is used in conjonction with town->flags12.

   305

 * IT simply states what bit is used for.

   306

 * It is pretty unrealistic (IMHO) to only have one church/stadium

   307

 * per town, NO MATTER the population of it.

   308

 * And there are 5 more bits available on flags12...

   309

 */

   310

enum {

   311

	TOWN_IS_FUNDED      = 0,   // Town has received some funds for

   312

	TOWN_HAS_CHURCH     = 1,   // There can be only one church by town.

   313

	TOWN_HAS_STADIUM    = 2    // There can be only one stadium by town.

   314

};

   315

   316

bool CheckforTownRating(uint32 flags, Town *t, byte type);

   317

   318

VARDEF const Town** _town_sort;

   319

   320

DECLARE_OLD_POOL(Town, Town, 3, 8000)

   321

   328

/**

   329

 * Check if a Town really exists.

   330

 */

   331

static inline bool IsValidTown(const Town* town)

   332

{

   333

	return town->xy != 0;

   334

}

   335

   336

static inline bool IsValidTownID(TownID index)

   337

{

   338

	return index < GetTownPoolSize() && IsValidTown(GetTown(index));

   339

}

   340

   341

VARDEF uint _total_towns;

   342

   343

static inline TownID GetMaxTownIndex()

   344

{

   345

	/* TODO - This isn't the real content of the function, but

   346

	 *  with the new pool-system this will be replaced with one that

   347

	 *  _really_ returns the highest index. Now it just returns

   348

	 *  the next safe value we are sure about everything is below.

   349

	 */

   350

	return GetTownPoolSize() - 1;

   351

}

   352

   353

static inline uint GetNumTowns()

   354

{

   355

	return _total_towns;

   356

}

   357

   358

/**

   359

 * Return a random valid town.

   360

 */

   361

static inline Town *GetRandomTown()

   362

{

   363

	int num = RandomRange(GetNumTowns());

   364

	TownID index = INVALID_TOWN;

   365

   366

	while (num >= 0) {

   367

		num--;

   368

   369

		index++;

   370

		/* Make sure we have a valid town */

   371

		while (!IsValidTownID(index)) {

   372

			index++;

   373

			assert(index <= GetMaxTownIndex());

   374

		}

   375

	}

   376

   377

	return GetTown(index);

   378

}

   379

   380

void DestroyTown(Town *t);

   381

   382

static inline void DeleteTown(Town *t)

   383

{

   384

	DestroyTown(t);

   385

	t->xy = 0;

   386

}

   387

   388

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

   389

   390

#define FOR_ALL_TOWNS_FROM(t, start) for (t = GetTown(start); t != NULL; t = (t->index + 1U < GetTownPoolSize()) ? GetTown(t->index + 1U) : NULL) if (IsValidTown(t))

   391

#define FOR_ALL_TOWNS(t) FOR_ALL_TOWNS_FROM(t, 0)

   392

   393

VARDEF bool _town_sort_dirty;

   394

VARDEF byte _town_sort_order;

   395

   396

VARDEF Town *_cleared_town;

   397

VARDEF int _cleared_town_rating;

   398

   404

#endif /* TOWN_H */