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_type.h"

    11

#include "road_func.h"

    12

#include "cargo_type.h"

    13

#include "command_type.h"

    14

#include "engine.h"

    15

#include "livery.h"

    16

#include "genworld.h"

    17

    18

struct PlayerEconomyEntry {

    19

	Money income;

    20

	Money expenses;

    21

	int32 delivered_cargo;

    22

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

    23

	Money company_value;

    24

};

    25

    26

struct AiBuildRec {

    27

	TileIndex spec_tile;

    28

	TileIndex use_tile;

    29

	byte rand_rng;

    30

	byte cur_building_rule;

    31

	byte unk6;

    32

	byte unk7;

    33

	byte buildcmd_a;

    34

	byte buildcmd_b;

    35

	byte direction;

    36

	CargoID cargo;

    37

};

    38

    39

struct PlayerAI {

    40

	byte state;

    41

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

    42

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

    43

	uint16 timeout_counter;

    44

    45

	byte state_mode;

    46

	byte banned_tile_count;

    47

	RailTypeByte railtype_to_use;

    48

    49

	CargoID cargo_type;

    50

	byte num_wagons;

    51

	byte build_kind;

    52

	byte num_build_rec;

    53

	byte num_loco_to_build;

    54

	byte num_want_fullload;

    55

    56

	byte route_type_mask;

    57

    58

	TileIndex start_tile_a;

    59

	TileIndex cur_tile_a;

    60

	DiagDirectionByte cur_dir_a;

    61

	DiagDirectionByte start_dir_a;

    62

    63

	TileIndex start_tile_b;

    64

	TileIndex cur_tile_b;

    65

	DiagDirectionByte cur_dir_b;

    66

	DiagDirectionByte start_dir_b;

    67

    68

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

    69

    70

	AiBuildRec src, dst, mid1, mid2;

    71

    72

	VehicleID wagon_list[9];

    73

	byte order_list_blocks[20];

    74

    75

	TileIndex banned_tiles[16];

    76

	byte banned_val[16];

    77

};

    78

    79

struct Ai_PathFinderInfo {

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

    87

	TileIndex route[500];

    88

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

    89

	int route_length;

    90

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

    91

    92

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

    93

};

    94

    95

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

    96

#define AI_MAX_SPECIAL_VEHICLES 100

    97

    98

struct Ai_SpecialVehicle {

    99

	VehicleID veh_id;

   100

	uint32 flag;

   101

};

   102

   103

struct PlayerAiNew {

   104

	uint8 state;

   105

	uint tick;

   106

	uint idle;

   107

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

   115

	/* Pathfinder stuff */

   116

	Ai_PathFinderInfo path_info;

   117

	AyStar *pathfinder;

   118

   119

	/* Route stuff */

   120

   121

	CargoID cargo;

   122

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

   123

	Money new_cost;

   124

   125

	byte action;

   126

   127

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

   128

	Date last_vehiclecheck_date; // Used in CheckVehicle

   129

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

   130

   131

	TileIndex from_tile;

   132

	TileIndex to_tile;

   133

   134

	DiagDirectionByte from_direction;

   135

	DiagDirectionByte to_direction;

   136

   137

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

   138

	bool to_deliver;

   139

   140

	TileIndex depot_tile;

   141

	DiagDirectionByte depot_direction;

   142

   143

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

   144

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

   145

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

   146

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

   147

   148

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

   149

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

   150

	int to_ic;

   151

	byte to_type;

   152

   153

};

   154

   155

   156

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

   157

enum {

   158

	LOAN_INTERVAL        = 10000,

   159

	LOAN_INTERVAL_OLD_AI = 50000,

   160

};

   161

   162

struct Player {

   163

	uint32 name_2;

   164

	uint16 name_1;

   165

   166

	uint16 president_name_1;

   167

	uint32 president_name_2;

   168

   169

	PlayerFace face;

   170

   171

	Money player_money;

   172

	Money current_loan;

   173

   174

	byte player_color;

   175

	Livery livery[LS_END];

   176

	byte player_money_fraction;

   177

	byte avail_railtypes;

   178

	byte avail_roadtypes;

   179

	byte block_preview;

   180

	PlayerByte index;

   181

   182

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

   183

   184

	TileIndex location_of_house;

   185

	TileIndex last_build_coordinate;

   186

   187

	PlayerByte share_owners[4];

   188

   189

	Year inaugurated_year;

   190

	byte num_valid_stat_ent;

   191

   192

	byte quarters_of_bankrupcy;

   193

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

   194

	int16 bankrupt_timeout;

   195

	Money bankrupt_value;

   196

   197

	bool is_active;

   198

	bool is_ai;

   199

	PlayerAI ai;

   200

	PlayerAiNew ainew;

   201

   202

	Money yearly_expenses[3][13];

   203

	PlayerEconomyEntry cur_economy;

   204

	PlayerEconomyEntry old_economy[24];

   205

	EngineRenewList engine_renew_list; ///< Defined later

   206

	bool engine_renew;

   207

	bool renew_keep_length;

   208

	int16 engine_renew_months;

   209

	uint32 engine_renew_money;

   210

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

   211

};

   212

   213

uint16 GetDrawStringPlayerColor(PlayerID player);

   214

   215

void ChangeOwnershipOfPlayerItems(PlayerID old_player, PlayerID new_player);

   216

void GetNameOfOwner(Owner owner, TileIndex tile);

   217

Money CalculateCompanyValue(const Player *p);

   218

void InvalidatePlayerWindows(const Player *p);

   219

void SetLocalPlayer(PlayerID new_player);

   220

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

   221

   222

VARDEF PlayerByte _local_player;

   223

VARDEF PlayerByte _current_player;

   224

   225

VARDEF Player _players[MAX_PLAYERS];

   226

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

   227

VARDEF byte _player_colors[MAX_PLAYERS];

   228

   229

static inline byte ActivePlayerCount()

   230

{

   231

	const Player *p;

   232

	byte count = 0;

   233

   234

	FOR_ALL_PLAYERS(p) {

   235

		if (p->is_active) count++;

   236

	}

   237

   238

	return count;

   239

}

   240

   241

static inline Player *GetPlayer(PlayerID i)

   242

{

   243

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

   244

	return &_players[i];

   245

}

   246

   247

static inline bool IsLocalPlayer()

   248

{

   249

	return _local_player == _current_player;

   250

}

   251

   252

static inline bool IsValidPlayer(PlayerID pi)

   253

{

   254

	return IsInsideBS(pi, PLAYER_FIRST, MAX_PLAYERS);

   255

}

   256

   257

byte GetPlayerRailtypes(PlayerID p);

   258

byte GetPlayerRoadtypes(PlayerID p);

   259

   260

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

   261

 * @param p Player in question

   262

 * @param Railtype requested RailType

   263

 * @return true if player has requested RailType available

   264

 */

   265

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

   266

{

   267

	return HasBit(p->avail_railtypes, Railtype);

   268

}

   269

   270

/** Finds out, whether given player has all given RoadTypes available

   271

 * @param PlayerID ID of player

   272

 * @param rts RoadTypes to test

   273

 * @return true if player has all requested RoadTypes available

   274

 */

   275

static inline bool HasRoadTypesAvail(const PlayerID p, const RoadTypes rts)

   276

{

   277

	RoadTypes avail_roadtypes;

   278

   279

	if (p == OWNER_TOWN || _game_mode == GM_EDITOR || IsGeneratingWorld()) {

   280

		avail_roadtypes = ROADTYPES_ROAD;

   281

	} else {

   282

		if (!IsValidPlayer(p)) return false;

   283

		avail_roadtypes = (RoadTypes)GetPlayer(p)->avail_roadtypes | ROADTYPES_ROAD; // road is available for always for everybody

   284

	}

   285

	return (rts & ~avail_roadtypes) == 0;

   286

}

   287

   288

static inline bool IsHumanPlayer(PlayerID pi)

   289

{

   290

	return !GetPlayer(pi)->is_ai;

   291

}

   292

   293

static inline bool IsInteractivePlayer(PlayerID pi)

   294

{

   295

	return pi == _local_player;

   296

}

   297

   298

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

   299

   300

/* Validate functions for rail building */

   301

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

   302

   303

/* Validate functions for road building */

   304

static inline bool ValParamRoadType(const RoadType rt) { return HasRoadTypesAvail(_current_player, RoadTypeToRoadTypes(rt));}

   305

   306

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

   307

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

   308

 * here. When adding new railtypes, modify this function

   309

 * @param p the player "in action"

   310

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

   311

 */

   312

static inline RailType GetBestRailtype(const Player *p)

   313

{

   314

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

   315

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

   316

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

   317

	return RAILTYPE_RAIL;

   318

}

   319

   320

struct HighScore {

   321

	char company[100];

   322

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

   323

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

   324

};

   325

   326

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

   327

void SaveToHighScore();

   328

void LoadFromHighScore();

   329

int8 SaveHighScoreValue(const Player *p);

   330

int8 SaveHighScoreValueNetwork();

   331

   332

/* Engine Replacement Functions */

   333

   334

/**

   335

 * Remove all engine replacement settings for the given player.

   336

 * @param p Player.

   337

 */

   338

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

   339

   340

/**

   341

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

   342

 * @param p Player.

   343

 * @param engine Engine type.

   344

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

   345

 * replacement is in the list.

   346

 */

   347

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

   348

   349

/**

   350

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

   351

 * @param p Player.

   352

 * @param  engine Engine type to be replaced.

   353

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

   354

 */

   355

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

   356

   357

/**

   358

 * Add an engine replacement for the player.

   359

 * @param p Player.

   360

 * @param old_engine The original engine type.

   361

 * @param new_engine The replacement engine type.

   362

 * @param flags The calling command flags.

   363

 * @return 0 on success, CMD_ERROR on failure.

   364

 */

   365

static inline CommandCost AddEngineReplacementForPlayer(Player *p, EngineID old_engine, EngineID new_engine, GroupID group, uint32 flags) { return AddEngineReplacement(&p->engine_renew_list, old_engine, new_engine, group, flags); }

   366

   367

/**

   368

 * Remove an engine replacement for the player.

   369

 * @param p Player.

   370

 * @param engine The original engine type.

   371

 * @param flags The calling command flags.

   372

 * @return 0 on success, CMD_ERROR on failure.

   373

 */

   374

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

   375

   376

/**

   377

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

   378

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

   379

 * @param p Player to reset.

   380

 */

   381

void ResetPlayerLivery(Player *p);

   382

   383

#endif /* PLAYER_H */