1

/* $Id$ */

     2

     3

#ifndef PLAYER_H

     4

#define PLAYER_H

     5

     6

#include "aystar.h"

     7

#include "rail.h"

     8

     9

typedef struct PlayerEconomyEntry {

    10

	int32 income;

    11

	int32 expenses;

    12

	int32 delivered_cargo;

    13

	int32 performance_history;	// player score (scale 0-1000)

    14

	int64 company_value;

    15

} PlayerEconomyEntry;

    16

    17

typedef struct AiBuildRec {

    18

	TileIndex spec_tile;

    19

	TileIndex use_tile;

    20

	byte rand_rng;

    21

	byte cur_building_rule;

    22

	byte unk6;

    23

	byte unk7;

    24

	byte buildcmd_a;

    25

	byte buildcmd_b;

    26

	byte direction;

    27

	byte cargo;

    28

} AiBuildRec;

    29

    30

typedef struct PlayerAI {

    31

	byte state;

    32

	byte tick; // Used to determine how often to move

    33

	uint32 state_counter; // Can hold tile index!

    34

	uint16 timeout_counter;

    35

    36

	byte state_mode;

    37

	byte banned_tile_count;

    38

	byte railtype_to_use;

    39

    40

	byte cargo_type;

    41

	byte num_wagons;

    42

	byte build_kind;

    43

	byte num_build_rec;

    44

	byte num_loco_to_build;

    45

	byte num_want_fullload;

    46

    47

	byte route_type_mask;

    48

    49

	TileIndex start_tile_a;

    50

	TileIndex cur_tile_a;

    51

	byte cur_dir_a;

    52

	byte start_dir_a;

    53

    54

	TileIndex start_tile_b;

    55

	TileIndex cur_tile_b;

    56

	byte cur_dir_b;

    57

	byte start_dir_b;

    58

    59

	Vehicle *cur_veh; /* only used by some states */

    60

    61

	AiBuildRec src, dst, mid1, mid2;

    62

    63

	VehicleID wagon_list[9];

    64

	byte order_list_blocks[20];

    65

    66

	TileIndex banned_tiles[16];

    67

	byte banned_val[16];

    68

} PlayerAI;

    69

    70

typedef struct Ai_PathFinderInfo {

    71

	TileIndex start_tile_tl; // tl = top-left

    72

	TileIndex start_tile_br; // br = bottom-right

    73

	TileIndex end_tile_tl; // tl = top-left

    74

	TileIndex end_tile_br; // br = bottom-right

    75

	byte start_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    76

	byte end_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    77

    78

	TileIndex route[500];

    79

	byte route_extra[500]; // Some extra information about the route like bridge/tunnel

    80

	int route_length;

    81

	int position; // Current position in the build-path, needed to build the path

    82

    83

	bool rail_or_road; // true = rail, false = road

    84

} Ai_PathFinderInfo;

    85

    86

// The amount of memory reserved for the AI-special-vehicles

    87

#define AI_MAX_SPECIAL_VEHICLES 100

    88

    89

typedef struct Ai_SpecialVehicle {

    90

	VehicleID veh_id;

    91

	uint32 flag;

    92

} Ai_SpecialVehicle;

    93

    94

typedef struct PlayerAiNew {

    95

	uint8 state;

    96

	uint tick;

    97

	uint idle;

    98

    99

	int temp; 	// A value used in more than one function, but it just temporary

   100

				// The use is pretty simple: with this we can 'think' about stuff

   101

				//   in more than one tick, and more than one AI. A static will not

   102

				//   do, because they are not saved. This way, the AI is almost human ;)

   103

	int counter; 	// For the same reason as temp, we have counter. It can count how

   104

					//  long we are trying something, and just abort if it takes too long

   105

   106

	// Pathfinder stuff

   107

	Ai_PathFinderInfo path_info;

   108

	AyStar *pathfinder;

   109

   110

	// Route stuff

   111

   112

	byte cargo;

   113

	byte tbt; // train/bus/truck 0/1/2 AI_TRAIN/AI_BUS/AI_TRUCK

   114

	int new_cost;

   115

   116

	byte action;

   117

   118

	int last_id; // here is stored the last id of the searched city/industry

   119

	uint last_vehiclecheck_date; // Used in CheckVehicle

   120

	Ai_SpecialVehicle special_vehicles[AI_MAX_SPECIAL_VEHICLES]; // Some vehicles have some special flags

   121

   122

	TileIndex from_tile;

   123

	TileIndex to_tile;

   124

   125

	byte from_direction;

   126

	byte to_direction;

   127

   128

	bool from_deliver; // True if this is the station that GIVES cargo

   129

	bool to_deliver;

   130

   131

	TileIndex depot_tile;

   132

	byte depot_direction;

   133

   134

	byte amount_veh; // How many vehicles we are going to build in this route

   135

	byte cur_veh; // How many vehicles did we bought?

   136

	VehicleID veh_id; // Used when bought a vehicle

   137

	VehicleID veh_main_id; // The ID of the first vehicle, for shared copy

   138

   139

	int from_ic; // ic = industry/city. This is the ID of them

   140

	byte from_type; // AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   141

	int to_ic;

   142

	byte to_type;

   143

   144

} PlayerAiNew;

   145

   146

   147

   148

typedef struct Player {

   149

	uint32 name_2;

   150

	uint16 name_1;

   151

   152

	uint16 president_name_1;

   153

	uint32 president_name_2;

   154

   155

	uint32 face;

   156

   157

	int32 player_money;

   158

	int32 current_loan;

   159

	int64 money64; // internal 64-bit version of the money. the 32-bit field will be clamped to plus minus 2 billion

   160

   161

	byte player_color;

   162

	byte player_money_fraction;

   163

	byte avail_railtypes;

   164

	byte block_preview;

   165

	PlayerID index;

   166

   167

	uint16 cargo_types; /* which cargo types were transported the last year */

   168

   169

	TileIndex location_of_house;

   170

	TileIndex last_build_coordinate;

   171

   172

	PlayerID share_owners[4];

   173

   174

	byte inaugurated_year;

   175

	byte num_valid_stat_ent;

   176

   177

	byte quarters_of_bankrupcy;

   178

	byte bankrupt_asked; // which players were asked about buying it?

   179

	int16 bankrupt_timeout;

   180

	int32 bankrupt_value;

   181

   182

	bool is_active;

   183

	byte is_ai;

   184

	PlayerAI ai;

   185

	PlayerAiNew ainew;

   186

   187

	int64 yearly_expenses[3][13];

   188

	PlayerEconomyEntry cur_economy;

   189

	PlayerEconomyEntry old_economy[24];

   190

	EngineID engine_replacement[256];

   191

	bool engine_renew;

   192

	int16 engine_renew_months;

   193

	uint32 engine_renew_money;

   194

} Player;

   195

   196

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

   197

void GetNameOfOwner(PlayerID owner, TileIndex tile);

   200

void UpdatePlayerMoney32(Player *p);

   201

#define FOR_ALL_PLAYERS(p) for(p=_players; p != endof(_players); p++)

   202

   203

VARDEF PlayerID _local_player;

   204

VARDEF PlayerID _current_player;

   205

   206

#define MAX_PLAYERS 8

   207

VARDEF Player _players[MAX_PLAYERS];

   208

// NOSAVE: can be determined from player structs

   209

VARDEF byte _player_colors[MAX_PLAYERS];

   210

   211

static inline Player* GetPlayer(PlayerID i)

   212

{

   213

	assert(i < lengthof(_players));

   214

	return &_players[i];

   215

}

   216

   217

static inline bool IsLocalPlayer(void)

   218

{

   219

	return _local_player == _current_player;

   220

}

   221

   222

/** Returns the number of rail types the player can build

   223

  * @param *p Player in question

   224

  */

   225

static inline int GetNumRailtypes(const Player *p)

   226

{

   227

	int num = 0;

   228

	int i;

   229

   230

	for (i = 0; i < (int)sizeof(p->avail_railtypes) * 8; i++)

   231

		if (HASBIT(p->avail_railtypes, i)) num++;

   232

   233

	assert(num <= RAILTYPE_END);

   234

	return num;

   235

}

   236

   237

byte GetPlayerRailtypes(int p);

   238

   239

/** Finds out if a Player has a certain railtype available

   240

  */

   241

static inline bool HasRailtypeAvail(const Player *p, RailType Railtype)

   242

{

   243

	return HASBIT(p->avail_railtypes, Railtype);

   244

}

   245

   246

/* Validate functions for rail building */

   247

static inline bool ValParamRailtype(uint32 rail) { return HASBIT(GetPlayer(_current_player)->avail_railtypes, rail);}

   248

   249

/** Returns the "best" railtype a player can build.

   250

  * As the AI doesn't know what the BEST one is, we

   251

  * have our own priority list here. When adding

   252

  * new railtypes, modify this function

   253

  * @param p the player "in action"

   254

  * @return The "best" railtype a player has available

   255

  */

   256

static inline byte GetBestRailtype(const Player *p)

   257

{

   258

	if (HasRailtypeAvail(p, RAILTYPE_MAGLEV)) return RAILTYPE_MAGLEV;

   259

	if (HasRailtypeAvail(p, RAILTYPE_MONO)) return RAILTYPE_MONO;

   260

	return RAILTYPE_RAIL;

   261

}

   262

   265

   266

typedef struct HighScore {

   267

	char company[100];

   268

	StringID title;

   269

	uint16 score;

   270

} HighScore;

   271

   272

VARDEF HighScore _highscore_table[5][5]; // 4 difficulty-settings (+ network); top 5

   273

void SaveToHighScore(void);

   274

void LoadFromHighScore(void);

   275

int8 SaveHighScoreValue(const Player *p);

   276

int8 SaveHighScoreValueNetwork(void);

   277

   278

#endif /* PLAYER_H */