src/map/tilearea.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file map/tilearea.h Handling of tile areas. */
   9
  10 #ifndef MAP_TILEAREA_H
  11 #define MAP_TILEAREA_H
  12
  13 #include "coord.h"
  14
  15 /** Represents the covered area of e.g. a rail station */
  16 struct OrthogonalTileArea {
  17         TileIndex tile; ///< The base tile of the area
  18         uint16 w;       ///< The width of the area
  19         uint16 h;       ///< The height of the area
  20
  21         /** Just construct this tile area */
  22         OrthogonalTileArea() : tile(INVALID_TILE), w(0), h(0) {}
  23
  24         /**
  25          * Construct this tile area with some set values
  26          * @param tile the base tile
  27          * @param w the width
  28          * @param h the height
  29          */
  30         OrthogonalTileArea(TileIndex tile, uint8 w, uint8 h) : tile(tile), w(w), h(h) {}
  31
  32         OrthogonalTileArea(TileIndex start, TileIndex end);
  33
  34         void Set(uint x0, uint y0, uint x1, uint y1);
  35
  36         void Add(TileIndex to_add);
  37
  38         void Add(const OrthogonalTileArea &to_add);
  39
  40         /**
  41          * Clears the 'tile area', i.e. make the tile invalid.
  42          */
  43         void Clear()
  44         {
  45                 this->tile = INVALID_TILE;
  46                 this->w    = 0;
  47                 this->h    = 0;
  48         }
  49
  50         bool Intersects(const OrthogonalTileArea &ta) const;
  51
  52         bool Contains(TileIndex tile) const;
  53
  54         void ClampToMap();
  55
  56         /**
  57          * Get the center tile.
  58          * @return The tile at the center, or just north of it.
  59          */
  60         TileIndex GetCenterTile() const
  61         {
  62                 return TILE_ADDXY(this->tile, this->w / 2, this->h / 2);
  63         }
  64
  65         /**
  66          * Get the tile in the area closest to a given tile.
  67          * @param t The reference tile.
  68          * @return The closest tile, or INVALID_TILE if the area is empty.
  69          */
  70         TileIndex get_closest_tile(TileIndex t) const
  71         {
  72                 if (this->tile == INVALID_TILE) return INVALID_TILE;
  73
  74                 /* clamp x coordinate */
  75                 uint x = TileX(this->tile);
  76                 x = ClampU(TileX(t), x, x + this->w - 1);
  77
  78                 /* clamp y coordinate */
  79                 uint y = TileY(this->tile);
  80                 y = ClampU(TileY(t), y, y + this->h - 1);
  81
  82                 /* return the tile of our target coordinates */
  83                 return TileXY(x, y);
  84         }
  85 };
  86
  87 /** Shorthand for the much more common orthogonal tile area. */
  88 typedef OrthogonalTileArea TileArea;
  89
  90
  91 /** Base class for tile iterators. */
  92 class TileIterator {
  93 protected:
  94         TileIndex tile; ///< The current tile we are at.
  95
  96         /**
  97          * Initialise the iterator starting at this tile.
  98          * @param tile The tile we start iterating from.
  99          */
 100         TileIterator(TileIndex tile) : tile(tile)
 101         {
 102         }
 103
 104         /**
 105          * Compute the next tile.
 106          */
 107         virtual void Next() = 0;
 108
 109 public:
 110         /** Some compilers really like this. */
 111         virtual ~TileIterator()
 112         {
 113         }
 114
 115         /**
 116          * Get the tile we are currently at.
 117          * @return The tile we are at, or INVALID_TILE when we're done.
 118          */
 119         inline operator TileIndex () const
 120         {
 121                 return this->tile;
 122         }
 123
 124         /**
 125          * Move ourselves to the next tile in the rectangle on the map.
 126          */
 127         TileIterator& operator ++()
 128         {
 129                 assert(this->tile != INVALID_TILE);
 130                 this->Next();
 131                 return *this;
 132         }
 133
 134         /**
 135          * Allocate a new iterator that is a copy of this one.
 136          */
 137         virtual TileIterator *Clone() const = 0;
 138 };
 139
 140 /** Iterator to iterate over a tile area (rectangle) of the map. */
 141 class OrthogonalTileIterator : public TileIterator {
 142 private:
 143         const uint w;       ///< The width of the iterated area.
 144         const uint rowdiff; ///< The amount to add when switching rows
 145         uint x;             ///< The current 'x' position in the rectangle.
 146         uint y;             ///< The current 'y' position in the rectangle.
 147
 148 protected:
 149         /**
 150          * Move ourselves to the next tile in the rectangle on the map.
 151          */
 152         inline void Next() OVERRIDE
 153         {
 154                 assert(this->tile != INVALID_TILE);
 155
 156                 if (--this->x > 0) {
 157                         this->tile++;
 158                 } else if (--this->y > 0) {
 159                         this->x = this->w;
 160                         this->tile += this->rowdiff;
 161                 } else {
 162                         this->tile = INVALID_TILE;
 163                 }
 164         }
 165
 166 public:
 167         /**
 168          * Construct the iterator.
 169          * @param ta Area, i.e. begin point and width/height of to-be-iterated area.
 170          */
 171         OrthogonalTileIterator(const OrthogonalTileArea &ta)
 172                 : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile),
 173                         w(ta.w), rowdiff(TileDiffXY(1, 1) - ta.w), x(ta.w), y(ta.h)
 174         {
 175         }
 176
 177         OrthogonalTileIterator *Clone() const OVERRIDE
 178         {
 179                 return new OrthogonalTileIterator(*this);
 180         }
 181 };
 182
 183 /** Iterator to iterate over a diagonal area of the map. */
 184 class DiagonalTileIterator : public TileIterator {
 185 private:
 186         uint x;   ///< x coordinate of the current tile
 187         uint y;   ///< y coordinate of the current tile
 188         bool odd; ///< Whether this is an "odd" area
 189         int8 s1;  ///< Advancing a tile adds (s1,s1)
 190         int  s2x; ///< Advancing a row adds (s2x,s2y)
 191         int  s2y; ///< Advancing a row adds (s2x,s2y)
 192         uint w;   ///< The width of the main rectangle side
 193         uint n;   ///< The number of tiles left on the current row
 194         uint m;   ///< The number of rows left
 195
 196 protected:
 197         void Next() OVERRIDE;
 198
 199 public:
 200         DiagonalTileIterator(TileIndex begin, TileIndex end);
 201
 202         DiagonalTileIterator *Clone() const OVERRIDE
 203         {
 204                 return new DiagonalTileIterator(*this);
 205         }
 206 };
 207
 208 /**
 209  * A loop which iterates over the tiles of a TileArea.
 210  * @param var The name of the variable which contains the current tile.
 211  *            This variable will be allocated in this \c for of this loop.
 212  * @param ta  The tile area to search over.
 213  */
 214 #define TILE_AREA_LOOP(var, ta) for (OrthogonalTileIterator var(ta); var != INVALID_TILE; ++var)
 215
 216 #endif /* MAP_TILEAREA_H */