tilearea_type.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#ifndef TILEAREA_TYPE_H
#define TILEAREA_TYPE_H
 
#include "map_func.h"
 
class OrthogonalTileIterator;
 
struct OrthogonalTileArea {
  TileIndex tile; 
  uint16_t w;       
  uint16_t h;       
 
  OrthogonalTileArea(TileIndex tile = INVALID_TILE, uint16_t w = 0, uint16_t h = 0) : tile(tile), w(w), h(h)
  {
  }
 
  OrthogonalTileArea(TileIndex start, TileIndex end);
 
  void Add(TileIndex to_add);
 
  void Clear()
  {
    this->tile = INVALID_TILE;
    this->w    = 0;
    this->h    = 0;
  }
 
  bool Intersects(const OrthogonalTileArea &ta) const;
 
  bool Contains(TileIndex tile) const;
 
  OrthogonalTileArea &Expand(int rad);
 
  void ClampToMap();
 
  TileIndex GetCenterTile() const
  {
    return TileAddXY(this->tile, this->w / 2, this->h / 2);
  }
 
  OrthogonalTileIterator begin() const;
 
  OrthogonalTileIterator end() const;
};
 
struct DiagonalTileArea {
 
  TileIndex tile; 
  int16_t a;        
  int16_t b;        
 
  DiagonalTileArea(TileIndex tile = INVALID_TILE, int16_t a = 0, int16_t b = 0) : tile(tile), a(a), b(b)
  {
  }
 
  DiagonalTileArea(TileIndex start, TileIndex end);
 
  void Clear()
  {
    this->tile = INVALID_TILE;
    this->a    = 0;
    this->b    = 0;
  }
 
  bool Contains(TileIndex tile) const;
};
 
typedef OrthogonalTileArea TileArea;
 
class TileIterator {
protected:
  TileIndex tile; 
 
  TileIterator(TileIndex tile = INVALID_TILE) : tile(tile)
  {
  }
 
public:
  virtual ~TileIterator()
  {
  }
 
  inline operator TileIndex () const
  {
    return this->tile;
  }
 
  inline TileIndex operator *() const
  {
    return this->tile;
  }
 
  virtual TileIterator& operator ++() = 0;
 
  virtual std::unique_ptr<TileIterator> Clone() const = 0;
 
  bool operator ==(const TileIterator &rhs) const
  {
    return this->tile == rhs.tile;
  }
  bool operator !=(const TileIterator &rhs) const
  {
    return this->tile != rhs.tile;
  }
 
  bool operator ==(const TileIndex &rhs) const
  {
    return this->tile == rhs;
  }
  bool operator !=(const TileIndex &rhs) const
  {
    return this->tile != rhs;
  }
 
  static std::unique_ptr<TileIterator> Create(TileIndex corner1, TileIndex corner2, bool diagonal);
};
 
class OrthogonalTileIterator : public TileIterator {
private:
  int w;          
  int x;          
  int y;          
 
public:
  OrthogonalTileIterator(const OrthogonalTileArea &ta) : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile), w(ta.w), x(ta.w), y(ta.h)
  {
  }
 
  OrthogonalTileIterator(TileIndex corner1, TileIndex corner2)
  {
    *this = OrthogonalTileIterator(OrthogonalTileArea(corner1, corner2));
  }
 
  inline TileIterator& operator ++() override
  {
    assert(this->tile != INVALID_TILE);
 
    if (--this->x > 0) {
      this->tile++;
    } else if (--this->y > 0) {
      this->x = this->w;
      this->tile += TileDiffXY(1 - this->w, 1);
    } else {
      this->tile = INVALID_TILE;
    }
    return *this;
  }
 
  std::unique_ptr<TileIterator> Clone() const override
  {
    return std::make_unique<OrthogonalTileIterator>(*this);
  }
};
 
class DiagonalTileIterator : public TileIterator {
private:
  uint base_x; 
  uint base_y; 
  int a_cur;   
  int b_cur;   
  int a_max;   
  int b_max;   
 
public:
 
  DiagonalTileIterator(const DiagonalTileArea &ta) :
    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)
  {
  }
 
  DiagonalTileIterator(TileIndex corner1, TileIndex corner2)
  {
    *this = DiagonalTileIterator(DiagonalTileArea(corner1, corner2));
  }
 
  TileIterator& operator ++() override;
 
  std::unique_ptr<TileIterator> Clone() const override
  {
    return std::make_unique<DiagonalTileIterator>(*this);
  }
};
 
#endif /* TILEAREA_TYPE_H */