Initialize with OpenTTD 1.9.3
This commit is contained in:
dP
245
src/tilearea.cpp
Normal file
245
src/tilearea.cpp
Normal file
@@ -0,0 +1,245 @@
|
||||
/* $Id$ */
|
||||
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
/** @file tilearea.cpp Handling of tile areas. */
|
||||
|
||||
#include "stdafx.h"
|
||||
|
||||
#include "tilearea_type.h"
|
||||
|
||||
#include "safeguards.h"
|
||||
|
||||
/**
|
||||
* Construct this tile area based on two points.
|
||||
* @param start the start of the area
|
||||
* @param end the end of the area
|
||||
*/
|
||||
OrthogonalTileArea::OrthogonalTileArea(TileIndex start, TileIndex end)
|
||||
{
|
||||
assert(start < MapSize());
|
||||
assert(end < MapSize());
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a single tile to a tile area; enlarge if needed.
|
||||
* @param to_add The tile to add
|
||||
*/
|
||||
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 = min(ax, sx);
|
||||
sy = min(ay, sy);
|
||||
ex = max(ax, ex);
|
||||
ey = max(ay, ey);
|
||||
|
||||
this->tile = TileXY(sx, sy);
|
||||
this->w = ex - sx + 1;
|
||||
this->h = ey - sy + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does this tile area intersect with another?
|
||||
* @param ta the other tile area to check against.
|
||||
* @return true if they intersect.
|
||||
*/
|
||||
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
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Does this tile area contain a tile?
|
||||
* @param tile Tile to test for.
|
||||
* @return True if the tile is inside the area.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clamp the tile area to map borders.
|
||||
*/
|
||||
void OrthogonalTileArea::ClampToMap()
|
||||
{
|
||||
assert(this->tile < MapSize());
|
||||
this->w = min(this->w, MapSizeX() - TileX(this->tile));
|
||||
this->h = min(this->h, MapSizeY() - TileY(this->tile));
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a diagonal tile area from two corners.
|
||||
* @param start First corner of the area.
|
||||
* @param end Second corner of the area.
|
||||
*/
|
||||
DiagonalTileArea::DiagonalTileArea(TileIndex start, TileIndex end) : tile(start)
|
||||
{
|
||||
assert(start < MapSize());
|
||||
assert(end < MapSize());
|
||||
|
||||
/* 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--;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Does this tile area contain a tile?
|
||||
* @param tile Tile to test for.
|
||||
* @return True if the tile is inside the area.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Move ourselves to the next tile in the rectangle on the map.
|
||||
*/
|
||||
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 = min(this->b_cur + 2, this->b_max);
|
||||
} else {
|
||||
this->b_cur = 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 >= MapSizeX() || y >= MapSizeY() ? INVALID_TILE : TileXY(x, y);
|
||||
} while (this->tile > MapSize() && this->b_max != this->b_cur);
|
||||
|
||||
if (this->b_max == this->b_cur) this->tile = INVALID_TILE;
|
||||
return *this;
|
||||
}
|
||||
Reference in New Issue
Block a user