1

/* $Id$ */

     2

     3

#ifndef TOWN_H

     4

#define TOWN_H

     5

     6

#include "oldpool.h"

     7

#include "player.h"

     8

#include "functions.h"

     9

#include "helpers.hpp"

    10

    11

enum {

    12

	HOUSE_NO_CLASS   = 0,

    13

	NEW_HOUSE_OFFSET = 110,

    14

	HOUSE_MAX        = 512,

    15

	INVALID_TOWN     = 0xFFFF,

    16

	INVALID_HOUSE_ID = 0xFFFF,

    17

    18

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

    19

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

    20

	HOUSE_CLASS_MAX  = HOUSE_MAX - NEW_HOUSE_OFFSET + 1,

    21

};

    22

    23

enum BuildingFlags {

    24

	TILE_NO_FLAG         =       0,

    25

	TILE_SIZE_1x1        = 1U << 0,

    26

	TILE_NOT_SLOPED      = 1U << 1,

    27

	TILE_SIZE_2x1        = 1U << 2,

    28

	TILE_SIZE_1x2        = 1U << 3,

    29

	TILE_SIZE_2x2        = 1U << 4,

    30

	BUILDING_IS_ANIMATED = 1U << 5,

    31

	BUILDING_IS_CHURCH   = 1U << 6,

    32

	BUILDING_IS_STADIUM  = 1U << 7,

    33

	BUILDING_HAS_1_TILE  = TILE_SIZE_1x1 | TILE_SIZE_2x1 | TILE_SIZE_1x2 | TILE_SIZE_2x2,

    34

	BUILDING_2_TILES_X   = TILE_SIZE_2x1 | TILE_SIZE_2x2,

    35

	BUILDING_2_TILES_Y   = TILE_SIZE_1x2 | TILE_SIZE_2x2,

    36

	BUILDING_HAS_4_TILES = TILE_SIZE_2x2,

    37

};

    38

    39

DECLARE_ENUM_AS_BIT_SET(BuildingFlags)

    40

    41

enum HouseZones {                  ///< Bit  Value       Meaning

    42

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

    43

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

    44

	HZ_ZON2              = 0x0002,

    45

	HZ_ZON3              = 0x0004,

    46

	HZ_ZON4              = 0x0008,

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

};

    55

    56

DECLARE_ENUM_AS_BIT_SET(HouseZones)

    57

    58

enum HouseExtraFlags {

    59

	NO_EXTRA_FLAG            =       0,

    60

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

    61

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

    62

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

    63

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

    64

};

    65

    66

DECLARE_ENUM_AS_BIT_SET(HouseExtraFlags)

    67

    68

typedef uint16 HouseID;

    69

typedef uint16 HouseClassID;

    70

    71

struct BuildingCounts {

    72

	uint8 id_count[HOUSE_MAX];

    73

	uint8 class_count[HOUSE_CLASS_MAX];

    74

};

    75

    76

struct Town {

    77

	TileIndex xy;

    78

    79

	// Current population of people and amount of houses.

    80

	uint16 num_houses;

    81

	uint32 population;

    82

    83

	// Town name

    84

	uint16 townnametype;

    85

	uint32 townnameparts;

    86

    87

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

    88

	ViewportSign sign;

    89

    90

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

    91

	// bit 0 = Building funds received

    92

	// bit 1 = CHURCH

    93

	// bit 2 = STADIUM

    94

	byte flags12;

    95

    96

	// Which players have a statue?

    97

	byte statues;

    98

    99

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

   100

	byte have_ratings;

   101

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

   102

	PlayerByte exclusivity;        // which player has exslusivity

   103

	uint8 exclusive_counter;     // months till the exclusivity expires

   104

	int16 ratings[MAX_PLAYERS];

   105

   106

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

   107

	uint32 max_pass;

   108

	uint32 max_mail;

   109

	uint32 new_max_pass;

   110

	uint32 new_max_mail;

   111

	uint32 act_pass;

   112

	uint32 act_mail;

   113

	uint32 new_act_pass;

   114

	uint32 new_act_mail;

   115

   116

	// Amount of passengers that were transported.

   117

	byte pct_pass_transported;

   118

	byte pct_mail_transported;

   119

   120

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

   121

	uint16 act_food;

   122

	uint16 act_water;

   123

	uint16 new_act_food;

   124

	uint16 new_act_water;

   125

   126

	// Time until we rebuild a house.

   127

	byte time_until_rebuild;

   128

   129

	// When to grow town next time.

   130

	byte grow_counter;

   131

	byte growth_rate;

   132

   133

	// Fund buildings program in action?

   134

	byte fund_buildings_months;

   135

   136

	// Fund road reconstruction in action?

   137

	byte road_build_months;

   138

   139

	// Index in town array

   140

	TownID index;

   141

   142

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

   143

	uint16 radius[5];

   144

   145

	// NOSAVE: The number of each type of building in the town.

   146

	BuildingCounts building_counts;

   147

};

   148

   149

struct HouseSpec {

   150

	/* Standard properties */

   151

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

   152

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

   153

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

   154

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

   155

	StringID building_name;            ///< building name

   156

	uint16 remove_rating_decrease;     ///< rating decrease if removed

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

   164

	/* NewHouses properties */

   165

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

   166

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

   167

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

   168

	uint16 callback_mask;              ///< House callback flags

   169

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

   170

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

   171

	HouseExtraFlags extra_flags;       ///< some more flags

   172

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

   173

	byte animation_frames;             ///< number of animation frames

   174

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

   175

	byte processing_time;              ///< Periodic refresh multiplier

   176

   177

	/* grf file related properties*/

   178

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

   179

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

   180

};

   181

   182

VARDEF HouseSpec _house_specs[HOUSE_MAX];

   183

   184

uint32 GetWorldPopulation();

   185

   186

void UpdateTownVirtCoord(Town *t);

   187

void InitializeTown();

   188

void ShowTownViewWindow(TownID town);

   189

void ExpandTown(Town *t);

   190

Town *CreateRandomTown(uint attempts, uint size_mode);

   191

   192

enum {

   193

	ROAD_REMOVE = 0,

   194

	UNMOVEABLE_REMOVE = 1,

   195

	TUNNELBRIDGE_REMOVE = 1,

   196

	INDUSTRY_REMOVE = 2

   197

};

   198

   199

enum {

   200

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

   201

	// MAXIMUM RATINGS BOUNDARIES

   202

	RATING_MINIMUM     = -1000,

   203

	RATING_APPALLING   =  -400,

   204

	RATING_VERYPOOR    =  -200,

   205

	RATING_POOR        =     0,

   206

	RATING_MEDIOCRE    =   200,

   207

	RATING_GOOD        =   400,

   208

	RATING_VERYGOOD    =   600,

   209

	RATING_EXCELLENT   =   800,

   210

	RATING_OUTSTANDING =  1000,         // OUTSTANDING

   211

   212

	RATING_MAXIMUM = RATING_OUTSTANDING,

   213

   214

	// RATINGS AFFECTING NUMBERS

   215

	RATING_TREE_DOWN_STEP = -35,

   216

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   217

	RATING_TREE_UP_STEP   = 7,

   218

	RATING_TREE_MAXIMUM   = 220,

   219

   220

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   221

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   222

   223

	RATING_INDUSTRY_DOWN_STEP = -1500,

   224

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   225

   226

	RATING_ROAD_DOWN_STEP = -50,

   227

	RATING_ROAD_MINIMUM   = -100,

   228

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   229

   230

	RATING_BRIBE_UP_STEP = 200,

   231

	RATING_BRIBE_MAXIMUM = 800,

   232

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

   233

};

   234

   235

enum {

   236

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

   237

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

   238

 * are then scaled based on that. */

   239

	TOWN_GROWTH_FREQUENCY = 23,

   240

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

   241

	TOWN_HOUSE_COMPLETED  =  3,

   242

};

   243

   244

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

   245

 * IT simply states what bit is used for.

   246

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

   247

 * per town, NO MATTER the population of it.

   248

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

   249

 */

   250

enum {

   251

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

   252

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

   253

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

   254

};

   255

   256

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

   257

   258

VARDEF const Town** _town_sort;

   259

   260

DECLARE_OLD_POOL(Town, Town, 3, 8000)

   261

   262

static inline HouseSpec *GetHouseSpecs(HouseID house_id)

   263

{

   264

	assert(house_id < HOUSE_MAX);

   265

	return &_house_specs[house_id];

   266

}

   267

   268

/**

   269

 * Check if a Town really exists.

   270

 */

   271

static inline bool IsValidTown(const Town* town)

   272

{

   273

	return town->xy != 0;

   274

}

   275

   276

static inline bool IsValidTownID(TownID index)

   277

{

   278

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

   279

}

   280

   281

VARDEF uint _total_towns;

   282

   283

static inline TownID GetMaxTownIndex()

   284

{

   285

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

   286

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

   287

	 *  _really_ returns the highest index. Now it just returns

   288

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

   289

	 */

   290

	return GetTownPoolSize() - 1;

   291

}

   292

   293

static inline uint GetNumTowns()

   294

{

   295

	return _total_towns;

   296

}

   297

   298

/**

   299

 * Return a random valid town.

   300

 */

   301

static inline Town *GetRandomTown()

   302

{

   303

	int num = RandomRange(GetNumTowns());

   304

	TownID index = INVALID_TOWN;

   305

   306

	while (num >= 0) {

   307

		num--;

   308

   309

		index++;

   310

		/* Make sure we have a valid town */

   311

		while (!IsValidTownID(index)) {

   312

			index++;

   313

			assert(index <= GetMaxTownIndex());

   314

		}

   315

	}

   316

   317

	return GetTown(index);

   318

}

   319

   320

void DestroyTown(Town *t);

   321

   322

static inline void DeleteTown(Town *t)

   323

{

   324

	DestroyTown(t);

   325

	t->xy = 0;

   326

}

   327

   328

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

   329

   330

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

   331

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

   332

   333

VARDEF bool _town_sort_dirty;

   334

VARDEF byte _town_sort_order;

   335

   336

VARDEF Town *_cleared_town;

   337

VARDEF int _cleared_town_rating;

   338

   339

uint OriginalTileRandomiser(uint x, uint y);

   340

void ResetHouses();

   341

   342

void ClearTownHouse(Town *t, TileIndex tile);

   343

   344

#endif /* TOWN_H */