Files
@ r20075:2bda14adc373
Branch filter:
Location: cpp/openttd-patchpack/source/src/tilearea_type.h
r20075:2bda14adc373
4.6 KiB
text/x-c
(svn r25038) -Fix [FS#5479]: minimise gaps feature caused removal to only happen at the signal build interval instead of the implicit interval of 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | /* $Id$ */
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file tilearea_type.h Type for storing the 'area' of something uses on the map. */
#ifndef TILEAREA_TYPE_H
#define TILEAREA_TYPE_H
#include "map_func.h"
/** Represents the covered area of e.g. a rail station */
struct TileArea {
TileIndex tile; ///< The base tile of the area
uint16 w; ///< The width of the area
uint16 h; ///< The height of the area
/** Just construct this tile area */
TileArea() {}
/**
* Construct this tile area with some set values
* @param tile the base tile
* @param w the width
* @param h the height
*/
TileArea(TileIndex tile, uint8 w, uint8 h) : tile(tile), w(w), h(h) {}
TileArea(TileIndex start, TileIndex end);
void Add(TileIndex to_add);
/**
* Clears the 'tile area', i.e. make the tile invalid.
*/
void Clear()
{
this->tile = INVALID_TILE;
this->w = 0;
this->h = 0;
}
bool Intersects(const TileArea &ta) const;
bool Contains(TileIndex tile) const;
void ClampToMap();
/**
* Get the center tile.
* @return The tile at the center, or just north of it.
*/
TileIndex GetCenterTile() const
{
return TILE_ADDXY(this->tile, this->w / 2, this->h / 2);
}
};
/** Base class for tile iterators. */
class TileIterator {
protected:
TileIndex tile; ///< The current tile we are at.
/**
* Initialise the iterator starting at this tile.
* @param tile The tile we start iterating from.
*/
TileIterator(TileIndex tile) : tile(tile)
{
}
public:
/** Some compilers really like this. */
virtual ~TileIterator()
{
}
/**
* Get the tile we are currently at.
* @return The tile we are at, or INVALID_TILE when we're done.
*/
inline operator TileIndex () const
{
return this->tile;
}
/**
* Move ourselves to the next tile in the rectangle on the map.
*/
virtual TileIterator& operator ++() = 0;
/**
* Allocate a new iterator that is a copy of this one.
*/
virtual TileIterator *Clone() const = 0;
};
/** Iterator to iterate over a tile area (rectangle) of the map. */
class OrthogonalTileIterator : public TileIterator {
private:
int w; ///< The width of the iterated area.
int x; ///< The current 'x' position in the rectangle.
int y; ///< The current 'y' position in the rectangle.
public:
/**
* Construct the iterator.
* @param ta Area, i.e. begin point and width/height of to-be-iterated area.
*/
OrthogonalTileIterator(const TileArea &ta) : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile), w(ta.w), x(ta.w), y(ta.h)
{
}
/**
* Move ourselves to the next tile in the rectangle on the map.
*/
inline TileIterator& operator ++()
{
assert(this->tile != INVALID_TILE);
if (--this->x > 0) {
this->tile++;
} else if (--this->y > 0) {
this->x = this->w;
this->tile += TileDiffXY(1, 1) - this->w;
} else {
this->tile = INVALID_TILE;
}
return *this;
}
virtual TileIterator *Clone() const
{
return new OrthogonalTileIterator(*this);
}
};
/** Iterator to iterate over a diagonal area of the map. */
class DiagonalTileIterator : public TileIterator {
private:
uint base_x; ///< The base tile x coordinate from where the iterating happens.
uint base_y; ///< The base tile y coordinate from where the iterating happens.
int a_cur; ///< The current (rotated) x coordinate of the iteration.
int b_cur; ///< The current (rotated) y coordinate of the iteration.
int a_max; ///< The (rotated) x coordinate of the end of the iteration.
int b_max; ///< The (rotated) y coordinate of the end of the iteration.
public:
DiagonalTileIterator(TileIndex begin, TileIndex end);
TileIterator& operator ++();
virtual TileIterator *Clone() const
{
return new DiagonalTileIterator(*this);
}
};
/**
* A loop which iterates over the tiles of a TileArea.
* @param var The name of the variable which contains the current tile.
* This variable will be allocated in this \c for of this loop.
* @param ta The tile area to search over.
*/
#define TILE_AREA_LOOP(var, ta) for (OrthogonalTileIterator var(ta); var != INVALID_TILE; ++var)
#endif /* TILEAREA_TYPE_H */
|