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 "core/enum_type.hpp"

    12

#include "strings_type.h"

    13

    14

// Forward declarations of structs.

    15

struct Depot;

    16

struct Waypoint;

    17

struct Station;

    18

struct ViewPort;

    19

struct NewsItem;

    20

struct DrawPixelInfo;

    21

struct Group;

    22

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

    23

typedef byte LandscapeID;

    24

typedef uint16 EngineID;

    25

typedef uint16 UnitID;

    26

    27

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

    28

    29

/* IDs used in Pools */

    30

typedef uint16 StationID;

    31

static const StationID INVALID_STATION = 0xFFFF;

    32

typedef uint16 RoadStopID;

    33

typedef uint16 DepotID;

    34

typedef uint16 WaypointID;

    35

typedef uint16 OrderID;

    36

typedef uint16 SignID;

    37

typedef uint16 GroupID;

    38

typedef uint16 EngineRenewID;

    39

typedef uint16 DestinationID;

    40

    41

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

    42

 * be any of them

    43

 */

    44

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

    45

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

    46

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

    47

    48

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

    49

    50

enum GameModes {

    51

	GM_MENU,

    52

	GM_NORMAL,

    53

	GM_EDITOR

    54

};

    55

    56

enum SwitchModes {

    57

	SM_NONE            =  0,

    58

	SM_NEWGAME         =  1,

    59

	SM_EDITOR          =  2,

    60

	SM_LOAD            =  3,

    61

	SM_MENU            =  4,

    62

	SM_SAVE            =  5,

    63

	SM_GENRANDLAND     =  6,

    64

	SM_LOAD_SCENARIO   =  9,

    65

	SM_START_SCENARIO  = 10,

    66

	SM_START_HEIGHTMAP = 11,

    67

	SM_LOAD_HEIGHTMAP  = 12,

    68

};

    69

    70

    71

/* Modes for GenerateWorld */

    72

enum GenerateWorldModes {

    73

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

    74

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

    75

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

    76

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

    77

};

    78

    79

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

    80

enum InitializeGameModes {

    81

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

    82

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

    83

};

    84

    85

enum Owner {

    86

	PLAYER_INACTIVE_CLIENT = 253,

    87

	PLAYER_NEW_COMPANY = 254,

    88

	PLAYER_SPECTATOR = 255,

    89

	OWNER_BEGIN     = 0x00,

    90

	PLAYER_FIRST    = 0x00,

    91

	MAX_PLAYERS     = 8,

    92

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

    93

	OWNER_NONE      = 0x10, // nobody owns the tile

    94

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

    95

	OWNER_END       = 0x12,

    96

	INVALID_OWNER   = 0xFF,

    97

	INVALID_PLAYER  = 0xFF,

    98

	/* Player identifiers All players below MAX_PLAYERS are playable

    99

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

   100

};

   101

   102

typedef Owner PlayerID;

   103

   104

DECLARE_POSTFIX_INCREMENT(Owner);

   105

   106

/** Define basic enum properties */

   107

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

   108

typedef TinyEnumT<Owner> OwnerByte;

   109

typedef OwnerByte PlayerByte;

   110

   111

   112

enum TransportType {

   113

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

   114

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

   115

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

   116

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

   117

	 * the values for road and rail.

   118

	 */

   119

	TRANSPORT_BEGIN = 0,

   120

	TRANSPORT_RAIL = 0,

   121

	TRANSPORT_ROAD = 1,

   122

	TRANSPORT_WATER, // = 2

   123

	TRANSPORT_END,

   124

	INVALID_TRANSPORT = 0xff,

   125

};

   126

   127

/** Define basic enum properties */

   128

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

   129

typedef TinyEnumT<TransportType> TransportTypeByte;

   130

   131

   132

/* Display Options */

   133

enum {

   134

	DO_SHOW_TOWN_NAMES    = 0,

   135

	DO_SHOW_STATION_NAMES = 1,

   136

	DO_SHOW_SIGNS         = 2,

   137

	DO_FULL_ANIMATION     = 3,

   138

	DO_FULL_DETAIL        = 5,

   139

	DO_WAYPOINTS          = 6,

   140

};

   141

   142

/* Landscape types */

   143

enum {

   144

	LT_TEMPERATE  = 0,

   145

	LT_ARCTIC     = 1,

   146

	LT_TROPIC     = 2,

   147

	LT_TOYLAND    = 3,

   148

   149

	NUM_LANDSCAPE = 4,

   150

};

   151

   152

#define GAME_DIFFICULTY_NUM 18

   153

   154

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

   155

typedef uint16 GDType;

   156

struct GameDifficulty {

   157

	GDType max_no_competitors;

   158

	GDType competitor_start_time;

   159

	GDType number_towns;

   160

	GDType number_industries;

   161

	GDType max_loan;

   162

	GDType initial_interest;

   163

	GDType vehicle_costs;

   164

	GDType competitor_speed;

   165

	GDType competitor_intelligence; // no longer in use

   166

	GDType vehicle_breakdowns;

   167

	GDType subsidy_multiplier;

   168

	GDType construction_cost;

   169

	GDType terrain_type;

   170

	GDType quantity_sea_lakes;

   171

	GDType economy;

   172

	GDType line_reverse_mode;

   173

	GDType disasters;

   174

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

   175

};

   176

   177

struct ViewportSign {

   178

	int32 left;

   179

	int32 top;

   180

	byte width_1, width_2;

   181

};

   182

   183

enum {

   184

	SORT_ASCENDING  = 0,

   185

	SORT_DESCENDING = 1,

   186

	SORT_BY_DATE    = 0,

   187

	SORT_BY_NAME    = 2

   188

};

   189

   190

VARDEF byte _savegame_sort_order;

   191

   192

enum {

   193

	MAX_SCREEN_WIDTH  = 2048,

   194

	MAX_SCREEN_HEIGHT = 1200,

   195

};

   196

   197

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

   198

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

   199

 * elements are zero */

   200

enum {

   201

	SCROLL_CON  = 0,

   202

	SCROLL_EDIT = 1,

   203

	SCROLL_SAVE = 2,

   204

	SCROLL_CHAT = 4,

   205

};

   206

VARDEF byte _no_scroll;

   207

   208

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

   209

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

   210

 * in the ProcessSentMessage() function */

   211

enum ThreadMsg {

   212

	MSG_OTTD_NO_MESSAGE,

   213

	MSG_OTTD_SAVETHREAD_DONE,

   214

	MSG_OTTD_SAVETHREAD_ERROR,

   215

};

   216

   217

void OTTD_SendThreadMessage(ThreadMsg msg);

   218

   219

extern byte _game_mode;

   220

extern bool _exit_game;

   221

extern byte _pause_game;

   222

   223

#endif /* OPENTTD_H */