1

/* $Id$ */

     2

     3

#ifndef FUNCTIONS_H

     4

#define FUNCTIONS_H

     5

     6

/* landscape.c */

     7

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

     8

     9

void DoClearSquare(TileIndex tile);

    10

void RunTileLoop(void);

    11

    12

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

    13

uint GetSlopeZ(int x, int y);

    14

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode);

    15

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac);

    16

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

    17

void AnimateTile(TileIndex tile);

    18

void ClickTile(TileIndex tile);

    19

void GetTileDesc(TileIndex tile, TileDesc *td);

    20

void DrawTile(TileInfo *ti);

    21

void UpdateTownMaxPass(Town *t);

    22

    23

bool IsValidTile(TileIndex tile);

    24

    25

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

    26

{

    27

#if !defined(NEW_ROTATION)

    28

	Point pt;

    29

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

    30

	pt.y = y + x - z;

    31

#else

    32

	Point pt;

    33

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

    34

	pt.y = x - y - z;

    35

#endif

    36

	return pt;

    37

}

    38

    39

static inline Point RemapCoords2(int x, int y)

    40

{

    41

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

    42

}

    43

    44

    45

/* clear_land.c */

    46

void DrawHillyLandTile(const TileInfo *ti);

    47

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

    48

void DrawClearLandFence(const TileInfo *ti);

    49

void TileLoopClearHelper(TileIndex tile);

    50

    51

/* road_land.c */

    52

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

    53

    54

/* water_land.c */

    55

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

    56

void TileLoop_Water(TileIndex tile);

    57

    58

/* players.c */

    59

bool CheckPlayerHasMoney(int32 cost);

    60

void SubtractMoneyFromPlayer(int32 cost);

    61

void SubtractMoneyFromPlayerFract(PlayerID player, int32 cost);

    62

bool CheckOwnership(PlayerID owner);

    63

bool CheckTileOwnership(TileIndex tile);

    64

StringID GetPlayerNameString(PlayerID player, uint index);

    65

    66

/* standard */

    67

void ShowInfo(const char *str);

    68

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

    69

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

    70

    71

/* openttd.c */

    72

    73

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

    74

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

    75

// *

    76

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

    77

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

    78

// *  is to help finding desync problems.

    79

// *

    80

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

    81

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

    82

    83

//#define RANDOM_DEBUG

    84

    85

    86

// Enable this to produce higher quality random numbers.

    87

// Doesn't work with network yet.

    88

//#define MERSENNE_TWISTER

    89

    90

// Mersenne twister functions

    91

void SeedMT(uint32 seed);

    92

uint32 RandomMT(void);

    93

    94

    95

#ifdef MERSENNE_TWISTER

    96

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

    97

	uint RandomRange(uint max);

    98

#else

    99

   100

#ifdef RANDOM_DEBUG

   101

	#define Random() DoRandom(__LINE__, __FILE__)

   102

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

   103

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

   104

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

   105

#else

   106

	uint32 Random(void);

   107

	uint RandomRange(uint max);

   108

#endif

   109

#endif // MERSENNE_TWISTER

   110

   111

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

   112

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

   113

   114

   115

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

   116

uint InteractiveRandomRange(uint max);

   117

   118

void SetDate(uint date);

   119

/* facedraw.c */

   120

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

   121

   122

/* texteff.c */

   123

void MoveAllTextEffects(void);

   124

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

   125

void InitTextEffects(void);

   126

void DrawTextEffects(DrawPixelInfo *dpi);

   127

   128

void InitTextMessage(void);

   129

void DrawTextMessage(void);

   130

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

   131

void UndrawTextMessage(void);

   132

void TextMessageDailyLoop(void);

   133

   134

bool AddAnimatedTile(TileIndex tile);

   135

void DeleteAnimatedTile(TileIndex tile);

   136

void AnimateAnimatedTiles(void);

   137

void InitializeAnimatedTiles(void);

   138

   139

/* tunnelbridge_cmd.c */

   140

bool CheckBridge_Stuff(byte bridge_type, uint bridge_len);

   141

uint32 GetBridgeLength(TileIndex begin, TileIndex end);

   142

int CalcBridgeLenCostFactor(int x);

   143

   144

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

   145

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

   146

   147

/* network.c */

   148

void NetworkUDPClose(void);

   149

void NetworkStartUp(void);

   150

void NetworkShutDown(void);

   151

void NetworkGameLoop(void);

   152

void NetworkUDPGameLoop(void);

   153

bool NetworkServerStart(void);

   154

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

   155

void NetworkReboot(void);

   156

void NetworkDisconnect(void);

   157

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

   158

   159

/* misc_cmd.c */

   160

void PlaceTreesRandomly(void);

   161

   162

void InitializeLandscapeVariables(bool only_constants);

   163

   164

/* misc.c */

   165

void DeleteName(StringID id);

   166

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

   167

   168

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

   169

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

   170

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

   171

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

   172

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

   173

void ConvertDayToYMD(YearMonthDay *ymd, uint16 date);

   174

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

   175

uint ConvertIntDate(uint date);

   176

   177

/* misc functions */

   178

void MarkTileDirty(int x, int y);

   179

void MarkTileDirtyByTile(TileIndex tile);

   180

void InvalidateWindow(WindowClass cls, WindowNumber number);

   181

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

   182

void InvalidateWindowClasses(WindowClass cls);

   183

void DeleteWindowById(WindowClass cls, WindowNumber number);

   184

void DeleteWindowByClass(WindowClass cls);

   185

   186

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

   187

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

   188

   189

void ResetObjectToPlace(void);

   190

   191

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

   192

   193

bool ScrollMainWindowToTile(TileIndex tile);

   194

bool ScrollMainWindowTo(int x, int y);

   195

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

   196

bool EnsureNoVehicle(TileIndex tile);

   197

bool EnsureNoVehicleOnGround(TileIndex tile);

   198

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

   199

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

   200

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

   201

   202

void DrawFoundation(TileInfo *ti, uint f);

   203

   204

bool CheckIfAuthorityAllows(TileIndex tile);

   205

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   206

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

   207

   208

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

   209

void ShowNetworkChatQueryWindow(byte desttype, byte dest);

   210

void ShowNetworkGiveMoneyWindow(byte player);

   211

void ShowNetworkNeedGamePassword(void);

   212

void ShowNetworkNeedCompanyPassword(void);

   213

int FindFirstBit(uint32 x);

   214

void ShowHighscoreTable(int difficulty, int8 rank);

   215

void ShowEndGameChart(void);

   216

TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng);

   217

   218

void AfterLoadTown(void);

   219

void UpdatePatches(void);

   220

void GenRandomNewGame(uint32 rnd1, uint32 rnd2);

   221

void StartScenarioEditor(uint32 rnd1, uint32 rnd2);

   222

void AskExitGame(void);

   223

void AskExitToGameMenu(void);

   224

   225

void RedrawAutosave(void);

   226

   227

StringID RemapOldStringID(StringID s);

   228

   229

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

   230

   231

enum {

   232

	SLD_LOAD_GAME = 0,

   233

	SLD_LOAD_SCENARIO = 1,

   234

	SLD_SAVE_GAME = 2,

   235

	SLD_SAVE_SCENARIO = 3,

   236

	SLD_NEW_GAME = 4,

   237

};

   238

void ShowSaveLoadDialog(int mode);

   239

   240

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

   241

void GameSizeChanged(void);

   242

bool FileExists(const char *filename);

   243

bool ReadLanguagePack(int index);

   244

void InitializeLanguagePacks(void);

   245

const char *GetCurrentLocale(const char *param);

   246

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

   247

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

   248

   249

void LoadFromConfig(void);

   250

void SaveToConfig(void);

   251

void CheckConfig(void);

   252

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

   253

   254

void DeterminePaths(void);

   255

   256

void CSleep(int milliseconds);

   257

#endif /* FUNCTIONS_H */