1

#ifndef FUNCTIONS_H

     2

#define FUNCTIONS_H

     3

     4

/* vehicle.c */

     5

     6

/* window.c */

     7

     8

     9

/* landscape.c */

    10

void FindLandscapeHeight(TileInfo *ti, uint x, uint y);

    11

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile);

    12

    13

void DoClearSquare(TileIndex tile);

    14

void CDECL ModifyTile(TileIndex tile, uint flags, ...);

    15

void RunTileLoop(void);

    16

    17

uint GetPartialZ(int x, int y, int corners);

    18

uint GetSlopeZ(int x, int y);

    19

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode);

    20

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac);

    21

void ChangeTileOwner(TileIndex tile, byte old_player, byte new_player);

    22

void AnimateTile(TileIndex tile);

    23

void ClickTile(TileIndex tile);

    24

void GetTileDesc(TileIndex tile, TileDesc *td);

    25

void DrawTile(TileInfo *ti);

    26

void UpdateTownMaxPass(Town *t);

    27

    28

bool IsValidTile(TileIndex tile);

    29

    30

static inline Point RemapCoords(int x, int y, int z)

    31

{

    32

#if !defined(NEW_ROTATION)

    33

	Point pt;

    34

	pt.x = (y - x) * 2;

    35

	pt.y = y + x - z;

    36

#else

    37

	Point pt;

    38

	pt.x = (x + y) * 2;

    39

	pt.y = x - y - z;

    40

#endif

    41

	return pt;

    42

}

    43

    44

static inline Point RemapCoords2(int x, int y)

    45

{

    46

	return RemapCoords(x, y, GetSlopeZ(x, y));

    47

}

    48

    49

    50

/* clear_land.c */

    51

void DrawHillyLandTile(TileInfo *ti);

    52

void DrawClearLandTile(TileInfo *ti, byte set);

    53

void DrawClearLandFence(TileInfo *ti, byte img);

    54

void TileLoopClearHelper(TileIndex tile);

    55

    56

/* station_land.c */

    57

void StationPickerDrawSprite(int x, int y, int railtype, int image);

    58

    59

/* track_land.c */

    60

void DrawTrainDepotSprite(int x, int y, int image, int railtype);

    61

    62

/* road_land.c */

    63

void DrawRoadDepotSprite(int x, int y, int image);

    64

    65

/* water_land.c */

    66

void DrawShipDepotSprite(int x, int y, int image);

    67

void TileLoop_Water(TileIndex tile);

    68

    69

/* players.c */

    70

bool CheckPlayerHasMoney(int32 cost);

    71

void SubtractMoneyFromPlayer(int32 cost);

    72

void SubtractMoneyFromPlayerFract(byte player, int32 cost);

    73

bool CheckOwnership(byte owner);

    74

bool CheckTileOwnership(TileIndex tile);

    75

StringID GetPlayerNameString(byte player, byte index);

    76

    77

/* standard */

    78

void ShowInfo(const char *str);

    79

void CDECL ShowInfoF(const char *str, ...);

    80

void NORETURN CDECL error(const char *str, ...);

    81

    82

/* openttd.c */

    83

    84

// **************

    85

// * Warning: DO NOT enable this unless you understand what it does

    86

// *

    87

// * If enabled, in a network game all randoms will be dumped to the

    88

// *  stdout if the first client joins (or if you are a client). This

    89

// *  is to help finding desync problems.

    90

// *

    91

// * Warning: DO NOT enable this unless you understand what it does

    92

// **************

    93

    94

//#define RANDOM_DEBUG

    95

    96

    97

// Enable this to produce higher quality random numbers.

    98

// Doesn't work with network yet.

    99

//#define MERSENNE_TWISTER

   100

   101

// Mersenne twister functions

   102

void SeedMT(uint32 seed);

   103

uint32 RandomMT(void);

   104

   105

   106

#ifdef MERSENNE_TWISTER

   107

	static inline uint32 Random(void) { return RandomMT(); }

   108

	uint RandomRange(uint max);

   109

#else

   110

   111

#ifdef RANDOM_DEBUG

   112

	#define Random() DoRandom(__LINE__, __FILE__)

   113

	uint32 DoRandom(int line, const char *file);

   114

	#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)

   115

	uint DoRandomRange(uint max, int line, const char *file);

   116

#else

   117

	uint32 Random(void);

   118

	uint RandomRange(uint max);

   119

#endif

   120

#endif // MERSENNE_TWISTER

   121

   122

static inline TileIndex RandomTileSeed(uint32 r) { return TILE_MASK(r); }

   123

static inline TileIndex RandomTile(void) { return TILE_MASK(Random()); }

   124

   125

   126

uint32 InteractiveRandom(void); /* Used for random sequences that are not the same on the other end of the multiplayer link */

   127

uint InteractiveRandomRange(uint max);

   128

   135

void SetDate(uint date);

   136

/* facedraw.c */

   137

void DrawPlayerFace(uint32 face, int color, int x, int y);

   138

   139

/* texteff.c */

   140

void MoveAllTextEffects(void);

   141

void AddTextEffect(StringID msg, int x, int y, uint16 duration);

   142

void InitTextEffects(void);

   143

void DrawTextEffects(DrawPixelInfo *dpi);

   144

   145

void InitTextMessage(void);

   146

void DrawTextMessage(void);

   147

void CDECL AddTextMessage(uint16 color, uint8 duration, const char *message, ...);

   148

void UndrawTextMessage(void);

   149

void TextMessageDailyLoop(void);

   150

   151

bool AddAnimatedTile(TileIndex tile);

   152

void DeleteAnimatedTile(TileIndex tile);

   153

void AnimateAnimatedTiles(void);

   154

void InitializeAnimatedTiles(void);

   155

   156

/* tunnelbridge_cmd.c */

   157

bool CheckTunnelInWay(TileIndex tile, int z);

   158

bool CheckBridge_Stuff(byte bridge_type, int bridge_len);

   159

uint32 GetBridgeLength(TileIndex begin, TileIndex end);

   160

int CalcBridgeLenCostFactor(int x);

   161

   162

typedef void CommandCallback(bool success, TileIndex tile, uint32 p1, uint32 p2);

   163

bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, CommandCallback *callback, uint32 cmd);

   164

   165

/* network.c */

   166

void NetworkUDPClose(void);

   167

void NetworkStartUp(void);

   168

void NetworkShutDown(void);

   169

void NetworkGameLoop(void);

   170

void NetworkUDPGameLoop(void);

   171

bool NetworkServerStart(void);

   172

bool NetworkClientConnectGame(const char* host, unsigned short port);

   173

void NetworkReboot(void);

   174

void NetworkDisconnect(void);

   175

void NetworkSend_Command(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback);

   176

   177

/* misc_cmd.c */

   178

void PlaceTreesRandomly(void);

   179

   180

void InitializeLandscapeVariables(bool only_constants);

   181

   182

/* misc.c */

   183

void DeleteName(StringID id);

   184

char *GetName(int id, char *buff);

   185

   186

// AllocateNameUnique also tests if the name used is not used anywere else

   187

//  and if it is used, it returns an error.

   188

#define AllocateNameUnique(name, skip) RealAllocateName(name, skip, true)

   189

#define AllocateName(name, skip) RealAllocateName(name, skip, false)

   190

StringID RealAllocateName(const char *name, byte skip, bool check_double);

   191

void ConvertDayToYMD(YearMonthDay *ymd, uint16 date);

   192

uint ConvertYMDToDay(uint year, uint month, uint day);

   193

uint ConvertIntDate(uint date);

   194

   195

/* misc functions */

   196

void MarkTileDirty(int x, int y);

   197

void MarkTileDirtyByTile(TileIndex tile);

   198

void InvalidateWindow(byte cls, WindowNumber number);

   199

void InvalidateWindowWidget(byte cls, WindowNumber number, byte widget_index);

   200

void InvalidateWindowClasses(byte cls);

   201

void DeleteWindowById(WindowClass cls, WindowNumber number);

   202

void DeleteWindowByClass(WindowClass cls);

   203

   204

void SetObjectToPlaceWnd(CursorID icon, byte mode, Window *w);

   205

void SetObjectToPlace(CursorID icon, byte mode, WindowClass window_class, WindowNumber window_num);

   206

   207

void ResetObjectToPlace(void);

   208

   209

bool ScrollWindowToTile(TileIndex tile, Window * w);

   210

bool ScrollWindowTo(int x, int y, Window * w);

   211

   212

bool ScrollMainWindowToTile(TileIndex tile);

   213

bool ScrollMainWindowTo(int x, int y);

   214

void DrawSprite(uint32 img, int x, int y);

   215

uint GetCorrectTileHeight(TileIndex tile);

   216

bool EnsureNoVehicle(TileIndex tile);

   217

bool EnsureNoVehicleZ(TileIndex tile, byte z);

   218

void MarkAllViewportsDirty(int left, int top, int right, int bottom);

   219

void ShowCostOrIncomeAnimation(int x, int y, int z, int32 cost);

   220

void ShowFeederIncomeAnimation(int x, int y, int z, int32 cost);

   221

   222

void DrawFoundation(TileInfo *ti, uint f);

   223

   224

bool CheckIfAuthorityAllows(TileIndex tile);

   225

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   226

void ChangeTownRating(Town *t, int add, int max);

   227

   228

uint GetRoadBitsByTile(TileIndex tile);

   229

int GetTownRadiusGroup(Town *t, TileIndex tile);

   230

void ShowNetworkChatQueryWindow(byte desttype, byte dest);

   231

void ShowNetworkGiveMoneyWindow(byte player);

   232

void ShowNetworkNeedGamePassword(void);

   233

void ShowNetworkNeedCompanyPassword(void);

   234

int FindFirstBit(uint32 x);

   235

void ShowHighscoreTable(int difficulty, int8 rank);

   236

void ShowEndGameChart(void);

   237

TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng);

   238

   239

enum SaveOrLoadResult {

   240

	SL_OK = 0, // completed successfully

   241

	SL_ERROR = 1, // error that was caught before internal structures were modified

   242

	SL_REINIT = 2, // error that was caught in the middle of updating game state, need to clear it. (can only happen during load)

   243

};

   244

enum SaveOrLoadMode {

   245

	SL_INVALID = -1,

   246

	SL_LOAD = 0,

   247

	SL_SAVE = 1,

   248

	SL_OLD_LOAD = 2,

   249

};

   250

   251

int SaveOrLoad(const char *filename, int mode);

   252

   253

void AfterLoadTown(void);

   254

void GenRandomNewGame(uint32 rnd1, uint32 rnd2);

   255

void StartScenarioEditor(uint32 rnd1, uint32 rnd2);

   256

void AskExitGame(void);

   257

void AskExitToGameMenu(void);

   258

   259

void RedrawAutosave(void);

   260

   261

StringID RemapOldStringID(StringID s);

   262

   263

void UpdateViewportSignPos(ViewportSign *sign, int left, int top, StringID str);

   264

   265

enum {

   266

	SLD_LOAD_GAME = 0,

   267

	SLD_LOAD_SCENARIO = 1,

   268

	SLD_SAVE_GAME = 2,

   269

	SLD_SAVE_SCENARIO = 3,

   270

	SLD_NEW_GAME = 4,

   271

};

   272

void ShowSaveLoadDialog(int mode);

   273

   274

// callback from drivers that is called if the game size changes dynamically

   275

void GameSizeChanged(void);

   276

bool FileExists(const char *filename);

   277

bool ReadLanguagePack(int index);

   278

void InitializeLanguagePacks(void);

   279

void *ReadFileToMem(const char *filename, size_t *lenp, size_t maxsize);

   280

int GetLanguageList(char **languages, int max);

   281

   282

void CheckSwitchToEuro(void);

   283

   284

void LoadFromConfig(void);

   285

void SaveToConfig(void);

   286

void CheckConfig(void);

   287

int ttd_main(int argc, char* argv[]);

   288

byte GetOSVersion(void);

   289

   290

void DeterminePaths(void);

   291

char * CDECL str_fmt(const char *str, ...);

   292

   293

void bubblesort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));

   294

bool CreateOTTDThread(void *func, void *param);

   295

void CloseOTTDThread(void);

   296

void JoinOTTDThread(void);

   297

#endif /* FUNCTIONS_H */