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

#include "strings_type.h"

    13

    14

#include "map.h"

    15

#include "slope_type.h"

    16

    17

// Forward declarations of structs.

    18

struct Depot;

    19

struct Waypoint;

    20

struct Station;

    21

struct ViewPort;

    22

struct Town;

    23

struct NewsItem;

    24

struct Industry;

    25

struct DrawPixelInfo;

    26

struct Group;

    27

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

    28

typedef byte LandscapeID;

    29

typedef uint16 EngineID;

    30

typedef uint16 UnitID;

    31

    32

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

    33

    34

/* IDs used in Pools */

    35

typedef uint16 StationID;

    36

static const StationID INVALID_STATION = 0xFFFF;

    37

typedef uint16 RoadStopID;

    38

typedef uint16 TownID;

    39

typedef uint16 IndustryID;

    40

typedef uint16 DepotID;

    41

typedef uint16 WaypointID;

    42

typedef uint16 OrderID;

    43

typedef uint16 SignID;

    44

typedef uint16 GroupID;

    45

typedef uint16 EngineRenewID;

    46

typedef uint16 DestinationID;

    47

    48

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

    49

 * be any of them

    50

 */

    51

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

    52

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

    53

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

    54

    55

    56

enum {

    57

	INVALID_YEAR = -1,

    58

	INVALID_DATE = -1,

    59

};

    60

    61

typedef int32 Year;

    62

typedef int32 Date;

    63

    64

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

    65

    66

enum GameModes {

    67

	GM_MENU,

    68

	GM_NORMAL,

    69

	GM_EDITOR

    70

};

    71

    72

enum SwitchModes {

    73

	SM_NONE            =  0,

    74

	SM_NEWGAME         =  1,

    75

	SM_EDITOR          =  2,

    76

	SM_LOAD            =  3,

    77

	SM_MENU            =  4,

    78

	SM_SAVE            =  5,

    79

	SM_GENRANDLAND     =  6,

    80

	SM_LOAD_SCENARIO   =  9,

    81

	SM_START_SCENARIO  = 10,

    82

	SM_START_HEIGHTMAP = 11,

    83

	SM_LOAD_HEIGHTMAP  = 12,

    84

};

    85

    86

    87

/* Modes for GenerateWorld */

    88

enum GenerateWorldModes {

    89

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

    90

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

    91

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

    92

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

    93

};

    94

    95

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

    96

enum InitializeGameModes {

    97

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

    98

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

    99

};

   100

   101

enum Owner {

   102

	PLAYER_INACTIVE_CLIENT = 253,

   103

	PLAYER_NEW_COMPANY = 254,

   104

	PLAYER_SPECTATOR = 255,

   105

	OWNER_BEGIN     = 0x00,

   106

	PLAYER_FIRST    = 0x00,

   107

	MAX_PLAYERS     = 8,

   108

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

   109

	OWNER_NONE      = 0x10, // nobody owns the tile

   110

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

   111

	OWNER_END       = 0x12,

   112

	INVALID_OWNER   = 0xFF,

   113

	INVALID_PLAYER  = 0xFF,

   114

	/* Player identifiers All players below MAX_PLAYERS are playable

   115

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

   116

};

   117

   118

typedef Owner PlayerID;

   119

   120

DECLARE_POSTFIX_INCREMENT(Owner);

   121

   122

/** Define basic enum properties */

   123

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

   124

typedef TinyEnumT<Owner> OwnerByte;

   125

typedef OwnerByte PlayerByte;

   126

   127

   128

enum TransportType {

   129

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

   130

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

   131

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

   132

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

   133

	 * the values for road and rail.

   134

	 */

   135

	TRANSPORT_BEGIN = 0,

   136

	TRANSPORT_RAIL = 0,

   137

	TRANSPORT_ROAD = 1,

   138

	TRANSPORT_WATER, // = 2

   139

	TRANSPORT_END,

   140

	INVALID_TRANSPORT = 0xff,

   141

};

   142

   143

/** Define basic enum properties */

   144

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

   145

typedef TinyEnumT<TransportType> TransportTypeByte;

   146

   147

   148

struct TileInfo {

   149

	uint x;

   150

	uint y;

   151

	Slope tileh;

   152

	TileIndex tile;

   153

	uint z;

   154

};

   155

   156

   157

/* Display Options */

   158

enum {

   159

	DO_SHOW_TOWN_NAMES    = 0,

   160

	DO_SHOW_STATION_NAMES = 1,

   161

	DO_SHOW_SIGNS         = 2,

   162

	DO_FULL_ANIMATION     = 3,

   163

	DO_FULL_DETAIL        = 5,

   164

	DO_WAYPOINTS          = 6,

   165

};

   166

   167

/* Landscape types */

   168

enum {

   169

	LT_TEMPERATE  = 0,

   170

	LT_ARCTIC     = 1,

   171

	LT_TROPIC     = 2,

   172

	LT_TOYLAND    = 3,

   173

   174

	NUM_LANDSCAPE = 4,

   175

};

   176

   177

/**

   178

 * Town Layouts

   179

 */

   180

enum TownLayout {

   181

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

   182

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

   183

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

   184

	TL_2X2_GRID,         ///< Geometric 2x2 grid algorithm

   185

	TL_3X3_GRID,         ///< Geometric 3x3 grid algorithm

   186

   187

	NUM_TLS,             ///< Number of town layouts

   188

};

   189

   190

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

   191

/** Define basic enum properties */

   192

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

   193

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

   194

   195

#define GAME_DIFFICULTY_NUM 18

   196

   197

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

   198

typedef uint16 GDType;

   199

struct GameDifficulty {

   200

	GDType max_no_competitors;

   201

	GDType competitor_start_time;

   202

	GDType number_towns;

   203

	GDType number_industries;

   204

	GDType max_loan;

   205

	GDType initial_interest;

   206

	GDType vehicle_costs;

   207

	GDType competitor_speed;

   208

	GDType competitor_intelligence; // no longer in use

   209

	GDType vehicle_breakdowns;

   210

	GDType subsidy_multiplier;

   211

	GDType construction_cost;

   212

	GDType terrain_type;

   213

	GDType quantity_sea_lakes;

   214

	GDType economy;

   215

	GDType line_reverse_mode;

   216

	GDType disasters;

   217

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

   218

};

   219

   220

struct TileDesc {

   221

	StringID str;

   222

	Owner owner;

   223

	Date build_date;

   224

	uint64 dparam[2];

   225

};

   226

   227

struct ViewportSign {

   228

	int32 left;

   229

	int32 top;

   230

	byte width_1, width_2;

   231

};

   232

   233

typedef void PlaceProc(TileIndex tile);

   234

   235

enum {

   236

	SORT_ASCENDING  = 0,

   237

	SORT_DESCENDING = 1,

   238

	SORT_BY_DATE    = 0,

   239

	SORT_BY_NAME    = 2

   240

};

   241

   242

VARDEF byte _savegame_sort_order;

   243

   244

enum {

   245

	MAX_SCREEN_WIDTH  = 2048,

   246

	MAX_SCREEN_HEIGHT = 1200,

   247

};

   248

   249

/* In certain windows you navigate with the arrow keys. Do not scroll the

   250

 * gameview when here. Bitencoded variable that only allows scrolling if all

   251

 * elements are zero */

   252

enum {

   253

	SCROLL_CON  = 0,

   254

	SCROLL_EDIT = 1,

   255

	SCROLL_SAVE = 2,

   256

	SCROLL_CHAT = 4,

   257

};

   258

VARDEF byte _no_scroll;

   259

   260

/** To have a concurrently running thread interface with the main program, use

   261

 * the OTTD_SendThreadMessage() function. Actions to perform upon the message are handled

   262

 * in the ProcessSentMessage() function */

   263

enum ThreadMsg {

   264

	MSG_OTTD_NO_MESSAGE,

   265

	MSG_OTTD_SAVETHREAD_DONE,

   266

	MSG_OTTD_SAVETHREAD_ERROR,

   267

};

   268

   269

void OTTD_SendThreadMessage(ThreadMsg msg);

   270

   271

extern byte _game_mode;

   272

extern bool _exit_game;

   273

extern byte _pause_game;

   274

   275

#endif /* OPENTTD_H */