1

/* $Id$ */

     2

/** @file openttd.h */

     3

     4

#ifndef OPENTTD_H

     5

#define OPENTTD_H

     6

     7

#ifndef VARDEF

     8

#define VARDEF extern

     9

#endif

    10

    11

#include "helpers.hpp"

    12

    13

struct Oblong {

    14

	int x, y;

    15

	int width, height;

    16

};

    17

    18

struct BoundingRect {

    19

	int width;

    20

	int height;

    21

};

    22

    23

struct Pair {

    24

	int a;

    25

	int b;

    26

};

    27

    28

#include "map.h"

    29

#include "slope.h"

    30

    31

// Forward declarations of structs.

    32

struct Vehicle;

    33

struct Depot;

    34

struct Waypoint;

    35

struct Station;

    36

struct ViewPort;

    37

struct Town;

    38

struct NewsItem;

    39

struct Industry;

    40

struct DrawPixelInfo;

    41

struct Group;

    42

typedef byte VehicleOrderID;  ///< The index of an order within its current vehicle (not pool related)

    43

typedef byte CargoID;

    44

typedef byte LandscapeID;

    45

typedef uint32 SpriteID;      ///< The number of a sprite, without mapping bits and colortables

    46

struct PalSpriteID {

    47

	SpriteID sprite;

    48

	SpriteID pal;

    49

};

    50

typedef uint16 EngineID;

    51

typedef uint16 UnitID;

    52

typedef uint16 StringID;

    53

static const StringID INVALID_STRING_ID = 0xFFFF;

    54

    55

typedef EngineID *EngineList; ///< engine list type placeholder acceptable for C code (see helpers.cpp)

    56

    57

/* IDs used in Pools */

    58

typedef uint16 VehicleID;

    59

typedef uint16 StationID;

    60

static const StationID INVALID_STATION = 0xFFFF;

    61

typedef uint16 RoadStopID;

    62

typedef uint16 TownID;

    63

typedef uint16 IndustryID;

    64

typedef uint16 DepotID;

    65

typedef uint16 WaypointID;

    66

typedef uint16 OrderID;

    67

typedef uint16 SignID;

    68

typedef uint16 GroupID;

    69

typedef uint16 EngineRenewID;

    70

typedef uint16 DestinationID;

    71

    72

typedef OverflowSafeInt<int64, INT64_MAX, INT64_MIN> OverflowSafeInt64;

    73

typedef OverflowSafeInt64 Money;

    74

    75

/* DestinationID must be at least as large as every these below, because it can

    76

 * be any of them

    77

 */

    78

assert_compile(sizeof(DestinationID) == sizeof(DepotID));

    79

assert_compile(sizeof(DestinationID) == sizeof(WaypointID));

    80

assert_compile(sizeof(DestinationID) == sizeof(StationID));

    81

    82

    83

enum {

    84

	INVALID_YEAR = -1,

    85

	INVALID_DATE = -1,

    86

};

    87

    88

typedef int32 Year;

    89

typedef int32 Date;

    90

    91

typedef uint32 PlayerFace; ///< player face bits, info see in player_face.h

    92

    93

enum SwitchModes {

    94

	SM_NONE            =  0,

    95

	SM_NEWGAME         =  1,

    96

	SM_EDITOR          =  2,

    97

	SM_LOAD            =  3,

    98

	SM_MENU            =  4,

    99

	SM_SAVE            =  5,

   100

	SM_GENRANDLAND     =  6,

   101

	SM_LOAD_SCENARIO   =  9,

   102

	SM_START_SCENARIO  = 10,

   103

	SM_START_HEIGHTMAP = 11,

   104

	SM_LOAD_HEIGHTMAP  = 12,

   105

};

   106

   107

   108

/* Modes for GenerateWorld */

   109

enum GenerateWorldModes {

   110

	GW_NEWGAME   = 0,    /* Generate a map for a new game */

   111

	GW_EMPTY     = 1,    /* Generate an empty map (sea-level) */

   112

	GW_RANDOM    = 2,    /* Generate a random map for SE */

   113

	GW_HEIGHTMAP = 3,    /* Generate a newgame from a heightmap */

   114

};

   115

   116

/* Modes for InitializeGame, those are _bits_! */

   117

enum InitializeGameModes {

   118

	IG_NONE       = 0,  /* Don't do anything special */

   119

	IG_DATE_RESET = 1,  /* Reset the date when initializing a game */

   120

};

   121

   122

enum Owner {

   123

	PLAYER_INACTIVE_CLIENT = 253,

   124

	PLAYER_NEW_COMPANY = 254,

   125

	PLAYER_SPECTATOR = 255,

   126

	OWNER_BEGIN     = 0x00,

   127

	PLAYER_FIRST    = 0x00,

   128

	MAX_PLAYERS     = 8,

   129

	OWNER_TOWN      = 0x0F, // a town owns the tile

   130

	OWNER_NONE      = 0x10, // nobody owns the tile

   131

	OWNER_WATER     = 0x11, // "water" owns the tile

   132

	OWNER_END       = 0x12,

   133

	INVALID_OWNER   = 0xFF,

   134

	INVALID_PLAYER  = 0xFF,

   135

	/* Player identifiers All players below MAX_PLAYERS are playable

   136

	* players, above, they are special, computer controlled players */

   137

};

   138

   139

typedef Owner PlayerID;

   140

   141

DECLARE_POSTFIX_INCREMENT(Owner);

   142

   143

/** Define basic enum properties */

   144

template <> struct EnumPropsT<Owner> : MakeEnumPropsT<Owner, byte, OWNER_BEGIN, OWNER_END, INVALID_OWNER> {};

   145

typedef TinyEnumT<Owner> OwnerByte;

   146

typedef OwnerByte PlayerByte;

   147

   148

   149

enum TransportType {

   150

	/* These constants are for now linked to the representation of bridges

   151

	 * and tunnels, so they can be used by GetTileTrackStatus_TunnelBridge.

   152

	 * In an ideal world, these constants would be used everywhere when

   153

	 * accessing tunnels and bridges. For now, you should just not change

   154

	 * the values for road and rail.

   155

	 */

   156

	TRANSPORT_BEGIN = 0,

   157

	TRANSPORT_RAIL = 0,

   158

	TRANSPORT_ROAD = 1,

   159

	TRANSPORT_WATER, // = 2

   160

	TRANSPORT_END,

   161

	INVALID_TRANSPORT = 0xff,

   162

};

   163

   164

/** Define basic enum properties */

   165

template <> struct EnumPropsT<TransportType> : MakeEnumPropsT<TransportType, byte, TRANSPORT_BEGIN, TRANSPORT_END, INVALID_TRANSPORT> {};

   166

typedef TinyEnumT<TransportType> TransportTypeByte;

   167

   168

   169

struct TileInfo {

   170

	uint x;

   171

	uint y;

   172

	Slope tileh;

   173

	TileIndex tile;

   174

	uint z;

   175

};

   176

   177

   178

/* Display Options */

   179

enum {

   180

	DO_SHOW_TOWN_NAMES    = 0,

   181

	DO_SHOW_STATION_NAMES = 1,

   182

	DO_SHOW_SIGNS         = 2,

   183

	DO_FULL_ANIMATION     = 3,

   184

	DO_FULL_DETAIL        = 5,

   185

	DO_WAYPOINTS          = 6,

   186

};

   187

   188

/* Landscape types */

   189

enum {

   190

	LT_TEMPERATE  = 0,

   191

	LT_ARCTIC     = 1,

   192

	LT_TROPIC     = 2,

   193

	LT_TOYLAND    = 3,

   194

   195

	NUM_LANDSCAPE = 4,

   196

};

   197

   198

/**

   199

 * Town Layouts

   200

 */

   201

enum TownLayout {

   202

	TL_NO_ROADS     = 0, ///< Build no more roads, but still build houses

   203

	TL_ORIGINAL,         ///< Original algorithm (min. 1 distance between roads)

   204

	TL_BETTER_ROADS,     ///< Extended original algorithm (min. 2 distance between roads)

   205

	TL_2X2_GRID,         ///< Geometric 2x2 grid algorithm

   206

	TL_3X3_GRID,         ///< Geometric 3x3 grid algorithm

   207

   208

	NUM_TLS,             ///< Number of town layouts

   209

};

   210

   211

/* It needs to be 8bits, because we save and load it as such */

   212

/** Define basic enum properties */

   213

template <> struct EnumPropsT<TownLayout> : MakeEnumPropsT<TownLayout, byte, TL_NO_ROADS, NUM_TLS, NUM_TLS> {};

   214

typedef TinyEnumT<TownLayout> TownLayoutByte; //typedefing-enumification of TownLayout

   215

   216

enum {

   217

	NUM_PRICES = 49,

   218

};

   219

   220

struct Prices {

   221

	Money station_value;

   222

	Money build_rail;

   223

	Money build_road;

   224

	Money build_signals;

   225

	Money build_bridge;

   226

	Money build_train_depot;

   227

	Money build_road_depot;

   228

	Money build_ship_depot;

   229

	Money build_tunnel;

   230

	Money train_station_track;

   231

	Money train_station_length;

   232

	Money build_airport;

   233

	Money build_bus_station;

   234

	Money build_truck_station;

   235

	Money build_dock;

   236

	Money build_railvehicle;

   237

	Money build_railwagon;

   238

	Money aircraft_base;

   239

	Money roadveh_base;

   240

	Money ship_base;

   241

	Money build_trees;

   242

	Money terraform;

   243

	Money clear_grass;

   244

	Money clear_roughland;

   245

	Money clear_rocks;

   246

	Money clear_fields;

   247

	Money remove_trees;

   248

	Money remove_rail;

   249

	Money remove_signals;

   250

	Money clear_bridge;

   251

	Money remove_train_depot;

   252

	Money remove_road_depot;

   253

	Money remove_ship_depot;

   254

	Money clear_tunnel;

   255

	Money clear_water;

   256

	Money remove_rail_station;

   257

	Money remove_airport;

   258

	Money remove_bus_station;

   259

	Money remove_truck_station;

   260

	Money remove_dock;

   261

	Money remove_house;

   262

	Money remove_road;

   263

	Money running_rail[3];

   264

	Money aircraft_running;

   265

	Money roadveh_running;

   266

	Money ship_running;

   267

	Money build_industry;

   268

};

   269

   270

#define GAME_DIFFICULTY_NUM 18

   271

   272

/** Specific type for Game Difficulty to ease changing the type */

   273

typedef uint16 GDType;

   274

struct GameDifficulty {

   275

	GDType max_no_competitors;

   276

	GDType competitor_start_time;

   277

	GDType number_towns;

   278

	GDType number_industries;

   279

	GDType max_loan;

   280

	GDType initial_interest;

   281

	GDType vehicle_costs;

   282

	GDType competitor_speed;

   283

	GDType competitor_intelligence; // no longer in use

   284

	GDType vehicle_breakdowns;

   285

	GDType subsidy_multiplier;

   286

	GDType construction_cost;

   287

	GDType terrain_type;

   288

	GDType quantity_sea_lakes;

   289

	GDType economy;

   290

	GDType line_reverse_mode;

   291

	GDType disasters;

   292

	GDType town_council_tolerance; // minimum required town ratings to be allowed to demolish stuff

   293

};

   294

   295

enum {

   296

	// Temperate

   297

	CT_PASSENGERS   =  0,

   298

	CT_COAL         =  1,

   299

	CT_MAIL         =  2,

   300

	CT_OIL          =  3,

   301

	CT_LIVESTOCK    =  4,

   302

	CT_GOODS        =  5,

   303

	CT_GRAIN        =  6,

   304

	CT_WOOD         =  7,

   305

	CT_IRON_ORE     =  8,

   306

	CT_STEEL        =  9,

   307

	CT_VALUABLES    = 10,

   308

   309

	// Arctic

   310

	CT_WHEAT        =  6,

   311

	CT_HILLY_UNUSED =  8,

   312

	CT_PAPER        =  9,

   313

	CT_GOLD         = 10,

   314

	CT_FOOD         = 11,

   315

   316

	// Tropic

   317

	CT_RUBBER       =  1,

   318

	CT_FRUIT        =  4,

   319

	CT_MAIZE        =  6,

   320

	CT_COPPER_ORE   =  8,

   321

	CT_WATER        =  9,

   322

	CT_DIAMONDS     = 10,

   323

   324

	// Toyland

   325

	CT_SUGAR        =  1,

   326

	CT_TOYS         =  3,

   327

	CT_BATTERIES    =  4,

   328

	CT_CANDY        =  5,

   329

	CT_TOFFEE       =  6,

   330

	CT_COLA         =  7,

   331

	CT_COTTON_CANDY =  8,

   332

	CT_BUBBLES      =  9,

   333

	CT_PLASTIC      = 10,

   334

	CT_FIZZY_DRINKS = 11,

   335

   336

	NUM_CARGO       = 32,

   337

   338

	CT_NO_REFIT     = 0xFE,

   339

	CT_INVALID      = 0xFF

   340

};

   341

   342

typedef uint AcceptedCargo[NUM_CARGO];

   343

   344

struct TileDesc {

   345

	StringID str;

   346

	Owner owner;

   347

	Date build_date;

   348

	uint64 dparam[2];

   349

};

   350

   351

struct ViewportSign {

   352

	int32 left;

   353

	int32 top;

   354

	byte width_1, width_2;

   355

};

   356

   357

/**

   358

 * Common return value for all commands. Wraps the cost and

   359

 * a possible error message/state together.

   360

 */

   361

class CommandCost {

   362

	Money cost;       ///< The cost of this action

   363

	StringID message; ///< Warning message for when success is unset

   364

	bool success;     ///< Whether the comment went fine up to this moment

   365

   366

public:

   367

	/**

   368

	 * Creates a command cost return with no cost and no error

   369

	 */

   370

	CommandCost() : cost(0), message(INVALID_STRING_ID), success(true) {}

   371

   372

	/**

   373

	 * Creates a command return value the is failed with the given message

   374

	 */

   375

	CommandCost(StringID msg) : cost(0), message(msg), success(false) {}

   376

   377

	/**

   378

	 * Creates a command return value with the given start cost

   379

	 * @param cst the initial cost of this command

   380

	 */

   381

	CommandCost(Money cst) : cost(cst), message(INVALID_STRING_ID), success(true) {}

   382

   383

	/**

   384

	 * Adds the cost of the given command return value to this cost.

   385

	 * Also takes a possible error message when it is set.

   386

	 * @param ret the command to add the cost of.

   387

	 * @return this class.

   388

	 */

   389

	CommandCost AddCost(CommandCost ret);

   390

   391

	/**

   392

	 * Adds the given cost to the cost of the command.

   393

	 * @param cost the cost to add

   394

	 * @return this class.

   395

	 */

   396

	CommandCost AddCost(Money cost);

   397

   398

	/**

   399

	 * Multiplies the cost of the command by the given factor.

   400

	 * @param cost factor to multiply the costs with

   401

	 * @return this class

   402

	 */

   403

	CommandCost MultiplyCost(int factor);

   404

   405

	/**

   406

	 * The costs as made up to this moment

   407

	 * @return the costs

   408

	 */

   409

	Money GetCost() const;

   410

   411

	/**

   412

	 * Sets the global error message *if* this class has one.

   413

	 */

   414

	void SetGlobalErrorMessage() const;

   415

   416

	/**

   417

	 * Did this command succeed?

   418

	 * @return true if and only if it succeeded

   419

	 */

   420

	bool Succeeded() const;

   421

   422

	/**

   423

	 * Did this command fail?

   424

	 * @return true if and only if it failed

   425

	 */

   426

	bool Failed() const;

   427

};

   428

   429

   430

typedef void DrawTileProc(TileInfo *ti);

   431

typedef uint GetSlopeZProc(TileIndex tile, uint x, uint y);

   432

typedef CommandCost ClearTileProc(TileIndex tile, byte flags);

   433

typedef void GetAcceptedCargoProc(TileIndex tile, AcceptedCargo res);

   434

typedef void GetTileDescProc(TileIndex tile, TileDesc *td);

   435

/**

   436

 * GetTileTrackStatusProcs return a value that contains the possible tracks

   437

 * that can be taken on a given tile by a given transport. The return value is

   438

 * composed as follows: 0xaabbccdd. ccdd and aabb are bitmasks of trackdirs,

   439

 * where bit n corresponds to trackdir n. ccdd are the trackdirs that are

   440

 * present in the tile (1==present, 0==not present), aabb is the signal

   441

 * status, if applicable (0==green/no signal, 1==red, note that this is

   442

 * reversed from map3/2[tile] for railway signals).

   443

 *

   444

 * The result (let's call it ts) is often used as follows:

   445

 * tracks = (byte)(ts | ts >>8)

   446

 * This effectively converts the present part of the result (ccdd) to a

   447

 * track bitmask, which disregards directions. Normally, this is the same as just

   448

 * doing (byte)ts I think, although I am not really sure

   449

 *

   450

 * A trackdir is combination of a track and a dir, where the lower three bits

   451

 * are a track, the fourth bit is the direction. these give 12 (or 14)

   452

 * possible options: 0-5 and 8-13, so we need 14 bits for a trackdir bitmask

   453

 * above.

   454

 * @param tile     the tile to get the track status from

   455

 * @param mode     the mode of transportation

   456

 * @param sub_mode used to differentiate between different kinds within the mode

   457

 * @return the above mentions track status information

   458

 */

   459

typedef uint32 GetTileTrackStatusProc(TileIndex tile, TransportType mode, uint sub_mode);

   460

typedef void GetProducedCargoProc(TileIndex tile, CargoID *b);

   461

typedef void ClickTileProc(TileIndex tile);

   462

typedef void AnimateTileProc(TileIndex tile);

   463

typedef void TileLoopProc(TileIndex tile);

   464

typedef void ChangeTileOwnerProc(TileIndex tile, PlayerID old_player, PlayerID new_player);

   465

/** @see VehicleEnterTileStatus to see what the return values mean */

   466

typedef uint32 VehicleEnterTileProc(Vehicle *v, TileIndex tile, int x, int y);

   467

typedef Foundation GetFoundationProc(TileIndex tile, Slope tileh);

   468

/**

   469

 * Called when a tile is affected by a terraforming operation.

   470

 * The function has to check if terraforming of the tile is allowed and return extra terraform-cost that depend on the tiletype.

   471

 * With DC_EXEC in flags it has to perform tiletype-specific actions (like clearing land etc., but not the terraforming itself).

   472

 *

   473

 * @note The terraforming has not yet taken place. So GetTileZ() and GetTileSlope() refer to the landscape before the terraforming operation.

   474

 *

   475

 * @param tile      The involved tile.

   476

 * @param flags     Command flags passed to the terraform command (DC_EXEC, DC_QUERY_COST, etc.).

   477

 * @param z_new     TileZ after terraforming.

   478

 * @param tileh_new Slope after terraforming.

   479

 * @return Error code or extra cost for terraforming (like clearing land, building foundations, etc., but not the terraforming itself.)

   480

 */

   481

typedef CommandCost TerraformTileProc(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new);

   482

   483

struct TileTypeProcs {

   484

	DrawTileProc *draw_tile_proc;

   485

	GetSlopeZProc *get_slope_z_proc;

   486

	ClearTileProc *clear_tile_proc;

   487

	GetAcceptedCargoProc *get_accepted_cargo_proc;

   488

	GetTileDescProc *get_tile_desc_proc;

   489

	GetTileTrackStatusProc *get_tile_track_status_proc;

   490