Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #ifndef TILEAREA_TYPE_H
00013 #define TILEAREA_TYPE_H
00014
00015 #include "map_func.h"
00016
00018 struct OrthogonalTileArea {
00019 TileIndex tile;
00020 uint16 w;
00021 uint16 h;
00022
00029 OrthogonalTileArea(TileIndex tile = INVALID_TILE, uint8 w = 0, uint8 h = 0) : tile(tile), w(w), h(h)
00030 {
00031 }
00032
00033 OrthogonalTileArea(TileIndex start, TileIndex end);
00034
00035 void Add(TileIndex to_add);
00036
00040 void Clear()
00041 {
00042 this->tile = INVALID_TILE;
00043 this->w = 0;
00044 this->h = 0;
00045 }
00046
00047 bool Intersects(const OrthogonalTileArea &ta) const;
00048
00049 bool Contains(TileIndex tile) const;
00050
00051 void ClampToMap();
00052
00057 TileIndex GetCenterTile() const
00058 {
00059 return TILE_ADDXY(this->tile, this->w / 2, this->h / 2);
00060 }
00061 };
00062
00064 struct DiagonalTileArea {
00065
00066 TileIndex tile;
00067 int16 a;
00068 int16 b;
00069
00076 DiagonalTileArea(TileIndex tile = INVALID_TILE, int8 a = 0, int8 b = 0) : tile(tile), a(a), b(b)
00077 {
00078 }
00079
00080 DiagonalTileArea(TileIndex start, TileIndex end);
00081
00085 void Clear()
00086 {
00087 this->tile = INVALID_TILE;
00088 this->a = 0;
00089 this->b = 0;
00090 }
00091
00092 bool Contains(TileIndex tile) const;
00093 };
00094
00096 typedef OrthogonalTileArea TileArea;
00097
00099 class TileIterator {
00100 protected:
00101 TileIndex tile;
00102
00107 TileIterator(TileIndex tile = INVALID_TILE) : tile(tile)
00108 {
00109 }
00110
00111 public:
00113 virtual ~TileIterator()
00114 {
00115 }
00116
00121 inline operator TileIndex () const
00122 {
00123 return this->tile;
00124 }
00125
00129 virtual TileIterator& operator ++() = 0;
00130
00134 virtual TileIterator *Clone() const = 0;
00135 };
00136
00138 class OrthogonalTileIterator : public TileIterator {
00139 private:
00140 int w;
00141 int x;
00142 int y;
00143
00144 public:
00149 OrthogonalTileIterator(const OrthogonalTileArea &ta) : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile), w(ta.w), x(ta.w), y(ta.h)
00150 {
00151 }
00152
00158 OrthogonalTileIterator(TileIndex corner1, TileIndex corner2)
00159 {
00160 *this = OrthogonalTileIterator(OrthogonalTileArea(corner1, corner2));
00161 }
00162
00166 inline TileIterator& operator ++()
00167 {
00168 assert(this->tile != INVALID_TILE);
00169
00170 if (--this->x > 0) {
00171 this->tile++;
00172 } else if (--this->y > 0) {
00173 this->x = this->w;
00174 this->tile += TileDiffXY(1, 1) - this->w;
00175 } else {
00176 this->tile = INVALID_TILE;
00177 }
00178 return *this;
00179 }
00180
00181 virtual TileIterator *Clone() const
00182 {
00183 return new OrthogonalTileIterator(*this);
00184 }
00185 };
00186
00188 class DiagonalTileIterator : public TileIterator {
00189 private:
00190 uint base_x;
00191 uint base_y;
00192 int a_cur;
00193 int b_cur;
00194 int a_max;
00195 int b_max;
00196
00197 public:
00198
00203 DiagonalTileIterator(const DiagonalTileArea &ta) :
00204 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)
00205 {
00206 }
00207
00213 DiagonalTileIterator(TileIndex corner1, TileIndex corner2)
00214 {
00215 *this = DiagonalTileIterator(DiagonalTileArea(corner1, corner2));
00216 }
00217
00218 TileIterator& operator ++();
00219
00220 virtual TileIterator *Clone() const
00221 {
00222 return new DiagonalTileIterator(*this);
00223 }
00224 };
00225
00232 #define TILE_AREA_LOOP(var, ta) for (OrthogonalTileIterator var(ta); var != INVALID_TILE; ++var)
00233
00234 #endif