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

typedef uint32 PlayerFace;

    23

    24

enum {

    25

	/** The stepping in pounds for loans */

    26

	LOAN_INTERVAL = 10000,

    27

};

    28

    29

struct Player {

    30

	uint32 name_2;

    31

	uint16 name_1;

    32

    33

	uint16 president_name_1;

    34

	uint32 president_name_2;

    35

    36

	PlayerFace face;

    37

    38

	int32 player_money;

    39

	int32 current_loan;

    40

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

    41

    42

	byte player_color;

    43

	Livery livery[LS_END];

    44

	byte player_money_fraction;

    45

	byte avail_railtypes;

    46

	byte block_preview;

    47

	PlayerByte index;

    48

    49

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

    50

    51

	TileIndex location_of_house;

    52

	TileIndex last_build_coordinate;

    53

    54

	PlayerByte share_owners[4];

    55

    56

	Year inaugurated_year;

    57

	byte num_valid_stat_ent;

    58

    59

	byte quarters_of_bankrupcy;

    60

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

    61

	int16 bankrupt_timeout;

    62

	int32 bankrupt_value;

    63

    64

	bool is_active;

    65

	bool is_ai;

    67

    68

	int64 yearly_expenses[3][13];

    69

	PlayerEconomyEntry cur_economy;

    70

	PlayerEconomyEntry old_economy[24];

    71

	EngineRenewList engine_renew_list; ///< Defined later

    72

	bool engine_renew;

    73

	bool renew_keep_length;

    74

	int16 engine_renew_months;

    75

	uint32 engine_renew_money;

    76

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

    77

};

    78

    79

uint16 GetDrawStringPlayerColor(PlayerID player);

    80

    81

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

    82

void GetNameOfOwner(Owner owner, TileIndex tile);

    83

int64 CalculateCompanyValue(const Player* p);

    84

void InvalidatePlayerWindows(const Player* p);

    85

void UpdatePlayerMoney32(Player *p);

    86

void SetLocalPlayer(PlayerID new_player);

    87

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

    88

    89

VARDEF PlayerID _local_player;

    90

VARDEF PlayerID _current_player;

    91

    92

VARDEF Player _players[MAX_PLAYERS];

    93

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

    94

VARDEF byte _player_colors[MAX_PLAYERS];

    95

    96

static inline byte ActivePlayerCount()

    97

{

    98

	const Player *p;

    99

	byte count = 0;

   100

   101

	FOR_ALL_PLAYERS(p) {

   102

		if (p->is_active) count++;

   103

	}

   104

   105

	return count;

   106

}

   107

   108

static inline Player* GetPlayer(PlayerID i)

   109

{

   110

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

   111

	return &_players[i];

   112

}

   113

   114

static inline bool IsLocalPlayer()

   115

{

   116

	return _local_player == _current_player;

   117

}

   118

   119

static inline bool IsValidPlayer(PlayerID pi)

   120

{

   121

	return IS_INSIDE_1D(pi, PLAYER_FIRST, MAX_PLAYERS);

   122

}

   123

   124

byte GetPlayerRailtypes(PlayerID p);

   125

   126

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

   127

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

   128

{

   129

	return HASBIT(p->avail_railtypes, Railtype);

   130

}

   131

   132

static inline bool IsHumanPlayer(PlayerID pi)

   133

{

   134

	return !GetPlayer(pi)->is_ai;

   135

}

   136

   137

static inline bool IsInteractivePlayer(PlayerID pi)

   138

{

   139

	return pi == _local_player;

   140

}

   141

   142

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

   143

   144

/* Validate functions for rail building */

   145

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

   146

   147

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

   148

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

   149

 * here. When adding new railtypes, modify this function

   150

 * @param p the player "in action"

   151

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

   152

 */

   153

static inline RailType GetBestRailtype(const Player* p)

   154

{

   155

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

   156

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

   157

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

   158

	return RAILTYPE_RAIL;

   159

}

   160

   161

struct HighScore {

   162

	char company[100];

   163

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

   164

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

   165

};

   166

   167

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

   168

void SaveToHighScore();

   169

void LoadFromHighScore();

   170

int8 SaveHighScoreValue(const Player *p);

   171

int8 SaveHighScoreValueNetwork();

   172

   173

/* Engine Replacement Functions */

   174

   175

/**

   176

 * Remove all engine replacement settings for the given player.

   177

 * @param p Player.

   178

 */

   179

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

   180

   181

/**

   182

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

   183

 * @param p Player.

   184

 * @param engine Engine type.

   185

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

   186

 * replacement is in the list.

   187

 */

   188

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

   189

   190

/**

   191

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

   192

 * @param p Player.

   193

 * @param  engine Engine type to be replaced.

   194

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

   195

 */

   196

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

   197

   198

/**

   199

 * Add an engine replacement for the player.

   200

 * @param p Player.

   201

 * @param old_engine The original engine type.

   202

 * @param new_engine The replacement engine type.

   203

 * @param flags The calling command flags.

   204

 * @return 0 on success, CMD_ERROR on failure.

   205

 */

   206

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

   207

   208

/**

   209

 * Remove an engine replacement for the player.

   210

 * @param p Player.

   211

 * @param engine The original engine type.

   212

 * @param flags The calling command flags.

   213

 * @return 0 on success, CMD_ERROR on failure.

   214

 */

   215

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

   216

   217

/**

   218

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

   219

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

   220

 * @param p Player to reset.

   221

 */

   222

void ResetPlayerLivery(Player *p);

   223

   224

#endif /* PLAYER_H */