1

#ifndef PLAYER_H

     2

#define PLAYER_H

     3

     4

#include "aystar.h"

     5

     6

typedef struct PlayerEconomyEntry {

     7

	int32 income;

     8

	int32 expenses;

     9

	int32 delivered_cargo;

    10

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

    11

	int64 company_value;

    12

} PlayerEconomyEntry;

    13

    14

typedef struct AiBuildRec {

    15

	TileIndex spec_tile;

    16

	TileIndex use_tile;

    17

	byte rand_rng;

    18

	byte cur_building_rule;

    19

	byte unk6;

    20

	byte unk7;

    21

	byte buildcmd_a;

    22

	byte buildcmd_b;

    23

	byte direction;

    24

	byte cargo;

    25

} AiBuildRec;

    26

    27

typedef struct PlayerAI {

    28

	byte state;

    29

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

    30

	uint16 state_counter;

    31

	uint16 timeout_counter;

    32

    33

	byte state_mode;

    34

	byte banned_tile_count;

    35

	byte railtype_to_use;

    36

    37

	byte cargo_type;

    38

	byte num_wagons;

    39

	byte build_kind;

    40

	byte num_build_rec;

    41

	byte num_loco_to_build;

    42

	byte num_want_fullload;

    43

    44

	byte route_type_mask;

    45

    46

	TileIndex start_tile_a;

    47

	TileIndex cur_tile_a;

    48

	byte cur_dir_a;

    49

	byte start_dir_a;

    50

    51

	TileIndex start_tile_b;

    52

	TileIndex cur_tile_b;

    53

	byte cur_dir_b;

    54

	byte start_dir_b;

    55

    56

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

    57

    58

	AiBuildRec src, dst, mid1, mid2;

    59

    60

	VehicleID wagon_list[9];

    61

	byte order_list_blocks[20];

    62

    63

	TileIndex banned_tiles[16];

    64

	byte banned_val[16];

    65

} PlayerAI;

    66

    67

typedef struct Ai_PathFinderInfo {

    68

	TileIndex start_tile_tl; // tl = top-left

    69

	TileIndex start_tile_br; // br = bottom-right

    70

	TileIndex end_tile_tl; // tl = top-left

    71

	TileIndex end_tile_br; // br = bottom-right

    72

	byte start_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    73

	byte end_direction; // 0 to 3 or AI_PATHFINDER_NO_DIRECTION

    74

    75

	TileIndex route[500];

    76

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

    77

	int route_length;

    78

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

    79

    80

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

    81

} Ai_PathFinderInfo;

    82

    83

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

    84

#define AI_MAX_SPECIAL_VEHICLES 100

    85

    86

typedef struct Ai_SpecialVehicle {

    87

	VehicleID veh_id;

    88

	uint32 flag;

    89

} Ai_SpecialVehicle;

    90

    91

typedef struct PlayerAiNew {

    92

	uint8 state;

    93

	uint tick;

    94

	uint idle;

    95

    96

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

    97

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

    98

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

    99

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

   100

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

   101

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

   102

   103

	// Pathfinder stuff

   104

	Ai_PathFinderInfo path_info;

   105

	AyStar *pathfinder;

   106

   107

	// Route stuff

   108

   109

	byte cargo;

   110

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

   111

	int new_cost;

   112

   113

	byte action;

   114

   115

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

   116

	uint last_vehiclecheck_date; // Used in CheckVehicle

   117

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

   118

   119

	TileIndex from_tile;

   120

	TileIndex to_tile;

   121

   122

	byte from_direction;

   123

	byte to_direction;

   124

   125

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

   126

	bool to_deliver;

   127

   128

	TileIndex depot_tile;

   129

	byte depot_direction;

   130

   131

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

   132

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

   133

	VehicleID veh_id; // Used when bought a vehicle

   134

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

   135

   136

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

   137

	byte from_type; // AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   138

	int to_ic;

   139

	byte to_type;

   140

   141

} PlayerAiNew;

   142

   143

   144

   145

typedef struct Player {

   146

	uint32 name_2;

   147

	uint16 name_1;

   148

   149

	uint16 president_name_1;

   150

	uint32 president_name_2;

   151

   152

	uint32 face;

   153

   154

	int32 player_money;

   155

	int32 current_loan;

   156

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

   157

   158

	byte player_color;

   159

	byte player_money_fraction;

   160

	byte max_railtype;

   161

	byte block_preview;

   162

	byte index;

   163

   164

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

   165

   166

	TileIndex location_of_house;

   167

	TileIndex last_build_coordinate;

   168

   169

	byte share_owners[4];

   170

   171

	byte inaugurated_year;

   172

	byte num_valid_stat_ent;

   173

   174

	byte quarters_of_bankrupcy;

   175

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

   176

	int16 bankrupt_timeout;

   177

	int32 bankrupt_value;

   178

   179

	bool is_active;

   180

	byte is_ai;

   181

	PlayerAI ai;

   182

	PlayerAiNew ainew;

   183

   184

	int64 yearly_expenses[3][13];

   185

	PlayerEconomyEntry cur_economy;

   186

	PlayerEconomyEntry old_economy[24];

   187

} Player;

   188

   189

void ChangeOwnershipOfPlayerItems(byte old_player, byte new_player);

   190

void GetNameOfOwner(byte owner, uint tile);

   191

int64 CalculateCompanyValue(Player *p);

   192

void InvalidatePlayerWindows(Player *p);

   193

void AiDoGameLoop(Player *p);

   194

void UpdatePlayerMoney32(Player *p);

   195

#define DEREF_PLAYER(i) (&_players[i])

   196

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

   197

   198

#define MAX_PLAYERS 8

   199

VARDEF Player _players[MAX_PLAYERS];

   200

   201

#define IS_HUMAN_PLAYER(p) (!DEREF_PLAYER((byte)(p))->is_ai)

   202

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

   203

   204

typedef struct HighScore {

   205

	char company[100];

   206

	StringID title;

   207

	uint16 score;

   208

} HighScore;

   209

   210

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

   211

void SaveToHighScore(void);

   212

void LoadFromHighScore(void);

   213

int8 SaveHighScoreValue(const Player *p);

   214

int8 SaveHighScoreValueNetwork(void);

   215

   216

#endif /* PLAYER_H */