1

/* $Id$ */

     2

     3

#ifndef FUNCTIONS_H

     4

#define FUNCTIONS_H

     5

     6

void DoClearSquare(TileIndex tile);

     7

void RunTileLoop(void);

     8

     9

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

    10

uint GetSlopeZ(int x, int y);

    11

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode);

    12

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac);

    13

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

    14

void AnimateTile(TileIndex tile);

    15

void ClickTile(TileIndex tile);

    16

void GetTileDesc(TileIndex tile, TileDesc *td);

    17

void UpdateTownMaxPass(Town *t);

    18

    19

bool IsValidTile(TileIndex tile);

    20

    21

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

    22

{

    23

#if !defined(NEW_ROTATION)

    24

	Point pt;

    25

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

    26

	pt.y = y + x - z;

    27

#else

    28

	Point pt;

    29

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

    30

	pt.y = x - y - z;

    31

#endif

    32

	return pt;

    33

}

    34

    35

static inline Point RemapCoords2(int x, int y)

    36

{

    37

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

    38

}

    39

    40

    41

/* clear_land.c */

    42

void DrawHillyLandTile(const TileInfo *ti);

    43

void DrawClearLandTile(const TileInfo *ti, byte set);

    44

void DrawClearLandFence(const TileInfo *ti);

    45

void TileLoopClearHelper(TileIndex tile);

    46

    47

/* water_land.c */

    48

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

    49

void TileLoop_Water(TileIndex tile);

    50

    51

/* players.c */

    52

bool CheckPlayerHasMoney(int32 cost);

    53

void SubtractMoneyFromPlayer(int32 cost);

    54

void SubtractMoneyFromPlayerFract(PlayerID player, int32 cost);

    55

bool CheckOwnership(Owner owner);

    56

bool CheckTileOwnership(TileIndex tile);

    57

StringID GetPlayerNameString(PlayerID player, uint index);

    58

    59

/* standard */

    60

void ShowInfo(const char *str);

    61

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

    62

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

    63

    64

/* openttd.c */

    65

    66

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

    67

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

    68

 *

    69

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

    70

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

    71

 *  is to help finding desync problems.

    72

 *

    73

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

    74

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

    75

    76

//#define RANDOM_DEBUG

    77

    78

    79

// Enable this to produce higher quality random numbers.

    80

// Doesn't work with network yet.

    81

//#define MERSENNE_TWISTER

    82

    83

// Mersenne twister functions

    84

void SeedMT(uint32 seed);

    85

uint32 RandomMT(void);

    86

    87

    88

#ifdef MERSENNE_TWISTER

    89

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

    90

	uint RandomRange(uint max);

    91

#else

    92

    93

#ifdef RANDOM_DEBUG

    94

	#define Random() DoRandom(__LINE__, __FILE__)

    95

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

    96

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

    97

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

    98

#else

    99

	uint32 Random(void);

   100

	uint RandomRange(uint max);

   101

#endif

   102

#endif // MERSENNE_TWISTER

   103

   104

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

   105

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

   106

   107

   108

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

   109

uint InteractiveRandomRange(uint max);

   110

   111

/* facedraw.c */

   112

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

   113

   114

/* texteff.c */

   115

void MoveAllTextEffects(void);

   116

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

   117

void InitTextEffects(void);

   118

void DrawTextEffects(DrawPixelInfo *dpi);

   119

   120

void InitTextMessage(void);

   121

void DrawTextMessage(void);

   122

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

   123

void UndrawTextMessage(void);

   124

   125

bool AddAnimatedTile(TileIndex tile);

   126

void DeleteAnimatedTile(TileIndex tile);

   127

void AnimateAnimatedTiles(void);

   128

void InitializeAnimatedTiles(void);

   129

   130

/* tunnelbridge_cmd.c */

   131

bool CheckBridge_Stuff(byte bridge_type, uint bridge_len);

   132

uint32 GetBridgeLength(TileIndex begin, TileIndex end);

   133

int CalcBridgeLenCostFactor(int x);

   134

   135

/* misc_cmd.c */

   136

void PlaceTreesRandomly(void);

   137

   138

void InitializeLandscapeVariables(bool only_constants);

   139

   140

/* misc.c */

   141

bool IsCustomName(StringID id);

   142

void DeleteName(StringID id);

   143

char *GetName(char *buff, StringID id, const char* last);

   144

   145

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

   146

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

   147

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

   148

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

   149

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

   150

void ConvertNameArray(void);

   151

   152

/* misc functions */

   153

void MarkTileDirty(int x, int y);

   154

void MarkTileDirtyByTile(TileIndex tile);

   155

void InvalidateWindow(WindowClass cls, WindowNumber number);

   156

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

   157

void InvalidateWindowClasses(WindowClass cls);

   158

void InvalidateWindowClassesData(WindowClass cls);

   159

void DeleteWindowById(WindowClass cls, WindowNumber number);

   160

void DeleteWindowByClass(WindowClass cls);

   161

   162

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

   163

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

   164

   165

void ResetObjectToPlace(void);

   166

   167

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

   168

   169

bool ScrollMainWindowToTile(TileIndex tile);

   170

bool ScrollMainWindowTo(int x, int y);

   171

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

   172

bool EnsureNoVehicle(TileIndex tile);

   173

bool EnsureNoVehicleOnGround(TileIndex tile);

   174

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

   175

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

   176

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

   177

   178

void DrawFoundation(TileInfo *ti, uint f);

   179

   180

bool CheckIfAuthorityAllows(TileIndex tile);

   181

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   182

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

   183

   184

uint GetTownRadiusGroup(const Town* t, TileIndex tile);

   185

int FindFirstBit(uint32 x);

   186

void ShowHighscoreTable(int difficulty, int8 rank);

   187

TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng);

   188

   189

void AfterLoadTown(void);

   190

void UpdatePatches(void);

   191

void AskExitGame(void);

   192

void AskExitToGameMenu(void);

   193

   194

void RedrawAutosave(void);

   195

   196

StringID RemapOldStringID(StringID s);

   197

   198

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

   199

   200

enum {

   201

	SLD_LOAD_GAME,

   202

	SLD_LOAD_SCENARIO,

   203

	SLD_SAVE_GAME,

   204

	SLD_SAVE_SCENARIO,

   205

	SLD_LOAD_HEIGHTMAP,

   206

	SLD_NEW_GAME,

   207

};

   208

void ShowSaveLoadDialog(int mode);

   209

   210

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

   211

void GameSizeChanged(void);

   212

bool FileExists(const char *filename);

   213

bool ReadLanguagePack(int index);

   214

void InitializeLanguagePacks(void);

   215

const char *GetCurrentLocale(const char *param);

   216

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

   217

   218

void LoadFromConfig(void);

   219

void SaveToConfig(void);

   220

void CheckConfig(void);

   221

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

   222

void HandleExitGameRequest(void);

   223

   224

void DeterminePaths(void);

   225

   226

void CSleep(int milliseconds);

   227

#endif /* FUNCTIONS_H */