1

/* $Id$ */

     2

     3

#ifndef FUNCTIONS_H

     4

#define FUNCTIONS_H

     5

     6

/* vehicle.c */

     7

     8

/* window.c */

     9

    10

    11

/* landscape.c */

    12

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

    13

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile);

    14

    15

void DoClearSquare(TileIndex tile);

    16

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

    17

void RunTileLoop(void);

    18

    19

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

    20

uint GetSlopeZ(int x, int y);

    21

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode);

    22

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac);

    23

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

    24

void AnimateTile(TileIndex tile);

    25

void ClickTile(TileIndex tile);

    26

void GetTileDesc(TileIndex tile, TileDesc *td);

    27

void DrawTile(TileInfo *ti);

    28

void UpdateTownMaxPass(Town *t);

    29

    30

bool IsValidTile(TileIndex tile);

    31

    32

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

    33

{

    34

#if !defined(NEW_ROTATION)

    35

	Point pt;

    36

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

    37

	pt.y = y + x - z;

    38

#else

    39

	Point pt;

    40

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

    41

	pt.y = x - y - z;

    42

#endif

    43

	return pt;

    44

}

    45

    46

static inline Point RemapCoords2(int x, int y)

    47

{

    48

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

    49

}

    50

    51

    52

/* clear_land.c */

    53

void DrawHillyLandTile(TileInfo *ti);

    54

void DrawClearLandTile(TileInfo *ti, byte set);

    55

void DrawClearLandFence(const TileInfo *ti);

    56

void TileLoopClearHelper(TileIndex tile);

    57

    58

/* station_land.c */

    59

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

    60

    61

/* track_land.c */

    62

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

    63

void DrawDefaultWaypointSprite(int x, int y, int railtype);

    64

    65

/* road_land.c */

    66

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

    67

    68

/* water_land.c */

    69

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

    70

void TileLoop_Water(TileIndex tile);

    71

    72

/* players.c */

    73

bool CheckPlayerHasMoney(int32 cost);

    74

void SubtractMoneyFromPlayer(int32 cost);

    75

void SubtractMoneyFromPlayerFract(byte player, int32 cost);

    76

bool CheckOwnership(byte owner);

    77

bool CheckTileOwnership(TileIndex tile);

    78

StringID GetPlayerNameString(byte player, byte index);

    79

    80

/* standard */

    81

void ShowInfo(const char *str);

    82

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

    83

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

    84

    85

/* openttd.c */

    86

    87

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

    88

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

    89

// *

    90

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

    91

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

    92

// *  is to help finding desync problems.

    93

// *

    94

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

    95

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

    96

    97

//#define RANDOM_DEBUG

    98

    99

   100

// Enable this to produce higher quality random numbers.

   101

// Doesn't work with network yet.

   102

//#define MERSENNE_TWISTER

   103

   104

// Mersenne twister functions

   105

void SeedMT(uint32 seed);

   106

uint32 RandomMT(void);

   107

   108

   109

#ifdef MERSENNE_TWISTER

   110

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

   111

	uint RandomRange(uint max);

   112

#else

   113

   114

#ifdef RANDOM_DEBUG

   115

	#define Random() DoRandom(__LINE__, __FILE__)

   116

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

   117

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

   118

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

   119

#else

   120

	uint32 Random(void);

   121

	uint RandomRange(uint max);

   122

#endif

   123

#endif // MERSENNE_TWISTER

   124

   125

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

   126

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

   127

   128

   129

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

   130

uint InteractiveRandomRange(uint max);

   131

   132

   133

// Used for profiling

   134

#define TIC() { extern uint32 rdtsc(void); uint32 _xxx_ = rdtsc(); static float __avg__;

   135

#define TOC(s) 	_xxx_ = rdtsc() - _xxx_; __avg__=__avg__*0.99+_xxx_*0.01; printf("%s: %8d %f\n", s, _xxx_,__avg__); }

   136

   137

   138

void SetDate(uint date);

   139

/* facedraw.c */

   140

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

   141

   142

/* texteff.c */

   143

void MoveAllTextEffects(void);

   144

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

   145

void InitTextEffects(void);

   146

void DrawTextEffects(DrawPixelInfo *dpi);

   147

   148

void InitTextMessage(void);

   149

void DrawTextMessage(void);

   150

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

   151

void UndrawTextMessage(void);

   152

void TextMessageDailyLoop(void);

   153

   154

bool AddAnimatedTile(TileIndex tile);

   155

void DeleteAnimatedTile(TileIndex tile);

   156

void AnimateAnimatedTiles(void);

   157

void InitializeAnimatedTiles(void);

   158

   159

/* tunnelbridge_cmd.c */

   160

bool CheckTunnelInWay(TileIndex tile, int z);

   161

bool CheckBridge_Stuff(byte bridge_type, int bridge_len);

   162

uint32 GetBridgeLength(TileIndex begin, TileIndex end);

   163

int CalcBridgeLenCostFactor(int x);

   164

   165

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

   166

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

   167

   168

/* network.c */

   169

void NetworkUDPClose(void);

   170

void NetworkStartUp(void);

   171

void NetworkShutDown(void);

   172

void NetworkGameLoop(void);

   173

void NetworkUDPGameLoop(void);

   174

bool NetworkServerStart(void);

   175

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

   176

void NetworkReboot(void);

   177

void NetworkDisconnect(void);

   178

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

   179

   180

/* misc_cmd.c */

   181

void PlaceTreesRandomly(void);

   182

   183

void InitializeLandscapeVariables(bool only_constants);

   184

   185

/* misc.c */

   186

void DeleteName(StringID id);

   187

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

   188

   189

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

   190

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

   191

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

   192

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

   193

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

   194

void ConvertDayToYMD(YearMonthDay *ymd, uint16 date);

   195

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

   196

uint ConvertIntDate(uint date);

   197

   198

/* misc functions */

   199

void MarkTileDirty(int x, int y);

   200

void MarkTileDirtyByTile(TileIndex tile);

   201

void InvalidateWindow(byte cls, WindowNumber number);

   202

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

   203

void InvalidateWindowClasses(byte cls);

   204

void DeleteWindowById(WindowClass cls, WindowNumber number);

   205

void DeleteWindowByClass(WindowClass cls);

   206

   207

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

   208

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

   209

   210

void ResetObjectToPlace(void);

   211

   212

bool ScrollWindowToTile(TileIndex tile, Window * w);

   213

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

   214

   215

bool ScrollMainWindowToTile(TileIndex tile);

   216

bool ScrollMainWindowTo(int x, int y);

   217

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

   218

uint GetCorrectTileHeight(TileIndex tile);

   219

bool EnsureNoVehicle(TileIndex tile);

   220

bool EnsureNoVehicleZ(TileIndex tile, byte z);

   221

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

   222

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

   223

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

   224

   225

void DrawFoundation(TileInfo *ti, uint f);

   226

   227

bool CheckIfAuthorityAllows(TileIndex tile);

   228

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   229

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

   230

   231

uint GetRoadBitsByTile(TileIndex tile);

   232

int GetTownRadiusGroup(Town *t, TileIndex tile);

   233

void ShowNetworkChatQueryWindow(byte desttype, byte dest);

   234

void ShowNetworkGiveMoneyWindow(byte player);

   235

void ShowNetworkNeedGamePassword(void);

   236

void ShowNetworkNeedCompanyPassword(void);

   237

int FindFirstBit(uint32 x);

   238

void ShowHighscoreTable(int difficulty, int8 rank);

   239

void ShowEndGameChart(void);

   240

TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng);

   241

   242

void AfterLoadTown(void);

   243

void GenRandomNewGame(uint32 rnd1, uint32 rnd2);

   244

void StartScenarioEditor(uint32 rnd1, uint32 rnd2);

   245

void AskExitGame(void);

   246

void AskExitToGameMenu(void);

   247

   248

void RedrawAutosave(void);

   249

   250

StringID RemapOldStringID(StringID s);

   251

   252

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

   253

   254

enum {

   255

	SLD_LOAD_GAME = 0,

   256

	SLD_LOAD_SCENARIO = 1,

   257

	SLD_SAVE_GAME = 2,

   258

	SLD_SAVE_SCENARIO = 3,

   259

	SLD_NEW_GAME = 4,

   260

};

   261

void ShowSaveLoadDialog(int mode);

   262

   263

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

   264

void GameSizeChanged(void);

   265

bool FileExists(const char *filename);

   266

bool ReadLanguagePack(int index);

   267

void InitializeLanguagePacks(void);

   268

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

   269

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

   270

   271

void LoadFromConfig(void);

   272

void SaveToConfig(void);

   273

void CheckConfig(void);

   274

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

   275

   276

void DeterminePaths(void);

   277

   278

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

   280

#endif /* FUNCTIONS_H */