1

/* $Id$ */

     2

     3

#ifndef TOWN_H

     4

#define TOWN_H

     5

     6

#include "oldpool.h"

     7

#include "player.h"

     8

     9

struct Town {

    10

	TileIndex xy;

    11

    12

	// Current population of people and amount of houses.

    13

	uint16 num_houses;

    14

	uint32 population;

    15

    16

	// Town name

    17

	uint16 townnametype;

    18

	uint32 townnameparts;

    19

    20

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

    21

	ViewportSign sign;

    22

    23

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

    24

	// bit 0 = Building funds received

    25

	// bit 1 = CHURCH

    26

	// bit 2 = STADIUM

    27

	byte flags12;

    28

    29

	// Which players have a statue?

    30

	byte statues;

    31

    32

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

    33

	byte have_ratings;

    34

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

    35

	PlayerID exclusivity;        // which player has exslusivity

    36

	uint8 exclusive_counter;     // months till the exclusivity expires

    37

	int16 ratings[MAX_PLAYERS];

    38

    39

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

    40

	uint32 max_pass;

    41

	uint32 max_mail;

    42

	uint32 new_max_pass;

    43

	uint32 new_max_mail;

    44

	uint32 act_pass;

    45

	uint32 act_mail;

    46

	uint32 new_act_pass;

    47

	uint32 new_act_mail;

    48

    49

	// Amount of passengers that were transported.

    50

	byte pct_pass_transported;

    51

	byte pct_mail_transported;

    52

    53

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

    54

	uint16 act_food;

    55

	uint16 act_water;

    56

	uint16 new_act_food;

    57

	uint16 new_act_water;

    58

    59

	// Time until we rebuild a house.

    60

	byte time_until_rebuild;

    61

    62

	// When to grow town next time.

    63

	byte grow_counter;

    64

	byte growth_rate;

    65

    66

	// Fund buildings program in action?

    67

	byte fund_buildings_months;

    68

    69

	// Fund road reconstruction in action?

    70

	byte road_build_months;

    71

    72

	// Index in town array

    73

	TownID index;

    74

    75

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

    76

	uint16 radius[5];

    77

};

    78

    79

uint32 GetWorldPopulation(void);

    80

    81

void UpdateTownVirtCoord(Town *t);

    82

void InitializeTown(void);

    83

void ShowTownViewWindow(TownID town);

    84

void ExpandTown(Town *t);

    85

Town *CreateRandomTown(uint attempts, uint size_mode);

    86

    87

enum {

    88

	ROAD_REMOVE = 0,

    89

	UNMOVEABLE_REMOVE = 1,

    90

	TUNNELBRIDGE_REMOVE = 1,

    91

	INDUSTRY_REMOVE = 2

    92

};

    93

    94

enum {

    95

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

    96

	// MAXIMUM RATINGS BOUNDARIES

    97

	RATING_MINIMUM     = -1000,

    98

	RATING_APPALLING   =  -400,

    99

	RATING_VERYPOOR    =  -200,

   100

	RATING_POOR        =     0,

   101

	RATING_MEDIOCRE    =   200,

   102

	RATING_GOOD        =   400,

   103

	RATING_VERYGOOD    =   600,

   104

	RATING_EXCELLENT   =   800,

   105

	RATING_OUTSTANDING =  1000,         // OUTSTANDING

   106

   107

	RATING_MAXIMUM = RATING_OUTSTANDING,

   108

   109

	// RATINGS AFFECTING NUMBERS

   110

	RATING_TREE_DOWN_STEP = -35,

   111

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   112

	RATING_TREE_UP_STEP   = 7,

   113

	RATING_TREE_MAXIMUM   = 220,

   114

   115

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   116

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   117

   118

	RATING_INDUSTRY_DOWN_STEP = -1500,

   119

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   120

   121

	RATING_ROAD_DOWN_STEP = -50,

   122

	RATING_ROAD_MINIMUM   = -100,

   123

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   124

   125

	RATING_BRIBE_UP_STEP = 200,

   126

	RATING_BRIBE_MAXIMUM = 800,

   127

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

   128

};

   129

   130

enum {

   131

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

   132

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

   133

 * are then scaled based on that. */

   134

	TOWN_GROWTH_FREQUENCY = 23,

   135

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

   136

	TOWN_HOUSE_COMPLETED  =  3,

   137

};

   138

   139

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

   140

 * IT simply states what bit is used for.

   141

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

   142

 * per town, NO MATTER the population of it.

   143

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

   144

 */

   145

enum {

   146

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

   147

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

   148

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

   149

};

   150

   151

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

   152

   153

VARDEF const Town** _town_sort;

   154

   155

DECLARE_OLD_POOL(Town, Town, 3, 8000)

   156

   157

/**

   158

 * Check if a Town really exists.

   159

 */

   160

static inline bool IsValidTown(const Town* town)

   161

{

   162

	return town->xy != 0;

   163

}

   164

   165

VARDEF uint _total_towns;

   166

   167

static inline TownID GetMaxTownIndex(void)

   168

{

   169

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

   170

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

   171

	 *  _really_ returns the highest index. Now it just returns

   172

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

   173

	 */

   174

	return _total_towns - 1;

   175

}

   176

   177

static inline uint GetNumTowns(void)

   178

{

   179

	return _total_towns;

   180

}

   181

   182

/**

   183

 * Return a random valid town.

   184

 */

   185

static inline Town *GetRandomTown(void)

   186

{

   187

	uint num = RandomRange(GetNumTowns());

   188

	uint index = 0;

   189

   190

	while (num > 0) {

   191

		num--;

   192

   193

		index++;

   194

		/* Make sure we have a valid industry */

   195

		while (GetTown(index) == NULL) {

   196

			index++;

   197

			if (index > GetMaxTownIndex()) index = 0;

   198

		}

   199

	}

   200

   201

	return GetTown(index);

   202

}

   203

   204

static inline bool IsValidTownID(uint index)

   205

{

   206

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

   207

}

   208

   209

void DestroyTown(Town *t);

   210

   211

static inline void DeleteTown(Town *t)

   212

{

   213

	DestroyTown(t);

   214

	t->xy = 0;

   215

}

   216

   217

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

   218

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

   219

   220

VARDEF bool _town_sort_dirty;

   221

VARDEF byte _town_sort_order;

   222

   223

VARDEF Town *_cleared_town;

   224

VARDEF int _cleared_town_rating;

   225

   226

#endif /* TOWN_H */