src/tilearea_type.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 tilearea_type.h Type for storing the 'area' of something uses on the map. */
   9
  10 #ifndef TILEAREA_TYPE_H
  11 #define TILEAREA_TYPE_H
  12
  13 #include "map_func.h"
  14
  15 class OrthogonalTileIterator;
  16
  17 /** Represents the covered area of e.g. a rail station */
  18 struct OrthogonalTileArea {
  19         TileIndex tile; ///< The base tile of the area
  20         uint16_t w;       ///< The width of the area
  21         uint16_t h;       ///< The height of the area
  22
  23         /**
  24          * Construct this tile area with some set values
  25          * @param tile the base tile
  26          * @param w the width
  27          * @param h the height
  28          */
  29         OrthogonalTileArea(TileIndex tile = INVALID_TILE, uint16_t w = 0, uint16_t h = 0) : tile(tile), w(w), h(h)
  30         {
  31         }
  32
  33         OrthogonalTileArea(TileIndex start, TileIndex end);
  34
  35         void Add(TileIndex to_add);
  36
  37         /**
  38          * Clears the 'tile area', i.e. make the tile invalid.
  39          */
  40         void Clear()
  41         {
  42                 this->tile = INVALID_TILE;
  43                 this->w    = 0;
  44                 this->h    = 0;
  45         }
  46
  47         bool Intersects(const OrthogonalTileArea &ta) const;
  48
  49         bool Contains(TileIndex tile) const;
  50
  51         OrthogonalTileArea &Expand(int rad);
  52
  53         void ClampToMap();
  54
  55         /**
  56          * Get the center tile.
  57          * @return The tile at the center, or just north of it.
  58          */
  59         TileIndex GetCenterTile() const
  60         {
  61                 return TileAddXY(this->tile, this->w / 2, this->h / 2);
  62         }
  63
  64         OrthogonalTileIterator begin() const;
  65
  66         OrthogonalTileIterator end() const;
  67 };
  68
  69 /** Represents a diagonal tile area. */
  70 struct DiagonalTileArea {
  71
  72         TileIndex tile; ///< Base tile of the area
  73         int16_t a;        ///< Extent in diagonal "x" direction (may be negative to signify the area stretches to the left)
  74         int16_t b;        ///< Extent in diagonal "y" direction (may be negative to signify the area stretches upwards)
  75
  76         /**
  77          * Construct this tile area with some set values.
  78          * @param tile The base tile.
  79          * @param a The "x" extent.
  80          * @param b The "y" estent.
  81          */
  82         DiagonalTileArea(TileIndex tile = INVALID_TILE, int16_t a = 0, int16_t b = 0) : tile(tile), a(a), b(b)
  83         {
  84         }
  85
  86         DiagonalTileArea(TileIndex start, TileIndex end);
  87
  88         /**
  89          * Clears the TileArea by making the tile invalid and setting a and b to 0.
  90          */
  91         void Clear()
  92         {
  93                 this->tile = INVALID_TILE;
  94                 this->a    = 0;
  95                 this->b    = 0;
  96         }
  97
  98         bool Contains(TileIndex tile) const;
  99 };
 100
 101 /** Shorthand for the much more common orthogonal tile area. */
 102 typedef OrthogonalTileArea TileArea;
 103
 104 /** Base class for tile iterators. */
 105 class TileIterator {
 106 protected:
 107         TileIndex tile; ///< The current tile we are at.
 108
 109         /**
 110          * Initialise the iterator starting at this tile.
 111          * @param tile The tile we start iterating from.
 112          */
 113         TileIterator(TileIndex tile = INVALID_TILE) : tile(tile)
 114         {
 115         }
 116
 117 public:
 118         /** Some compilers really like this. */
 119         virtual ~TileIterator()
 120         {
 121         }
 122
 123         /**
 124          * Get the tile we are currently at.
 125          * @return The tile we are at, or INVALID_TILE when we're done.
 126          */
 127         inline operator TileIndex () const
 128         {
 129                 return this->tile;
 130         }
 131
 132         /**
 133          * Get the tile we are currently at.
 134          * @return The tile we are at, or INVALID_TILE when we're done.
 135          */
 136         inline TileIndex operator *() const
 137         {
 138                 return this->tile;
 139         }
 140
 141         /**
 142          * Move ourselves to the next tile in the rectangle on the map.
 143          */
 144         virtual TileIterator& operator ++() = 0;
 145
 146         /**
 147          * Allocate a new iterator that is a copy of this one.
 148          */
 149         virtual std::unique_ptr<TileIterator> Clone() const = 0;
 150
 151         /**
 152          * Equality comparison.
 153          */
 154         bool operator ==(const TileIterator &rhs) const
 155         {
 156                 return this->tile == rhs.tile;
 157         }
 158         /**
 159          * Inequality comparison.
 160          */
 161         bool operator !=(const TileIterator &rhs) const
 162         {
 163                 return this->tile != rhs.tile;
 164         }
 165
 166         /**
 167          * Equality comparison.
 168          */
 169         bool operator ==(const TileIndex &rhs) const
 170         {
 171                 return this->tile == rhs;
 172         }
 173         /**
 174          * Inequality comparison.
 175          */
 176         bool operator !=(const TileIndex &rhs) const
 177         {
 178                 return this->tile != rhs;
 179         }
 180
 181         static std::unique_ptr<TileIterator> Create(TileIndex corner1, TileIndex corner2, bool diagonal);
 182 };
 183
 184 /** Iterator to iterate over a tile area (rectangle) of the map. */
 185 class OrthogonalTileIterator : public TileIterator {
 186 private:
 187         int w;          ///< The width of the iterated area.
 188         int x;          ///< The current 'x' position in the rectangle.
 189         int y;          ///< The current 'y' position in the rectangle.
 190
 191 public:
 192         /**
 193          * Construct the iterator.
 194          * @param ta Area, i.e. begin point and width/height of to-be-iterated area.
 195          */
 196         OrthogonalTileIterator(const OrthogonalTileArea &ta) : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile), w(ta.w), x(ta.w), y(ta.h)
 197         {
 198         }
 199
 200         /**
 201          * Construct the iterator.
 202          * @param corner1 Tile from where to begin iterating.
 203          * @param corner2 Tile where to end the iterating.
 204          */
 205         OrthogonalTileIterator(TileIndex corner1, TileIndex corner2)
 206         {
 207                 *this = OrthogonalTileIterator(OrthogonalTileArea(corner1, corner2));
 208         }
 209
 210         /**
 211          * Move ourselves to the next tile in the rectangle on the map.
 212          */
 213         inline TileIterator& operator ++() override
 214         {
 215                 assert(this->tile != INVALID_TILE);
 216
 217                 if (--this->x > 0) {
 218                         this->tile++;
 219                 } else if (--this->y > 0) {
 220                         this->x = this->w;
 221                         this->tile += TileDiffXY(1 - this->w, 1);
 222                 } else {
 223                         this->tile = INVALID_TILE;
 224                 }
 225                 return *this;
 226         }
 227
 228         std::unique_ptr<TileIterator> Clone() const override
 229         {
 230                 return std::make_unique<OrthogonalTileIterator>(*this);
 231         }
 232 };
 233
 234 /** Iterator to iterate over a diagonal area of the map. */
 235 class DiagonalTileIterator : public TileIterator {
 236 private:
 237         uint base_x; ///< The base tile x coordinate from where the iterating happens.
 238         uint base_y; ///< The base tile y coordinate from where the iterating happens.
 239         int a_cur;   ///< The current (rotated) x coordinate of the iteration.
 240         int b_cur;   ///< The current (rotated) y coordinate of the iteration.
 241         int a_max;   ///< The (rotated) x coordinate of the end of the iteration.
 242         int b_max;   ///< The (rotated) y coordinate of the end of the iteration.
 243
 244 public:
 245
 246         /**
 247          * Construct the iterator.
 248          * @param ta Area, i.e. begin point and (diagonal) width/height of to-be-iterated area.
 249          */
 250         DiagonalTileIterator(const DiagonalTileArea &ta) :
 251                 TileIterator(ta.tile), base_x(TileX(ta.tile)), base_y(TileY(ta.tile)), a_cur(0), b_cur(0), a_max(ta.a), b_max(ta.b)
 252         {
 253         }
 254
 255         /**
 256          * Construct the iterator.
 257          * @param corner1 Tile from where to begin iterating.
 258          * @param corner2 Tile where to end the iterating.
 259          */
 260         DiagonalTileIterator(TileIndex corner1, TileIndex corner2)
 261         {
 262                 *this = DiagonalTileIterator(DiagonalTileArea(corner1, corner2));
 263         }
 264
 265         TileIterator& operator ++() override;
 266
 267         std::unique_ptr<TileIterator> Clone() const override
 268         {
 269                 return std::make_unique<DiagonalTileIterator>(*this);
 270         }
 271 };
 272
 273 #endif /* TILEAREA_TYPE_H */