1

/* $Id$ */

     2

     3

#ifndef TOWN_H

     4

#define TOWN_H

     5

     6

#include "pool.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

	byte flags12;

    25

    26

	// Which players have a statue?

    27

	byte statues;

    28

    29

	// Sort index in listings

    30

	byte sort_index_obsolete;

    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 DeleteTown(Town *t);

    85

void ExpandTown(Town *t);

    86

Town *CreateRandomTown(uint attempts);

    87

    88

enum {

    89

	ROAD_REMOVE = 0,

    90

	UNMOVEABLE_REMOVE = 1,

    91

	TUNNELBRIDGE_REMOVE = 1,

    92

	INDUSTRY_REMOVE = 2

    93

};

    94

    95

enum {

    96

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

    97

	// MAXIMUM RATINGS BOUNDARIES

    98

	RATING_MINIMUM 		= -1000,

    99

	RATING_APPALLING 	= -400,

   100

	RATING_VERYPOOR 	= -200,

   101

	RATING_POOR 			= 0,

   102

	RATING_MEDIOCRE		= 200,

   103

	RATING_GOOD				= 400,

   104

	RATING_VERYGOOD		= 600,

   105

	RATING_EXCELLENT	= 800,

   106

	RATING_OUTSTANDING= 1000, 	// OUTSTANDING

   107

   108

	RATING_MAXIMUM = RATING_OUTSTANDING,

   109

   110

	// RATINGS AFFECTING NUMBERS

   111

	RATING_TREE_DOWN_STEP = -35,

   112

	RATING_TREE_MINIMUM = RATING_MINIMUM,

   113

	RATING_TREE_UP_STEP = 7,

   114

	RATING_TREE_MAXIMUM = 220,

   115

   116

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   117

	RATING_TUNNEL_BRIDGE_MINIMUM = 0,

   118

   119

	RATING_INDUSTRY_DOWN_STEP = -1500,

   120

	RATING_INDUSTRY_MINIMUM = RATING_MINIMUM,

   121

   122

	RATING_ROAD_DOWN_STEP = -50,

   123

	RATING_ROAD_MINIMUM = -100,

   124

	RATING_HOUSE_MINIMUM = RATING_MINIMUM,

   125

   126

	RATING_BRIBE_UP_STEP = 200,

   127

	RATING_BRIBE_MAXIMUM = 800,

   128

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

   129

};

   130

   131

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

   132

   133

VARDEF TownID *_town_sort;

   134

   135

extern MemoryPool _town_pool;

   136

   137

/**

   138

 * Check if a Town really exists.

   139

 */

   140

static inline bool IsValidTown(const Town* town)

   141

{

   142

	return town->xy != 0; /* XXX: Replace by INVALID_TILE someday */

   143

}

   144

   145

/**

   146

 * Get the pointer to the town with index 'index'

   147

 */

   148

static inline Town *GetTown(uint index)

   149

{

   150

	return (Town*)GetItemFromPool(&_town_pool, index);

   151

}

   152

   153

/**

   154

 * Get the current size of the TownPool

   155

 */

   156

static inline uint16 GetTownPoolSize(void)

   157

{

   158

	return _town_pool.total_items;

   159

}

   160

   161

static inline bool IsTownIndex(uint index)

   162

{

   163

	return index < GetTownPoolSize();

   164

}

   165

   166

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

   167

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

   168

   169

VARDEF uint _total_towns; // For the AI: the amount of towns active

   170

   171

VARDEF bool _town_sort_dirty;

   172

VARDEF byte _town_sort_order;

   173

   174

VARDEF Town *_cleared_town;

   175

VARDEF int _cleared_town_rating;

   176

   177

#endif /* TOWN_H */