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"

     9

    10

enum {

    11

	INVALID_TOWN = 0xFFFF,

    12

};

    13

    14

struct Town : EconomicObject {

    15

	TileIndex xy;

    16

    17

	// Current population of people and amount of houses.

    18

	uint16 num_houses;

    19

	uint32 population;

    20

    21

	// Town name

    22

	uint16 townnametype;

    23

	uint32 townnameparts;

    24

    25

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

    26

	ViewportSign sign;

    27

    28

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

    29

	// bit 0 = Building funds received

    30

	// bit 1 = CHURCH

    31

	// bit 2 = STADIUM

    32

	byte flags12;

    33

    34

	// Which players have a statue?

    35

	byte statues;

    36

    37

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

    38

	byte have_ratings;

    39

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

    40

	PlayerByte exclusivity;        // which player has exslusivity

    41

	uint8 exclusive_counter;     // months till the exclusivity expires

    42

	int16 ratings[MAX_PLAYERS];

    43

    44

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

    45

	uint32 max_pass;

    46

	uint32 max_mail;

    47

	uint32 new_max_pass;

    48

	uint32 new_max_mail;

    49

	uint32 act_pass;

    50

	uint32 act_mail;

    51

	uint32 new_act_pass;

    52

	uint32 new_act_mail;

    53

    54

	// Amount of passengers that were transported.

    55

	byte pct_pass_transported;

    56

	byte pct_mail_transported;

    57

    58

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

    59

	uint16 act_food;

    60

	uint16 act_water;

    61

	uint16 new_act_food;

    62

	uint16 new_act_water;

    63

    64

	// Time until we rebuild a house.

    65

	byte time_until_rebuild;

    66

    67

	// When to grow town next time.

    68

	byte grow_counter;

    69

	byte growth_rate;

    70

    71

	// Fund buildings program in action?

    72

	byte fund_buildings_months;

    73

    74

	// Fund road reconstruction in action?

    75

	byte road_build_months;

    76

    77

	// Index in town array

    78

	TownID index;

    79

    80

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

    81

	uint16 radius[5];

    82

    83

	/**

    84

	 * Sets the economic activity level of a town

    85

	 * @param level The activity level

    86

	 */

    87

	/* virtual */

    88

	template <typename T>

    89

	void SetActivity(T level)

    90

	{

    92

		m_activity_level = level;

    93

	}

    94

};

    95

    96

uint32 GetWorldPopulation(void);

    97

    98

void UpdateTownVirtCoord(Town *t);

    99

void InitializeTown(void);

   100

void ShowTownViewWindow(TownID town);

   101

void ExpandTown(Town *t);

   102

Town *CreateRandomTown(uint attempts, uint size_mode);

   103

   104

enum {

   105

	ROAD_REMOVE = 0,

   106

	UNMOVEABLE_REMOVE = 1,

   107

	TUNNELBRIDGE_REMOVE = 1,

   108

	INDUSTRY_REMOVE = 2

   109

};

   110

   111

enum {

   112

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

   113

	// MAXIMUM RATINGS BOUNDARIES

   114

	RATING_MINIMUM     = -1000,

   115

	RATING_APPALLING   =  -400,

   116

	RATING_VERYPOOR    =  -200,

   117

	RATING_POOR        =     0,

   118

	RATING_MEDIOCRE    =   200,

   119

	RATING_GOOD        =   400,

   120

	RATING_VERYGOOD    =   600,

   121

	RATING_EXCELLENT   =   800,

   122

	RATING_OUTSTANDING =  1000,         // OUTSTANDING

   123

   124

	RATING_MAXIMUM = RATING_OUTSTANDING,

   125

   126

	// RATINGS AFFECTING NUMBERS

   127

	RATING_TREE_DOWN_STEP = -35,

   128

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   129

	RATING_TREE_UP_STEP   = 7,

   130

	RATING_TREE_MAXIMUM   = 220,

   131

   132

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   133

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   134

   135

	RATING_INDUSTRY_DOWN_STEP = -1500,

   136

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   137

   138

	RATING_ROAD_DOWN_STEP = -50,

   139

	RATING_ROAD_MINIMUM   = -100,

   140

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   141

   142

	RATING_BRIBE_UP_STEP = 200,

   143

	RATING_BRIBE_MAXIMUM = 800,

   144

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

   145

};

   146

   147

enum {

   148

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

   149

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

   150

 * are then scaled based on that. */

   151

	TOWN_GROWTH_FREQUENCY = 23,

   152

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

   153

	TOWN_HOUSE_COMPLETED  =  3,

   154

};

   155

   156

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

   157

 * IT simply states what bit is used for.

   158

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

   159

 * per town, NO MATTER the population of it.

   160

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

   161

 */

   162

enum {

   163

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

   164

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

   165

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

   166

};

   167

   168

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

   169

   170

VARDEF const Town** _town_sort;

   171

   172

DECLARE_OLD_POOL(Town, Town, 3, 8000)

   173

   174

/**

   175

 * Check if a Town really exists.

   176

 */

   177

static inline bool IsValidTown(const Town* town)

   178

{

   179

	return town->xy != 0;

   180

}

   181

   182

static inline bool IsValidTownID(TownID index)

   183

{

   184

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

   185

}

   186

   187

VARDEF uint _total_towns;

   188

   189

static inline TownID GetMaxTownIndex(void)

   190

{

   191

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

   192

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

   193

	 *  _really_ returns the highest index. Now it just returns

   194

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

   195

	 */

   196

	return GetTownPoolSize() - 1;

   197

}

   198

   199

static inline uint GetNumTowns(void)

   200

{

   201

	return _total_towns;

   202

}

   203

   204

/**

   205

 * Return a random valid town.

   206

 */

   207

static inline Town *GetRandomTown(void)

   208

{

   209

	int num = RandomRange(GetNumTowns());

   210

	TownID index = INVALID_TOWN;

   211

   212

	while (num >= 0) {

   213

		num--;

   214

   215

		index++;

   216

		/* Make sure we have a valid town */

   217

		while (!IsValidTownID(index)) {

   218

			index++;

   219

			assert(index <= GetMaxTownIndex());

   220

		}

   221

	}

   222

   223

	return GetTown(index);

   224

}

   225

   226

void DestroyTown(Town *t);

   227

   228

static inline void DeleteTown(Town *t)

   229

{

   230

	DestroyTown(t);

   231

	t->xy = 0;

   232

}

   233

   234

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

   235

   236

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

   237

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

   238

   239

VARDEF bool _town_sort_dirty;

   240

VARDEF byte _town_sort_order;

   241

   242

VARDEF Town *_cleared_town;

   243

VARDEF int _cleared_town_rating;

   244

   245

#endif /* TOWN_H */