1

#ifndef TOWN_H

     2

#define TOWN_H

     3

     4

#include "player.h"

     5

     6

struct Town {

     7

	TileIndex xy;

     8

     9

	// Current population of people and amount of houses.

    10

	uint16 num_houses;

    11

	uint32 population;

    12

    13

	// Town name

    14

	uint16 townnametype;

    15

	uint32 townnameparts;

    16

    17

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

    18

	ViewportSign sign;

    19

    20

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

    21

	byte flags12;

    22

    23

	// Which players have a statue?

    24

	byte statues;

    25

    26

	// Sort index in listings

    27

	byte sort_index_obsolete;

    28

    29

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

    30

	byte have_ratings;

    31

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

    32

	uint8 exclusivity;	     // which player has exslusivity

    33

	uint8 exclusive_counter;     // months till the exclusivity expires

    34

	int16 ratings[MAX_PLAYERS];

    35

    36

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

    37

	uint16 max_pass;

    38

	uint16 max_mail;

    39

	uint16 new_max_pass;

    40

	uint16 new_max_mail;

    41

	uint16 act_pass;

    42

	uint16 act_mail;

    43

	uint16 new_act_pass;

    44

	uint16 new_act_mail;

    45

    46

	// Amount of passengers that were transported.

    47

	byte pct_pass_transported;

    48

	byte pct_mail_transported;

    49

    50

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

    51

	uint16 act_food;

    52

	uint16 act_water;

    53

	uint16 new_act_food;

    54

	uint16 new_act_water;

    55

    56

	// Time until we rebuild a house.

    57

	byte time_until_rebuild;

    58

    59

	// When to grow town next time.

    60

	byte grow_counter;

    61

	byte growth_rate;

    62

    63

	// Fund buildings program in action?

    64

	byte fund_buildings_months;

    65

    66

	// Fund road reconstruction in action?

    67

	byte road_build_months;

    68

    69

	// Index in town array

    70

	uint16 index;

    71

    72

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

    73

	uint16 radius[5];

    74

};

    75

    77

    78

void UpdateTownVirtCoord(Town *t);

    79

void InitializeTown();

    80

void ShowTownViewWindow(uint town);

    81

void DeleteTown(Town *t);

    82

void ExpandTown(Town *t);

    83

bool GrowTown(Town *t);

    84

Town *CreateRandomTown();

    85

    86

enum {

    87

	ROAD_REMOVE = 0,

    88

	UNMOVEABLE_REMOVE = 1,

    89

	TUNNELBRIDGE_REMOVE = 1,

    90

	INDUSTRY_REMOVE = 2

    91

};

    92

    93

enum {

    94

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

    95

	// MAXIMUM RATINGS BOUNDARIES

    96

	RATING_MINIMUM 		= -1000,

    97

	RATING_APPALLING 	= -400,

    98

	RATING_VERYPOOR 	= -200,

    99

	RATING_POOR 			= 0,

   100

	RATING_MEDIOCRE		= 200,

   101

	RATING_GOOD				= 400,

   102

	RATING_VERYGOOD		= 600,

   103

	RATING_EXCELLENT	= 800,

   104

	RATING_OUTSTANDING= 1000, 	// OUTSTANDING

   105

   106

	RATING_MAXIMUM = RATING_OUTSTANDING,

   107

   108

	// RATINGS AFFECTING NUMBERS

   109

	RATING_TREE_DOWN_STEP = -35,

   110

	RATING_TREE_MINIMUM = RATING_MINIMUM,

   111

	RATING_TREE_UP_STEP = 7,

   112

	RATING_TREE_MAXIMUM = 220,

   113

   114

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   115

	RATING_TUNNEL_BRIDGE_MINIMUM = 0,

   116

   117

	RATING_INDUSTRY_DOWN_STEP = -1500,

   118

	RATING_INDUSTRY_MINIMUM = RATING_MINIMUM,

   119

   120

	RATING_ROAD_DOWN_STEP = -50,

   121

	RATING_ROAD_MINIMUM = -100,

   122

	RATING_HOUSE_MINIMUM = RATING_MINIMUM,

   123

   124

	RATING_BRIBE_UP_STEP = 200,

   125

	RATING_BRIBE_MAXIMUM = 800,

   126

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

   127

};

   128

   129

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

   130

   131

VARDEF Town _towns[70];

   132

VARDEF uint _towns_size;

   133

   134

VARDEF uint16 *_town_sort;

   135

   136

static inline Town *GetTown(uint index)

   137

{

   138

	assert(index < _towns_size);

   139

	return &_towns[index];

   140

}

   141

   142

#define FOR_ALL_TOWNS(t) for(t = _towns; t != &_towns[_towns_size]; t++)

   143

   144

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

   145

   146

VARDEF bool _town_sort_dirty;

   147

VARDEF byte _town_sort_order;

   148

   149

VARDEF Town *_cleared_town;

   150

VARDEF int _cleared_town_rating;

   151

   152

#endif /* TOWN_H */