1

/* $Id$ */

     2

     3

/** @file map.h */

     4

     5

#ifndef MAP_H

     6

#define MAP_H

     7

     8

#include "stdafx.h"

     9

#include "direction.h"

    10

    11

extern uint _map_tile_mask;

    12

    13

/**

    14

 * 'Wraps' the given tile to it is within the map. It does

    15

 * this by masking the 'high' bits of.

    16

 * @param x the tile to 'wrap'

    17

 */

    18

    19

#define TILE_MASK(x) ((x) & _map_tile_mask)

    20

/**

    21

 * Asserts when the tile is outside of the map.

    22

 * @param x the tile to check

    23

 */

    24

#define TILE_ASSERT(x) assert(TILE_MASK(x) == (x));

    25

    26

/**

    27

 * Data that is stored per tile. Also used TileExtended for this.

    28

 * Look at docs/landscape.html for the exact meaning of the members.

    29

 */

    30

struct Tile {

    31

	byte type_height; ///< The type (bits 4..7) and height of the northern corner

    32

	byte m1;   ///< Primarily used for ownership information

    33

	uint16 m2; ///< Primarily used for indices to towns, industries and stations

    34

	byte m3;   ///< General purpose

    35

	byte m4;   ///< General purpose

    36

	byte m5;   ///< General purpose

    37

	byte m6;   ///< Primarily used for bridges and rainforest/desert

    38

};

    39

    40

/**

    41

 * Data that is stored per tile. Also used Tile for this.

    42

 * Look at docs/landscape.html for the exact meaning of the members.

    43

 */

    44

struct TileExtended {

    45

	byte m7; ///< Primarily used for newgrf support

    46

};

    47

    48

extern Tile *_m;

    49

extern TileExtended *_me;

    50

    51

void AllocateMap(uint size_x, uint size_y);

    52

    53

/**

    54

 * Logarithm of the map size along the X side.

    55

 * @note try to avoid using this one

    56

 * @return 2^"return value" == MapSizeX()

    57

 */

    58

static inline uint MapLogX()

    59

{

    60

	extern uint _map_log_x;

    61

	return _map_log_x;

    62

}

    63

    64

/**

    65

 * Get the size of the map along the X

    66

 * @return the number of tiles along the X of the map

    67

 */

    68

static inline uint MapSizeX()

    69

{

    70

	extern uint _map_size_x;

    71

	return _map_size_x;

    72

}

    73

    74

/**

    75

 * Get the size of the map along the Y

    76

 * @return the number of tiles along the Y of the map

    77

 */

    78

static inline uint MapSizeY()

    79

{

    80

	extern uint _map_size_y;

    81

	return _map_size_y;

    82

}

    83

    84

/**

    85

 * Get the size of the map

    86

 * @return the number of tiles of the map

    87

 */

    88

static inline uint MapSize()

    89

{

    90

	extern uint _map_size;

    91

	return _map_size;

    92

}

    93

    94

/**

    95

 * Gets the maximum X coordinate within the map, including MP_VOID

    96

 * @return the maximum X coordinate

    97

 */

    98

static inline uint MapMaxX()

    99

{

   100

	return MapSizeX() - 1;

   101

}

   102

   103

/**

   104

 * Gets the maximum X coordinate within the map, including MP_VOID

   105

 * @return the maximum X coordinate

   106

 */

   107

static inline uint MapMaxY()

   108

{

   109

	return MapSizeY() - 1;

   110

}

   111

   112

/* Scale a number relative to the map size */

   113

uint ScaleByMapSize(uint); // Scale relative to the number of tiles

   114

uint ScaleByMapSize1D(uint); // Scale relative to the circumference of the map

   115

   116

typedef uint32 TileIndex;

   117

typedef int32 TileIndexDiff;

   118

   119

static inline TileIndex TileXY(uint x, uint y)

   120

{

   121

	return (y * MapSizeX()) + x;

   122

}

   123

   124

static inline TileIndexDiff TileDiffXY(int x, int y)

   125

{

   126

	/* Multiplication gives much better optimization on MSVC than shifting.

   127

	 * 0 << shift isn't optimized to 0 properly.

   128

	 * Typically x and y are constants, and then this doesn't result

   129

	 * in any actual multiplication in the assembly code.. */

   130

	return (y * MapSizeX()) + x;

   131

}

   132

   133

static inline TileIndex TileVirtXY(uint x, uint y)

   134

{

   135

	return (y >> 4 << MapLogX()) + (x >> 4);

   136

}

   137

   138

   139

enum {

   140

	INVALID_TILE = (TileIndex)-1 ///< The very nice invalid tile marker

   141

};

   142

   143

enum {

   144

	TILE_SIZE   = 16,   ///< Tiles are 16x16 "units" in size

   145

	TILE_PIXELS = 32,   ///< a tile is 32x32 pixels

   146

	TILE_HEIGHT =  8,   ///< The standard height-difference between tiles on two levels is 8 (z-diff 8)

   147

};

   148

   149

   150

/**

   151

 * Get the X component of a tile

   152

 * @param tile the tile to get the X component of

   153

 * @return the X component

   154

 */

   155

static inline uint TileX(TileIndex tile)

   156

{

   157

	return tile & MapMaxX();

   158

}

   159

   160

/**

   161

 * Get the Y component of a tile

   162

 * @param tile the tile to get the Y component of

   163

 * @return the Y component

   164

 */

   165

static inline uint TileY(TileIndex tile)

   166

{

   167

	return tile >> MapLogX();

   168

}

   169

   170

   171

struct TileIndexDiffC {

   172

	int16 x;

   173

	int16 y;

   174

};

   175

   176

static inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)

   177

{

   178

	return (tidc.y << MapLogX()) + tidc.x;

   179

}

   180

   181

   182

#ifndef _DEBUG

   183

	#define TILE_ADD(x,y) ((x) + (y))

   184

#else

   185

	extern TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

   186

		const char *exp, const char *file, int line);

   187

	#define TILE_ADD(x, y) (TileAdd((x), (y), #x " + " #y, __FILE__, __LINE__))

   188

#endif

   189

   190

#define TILE_ADDXY(tile, x, y) TILE_ADD(tile, TileDiffXY(x, y))

   191

   192

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

   193

   194

static inline TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)

   195

{

   196

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   197

   198

	assert(IsValidDiagDirection(dir));

   199

	return _tileoffs_by_diagdir[dir];

   200

}

   201

   202

/* Returns tile + the diff given in diff. If the result tile would end up

   203

 * outside of the map, INVALID_TILE is returned instead.

   204

 */

   205

static inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)

   206

{

   207

	int x = TileX(tile) + diff.x;

   208

	int y = TileY(tile) + diff.y;

   209

	if (x < 0 || y < 0 || x > (int)MapMaxX() || y > (int)MapMaxY())

   210

		return INVALID_TILE;

   211

	else

   212

		return TileXY(x, y);

   213

}

   214

   215

/**

   216

 * Returns the diff between two tiles

   217

 *

   218

 * @param tile_a from tile

   219

 * @param tile_b to tile

   220

 * @return the difference between tila_a and tile_b

   221

 */

   222

static inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)

   223

{

   224

	TileIndexDiffC difference;

   225

   226

	difference.x = TileX(tile_a) - TileX(tile_b);

   227

	difference.y = TileY(tile_a) - TileY(tile_b);

   228

   229

	return difference;

   230

}

   231

   232

/* Functions to calculate distances */

   233

uint DistanceManhattan(TileIndex, TileIndex); ///< also known as L1-Norm. Is the shortest distance one could go over diagonal tracks (or roads)

   234

uint DistanceSquare(TileIndex, TileIndex); ///< euclidian- or L2-Norm squared

   235

uint DistanceMax(TileIndex, TileIndex); ///< also known as L-Infinity-Norm

   236

uint DistanceMaxPlusManhattan(TileIndex, TileIndex); ///< Max + Manhattan

   237

uint DistanceFromEdge(TileIndex); ///< shortest distance from any edge of the map

   238

   239

   240

#define BEGIN_TILE_LOOP(var, w, h, tile)                      \

   241

	{                                                        \

   242

		int h_cur = h;                                         \

   243

		uint var = tile;                                       \

   244

		do {                                                   \

   245

			int w_cur = w;                                       \

   246

			do {

   247

   248

#define END_TILE_LOOP(var, w, h, tile)                        \

   249

			} while (++var, --w_cur != 0);                       \

   250

		} while (var += TileDiffXY(0, 1) - (w), --h_cur != 0); \

   251

	}

   252

   253

static inline TileIndexDiff TileOffsByDiagDir(DiagDirection dir)

   254

{

   255

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   256

   257

	assert(IsValidDiagDirection(dir));

   258

	return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);

   259

}

   260

   261

static inline TileIndexDiff TileOffsByDir(Direction dir)

   262

{

   263

	extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];

   264

   265

	assert(IsValidDirection(dir));

   266

	return ToTileIndexDiff(_tileoffs_by_dir[dir]);

   267

}

   268

   269

typedef bool TestTileOnSearchProc(TileIndex tile, uint32 data);

   270

bool CircularTileSearch(TileIndex tile, uint size, TestTileOnSearchProc proc, uint32 data);

   271

   272

/* Approximation of the length of a straight track, relative to a diagonal

   273

 * track (ie the size of a tile side). #defined instead of const so it can

   274

 * stay integer. (no runtime float operations) Is this needed?

   275

 * Watch out! There are _no_ brackets around here, to prevent intermediate

   276

 * rounding! Be careful when using this!

   277

 * This value should be sqrt(2)/2 ~ 0.7071 */

   278

#define STRAIGHT_TRACK_LENGTH 7071/10000

   279

   280

#endif /* MAP_H */