1

/* $Id$ */

     2

     3

#ifndef PLAYER_H

     4

#define PLAYER_H

     5

     6

#include "oldpool.h"

     7

#include "aystar.h"

     8

#include "rail.h"

     9

#include "engine.h"

    10

#include "livery.h"

    11

    12

typedef struct PlayerEconomyEntry {

    13

	int32 income;

    14

	int32 expenses;

    15

	int32 delivered_cargo;

    16

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

    17

	int64 company_value;

    18

} PlayerEconomyEntry;

    19

    20

typedef struct AiBuildRec {

    21

	TileIndex spec_tile;

    22

	TileIndex use_tile;

    23

	byte rand_rng;

    24

	byte cur_building_rule;

    25

	byte unk6;

    26

	byte unk7;

    27

	byte buildcmd_a;

    28

	byte buildcmd_b;

    29

	byte direction;

    30

	CargoID cargo;

    31

} AiBuildRec;

    32

    33

typedef struct PlayerAI {

    34

	byte state;

    35

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

    36

	uint32 state_counter; // Can hold tile index!

    37

	uint16 timeout_counter;

    38

    39

	byte state_mode;

    40

	byte banned_tile_count;

    41

	byte railtype_to_use;

    42

    43

	CargoID cargo_type;

    44

	byte num_wagons;

    45

	byte build_kind;

    46

	byte num_build_rec;

    47

	byte num_loco_to_build;

    48

	byte num_want_fullload;

    49

    50

	byte route_type_mask;

    51

    52

	TileIndex start_tile_a;

    53

	TileIndex cur_tile_a;

    54

	byte cur_dir_a;

    55

	byte start_dir_a;

    56

    57

	TileIndex start_tile_b;

    58

	TileIndex cur_tile_b;

    59

	byte cur_dir_b;

    60

	byte start_dir_b;

    61

    62

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

    63

    64

	AiBuildRec src, dst, mid1, mid2;

    65

    66

	VehicleID wagon_list[9];

    67

	byte order_list_blocks[20];

    68

    69

	TileIndex banned_tiles[16];

    70

	byte banned_val[16];

    71

} PlayerAI;

    72

    73

typedef struct Ai_PathFinderInfo {

    74

	TileIndex start_tile_tl; // tl = top-left

    75

	TileIndex start_tile_br; // br = bottom-right

    76

	TileIndex end_tile_tl;   // tl = top-left

    77

	TileIndex end_tile_br;   // br = bottom-right

    78

	byte start_direction;    // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    79

	byte end_direction;      // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    80

    81

	TileIndex route[500];

    82

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

    83

	int route_length;

    84

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

    85

    86

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

    87

} Ai_PathFinderInfo;

    88

    89

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

    90

#define AI_MAX_SPECIAL_VEHICLES 100

    91

    92

typedef struct Ai_SpecialVehicle {

    93

	VehicleID veh_id;

    94

	uint32 flag;

    95

} Ai_SpecialVehicle;

    96

    97

typedef struct PlayerAiNew {

    98

	uint8 state;

    99

	uint tick;

   100

	uint idle;

   101

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

	// Pathfinder stuff

   110

	Ai_PathFinderInfo path_info;

   111

	AyStar *pathfinder;

   112

   113

	// Route stuff

   114

   115

	CargoID cargo;

   116

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

   117

	int new_cost;

   118

   119

	byte action;

   120

   121

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

   122

	Date last_vehiclecheck_date; // Used in CheckVehicle

   123

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

   124

   125

	TileIndex from_tile;

   126

	TileIndex to_tile;

   127

   128

	byte from_direction;

   129

	byte to_direction;

   130

   131

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

   132

	bool to_deliver;

   133

   134

	TileIndex depot_tile;

   135

	byte depot_direction;

   136

   137

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

   138

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

   139

	VehicleID veh_id;      // Used when bought a vehicle

   140

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

   141

   142

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

   143

	byte from_type;        // AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   144

	int to_ic;

   145

	byte to_type;

   146

   147

} PlayerAiNew;

   148

   149

   150

   151

typedef struct Player {

   152

	uint32 name_2;

   153

	uint16 name_1;

   154

   155

	uint16 president_name_1;

   156

	uint32 president_name_2;

   157

   158

	uint32 face;

   159

   160

	int32 player_money;

   161

	int32 current_loan;

   162

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

   163

   164

	byte player_color;

   165

	Livery livery[LS_END];

   166

	byte player_money_fraction;

   167

	byte avail_railtypes;

   168

	byte block_preview;

   169

	PlayerID index;

   170

   171

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

   172

   173

	TileIndex location_of_house;

   174

	TileIndex last_build_coordinate;

   175

   176

	PlayerID share_owners[4];

   177

   178

	Year inaugurated_year;

   179

	byte num_valid_stat_ent;

   180

   181

	byte quarters_of_bankrupcy;

   182

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

   183

	int16 bankrupt_timeout;

   184

	int32 bankrupt_value;

   185

   186

	bool is_active;

   187

	bool is_ai;

   188

	PlayerAI ai;

   189

	PlayerAiNew ainew;

   190

   191

	int64 yearly_expenses[3][13];

   192

	PlayerEconomyEntry cur_economy;

   193

	PlayerEconomyEntry old_economy[24];

   194

	EngineRenewList engine_renew_list; // Defined later

   195

	bool engine_renew;

   196

	bool renew_keep_length;

   197

	int16 engine_renew_months;

   198

	uint32 engine_renew_money;

   199

	uint16 num_engines[TOTAL_NUM_ENGINES]; // caches the number of engines of each type the player owns (no need to save this)

   200

} Player;

   201

   202

uint16 GetDrawStringPlayerColor(PlayerID player);

   203

   204

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

   205

void GetNameOfOwner(Owner owner, TileIndex tile);

   206

int64 CalculateCompanyValue(const Player* p);

   207

void InvalidatePlayerWindows(const Player* p);

   208

void UpdatePlayerMoney32(Player *p);

   209

void SetLocalPlayer(PlayerID new_player);

   210

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

   211

   212

VARDEF PlayerID _local_player;

   213

VARDEF PlayerID _current_player;

   214

   215

/* Player identifiers All players below MAX_PLAYERS are playable

   216

 * players, above, they are special, computer controlled players */

   217

enum Players {

   218

	PLAYER_INACTIVE_CLIENT = 253,

   219

	PLAYER_NEW_COMPANY = 254, ///< Command 'player' in Multiplayer to create a new company

   220

	PLAYER_SPECTATOR   = 255, ///< Spectator in Multiplayer or the player in the scenario editor

   221

	MAX_PLAYERS        = 8,

   222

};

   223

   224

VARDEF Player _players[MAX_PLAYERS];

   225

// NOSAVE: can be determined from player structs

   226

VARDEF byte _player_colors[MAX_PLAYERS];

   227

   228

static inline byte ActivePlayerCount(void)

   229

{

   230

	const Player *p;

   231

	byte count = 0;

   232

   233

	FOR_ALL_PLAYERS(p) {

   234

		if (p->is_active) count++;

   235

	}

   236

   237

	return count;

   238

}

   239

   240

static inline Player* GetPlayer(PlayerID i)

   241

{

   242

	assert(i < lengthof(_players));

   243

	return &_players[i];

   244

}

   245

   246

static inline bool IsLocalPlayer(void)

   247

{

   248

	return _local_player == _current_player;

   249

}

   250

   251

static inline bool IsValidPlayer(PlayerID pi)

   252

{

   253

	return pi < MAX_PLAYERS;

   254

}

   255

   256

byte GetPlayerRailtypes(PlayerID p);

   257

   258

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

   259

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

   260

{

   261

	return HASBIT(p->avail_railtypes, Railtype);

   262

}

   263

   264

static inline bool IsHumanPlayer(PlayerID pi)

   265

{

   266

	return !GetPlayer(pi)->is_ai;

   267

}

   268

   269

static inline bool IsInteractivePlayer(PlayerID pi)

   270

{

   271

	return pi == _local_player;

   272

}

   273

   274

/* Validate functions for rail building */

   275

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

   276

   277

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

   278

 * As the AI doesn't know what the BEST one is, we have our own priority list

   279

 * here. When adding new railtypes, modify this function

   280

 * @param p the player "in action"

   281

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

   282

 */

   283

static inline RailType GetBestRailtype(const Player* p)

   284

{

   285

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

   286

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

   287

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

   288

	return RAILTYPE_RAIL;

   289

}

   290

   291

typedef struct HighScore {

   292

	char company[100];

   293

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

   294

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

   295

} HighScore;

   296

   297

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

   298

void SaveToHighScore(void);

   299

void LoadFromHighScore(void);

   300

int8 SaveHighScoreValue(const Player *p);

   301

int8 SaveHighScoreValueNetwork(void);

   302

   303

/* Engine Replacement Functions */

   304

   305

/**

   306

 * Remove all engine replacement settings for the given player.

   307

 * @param p Player.

   308

 */

   309

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

   310

   311

/**

   312

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

   313

 * @param p Player.

   314

 * @param engine Engine type.

   315

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

   316

 * replacement is in the list.

   317

 */

   318

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

   319

   320

/**

   321

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

   322

 * @param p Player.

   323

 * @param  engine Engine type to be replaced.

   324

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

   325

 */

   326

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

   327

   328

/**

   329

 * Add an engine replacement for the player.

   330

 * @param p Player.

   331

 * @param old_engine The original engine type.

   332

 * @param new_engine The replacement engine type.

   333

 * @param flags The calling command flags.

   334

 * @return 0 on success, CMD_ERROR on failure.

   335

 */

   336

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); }

   337

   338

/**

   339

 * Remove an engine replacement for the player.

   340

 * @param p Player.

   341

 * @param engine The original engine type.

   342

 * @param flags The calling command flags.

   343

 * @return 0 on success, CMD_ERROR on failure.

   344

 */

   345

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

   346

   347

/**

   348

 * Reset the livery schemes to the player's primary colour.

   349

 * This is used on loading games without livery information and on new player start up.

   350

 * @param p Player to reset.

   351

 */

   352

void ResetPlayerLivery(Player *p);

   353

   354

#endif /* PLAYER_H */