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

    12

#include "helpers.hpp"

    13

    14

struct Oblong {

    15

	int x, y;

    16

	int width, height;

    17

};

    18

    19

struct BoundingRect {

    20

	int width;

    21

	int height;

    22

};

    23

    24

struct Pair {

    25

	int a;

    26

	int b;

    27

};

    28

    29

#include "map.h"

    30

#include "slope.h"

    31

    32

// Forward declarations of structs.

    33

struct Vehicle;

    34

struct Depot;

    35

struct Waypoint;

    36

struct Window;

    37

struct Station;

    38

struct ViewPort;

    39

struct Town;

    40

struct NewsItem;

    41

struct Industry;

    42

struct DrawPixelInfo;

    43

struct Group;

    44

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

    45

typedef byte CargoID;

    46

typedef byte LandscapeID;

    47

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

    48

struct PalSpriteID {

    49

	SpriteID sprite;

    50

	SpriteID pal;

    51

};

    52

typedef uint16 EngineID;

    53

typedef uint16 UnitID;

    54

typedef uint16 StringID;

    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

typedef uint16 RoadStopID;

    61

typedef uint16 TownID;

    62

typedef uint16 IndustryID;

    63

typedef uint16 DepotID;

    64

typedef uint16 WaypointID;

    65

typedef uint16 OrderID;

    66

typedef uint16 SignID;

    67

typedef uint16 GroupID;

    68

typedef uint16 EngineRenewID;

    69

typedef uint16 DestinationID;

    71

    72

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

    73

 * be any of them

    74

 */

    75

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

    76

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

    77

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

    78

    79

typedef int32 WindowNumber;

    80

    81

enum {

    82

	INVALID_YEAR = -1,

    83

	INVALID_DATE = -1,

    84

};

    85

    86

typedef int32 Year;

    87

typedef int32 Date;

    88

    89

    90

enum SwitchModes {

    91

	SM_NONE            =  0,

    92

	SM_NEWGAME         =  1,

    93

	SM_EDITOR          =  2,

    94

	SM_LOAD            =  3,

    95

	SM_MENU            =  4,

    96

	SM_SAVE            =  5,

    97

	SM_GENRANDLAND     =  6,

    98

	SM_LOAD_SCENARIO   =  9,

    99

	SM_START_SCENARIO  = 10,

   100

	SM_START_HEIGHTMAP = 11,

   101

	SM_LOAD_HEIGHTMAP  = 12,

   102

};

   103

   104

   105

/* Modes for GenerateWorld */

   106

enum GenerateWorldModes {

   107

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

   108

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

   109

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

   110

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

   111

};

   112

   113

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

   114

enum InitializeGameModes {

   115

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

   116

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

   117

};

   118

   119

enum Owner {

   120

	PLAYER_INACTIVE_CLIENT = 253,

   121

	PLAYER_NEW_COMPANY = 254,

   122

	PLAYER_SPECTATOR = 255,

   123

	OWNER_BEGIN     = 0x00,

   124

	PLAYER_FIRST    = 0x00,

   125

	MAX_PLAYERS     = 8,

   126

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

   127

	OWNER_NONE      = 0x10, // nobody owns the tile

   128

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

   129

	OWNER_END       = 0x12,

   130

	INVALID_OWNER   = 0xFF,

   131

	INVALID_PLAYER  = 0xFF,

   132

	/* Player identifiers All players below MAX_PLAYERS are playable

   133

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

   134

};

   135

   136

typedef Owner PlayerID;

   137

   138

DECLARE_POSTFIX_INCREMENT(Owner);

   139

   140

/** Define basic enum properties */

   141

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

   142

typedef TinyEnumT<Owner> OwnerByte;

   143

typedef OwnerByte PlayerByte;

   144

   145

   146

enum TransportType {

   147

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

   148

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

   149

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

   150

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

   151

	 * the values for road and rail.

   152

	 */

   153

	TRANSPORT_BEGIN = 0,

   154

	TRANSPORT_RAIL = 0,

   155

	TRANSPORT_ROAD = 1,

   156

	TRANSPORT_WATER, // = 2

   157

	TRANSPORT_END,

   158

	INVALID_TRANSPORT = 0xff,

   159

};

   160

   161

/** Define basic enum properties */

   162

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

   163

typedef TinyEnumT<TransportType> TransportTypeByte;

   164

   165

   166

struct TileInfo {

   167

	uint x;

   168

	uint y;

   169

	Slope tileh;

   170

	TileIndex tile;

   171

	uint z;

   172

};

   173

   174

   175

/* Display Options */

   176

enum {

   177

	DO_SHOW_TOWN_NAMES    = 0,

   178

	DO_SHOW_STATION_NAMES = 1,

   179

	DO_SHOW_SIGNS         = 2,

   180

	DO_FULL_ANIMATION     = 3,

   181

	DO_FULL_DETAIL        = 5,

   182

	DO_WAYPOINTS          = 6,

   183

};

   184

   185

enum {

   186

	TO_SIGNS,

   187

	TO_TREES,

   188

	TO_HOUSES,

   189

	TO_INDUSTRIES,

   190

	TO_BUILDINGS,

   191

	TO_BRIDGES,

   192

	TO_STRUCTURES,

   193

};

   194

   195

/* Landscape types */

   196

enum {

   197

	LT_TEMPERATE  = 0,

   198

	LT_ARCTIC     = 1,

   199

	LT_TROPIC     = 2,

   200

	LT_TOYLAND    = 3,

   201

   202

	NUM_LANDSCAPE = 4,

   203

};

   204

   205

#define GAME_DIFFICULTY_NUM 20

   206

/**

   207

 * Town Layouts

   208

 */

   209

enum TownLayout {

   210

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

   211

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

   212

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

   213

	TL_2X2_GRID,         ///< Geometric 2x2 grid algorithm

   214

	TL_3X3_GRID,         ///< Geometric 3x3 grid algorithm

   215

   216

	NUM_TLS,             ///< Number of town layouts

   217

};

   218

   219

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

   220

/** Define basic enum properties */

   221

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

   222

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

   223

   224

struct GameDifficulty {

   225

	int max_no_competitors;

   226

	int competitor_start_time;

   227

	int number_towns;

   228

	int number_industries;

   229

	int max_loan;

   230

	int initial_interest;

   231

	int vehicle_costs;

   232

	int competitor_speed;

   233

	int competitor_intelligence; // no longer in use

   234

	int vehicle_breakdowns;

   235

	int subsidy_multiplier;

   236

	int construction_cost;

   237

	int terrain_type;

   238

	int quantity_sea_lakes;

   239

	int economy;

   240

	int line_reverse_mode;

   241

	int disasters;

   242

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

   243

	int economic_growth;

   244

	int economic_model;

   245

};

   246

   247

enum {

   248

	// Temperate

   249

	CT_PASSENGERS   =  0,

   250

	CT_COAL         =  1,

   251

	CT_MAIL         =  2,

   252

	CT_OIL          =  3,

   253

	CT_LIVESTOCK    =  4,

   254

	CT_GOODS        =  5,

   255

	CT_GRAIN        =  6,

   256

	CT_WOOD         =  7,

   257

	CT_IRON_ORE     =  8,

   258

	CT_STEEL        =  9,

   259

	CT_VALUABLES    = 10,

   260

   261

	// Arctic

   262

	CT_WHEAT        =  6,

   263

	CT_HILLY_UNUSED =  8,

   264

	CT_PAPER        =  9,

   265

	CT_GOLD         = 10,

   266

	CT_FOOD         = 11,

   267

   268

	// Tropic

   269

	CT_RUBBER       =  1,

   270

	CT_FRUIT        =  4,

   271

	CT_MAIZE        =  6,

   272

	CT_COPPER_ORE   =  8,

   273

	CT_WATER        =  9,

   274

	CT_DIAMONDS     = 10,

   275

   276

	// Toyland

   277

	CT_SUGAR        =  1,

   278

	CT_TOYS         =  3,

   279

	CT_BATTERIES    =  4,

   280

	CT_CANDY        =  5,

   281

	CT_TOFFEE       =  6,

   282

	CT_COLA         =  7,

   283

	CT_COTTON_CANDY =  8,

   284

	CT_BUBBLES      =  9,

   285

	CT_PLASTIC      = 10,

   286

	CT_FIZZY_DRINKS = 11,

   287

   288

	NUM_CARGO       = 32,

   289

   290

	CT_NO_REFIT     = 0xFE,

   291

	CT_INVALID      = 0xFF

   292

};

   293

   294

typedef uint AcceptedCargo[NUM_CARGO];

   295

   296

struct TileDesc {

   297

	StringID str;

   298

	Owner owner;

   299

	Date build_date;

   300

	uint32 dparam[2];

   301

};

   302

   303

struct ViewportSign {

   304

	int32 left;

   305

	int32 top;

   306

	byte width_1, width_2;

   307

};

   308

   309

   310

typedef void DrawTileProc(TileInfo *ti);

   311

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

   312

typedef int32 ClearTileProc(TileIndex tile, byte flags);

   313

typedef void GetAcceptedCargoProc(TileIndex tile, AcceptedCargo res);

   314

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

   315

/**

   316

 * GetTileTrackStatusProcs return a value that contains the possible tracks

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

 *

   324

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

   325

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

   326

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

   327

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

   328

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

   329

 *

   330

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

   331

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

   332

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

   333

 * above.

   334

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

   335

 * @param mode     the mode of transportation

   336

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

   337

 * @return the above mentions track status information

   338

 */

   339

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

   340

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

   341

typedef void ClickTileProc(TileIndex tile);

   342

typedef void AnimateTileProc(TileIndex tile);

   343

typedef void TileLoopProc(TileIndex tile);

   344

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

   345

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

   346

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

   347

typedef Slope GetSlopeTilehProc(TileIndex, Slope tileh);

   348

   349

struct TileTypeProcs {

   350

	DrawTileProc *draw_tile_proc;

   351

	GetSlopeZProc *get_slope_z_proc;

   352

	ClearTileProc *clear_tile_proc;

   353

	GetAcceptedCargoProc *get_accepted_cargo_proc;

   354

	GetTileDescProc *get_tile_desc_proc;

   355

	GetTileTrackStatusProc *get_tile_track_status_proc;

   356

	ClickTileProc *click_tile_proc;

   357

	AnimateTileProc *animate_tile_proc;

   358

	TileLoopProc *tile_loop_proc;

   359

	ChangeTileOwnerProc *change_tile_owner_proc;

   360

	GetProducedCargoProc *get_produced_cargo_proc;

   361

	VehicleEnterTileProc *vehicle_enter_tile_proc;

   362

	GetSlopeTilehProc *get_slope_tileh_proc;

   363

};

   364

   365

   366

enum WindowClass {

   367

	WC_NONE,

   368

	WC_MAIN_WINDOW = WC_NONE,

   369

	WC_MAIN_TOOLBAR,

   370

	WC_STATUS_BAR,

   371

	WC_BUILD_TOOLBAR,

   372

	WC_NEWS_WINDOW,

   373

	WC_TOWN_DIRECTORY,

   374

	WC_STATION_LIST,

   375

	WC_TOWN_VIEW,

   376

	WC_SMALLMAP,

   377

	WC_TRAINS_LIST,

   378

	WC_ROADVEH_LIST,

   379

	WC_SHIPS_LIST,

   380

	WC_AIRCRAFT_LIST,

   381

	WC_VEHICLE_VIEW,

   382

	WC_VEHICLE_DETAILS,

   383

	WC_VEHICLE_REFIT,

   384

	WC_VEHICLE_ORDERS,

   385

	WC_STATION_VIEW,

   386

	WC_VEHICLE_DEPOT,

   387

	WC_BUILD_VEHICLE,

   388

	WC_BUILD_BRIDGE,

   389

	WC_ERRMSG,

   390

	WC_BUILD_STATION,

   391

	WC_BUS_STATION,

   392

	WC_TRUCK_STATION,

   393

	WC_BUILD_DEPOT,

   394

	WC_COMPANY,

   395

	WC_FINANCES,

   396

	WC_PLAYER_COLOR,

   397

	WC_QUERY_STRING,

   398

	WC_SAVELOAD,

   399

	WC_SELECT_GAME,

   400

	WC_TOOLBAR_MENU,

   401

	WC_INCOME_GRAPH,

   402

	WC_OPERATING_PROFIT,

   403

	WC_TOOLTIPS,

   404

	WC_INDUSTRY_VIEW,

   405

	WC_PLAYER_FACE,

   406

	WC_LAND_INFO,

   407

	WC_TOWN_AUTHORITY,

   408

	WC_SUBSIDIES_LIST,

   409

	WC_GRAPH_LEGEND,

   410

	WC_DELIVERED_CARGO,

   411

	WC_PERFORMANCE_HISTORY,

   412

	WC_COMPANY_VALUE,

   413

	WC_COMPANY_LEAGUE,

   414

	WC_BUY_COMPANY,

   415

	WC_PAYMENT_RATES,

   416

	WC_ENGINE_PREVIEW,

   417

	WC_MUSIC_WINDOW,

   418

	WC_MUSIC_TRACK_SELECTION,

   419

	WC_SCEN_LAND_GEN,

   420

	WC_SCEN_TOWN_GEN,

   421

	WC_SCEN_INDUSTRY,

   422

	WC_SCEN_BUILD_ROAD,

   423

	WC_BUILD_TREES,

   424

	WC_SEND_NETWORK_MSG,

   425

	WC_DROPDOWN_MENU,

   426

	WC_BUILD_INDUSTRY,

   427

	WC_GAME_OPTIONS,

   428

	WC_NETWORK_WINDOW,

   429

	WC_INDUSTRY_DIRECTORY,

   430

	WC_MESSAGE_HISTORY,

   431

	WC_CHEATS,

   432

	WC_PERFORMANCE_DETAIL,

   433

	WC_CONSOLE,

   434

	WC_EXTRA_VIEW_PORT,

   435

	WC_CLIENT_LIST,

   436

	WC_NETWORK_STATUS_WINDOW,

   437

	WC_CUSTOM_CURRENCY,

   438

	WC_REPLACE_VEHICLE,

   439

	WC_HIGHSCORE,

   440

	WC_ENDSCREEN,

   441

	WC_SIGN_LIST,

   442

	WC_GENERATE_LANDSCAPE,

   443

	WC_GENERATE_PROGRESS_WINDOW,

   444

	WC_CONFIRM_POPUP_QUERY,

   445

	WC_TRANSPARENCY_TOOLBAR,

   446

};

   447

   448

   449

enum ExpensesType {

   450

	EXPENSES_CONSTRUCTION =  0,

   451

	EXPENSES_NEW_VEHICLES =  1,

   452

	EXPENSES_TRAIN_RUN    =  2,

   453

	EXPENSES_ROADVEH_RUN  =  3,

   454

	EXPENSES_AIRCRAFT_RUN =  4,

   455

	EXPENSES_SHIP_RUN     =  5,

   456

	EXPENSES_PROPERTY     =  6,

   457

	EXPENSES_TRAIN_INC    =  7,

   458

	EXPENSES_ROADVEH_INC  =  8,

   459

	EXPENSES_AIRCRAFT_INC =  9,

   460

	EXPENSES_SHIP_INC     = 10,

   461

	EXPENSES_LOAN_INT     = 11,

   462

	EXPENSES_OTHER        = 12,

   463

};

   464

   465

enum {

   466

	MAX_LANG = 64,

   467

};

   468

   469

// special string constants

   470

enum SpecialStrings {

   471

   472

	// special strings for town names. the town name is generated dynamically on request.

   473

	SPECSTR_TOWNNAME_START     = 0x20C0,

   474

	SPECSTR_TOWNNAME_ENGLISH   = SPECSTR_TOWNNAME_START,

   475

	SPECSTR_TOWNNAME_FRENCH,

   476

	SPECSTR_TOWNNAME_GERMAN,

   477

	SPECSTR_TOWNNAME_AMERICAN,

   478

	SPECSTR_TOWNNAME_LATIN,

   479

	SPECSTR_TOWNNAME_SILLY,

   480

	SPECSTR_TOWNNAME_SWEDISH,

   481

	SPECSTR_TOWNNAME_DUTCH,

   482

	SPECSTR_TOWNNAME_FINNISH,

   483

	SPECSTR_TOWNNAME_POLISH,

   484

	SPECSTR_TOWNNAME_SLOVAKISH,

   485

	SPECSTR_TOWNNAME_NORWEGIAN,

   486

	SPECSTR_TOWNNAME_HUNGARIAN,

   487

	SPECSTR_TOWNNAME_AUSTRIAN,

   488

	SPECSTR_TOWNNAME_ROMANIAN,

   489

	SPECSTR_TOWNNAME_CZECH,

   490

	SPECSTR_TOWNNAME_SWISS,

   491

	SPECSTR_TOWNNAME_DANISH,

   492

	SPECSTR_TOWNNAME_TURKISH,