tilearea.cpp

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/>.
 */
 
#include "stdafx.h"
 
#include "tilearea_type.h"
 
#include "safeguards.h"
 
OrthogonalTileArea::OrthogonalTileArea(TileIndex start, TileIndex end)
{
  assert(start < Map::Size());
  assert(end < Map::Size());
 
  uint sx = TileX(start);
  uint sy = TileY(start);
  uint ex = TileX(end);
  uint ey = TileY(end);
 
  if (sx > ex) Swap(sx, ex);
  if (sy > ey) Swap(sy, ey);
 
  this->tile = TileXY(sx, sy);
  this->w    = ex - sx + 1;
  this->h    = ey - sy + 1;
}
 
void OrthogonalTileArea::Add(TileIndex to_add)
{
  if (this->tile == INVALID_TILE) {
    this->tile = to_add;
    this->w = 1;
    this->h = 1;
    return;
  }
 
  uint sx = TileX(this->tile);
  uint sy = TileY(this->tile);
  uint ex = sx + this->w - 1;
  uint ey = sy + this->h - 1;
 
  uint ax = TileX(to_add);
  uint ay = TileY(to_add);
 
  sx = std::min(ax, sx);
  sy = std::min(ay, sy);
  ex = std::max(ax, ex);
  ey = std::max(ay, ey);
 
  this->tile = TileXY(sx, sy);
  this->w    = ex - sx + 1;
  this->h    = ey - sy + 1;
}
 
bool OrthogonalTileArea::Intersects(const OrthogonalTileArea &ta) const
{
  if (ta.w == 0 || this->w == 0) return false;
 
  assert(ta.w != 0 && ta.h != 0 && this->w != 0 && this->h != 0);
 
  uint left1   = TileX(this->tile);
  uint top1    = TileY(this->tile);
  uint right1  = left1 + this->w - 1;
  uint bottom1 = top1  + this->h - 1;
 
  uint left2   = TileX(ta.tile);
  uint top2    = TileY(ta.tile);
  uint right2  = left2 + ta.w - 1;
  uint bottom2 = top2  + ta.h - 1;
 
  return !(
      left2   > right1  ||
      right2  < left1   ||
      top2    > bottom1 ||
      bottom2 < top1
    );
}
 
bool OrthogonalTileArea::Contains(TileIndex tile) const
{
  if (this->w == 0) return false;
 
  assert(this->w != 0 && this->h != 0);
 
  uint left   = TileX(this->tile);
  uint top    = TileY(this->tile);
  uint tile_x = TileX(tile);
  uint tile_y = TileY(tile);
 
  return IsInsideBS(tile_x, left, this->w) && IsInsideBS(tile_y, top, this->h);
}
 
OrthogonalTileArea &OrthogonalTileArea::Expand(int rad)
{
  int x = TileX(this->tile);
  int y = TileY(this->tile);
 
  int sx = std::max<int>(x - rad, 0);
  int sy = std::max<int>(y - rad, 0);
  int ex = std::min<int>(x + this->w + rad, Map::SizeX());
  int ey = std::min<int>(y + this->h + rad, Map::SizeY());
 
  this->tile = TileXY(sx, sy);
  this->w    = ex - sx;
  this->h    = ey - sy;
  return *this;
}
 
void OrthogonalTileArea::ClampToMap()
{
  assert(this->tile < Map::Size());
  this->w = std::min<int>(this->w, Map::SizeX() - TileX(this->tile));
  this->h = std::min<int>(this->h, Map::SizeY() - TileY(this->tile));
}
 
OrthogonalTileIterator OrthogonalTileArea::begin() const
{
  return OrthogonalTileIterator(*this);
}
 
OrthogonalTileIterator OrthogonalTileArea::end() const
{
  return OrthogonalTileIterator(OrthogonalTileArea());
}
 
DiagonalTileArea::DiagonalTileArea(TileIndex start, TileIndex end) : tile(start)
{
  assert(start < Map::Size());
  assert(end < Map::Size());
 
  /* Unfortunately we can't find a new base and make all a and b positive because
   * the new base might be a "flattened" corner where there actually is no single
   * tile. If we try anyway the result is either inaccurate ("one off" half of the
   * time) or the code gets much more complex;
   *
   * We also need to increment/decrement a and b here to have one-past-end semantics
   * for a and b, just the way the orthogonal tile area does it for w and h. */
 
  this->a = TileY(end) + TileX(end) - TileY(start) - TileX(start);
  this->b = TileY(end) - TileX(end) - TileY(start) + TileX(start);
  if (this->a > 0) {
    this->a++;
  } else {
    this->a--;
  }
 
  if (this->b > 0) {
    this->b++;
  } else {
    this->b--;
  }
}
 
bool DiagonalTileArea::Contains(TileIndex tile) const
{
  int a = TileY(tile) + TileX(tile);
  int b = TileY(tile) - TileX(tile);
 
  int start_a = TileY(this->tile) + TileX(this->tile);
  int start_b = TileY(this->tile) - TileX(this->tile);
 
  int end_a = start_a + this->a;
  int end_b = start_b + this->b;
 
  /* Swap if necessary, preserving the "one past end" semantics. */
  if (start_a > end_a) {
    int tmp = start_a;
    start_a = end_a + 1;
    end_a = tmp + 1;
  }
  if (start_b > end_b) {
    int tmp = start_b;
    start_b = end_b + 1;
    end_b = tmp + 1;
  }
 
  return (a >= start_a && a < end_a && b >= start_b && b < end_b);
}
 
TileIterator &DiagonalTileIterator::operator++()
{
  assert(this->tile != INVALID_TILE);
 
  /* Determine the next tile, while clipping at map borders */
  bool new_line = false;
  do {
    /* Iterate using the rotated coordinates. */
    if (this->a_max == 1 || this->a_max == -1) {
      /* Special case: Every second column has zero length, skip them completely */
      this->a_cur = 0;
      if (this->b_max > 0) {
        this->b_cur = std::min(this->b_cur + 2, this->b_max);
      } else {
        this->b_cur = std::max(this->b_cur - 2, this->b_max);
      }
    } else {
      /* Every column has at least one tile to process */
      if (this->a_max > 0) {
        this->a_cur += 2;
        new_line = this->a_cur >= this->a_max;
      } else {
        this->a_cur -= 2;
        new_line = this->a_cur <= this->a_max;
      }
      if (new_line) {
        /* offset of initial a_cur: one tile in the same direction as a_max
         * every second line.
         */
        this->a_cur = abs(this->a_cur) % 2 ? 0 : (this->a_max > 0 ? 1 : -1);
 
        if (this->b_max > 0) {
          ++this->b_cur;
        } else {
          --this->b_cur;
        }
      }
    }
 
    /* And convert the coordinates back once we've gone to the next tile. */
    uint x = this->base_x + (this->a_cur - this->b_cur) / 2;
    uint y = this->base_y + (this->b_cur + this->a_cur) / 2;
    /* Prevent wrapping around the map's borders. */
    this->tile = x >= Map::SizeX() || y >= Map::SizeY() ? INVALID_TILE : TileXY(x, y);
  } while (this->tile > Map::Size() && this->b_max != this->b_cur);
 
  if (this->b_max == this->b_cur) this->tile = INVALID_TILE;
  return *this;
}
 
/* static */ std::unique_ptr<TileIterator> TileIterator::Create(TileIndex corner1, TileIndex corner2, bool diagonal)
{
  if (diagonal) {
    return std::make_unique<DiagonalTileIterator>(corner1, corner2);
  }
  return std::make_unique<OrthogonalTileIterator>(corner1, corner2);
}