1

/* $Id$ */

     2

     5

#ifndef TOWN_H

     6

#define TOWN_H

     7

     8

#include "oldpool.h"

     9

#include "player.h"

    10

#include "economy_new.h"

    11

#include "saveload.h"

    12

#include "functions.h"

    13

#include "helpers.hpp"

    14

    15

enum {

    16

	HOUSE_NO_CLASS   = 0,

    17

	NEW_HOUSE_OFFSET = 110,

    18

	HOUSE_MAX        = 512,

    19

	INVALID_TOWN     = 0xFFFF,

    20

	INVALID_HOUSE_ID = 0xFFFF,

    21

    22

	/* There can only be as many classes as there are new houses, plus one for

    23

	 * NO_CLASS, as the original houses don't have classes. */

    24

	HOUSE_CLASS_MAX  = HOUSE_MAX - NEW_HOUSE_OFFSET + 1,

    25

};

    26

    27

enum BuildingFlags {

    28

	TILE_NO_FLAG         =       0,

    29

	TILE_SIZE_1x1        = 1U << 0,

    30

	TILE_NOT_SLOPED      = 1U << 1,

    31

	TILE_SIZE_2x1        = 1U << 2,

    32

	TILE_SIZE_1x2        = 1U << 3,

    33

	TILE_SIZE_2x2        = 1U << 4,

    34

	BUILDING_IS_ANIMATED = 1U << 5,

    35

	BUILDING_IS_CHURCH   = 1U << 6,

    36

	BUILDING_IS_STADIUM  = 1U << 7,

    37

	BUILDING_HAS_1_TILE  = TILE_SIZE_1x1 | TILE_SIZE_2x1 | TILE_SIZE_1x2 | TILE_SIZE_2x2,

    38

	BUILDING_2_TILES_X   = TILE_SIZE_2x1 | TILE_SIZE_2x2,

    39

	BUILDING_2_TILES_Y   = TILE_SIZE_1x2 | TILE_SIZE_2x2,

    40

	BUILDING_HAS_4_TILES = TILE_SIZE_2x2,

    41

};

    42

    43

DECLARE_ENUM_AS_BIT_SET(BuildingFlags)

    44

    45

enum HouseZones {                  ///< Bit  Value       Meaning

    46

	HZ_NOZNS             = 0x0000,  ///<       0          This is just to get rid of zeros, meaning none

    47

	HZ_ZON1              = 0x0001,  ///< 0..4 1,2,4,8,10  which town zones the building can be built in, Zone1 been the further suburb

    48

	HZ_ZON2              = 0x0002,

    49

	HZ_ZON3              = 0x0004,

    50

	HZ_ZON4              = 0x0008,

    51

	HZ_ZON5              = 0x0010,  ///<                  center of town

    52

	HZ_ZONALL            = 0x001F,  ///<       1F         This is just to englobe all above types at once

    53

	HZ_SUBARTC_ABOVE     = 0x0800,  ///< 11    800        can appear in sub-arctic climate above the snow line

    54

	HZ_TEMP              = 0x1000,  ///< 12   1000        can appear in temperate climate

    55

	HZ_SUBARTC_BELOW     = 0x2000,  ///< 13   2000        can appear in sub-arctic climate below the snow line

    56

	HZ_SUBTROPIC         = 0x4000,  ///< 14   4000        can appear in subtropical climate

    57

	HZ_TOYLND            = 0x8000   ///< 15   8000        can appear in toyland climate

    58

};

    59

    60

DECLARE_ENUM_AS_BIT_SET(HouseZones)

    61

    62

enum HouseExtraFlags {

    63

	NO_EXTRA_FLAG            =       0,

    64

	BUILDING_IS_HISTORICAL   = 1U << 0,  ///< this house will only appear during town generation in random games, thus the historical

    65

	BUILDING_IS_PROTECTED    = 1U << 1,  ///< towns and AI will not remove this house, while human players will be able tp

    66

	SYNCHRONISED_CALLBACK_1B = 1U << 2,  ///< synchronized callback 1B will be performed, on multi tile houses

    67

	CALLBACK_1A_RANDOM_BITS  = 1U << 3,  ///< callback 1A needs random bits

    68

};

    69

    70

DECLARE_ENUM_AS_BIT_SET(HouseExtraFlags)

    71

    72

typedef uint16 HouseID;

    73

typedef uint16 HouseClassID;

    74

    75

struct BuildingCounts {

    76

	uint8 id_count[HOUSE_MAX];

    77

	uint8 class_count[HOUSE_CLASS_MAX];

    78

};

    79

    80

struct Town : EconomicObject {

    81

	TileIndex xy;

    82

    84

	uint16 num_houses;

    85

	uint32 population;

    86

    88

	uint16 townnametype;

    89

	uint32 townnameparts;

    90

    92

	ViewportSign sign;

    93

    98

	byte flags12;

    99

   101

	byte statues;

   102

   104

	byte have_ratings;

   108

	int16 ratings[MAX_PLAYERS];

   109

   111

	uint32 max_pass;

   112

	uint32 max_mail;

   113

	uint32 new_max_pass;

   114

	uint32 new_max_mail;

   115

	uint32 act_pass;

   116

	uint32 act_mail;

   117

	uint32 new_act_pass;

   118

	uint32 new_act_mail;

   119

   121

	byte pct_pass_transported;

   122

	byte pct_mail_transported;

   123

   125

	uint16 act_food;

   126

	uint16 act_water;

   127

	uint16 new_act_food;

   128

	uint16 new_act_water;

   129

   132

   136

   138

	byte fund_buildings_months;

   139

   141

	byte road_build_months;

   142

   144

	TownID index;

   145

   147

	uint16 radius[5];

   148

   150

	BuildingCounts building_counts;

   151

   152

	/**

   153

	 * Sets the economic activity level of a town

   154

	 * @param level The activity level

   155

	 */

   156

	/* virtual */

   157

	template <typename T>

   158

	void SetActivity(T level)

   159

	{

   160

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

   161

		m_activity_level = level;

   162

	}

   163

   164

	byte GetWealthLevel() const

   165

	{

   166

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

   167

		if (level <  7) return 0;

   168

		if (level <  9) return 1;

   169

		if (level < 12) return 2;

   170

		if (level < 15) return 3;

   171

		return 4;

   172

	}

   173

   174

	/**

   175

	 * Computes the cost of a single tile should the player

   176

	 * want to purcase or sell it.

   177

	 * @param t The tile which is to be purcahsed

   178

	 * @return  The cost for the purcahse

   179

	 * @todo    Incorporate the factor of 10 in the base price

   180

	 */

   181

	static int64 GetTilePrice(TileIndex tile);

   182

   183

	/**

   184

	 * Adjusts the activity level of a town dependent

   185

	 * on player performance. Towns with a high share of

   186

	 * transported passengers are increasing the EAL, those

   187

	 * with a low share of transported passengers will

   188

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

   189

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

   190

	 * and thus have zero transported passengers, These

   191

	 * will be untouched.

   192

	 * @pre Must be called BEFORE UpdateAmounts

   193

	 */

   194

	void UpdateActivity();

   195

   196

	/**

   197

	 * Gets the so ralled "town radius group" of a tile which is a

   198

	 * representation of how close a tile is relative to the town

   199

	 * center depending on the size of the town

   200

	 * @param tile            The tile which the town radius is to be computed for

   201

	 * @param ignore_funding  When a player opted to fund buildings, select the

   202

	 *                        appropriate group unless this flag is set.

   203

	 * @return                The town radius group

   204

	 */

   205

	uint GetRadiusGroup(TileIndex tile, bool ignore_funding = false) const;

   206

   207

	/**

   208

	 * Obtains the highest Town Radius Group a town is in.

   209

	 * @param [in]  tile  The tile which to find the radius group for

   210

	 * @param [out] group The group for in which tile is located

   211

	 * @return            The town to which 'group' belongs

   212

	 */

   213

	static const Town *GetRadiusGroupForTile(TileIndex tile, uint &group);

   214

   215

	/**

   216

	 * Descriptor for the "town" part of the savegame

   217

	 */

   218

	static const SaveLoad town_desc[];

   219

};

   220

   221

struct HouseSpec {

   222

	/* Standard properties */

   223

	Year min_date;                     ///< introduction year of the house

   224

	Year max_date;                     ///< last year it can be built

   225

	byte population;                   ///< population (Zero on other tiles in multi tile house.)

   226

	byte removal_cost;                 ///< cost multiplier for removing it

   227

	StringID building_name;            ///< building name

   228

	uint16 remove_rating_decrease;     ///< rating decrease if removed

   229

	byte mail_generation;              ///< mail generation multiplier (tile based, as the acceptances below)

   230

	byte cargo_acceptance[3];          ///< acceptance level for the cargo slots

   231

	CargoID accepts_cargo[3];          ///< 3 input cargo slots

   232

	BuildingFlags building_flags;      ///< some flags that describe the house (size, stadium etc...)

   233

	HouseZones building_availability;  ///< where can it be built (climates, zones)

   234

	bool enabled;                      ///< the house is still avaible (by default, true.newgrf can disable it, though)

   235

   236

	/* NewHouses properties */

   237

	HouseID substitute_id;             ///< which house this one is based on

   238

	struct SpriteGroup *spritegroup;   ///< pointer to the different sprites of the house

   239

	HouseID override;                  ///< which house this one replaces

   240

	uint16 callback_mask;              ///< House callback flags

   241

	byte random_colour[4];             ///< 4 "random" colours

   242

	byte probability;                  ///< Relative probability of appearing (16 is the standard value)

   243

	HouseExtraFlags extra_flags;       ///< some more flags

   244

	HouseClassID class_id;             ///< defines the class this house has (grf file based) @See HouseGetVariable, prop 0x44

   245

	byte animation_frames;             ///< number of animation frames

   246

	byte animation_speed;              ///< amount of time between each of those frames

   247

	byte processing_time;              ///< Periodic refresh multiplier

   248

   249

	/* grf file related properties*/

   250

	uint8 local_id;                    ///< id defined by the grf file for this house

   251

	const struct GRFFile *grffile;     ///< grf file that introduced this house

   252

};

   253

   254

VARDEF HouseSpec _house_specs[HOUSE_MAX];

   255

   256

uint32 GetWorldPopulation();

   257

   258

void UpdateTownVirtCoord(Town *t);

   259

void InitializeTown();

   260

void ShowTownViewWindow(TownID town);

   261

void ExpandTown(Town *t);

   262

Town *CreateRandomTown(uint attempts, uint size_mode);

   263

   264

enum {

   265

	ROAD_REMOVE = 0,

   266

	UNMOVEABLE_REMOVE = 1,

   267

	TUNNELBRIDGE_REMOVE = 1,

   268

	INDUSTRY_REMOVE = 2

   269

};

   270

   271

enum {

   274

	RATING_MINIMUM     = -1000,

   275

	RATING_APPALLING   =  -400,

   276

	RATING_VERYPOOR    =  -200,

   277

	RATING_POOR        =     0,

   278

	RATING_MEDIOCRE    =   200,

   279

	RATING_GOOD        =   400,

   280

	RATING_VERYGOOD    =   600,

   281

	RATING_EXCELLENT   =   800,

   283

   284

	RATING_MAXIMUM = RATING_OUTSTANDING,

   285

   287

	RATING_TREE_DOWN_STEP = -35,

   288

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   289

	RATING_TREE_UP_STEP   = 7,

   290

	RATING_TREE_MAXIMUM   = 220,

   291

   292

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   293

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   294

   295

	RATING_INDUSTRY_DOWN_STEP = -1500,

   296

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   297

   298

	RATING_ROAD_DOWN_STEP = -50,

   299

	RATING_ROAD_MINIMUM   = -100,

   300

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   301

   302

	RATING_BRIBE_UP_STEP = 200,

   303

	RATING_BRIBE_MAXIMUM = 800,

   304

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

   305

};

   306

   311

   317

 * IT simply states what bit is used for.

   318

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

   319

 * per town, NO MATTER the population of it.

   320

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

   321

 */

   322

enum {

   326

};

   327

   328

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

   329

   330

VARDEF const Town** _town_sort;

   331

   332

DECLARE_OLD_POOL(Town, Town, 3, 8000)

   333

   334

static inline HouseSpec *GetHouseSpecs(HouseID house_id)

   335

{

   336

	assert(house_id < HOUSE_MAX);

   337

	return &_house_specs[house_id];

   338

}

   339

   340

/**

   341

 * Check if a Town really exists.

   344

 */

   345

static inline bool IsValidTown(const Town* town)

   346

{

   347

	return town->xy != 0;

   348

}

   349

   355

static inline bool IsValidTownID(TownID index)

   356

{

   357

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

   358

}

   359

   360

VARDEF uint _total_towns;

   361

   362

static inline TownID GetMaxTownIndex()

   363

{

   364

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

   365

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

   366

	 *  _really_ returns the highest index. Now it just returns

   367

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

   368

	 */

   369

	return GetTownPoolSize() - 1;

   370

}

   371

   372

static inline uint GetNumTowns()

   373

{

   374

	return _total_towns;

   375

}

   376

   377

/**

   378

 * Return a random valid town.

   379

 */

   380

static inline Town *GetRandomTown()

   381

{

   382

	int num = RandomRange(GetNumTowns());

   383

	TownID index = INVALID_TOWN;

   384

   385

	while (num >= 0) {

   386

		num--;

   387

   388

		index++;

   389

		/* Make sure we have a valid town */

   390

		while (!IsValidTownID(index)) {

   391

			index++;

   392

			assert(index <= GetMaxTownIndex());

   393

		}

   394

	}

   395

   396

	return GetTown(index);

   397

}

   398

   399

void DestroyTown(Town *t);

   400

   401

static inline void DeleteTown(Town *t)

   402

{

   403

	DestroyTown(t);

   404

	t->xy = 0;

   405

}

   406

   407

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

   408

   409

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

   410

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

   411

   412

VARDEF bool _town_sort_dirty;

   413

VARDEF byte _town_sort_order;

   414

   415

VARDEF Town *_cleared_town;

   416

VARDEF int _cleared_town_rating;

   417

   418

uint OriginalTileRandomiser(uint x, uint y);

   419

void ResetHouses();

   420

   421

void ClearTownHouse(Town *t, TileIndex tile);

   422

   423

#endif /* TOWN_H */