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

/**

    49

 * Pointer to the tile-array.

    50

 *

    51

 * This variable points to the tile-array which contains the tiles of

    52

 * the map.

    53

 */

    54

extern Tile *_m;

    55

    56

/**

    57

 * Pointer to the extended tile-array.

    58

 *

    59

 * This variable points to the extended tile-array which contains the tiles

    60

 * of the map.

    61

 */

    62

extern TileExtended *_me;

    63

    64

/**

    65

 * Allocate a new map with the given size.

    66

 */

    67

void AllocateMap(uint size_x, uint size_y);

    68

    69

/**

    70

 * Logarithm of the map size along the X side.

    71

 * @note try to avoid using this one

    72

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

    73

 */

    74

static inline uint MapLogX()

    75

{

    76

	extern uint _map_log_x;

    77

	return _map_log_x;

    78

}

    79

    80

/**

    81

 * Get the size of the map along the X

    82

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

    83

 */

    84

static inline uint MapSizeX()

    85

{

    86

	extern uint _map_size_x;

    87

	return _map_size_x;

    88

}

    89

    90

/**

    91

 * Get the size of the map along the Y

    92

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

    93

 */

    94

static inline uint MapSizeY()

    95

{

    96

	extern uint _map_size_y;

    97

	return _map_size_y;

    98

}

    99

   100

/**

   101

 * Get the size of the map

   102

 * @return the number of tiles of the map

   103

 */

   104

static inline uint MapSize()

   105

{

   106

	extern uint _map_size;

   107

	return _map_size;

   108

}

   109

   110

/**

   111

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

   112

 * @return the maximum X coordinate

   113

 */

   114

static inline uint MapMaxX()

   115

{

   116

	return MapSizeX() - 1;

   117

}

   118

   119

/**

   120

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

   121

 * @return the maximum X coordinate

   122

 */

   123

static inline uint MapMaxY()

   124

{

   125

	return MapSizeY() - 1;

   126

}

   127

   128

/**

   129

 * Scales relative to the number of tiles.

   130

 */

   131

uint ScaleByMapSize(uint);

   132

   133

/**

   134

 * Scale relative to the circumference of the map.

   135

 */

   136

uint ScaleByMapSize1D(uint);

   137

   138

/**

   139

 * The index/ID of a Tile.

   140

 */

   141

typedef uint32 TileIndex;

   142

   143

/**

   144

 * An offset value between to tiles.

   145

 *

   146

 * This value is used fro the difference between

   147

 * to tiles. It can be added to a tileindex to get

   148

 * the resulting tileindex of the start tile applied

   149

 * with this saved difference.

   150

 *

   151

 * @see TileDiffXY(int, int)

   152

 */

   153

typedef int32 TileIndexDiff;

   154

   155

/**

   156

 * Returns the TileIndex of a coordinate.

   157

 *

   158

 * @param x The x coordinate of the tile

   159

 * @param y The y coordinate of the tile

   160

 * @return The TileIndex calculated by the coordinate

   161

 */

   162

static inline TileIndex TileXY(uint x, uint y)

   163

{

   164

	return (y * MapSizeX()) + x;

   165

}

   166

   167

/**

   168

 * Calculates an offset for the given coordinate(-offset).

   169

 *

   170

 * This function calculate an offset value which can be added to an

   171

 * #TileIndex. The coordinates can be negative.

   172

 *

   173

 * @param x The offset in x direction

   174

 * @param y The offset in y direction

   175

 * @return The resulting offset value of the given coordinate

   176

 * @see ToTileIndexDiff(TileIndexDiffC)

   177

 */

   178

static inline TileIndexDiff TileDiffXY(int x, int y)

   179

{

   180

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

   181

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

   182

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

   183

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

   184

	return (y * MapSizeX()) + x;

   185

}

   186

   187

static inline TileIndex TileVirtXY(uint x, uint y)

   188

{

   189

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

   190

}

   191

   192

   193

enum {

   194

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

   195

};

   196

   197

enum {

   198

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

   199

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

   200

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

   201

};

   202

   203

   204

/**

   205

 * Get the X component of a tile

   206

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

   207

 * @return the X component

   208

 */

   209

static inline uint TileX(TileIndex tile)

   210

{

   211

	return tile & MapMaxX();

   212

}

   213

   214

/**

   215

 * Get the Y component of a tile

   216

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

   217

 * @return the Y component

   218

 */

   219

static inline uint TileY(TileIndex tile)

   220

{

   221

	return tile >> MapLogX();

   222

}

   223

   224

/**

   225

 * A pair-construct of a TileIndexDiff.

   226

 *

   227

 * This can be used to save the difference between to

   228

 * tiles as a pair of x and y value.

   229

 */

   230

struct TileIndexDiffC {

   231

	int16 x;        ///< The x value of the coordinate

   232

	int16 y;        ///< The y value of the coordinate

   233

};

   234

   235

/**

   236

 * Return the offset between to tiles from a TileIndexDiffC struct.

   237

 *

   238

 * This function works like #TileDiffXY(int, int) and returns the

   239

 * difference between two tiles.

   240

 *

   241

 * @param tidc The coordinate of the offset as TileIndexDiffC

   242

 * @return The difference between two tiles.

   243

 * @see TileDiffXY(int, int)

   244

 */

   245

static inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)

   246

{

   247

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

   248

}

   249

   250

   251

#ifndef _DEBUG

   252

        /**

   253

         * Adds to tiles together.

   254

         *

   255

         * @param x One tile

   256

         * @param y An other tile to add

   257

         * @return The resulting tile(index)

   258

         */

   259

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

   260

#else

   261

	extern TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

   262

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

   263

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

   264

#endif

   265

   266

/**

   267

 * Adds a given offset to a tile.

   268

 *

   269

 * @param tile The tile to add an offset on it

   270

 * @param x The x offset to add to the tile

   271

 * @param y The y offset to add to the tile

   272

 */

   273

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

   274

   275

/**

   276

 * Adds an offset to a tile and check if we are still on the map.

   277

 */

   278

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

   279

   280

/**

   281

 * Returns the TileIndexDiffC offset from a DiagDirection.

   282

 *

   283

 * @param dir The given direction

   284

 * @return The offset as TileIndexDiffC value

   285

 */

   286

static inline TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)

   287

{

   288

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   289

   290

	assert(IsValidDiagDirection(dir));

   291

	return _tileoffs_by_diagdir[dir];

   292

}

   293

/**

   294

 * Add a TileIndexDiffC to a TileIndex and returns the new one.

   295

 *

   296

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

   297

 * outside of the map, INVALID_TILE is returned instead.

   298

 *

   299

 * @param tile The base tile to add the offset on

   300

 * @param diff The offset to add on the tile

   301

 * @return The resulting TileIndex

   302

 */

   303

static inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)

   304

{

   305

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

   306

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

   307

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

   308

		return INVALID_TILE;

   309

	else

   310

		return TileXY(x, y);

   311

}

   312

   313

/**

   314

 * Returns the diff between two tiles

   315

 *

   316

 * @param tile_a from tile

   317

 * @param tile_b to tile

   318

 * @return the difference between tila_a and tile_b

   319

 */

   320

static inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)

   321

{

   322

	TileIndexDiffC difference;

   323

   324

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

   325

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

   326

   327

	return difference;

   328

}

   329

   330

/* Functions to calculate distances */

   331

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

   332

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

   333

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

   334

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

   335

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

   336

   337

/**

   338

 * Starts a loop which iterates to a square of tiles

   339

 *

   340

 * This macro starts 2 nested loops which iterates over a square of tiles.

   341

 *

   342

 * @param var The name of the variable which contains the current tile

   343

 * @param w The width (x-width) of the square

   344

 * @param h The heigth (y-width) of the square

   345

 * @param tile The start tile of the square

   346

 */

   347

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

   348

	{                                                        \

   349

		int h_cur = h;                                         \

   350

		uint var = tile;                                       \

   351

		do {                                                   \

   352

			int w_cur = w;                                       \

   353

			do {

   354

/**

   355

 * Ends the square-loop used before

   356

 *

   357

 * @see BEGIN_TILE_LOOP

   358

 */

   359

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

   360

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

   361

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

   362

	}

   363

/**

   364

 * Convert a DiagDirection to a TileIndexDiff

   365

 *

   366

 * @param dir The DiagDirection

   367

 * @return The resulting TileIndexDiff

   368

 * @see TileIndexDiffCByDiagDir

   369

 */

   370

static inline TileIndexDiff TileOffsByDiagDir(DiagDirection dir)

   371

{

   372

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   373

   374

	assert(IsValidDiagDirection(dir));

   375

	return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);

   376

}

   377

   378

/**

   379

 * Convert a Direction to a TileIndexDiff.

   380

 *

   381

 * @param dir The direction to convert from

   382

 * @return The resulting TileIndexDiff

   383

 */

   384

static inline TileIndexDiff TileOffsByDir(Direction dir)

   385

{

   386

	extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];

   387

   388

	assert(IsValidDirection(dir));

   389

	return ToTileIndexDiff(_tileoffs_by_dir[dir]);

   390

}

   391

   392

/**

   393

 * Adds a DiagDir to a tile.

   394

 *

   395

 * @param tile The current tile

   396

 * @param dir The direction in which we want to step

   397

 * @return the moved tile

   398

 */

   399

static inline TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)

   400

{

   401

	return TILE_ADD(tile, TileOffsByDiagDir(dir));

   402

}

   403

   404

/**

   405

 * A callback function type for searching tiles.

   406

 *

   407

 * @param tile The tile to test

   408

 * @param data additional data for the callback function to use

   409

 * @return A boolean value, depend on the definition of the function.

   410

 */

   411

typedef bool TestTileOnSearchProc(TileIndex tile, uint32 data);

   412

   413

/**

   414

 * Searches for some cirumstances of a tile around a given tile with a helper function.

   415

 */

   416

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

   417

   418

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

   419

 * track (ie the size of a tile side).

   420

 *

   421

 * #defined instead of const so it can

   422

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

   423

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

   424

 * rounding! Be careful when using this!

   425

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

   426

#define STRAIGHT_TRACK_LENGTH 7071/10000

   427

   428

#endif /* MAP_H */