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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#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() = default;

  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 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);
  }
};

class SpiralTileIterator {
public:
  using value_type = TileIndex;
  using difference_type = std::ptrdiff_t;
  using iterator_category = std::forward_iterator_tag;
  using pointer = void;
  using reference = void;
 
  SpiralTileIterator(TileIndex center, uint diameter);
  SpiralTileIterator(TileIndex start_north, uint radius, uint w, uint h);
 
  bool operator==(const SpiralTileIterator &rhs) const { return this->x == rhs.x && this->y == rhs.y; }
  bool operator==(const std::default_sentinel_t &) const { return this->IsEnd(); }
 
  TileIndex operator*() const { return TileXY(this->x, this->y); }
 
  SpiralTileIterator &operator++()
  {
    this->Increment();
    this->SkipOutsideMap();
    return *this;
  }
 
  SpiralTileIterator operator++(int)
  {
    SpiralTileIterator result = *this;
    ++*this;
    return result;
  }
 
private:
  /* set by constructor, const afterwards */
  uint max_radius;
  std::array<uint, DIAGDIR_END> extent;
 
  /* mutable iterator state */
  uint cur_radius;
  DiagDirection dir;
  uint position;
  uint x, y;
 
  void SkipOutsideMap();
  void InitPosition();
  void Increment();

  bool IsEnd() const
  {
    return this->cur_radius == this->max_radius && this->dir != INVALID_DIAGDIR;
  }
};

class SpiralTileSequence {
public:
  SpiralTileSequence(TileIndex center, uint diameter) : start(center, diameter) {}

  SpiralTileSequence(TileIndex start_north, uint radius, uint w, uint h) : start(start_north, radius, w, h) {}
 
  SpiralTileIterator begin() const { return start; }
  std::default_sentinel_t end() const { return std::default_sentinel_t(); }
 
private:
  SpiralTileIterator start;
};
 
#endif /* TILEAREA_TYPE_H */