1

/* $Id$ */

     2

     3

#ifndef PLAYER_H

     4

#define PLAYER_H

     5

     6

#include "pool.h"

     7

#include "aystar.h"

     8

#include "rail.h"

     9

#include "engine.h"

    10

    11

typedef struct PlayerEconomyEntry {

    12

	int32 income;

    13

	int32 expenses;

    14

	int32 delivered_cargo;

    15

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

    16

	int64 company_value;

    17

} PlayerEconomyEntry;

    18

    19

typedef struct AiBuildRec {

    20

	TileIndex spec_tile;

    21

	TileIndex use_tile;

    22

	byte rand_rng;

    23

	byte cur_building_rule;

    24

	byte unk6;

    25

	byte unk7;

    26

	byte buildcmd_a;

    27

	byte buildcmd_b;

    28

	byte direction;

    29

	byte cargo;

    30

} AiBuildRec;

    31

    32

typedef struct PlayerAI {

    33

	byte state;

    34

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

    35

	uint32 state_counter; // Can hold tile index!

    36

	uint16 timeout_counter;

    37

    38

	byte state_mode;

    39

	byte banned_tile_count;

    40

	byte railtype_to_use;

    41

    42

	byte cargo_type;

    43

	byte num_wagons;

    44

	byte build_kind;

    45

	byte num_build_rec;

    46

	byte num_loco_to_build;

    47

	byte num_want_fullload;

    48

    49

	byte route_type_mask;

    50

    51

	TileIndex start_tile_a;

    52

	TileIndex cur_tile_a;

    53

	byte cur_dir_a;

    54

	byte start_dir_a;

    55

    56

	TileIndex start_tile_b;

    57

	TileIndex cur_tile_b;

    58

	byte cur_dir_b;

    59

	byte start_dir_b;

    60

    61

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

    62

    63

	AiBuildRec src, dst, mid1, mid2;

    64

    65

	VehicleID wagon_list[9];

    66

	byte order_list_blocks[20];

    67

    68

	TileIndex banned_tiles[16];

    69

	byte banned_val[16];

    70

} PlayerAI;

    71

    72

typedef struct Ai_PathFinderInfo {

    73

	TileIndex start_tile_tl; // tl = top-left

    74

	TileIndex start_tile_br; // br = bottom-right

    75

	TileIndex end_tile_tl; // tl = top-left

    76

	TileIndex end_tile_br; // br = bottom-right

    77

	byte start_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    78

	byte end_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    79

    80

	TileIndex route[500];

    81

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

    82

	int route_length;

    83

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

    84

    85

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

    86

} Ai_PathFinderInfo;

    87

    88

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

    89

#define AI_MAX_SPECIAL_VEHICLES 100

    90

    91

typedef struct Ai_SpecialVehicle {

    92

	VehicleID veh_id;

    93

	uint32 flag;

    94

} Ai_SpecialVehicle;

    95

    96

typedef struct PlayerAiNew {

    97

	uint8 state;

    98

	uint tick;

    99

	uint idle;

   100

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

   108

	// Pathfinder stuff

   109

	Ai_PathFinderInfo path_info;

   110

	AyStar *pathfinder;

   111

   112

	// Route stuff

   113

   114

	byte cargo;

   115

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

   116

	int new_cost;

   117

   118

	byte action;

   119

   120

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

   121

	uint last_vehiclecheck_date; // Used in CheckVehicle

   122

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

   123

   124

	TileIndex from_tile;

   125

	TileIndex to_tile;

   126

   127

	byte from_direction;

   128

	byte to_direction;

   129

   130

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

   131

	bool to_deliver;

   132

   133

	TileIndex depot_tile;

   134

	byte depot_direction;

   135

   136

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

   137

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

   138

	VehicleID veh_id; // Used when bought a vehicle

   139

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

   140

   141

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

   142

	byte from_type; // AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   143

	int to_ic;

   144

	byte to_type;

   145

   146

} PlayerAiNew;

   147

   148

   149

   150

typedef struct Player {

   151

	uint32 name_2;

   152

	uint16 name_1;

   153

   154

	uint16 president_name_1;

   155

	uint32 president_name_2;

   156

   157

	uint32 face;

   158

   159

	int32 player_money;

   160

	int32 current_loan;

   161

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

   162

   163

	byte player_color;

   164

	byte player_money_fraction;

   165

	byte avail_railtypes;

   166

	byte block_preview;

   167

	PlayerID index;

   168

   169

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

   170

   171

	TileIndex location_of_house;

   172

	TileIndex last_build_coordinate;

   173

   174

	PlayerID share_owners[4];

   175

   176

	byte inaugurated_year;

   177

	byte num_valid_stat_ent;

   178

   179

	byte quarters_of_bankrupcy;

   180

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

   181

	int16 bankrupt_timeout;

   182

	int32 bankrupt_value;

   183

   184

	bool is_active;

   185

	byte is_ai;

   186

	PlayerAI ai;

   187

	PlayerAiNew ainew;

   188

   189

	int64 yearly_expenses[3][13];

   190

	PlayerEconomyEntry cur_economy;

   191

	PlayerEconomyEntry old_economy[24];

   192

	EngineRenewList engine_renew_list; // Defined later

   193

	bool engine_renew;

   194

	bool renew_keep_length;

   195

	int16 engine_renew_months;

   196

	uint32 engine_renew_money;

   197

} Player;

   198

   199

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

   200

void GetNameOfOwner(PlayerID owner, TileIndex tile);

   201

int64 CalculateCompanyValue(const Player* p);

   202

void InvalidatePlayerWindows(const Player* p);

   203

void UpdatePlayerMoney32(Player *p);

   204

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

   205

   206

VARDEF PlayerID _local_player;

   207

VARDEF PlayerID _current_player;

   208

   209

#define MAX_PLAYERS 8

   210

VARDEF Player _players[MAX_PLAYERS];

   211

// NOSAVE: can be determined from player structs

   212

VARDEF byte _player_colors[MAX_PLAYERS];

   213

   214

byte ActivePlayerCount(void);

   215

   216

static inline Player* GetPlayer(PlayerID i)

   217

{

   218

	assert(i < lengthof(_players));

   219

	return &_players[i];

   220

}

   221

   222

static inline bool IsLocalPlayer(void)

   223

{

   224

	return _local_player == _current_player;

   225

}

   226

   227

void DeletePlayerWindows(PlayerID pi);

   228

byte GetPlayerRailtypes(PlayerID p);

   229

   230

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

   231

  */

   232

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

   233

{

   234

	return HASBIT(p->avail_railtypes, Railtype);

   235

}

   236

   237

/* Validate functions for rail building */

   238

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

   239

   240

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

   241

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

   242

  * have our own priority list here. When adding

   243

  * new railtypes, modify this function

   244

  * @param p the player "in action"

   245

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

   246

  */

   247

static inline RailType GetBestRailtype(const Player* p)

   248

{

   249

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

   250

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

   251

	return RAILTYPE_RAIL;

   252

}

   253

   254

#define IS_HUMAN_PLAYER(p) (!GetPlayer(p)->is_ai)

   255

#define IS_INTERACTIVE_PLAYER(p) ((p) == _local_player)

   256

   257

typedef struct HighScore {

   258

	char company[100];

   259

	StringID title; // NO_SAVE, has troubles with changing string-numbers.

   260

	uint16 score;   // do NOT change type, will break hs.dat

   261

} HighScore;

   262

   263

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

   264

void SaveToHighScore(void);

   265

void LoadFromHighScore(void);

   266

int8 SaveHighScoreValue(const Player *p);

   267

int8 SaveHighScoreValueNetwork(void);

   268

   269

/* Engine Replacement Functions */

   270

   271

/**

   272

 * Remove all engine replacement settings for the given player.

   273

 * @param p Player.

   274

 */

   275

static inline void RemoveAllEngineReplacementForPlayer(Player *p) { RemoveAllEngineReplacement(&p->engine_renew_list); }

   276

   277

/**

   278

 * Retrieve the engine replacement for the given player and original engine type.

   279

 * @param p Player.

   280

 * @param engine Engine type.

   281

 * @return The engine type to replace with, or INVALID_ENGINE if no

   282

 * replacement is in the list.

   283

 */

   284

static inline EngineID EngineReplacementForPlayer(const Player *p, EngineID engine) { return EngineReplacement(p->engine_renew_list, engine); }

   285

   286

/**

   287

 * Check if a player has a replacement set up for the given engine.

   288

 * @param p Player.

   289

 * @param  engine Engine type to be replaced.

   290

 * @return true if a replacement was set up, false otherwise.

   291

 */

   292

static inline bool EngineHasReplacementForPlayer(const Player *p, EngineID engine) { return EngineReplacementForPlayer(p, engine) != INVALID_ENGINE; }

   293

   294

/**

   295

 * Add an engine replacement for the player.

   296

 * @param p Player.

   297

 * @param old_engine The original engine type.

   298

 * @param new_engine The replacement engine type.

   299

 * @param flags The calling command flags.

   300

 * @return 0 on success, CMD_ERROR on failure.

   301

 */

   302

static inline int32 AddEngineReplacementForPlayer(Player *p, EngineID old_engine, EngineID new_engine, uint32 flags) { return AddEngineReplacement(&p->engine_renew_list, old_engine, new_engine, flags); }

   303

   304

/**

   305

 * Remove an engine replacement for the player.

   306

 * @param p Player.

   307

 * @param engine The original engine type.

   308

 * @param flags The calling command flags.

   309

 * @return 0 on success, CMD_ERROR on failure.

   310

 */

   311

static inline int32 RemoveEngineReplacementForPlayer(Player *p, EngineID engine, uint32 flags) {return RemoveEngineReplacement(&p->engine_renew_list, engine, flags); }

   312

   313

#endif /* PLAYER_H */