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, uint tile);

    12

uint GetTileSlope(uint tile, int *h);

    13

int GetTileZ(uint tile);

    14

    15

void DoClearSquare(uint tile);

    16

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

    17

void SetMapExtraBits(uint tile, byte flags);

    18

uint GetMapExtraBits(uint tile);

    19

void RunTileLoop(void);

    20

    21

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

    22

uint GetSlopeZ(int x, int y);

    23

uint32 GetTileTrackStatus(uint tile, TransportType mode);

    24

void GetAcceptedCargo(uint tile, AcceptedCargo ac);

    25

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

    26

void AnimateTile(uint tile);

    27

void ClickTile(uint tile);

    28

void GetTileDesc(uint tile, TileDesc *td);

    29

void DrawTile(TileInfo *ti);

    30

    31

uint TileAddWrap(TileIndex tile, int addx, int addy);

    32

enum {

    33

	TILE_WRAPPED = (uint)-1

    34

};

    35

    36

bool IsValidTile(uint tile);

    37

    38

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

    39

{

    40

#if !defined(NEW_ROTATION)

    41

	Point pt;

    42

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

    43

	pt.y = y + x - z;

    44

#else

    45

	Point pt;

    46

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

    47

	pt.y = x - y - z;

    48

#endif

    49

	return pt;

    50

}

    51

    52

static inline Point RemapCoords2(int x, int y)

    53

{

    54

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

    55

}

    56

    57

/* game.c */

    58

byte *GetString(byte *buffr, uint16 string);

    59

void InjectDparam(int amount);

    60

    61

int32 GetParamInt32(void);

    62

int GetParamInt16(void);

    63

int GetParamInt8(void);

    64

int GetParamUint16(void);

    65

    66

    67

/* clear_land.c */

    68

void DrawHillyLandTile(TileInfo *ti);

    69

void DrawClearLandTile(TileInfo *ti, byte set);

    70

void DrawClearLandFence(TileInfo *ti, byte img);

    71

void TileLoopClearHelper(uint tile);

    72

    73

/* station_land.c */

    74

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

    75

    76

/* track_land.c */

    77

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

    78

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

    79

    80

/* road_land.c */

    81

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

    82

    83

/* water_land.c */

    84

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

    85

void TileLoop_Water(uint tile);

    86

    87

/* players.c */

    88

bool CheckPlayerHasMoney(int32 cost);

    89

void SubtractMoneyFromPlayer(int32 cost);

    90

void SubtractMoneyFromPlayerFract(byte player, int32 cost);

    91

bool CheckOwnership(byte owner);

    92

bool CheckTileOwnership(uint tile);

    93

StringID GetPlayerNameString(byte player, byte index);

    94

    95

/* standard */

    96

void ShowInfo(const char *str);

    97

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

    98

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

    99

   100

/* ttd.c */

   101

   102

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

   103

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

   104

// *

   105

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

   106

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

   107

// *  is to help finding desync problems.

   108

// *

   109

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

   110

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

   111

   112

//#define RANDOM_DEBUG

   113

   114

#ifdef RANDOM_DEBUG

   115

	#define Random() DoRandom(__LINE__, __FILE__)

   117

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

   119

#else

   120

	uint32 Random(void);

   121

	uint RandomRange(uint max);

   122

#endif

   123

   124

void InitPlayerRandoms(void);

   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

   129

void SetDate(uint date);

   130

/* facedraw.c */

   131

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

   132

   133

/* texteff.c */

   134

void MoveAllTextEffects(void);

   135

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

   136

void InitTextEffects(void);

   137

void DrawTextEffects(DrawPixelInfo *dpi);

   138

   139

void InitTextMessage(void);

   140

void DrawTextMessage(void);

   141

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

   142

void UndrawTextMessage(void);

   143

void TextMessageDailyLoop(void);

   144

   145

bool AddAnimatedTile(uint tile);

   146

void DeleteAnimatedTile(uint tile);

   147

void AnimateAnimatedTiles(void);

   148

void InitializeAnimatedTiles(void);

   149

   150

/* tunnelbridge_cmd.c */

   151

bool CheckTunnelInWay(uint tile, int z);

   152

bool CheckBridge_Stuff(byte bridge_type, int bridge_len);

   153

uint32 GetBridgeLength(TileIndex begin, TileIndex end);

   154

int CalcBridgeLenCostFactor(int x);

   155

   156

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

   157

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

   158

   159

/* network.c */

   160

void NetworkUDPClose(void);

   161

void NetworkStartUp(void);

   162

void NetworkShutDown(void);

   163

void NetworkGameLoop(void);

   164

void NetworkUDPGameLoop(void);

   165

bool NetworkServerStart(void);

   166

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

   167

void NetworkReboot(void);

   168

void NetworkDisconnect(void);

   169

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

   170

   171

/* misc_cmd.c */

   172

void PlaceTreesRandomly(void);

   173

   174

uint GetTileDist(TileIndex xy1, TileIndex xy2);

   175

uint GetTileDist1D(TileIndex xy1, TileIndex xy2);

   176

uint GetTileDist1Db(TileIndex xy1, TileIndex xy2);

   177

uint GetTileDistAdv(TileIndex xy1, TileIndex xy2);

   178

bool CheckDistanceFromEdge(TileIndex tile, uint distance);

   179

   180

void InitializeLandscapeVariables(bool only_constants);

   181

   182

/* misc.c */

   183

void DeleteName(StringID id);

   184

byte *GetName(int id, byte *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 byte *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

void CSleep(int milliseconds);

   195

   196

   197

/* misc functions */

   198

void MarkTileDirty(int x, int y);

   199

void MarkTileDirtyByTile(TileIndex tile);

   200

void InvalidateWindow(byte cls, WindowNumber number);

   201

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

   202

void InvalidateWindowClasses(byte cls);

   203

void DeleteWindowById(WindowClass cls, WindowNumber number);

   204

void DeleteWindowByClass(WindowClass cls);

   205

   206

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

   207

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

   208

   209

void ResetObjectToPlace(void);

   210

   211

bool ScrollWindowToTile(TileIndex tile, Window * w);

   212

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

   213

   214

bool ScrollMainWindowToTile(TileIndex tile);

   215

bool ScrollMainWindowTo(int x, int y);

   216

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

   217

uint GetCorrectTileHeight(TileIndex tile);

   218

bool EnsureNoVehicle(TileIndex tile);

   219

bool EnsureNoVehicleZ(TileIndex tile, byte z);

   220

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

   221

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

   222

   223

void DrawFoundation(TileInfo *ti, uint f);

   224

   225

bool CheckIfAuthorityAllows(uint tile);

   226

Town *ClosestTownFromTile(uint tile, uint threshold);

   227

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

   228

   229

uint GetRoadBitsByTile(TileIndex tile);

   230

int GetTownRadiusGroup(Town *t, uint tile);

   231

void ShowNetworkChatQueryWindow(byte desttype, byte dest);

   232

void ShowNetworkGiveMoneyWindow(byte player);

   233

void ShowNetworkNeedGamePassword(void);

   234

void ShowNetworkNeedCompanyPassword(void);

   235

void ShowRenameWaypointWindow(Waypoint *cp);

   236

int FindFirstBit(uint32 x);

   237

void ShowHighscoreTable(int difficulty, int8 rank);

   238

void ShowEndGameChart(void);

   239

TileIndex AdjustTileCoordRandomly(TileIndex a, byte rng);

   240

   241

enum SaveOrLoadResult {

   242

	SL_OK = 0, // completed successfully

   243

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

   244

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

   245

};

   246

enum SaveOrLoadMode {

   247

	SL_INVALID = -1,

   248

	SL_LOAD = 0,

   249

	SL_SAVE = 1,

   250

	SL_OLD_LOAD = 2,

   251

};

   252

   253

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

   254

   255

void AfterLoadTown(void);

   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

void ttd_strlcpy(char *dst, const char *src, size_t size);

   275

void ttd_strlcat(char *dst, const char *src, size_t size);

   276

   277

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

   278

void GameSizeChanged(void);

   279

bool FileExists(const char *filename);

   280

bool ReadLanguagePack(int index);

   281

void InitializeLanguagePacks(void);

   282

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

   283

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

   284

   285

void CheckSwitchToEuro(void);

   286

   287

void LoadFromConfig(void);

   288

void SaveToConfig(void);

   289

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

   290

byte GetOSVersion(void);

   291

   292

void DeterminePaths(void);

   293

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

   294

   295

#endif /* FUNCTIONS_H */