1

/* $Id$ */

     2

     3

/** @file player.h */

     4

     5

#ifndef PLAYER_H

     6

#define PLAYER_H

     7

     8

#include "oldpool.h"

     9

#include "aystar.h"

    10

#include "rail.h"

    11

#include "engine.h"

    12

#include "livery.h"

    13

    14

struct PlayerEconomyEntry {

    15

	int32 income;

    16

	int32 expenses;

    17

	int32 delivered_cargo;

    18

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

    19

	int64 company_value;

    20

};

    21

    22

struct AiBuildRec {

    23

	TileIndex spec_tile;

    24

	TileIndex use_tile;

    25

	byte rand_rng;

    26

	byte cur_building_rule;

    27

	byte unk6;

    28

	byte unk7;

    29

	byte buildcmd_a;

    30

	byte buildcmd_b;

    31

	byte direction;

    32

	CargoID cargo;

    33

};

    34

    35

struct PlayerAI {

    36

	byte state;

    37

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

    38

	uint32 state_counter; ///< Can hold tile index!

    39

	uint16 timeout_counter;

    40

    41

	byte state_mode;

    42

	byte banned_tile_count;

    43

	RailTypeByte railtype_to_use;

    44

    45

	CargoID cargo_type;

    46

	byte num_wagons;

    47

	byte build_kind;

    48

	byte num_build_rec;

    49

	byte num_loco_to_build;

    50

	byte num_want_fullload;

    51

    52

	byte route_type_mask;

    53

    54

	TileIndex start_tile_a;

    55

	TileIndex cur_tile_a;

    56

	byte cur_dir_a;

    57

	byte start_dir_a;

    58

    59

	TileIndex start_tile_b;

    60

	TileIndex cur_tile_b;

    61

	byte cur_dir_b;

    62

	byte start_dir_b;

    63

    64

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

    65

    66

	AiBuildRec src, dst, mid1, mid2;

    67

    68

	VehicleID wagon_list[9];

    69

	byte order_list_blocks[20];

    70

    71

	TileIndex banned_tiles[16];

    72

	byte banned_val[16];

    73

};

    74

    75

struct Ai_PathFinderInfo {

    76

	TileIndex start_tile_tl; ///< tl = top-left

    77

	TileIndex start_tile_br; ///< br = bottom-right

    78

	TileIndex end_tile_tl;   ///< tl = top-left

    79

	TileIndex end_tile_br;   ///< br = bottom-right

    80

	byte start_direction;    ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    81

	byte end_direction;      ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    82

    83

	TileIndex route[500];

    84

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

    85

	int route_length;

    86

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

    87

    88

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

    89

};

    90

    91

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

    92

#define AI_MAX_SPECIAL_VEHICLES 100

    93

    94

struct Ai_SpecialVehicle {

    95

	VehicleID veh_id;

    96

	uint32 flag;

    97

};

    98

    99

struct PlayerAiNew {

   100

	uint8 state;

   101

	uint tick;

   102

	uint idle;

   103

   104

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

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

	/* Pathfinder stuff */

   112

	Ai_PathFinderInfo path_info;

   113

	AyStar *pathfinder;

   114

   115

	/* Route stuff */

   116

   117

	CargoID cargo;

   118

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

   119

	int new_cost;

   120

   121

	byte action;

   122

   123

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

   124

	Date last_vehiclecheck_date; // Used in CheckVehicle

   125

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

   126

   127

	TileIndex from_tile;

   128

	TileIndex to_tile;

   129

   130

	byte from_direction;

   131

	byte to_direction;

   132

   133

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

   134

	bool to_deliver;

   135

   136

	TileIndex depot_tile;

   137

	DiagDirectionByte depot_direction;

   138

   139

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

   140

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

   141

	VehicleID veh_id;      ///< Used when bought a vehicle

   142

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

   143

   144

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

   145

	byte from_type;        ///< AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   146

	int to_ic;

   147

	byte to_type;

   148

   149

};

   150

   151

   152

typedef uint32 PlayerFace;

   153

   154

struct Player {

   155

	uint32 name_2;

   156

	uint16 name_1;

   157

   158

	uint16 president_name_1;

   159

	uint32 president_name_2;

   160

   161

	PlayerFace face;

   162

   163

	int32 player_money;

   164

	int32 current_loan;

   165

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

   166

   167

	byte player_color;

   168

	Livery livery[LS_END];

   169

	byte player_money_fraction;

   170

	byte avail_railtypes;

   171

	byte block_preview;

   172

	PlayerByte index;

   173

   174

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

   175

   176

	TileIndex location_of_house;

   177

	TileIndex last_build_coordinate;

   178

   179

	PlayerByte share_owners[4];

   180

   181

	Year inaugurated_year;

   182

	byte num_valid_stat_ent;

   183

   184

	byte quarters_of_bankrupcy;

   185

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

   186

	int16 bankrupt_timeout;

   187

	int32 bankrupt_value;

   188

   189

	bool is_active;

   190

	bool is_ai;

   191

	PlayerAI ai;

   192

	PlayerAiNew ainew;

   193

   194

	int64 yearly_expenses[3][13];

   195

	PlayerEconomyEntry cur_economy;

   196

	PlayerEconomyEntry old_economy[24];

   197

	EngineRenewList engine_renew_list; ///< Defined later

   198

	bool engine_renew;

   199

	bool renew_keep_length;

   200

	int16 engine_renew_months;

   201

	uint32 engine_renew_money;

   202

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

   203

};

   204

   205

uint16 GetDrawStringPlayerColor(PlayerID player);

   206

   207

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

   208

void GetNameOfOwner(Owner owner, TileIndex tile);

   209

int64 CalculateCompanyValue(const Player* p);

   210

void InvalidatePlayerWindows(const Player* p);

   211

void UpdatePlayerMoney32(Player *p);

   212

void SetLocalPlayer(PlayerID new_player);

   213

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

   214

   215

VARDEF PlayerID _local_player;

   216

VARDEF PlayerID _current_player;

   217

   218

VARDEF Player _players[MAX_PLAYERS];

   219

/* NOSAVE: can be determined from player structs */

   220

VARDEF byte _player_colors[MAX_PLAYERS];

   221

   222

static inline byte ActivePlayerCount()

   223

{

   224

	const Player *p;

   225

	byte count = 0;

   226

   227

	FOR_ALL_PLAYERS(p) {

   228

		if (p->is_active) count++;

   229

	}

   230

   231

	return count;

   232

}

   233

   234

static inline Player* GetPlayer(PlayerID i)

   235

{

   236

	assert(IS_INSIDE_1D(i, PLAYER_FIRST, lengthof(_players)));

   237

	return &_players[i];

   238

}

   239

   240

static inline bool IsLocalPlayer()

   241

{

   242

	return _local_player == _current_player;

   243

}

   244

   245

static inline bool IsValidPlayer(PlayerID pi)

   246

{

   247

	return IS_INSIDE_1D(pi, PLAYER_FIRST, MAX_PLAYERS);

   248

}

   249

   250

byte GetPlayerRailtypes(PlayerID p);

   251

   252

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

   253

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

   254

{

   255

	return HASBIT(p->avail_railtypes, Railtype);

   256

}

   257

   258

static inline bool IsHumanPlayer(PlayerID pi)

   259

{

   260

	return !GetPlayer(pi)->is_ai;

   261

}

   262

   263

static inline bool IsInteractivePlayer(PlayerID pi)

   264

{

   265

	return pi == _local_player;

   266

}

   267

   268

void DrawPlayerIcon(PlayerID p, int x, int y);

   269

   270

/* Validate functions for rail building */

   271

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

   272

   273

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

   274

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

   275

 * here. When adding new railtypes, modify this function

   276

 * @param p the player "in action"

   277

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

   278

 */

   279

static inline RailType GetBestRailtype(const Player* p)

   280

{

   281

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

   282

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

   283

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

   284

	return RAILTYPE_RAIL;

   285

}

   286

   287

struct HighScore {

   288

	char company[100];

   289

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

   290

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

   291

};

   292

   293

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

   294

void SaveToHighScore();

   295

void LoadFromHighScore();

   296

int8 SaveHighScoreValue(const Player *p);

   297

int8 SaveHighScoreValueNetwork();

   298

   299

/* Engine Replacement Functions */

   300

   301

/**

   302

 * Remove all engine replacement settings for the given player.

   303

 * @param p Player.

   304

 */

   305

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

   306

   307

/**

   308

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

   309

 * @param p Player.

   310

 * @param engine Engine type.

   311

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

   312

 * replacement is in the list.

   313

 */

   314

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

   315

   316

/**

   317

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

   318

 * @param p Player.

   319

 * @param  engine Engine type to be replaced.

   320

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

   321

 */

   322

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

   323

   324

/**

   325

 * Add an engine replacement for the player.

   326

 * @param p Player.

   327

 * @param old_engine The original engine type.

   328

 * @param new_engine The replacement engine type.

   329

 * @param flags The calling command flags.

   330

 * @return 0 on success, CMD_ERROR on failure.

   331

 */

   332

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

   333

   334

/**

   335

 * Remove an engine replacement for the player.

   336

 * @param p Player.

   337

 * @param engine The original engine type.

   338

 * @param flags The calling command flags.

   339

 * @return 0 on success, CMD_ERROR on failure.

   340

 */

   341

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

   342

   343

/**

   344

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

   345

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

   346

 * @param p Player to reset.

   347

 */

   348

void ResetPlayerLivery(Player *p);

   349

   350

#endif /* PLAYER_H */