1

/* $Id$ */

     2

     3

/** @file player.h */

     4

     5

#ifndef PLAYER_H

     6

#define PLAYER_H

     7

     8

#include "road_type.h"

     9

#include "rail_type.h"

    10

#include "date_type.h"

    11

#include "engine.h"

    12

#include "livery.h"

    13

#include "autoreplace_type.h"

    14

#include "economy_type.h"

    15

#include "tile_type.h"

    16

    17

struct PlayerEconomyEntry {

    18

	Money income;

    19

	Money expenses;

    20

	int32 delivered_cargo;

    21

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

    22

	Money company_value;

    23

};

    24

    25

/* The "steps" in loan size, in British Pounds! */

    26

enum {

    27

	LOAN_INTERVAL        = 10000,

    28

	LOAN_INTERVAL_OLD_AI = 50000,

    29

};

    30

    31

struct Player {

    32

	uint32 name_2;

    33

	uint16 name_1;

    34

    35

	uint16 president_name_1;

    36

	uint32 president_name_2;

    37

    38

	PlayerFace face;

    39

    40

	Money player_money;

    41

	Money current_loan;

    42

    43

	byte player_color;

    44

	Livery livery[LS_END];

    45

	byte player_money_fraction;

    46

	RailTypes avail_railtypes;

    47

	RoadTypes avail_roadtypes;

    48

	byte block_preview;

    49

	PlayerByte index;

    50

    51

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

    52

    53

	TileIndex location_of_house;

    54

	TileIndex last_build_coordinate;

    55

    56

	PlayerByte share_owners[4];

    57

    58

	Year inaugurated_year;

    59

	byte num_valid_stat_ent;

    60

    61

	byte quarters_of_bankrupcy;

    62

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

    63

	int16 bankrupt_timeout;

    64

	Money bankrupt_value;

    65

    66

	bool is_active;

    67

	bool is_ai;

    68

    69

	Money yearly_expenses[3][13];

    70

	PlayerEconomyEntry cur_economy;

    71

	PlayerEconomyEntry old_economy[24];

    72

	EngineRenewList engine_renew_list; ///< Defined later

    73

	bool engine_renew;

    74

	bool renew_keep_length;

    75

	int16 engine_renew_months;

    76

	uint32 engine_renew_money;

    77

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

    78

};

    79

    80

uint16 GetDrawStringPlayerColor(PlayerID player);

    81

    82

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

    83

void GetNameOfOwner(Owner owner, TileIndex tile);

    84

Money CalculateCompanyValue(const Player *p);

    85

void InvalidatePlayerWindows(const Player *p);

    86

void SetLocalPlayer(PlayerID new_player);

    87

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

    88

    89

VARDEF PlayerByte _local_player;

    90

VARDEF PlayerByte _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(IsInsideBS(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 IsInsideBS(pi, PLAYER_FIRST, MAX_PLAYERS);

   122

}

   123

   124

static inline bool IsHumanPlayer(PlayerID pi)

   125

{

   126

	return !GetPlayer(pi)->is_ai;

   127

}

   128

   129

static inline bool IsInteractivePlayer(PlayerID pi)

   130

{

   131

	return pi == _local_player;

   132

}

   133

   134

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

   135

   136

struct HighScore {

   137

	char company[100];

   138

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

   139

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

   140

};

   141

   142

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

   143

void SaveToHighScore();

   144

void LoadFromHighScore();

   145

int8 SaveHighScoreValue(const Player *p);

   146

int8 SaveHighScoreValueNetwork();

   147

   148

/**

   149

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

   150

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

   151

 * @param p Player to reset.

   152

 */

   153

void ResetPlayerLivery(Player *p);

   154

   155

#endif /* PLAYER_H */