OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

tilearea.cpp
Go to the documentation of this file.
1 /* $Id: tilearea.cpp 26482 2014-04-23 20:13:33Z rubidium $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
8 */
9
12 #include "stdafx.h"
13
14 #include "tilearea_type.h"
15
16 #include "safeguards.h"
17
23 OrthogonalTileArea::OrthogonalTileArea(TileIndex start, TileIndex end)
24 {
25 assert(start < MapSize());
26 assert(end < MapSize());
27
28 uint sx = TileX(start);
29 uint sy = TileY(start);
30 uint ex = TileX(end);
31 uint ey = TileY(end);
32
33 if (sx > ex) Swap(sx, ex);
34 if (sy > ey) Swap(sy, ey);
35
36 this->tile = TileXY(sx, sy);
37 this->w = ex - sx + 1;
38 this->h = ey - sy + 1;
39 }
40
45 void OrthogonalTileArea::Add(TileIndex to_add)
46 {
47 if (this->tile == INVALID_TILE) {
48 this->tile = to_add;
49 this->w = 1;
50 this->h = 1;
51 return;
52 }
53
54 uint sx = TileX(this->tile);
55 uint sy = TileY(this->tile);
56 uint ex = sx + this->w - 1;
57 uint ey = sy + this->h - 1;
58
59 uint ax = TileX(to_add);
60 uint ay = TileY(to_add);
61
62 sx = min(ax, sx);
63 sy = min(ay, sy);
64 ex = max(ax, ex);
65 ey = max(ay, ey);
66
67 this->tile = TileXY(sx, sy);
68 this->w = ex - sx + 1;
69 this->h = ey - sy + 1;
70 }
71
77 bool OrthogonalTileArea::Intersects(const OrthogonalTileArea &ta) const
78 {
79 if (ta.w == 0 || this->w == 0) return false;
80
81 assert(ta.w != 0 && ta.h != 0 && this->w != 0 && this->h != 0);
82
83 uint left1 = TileX(this->tile);
84 uint top1 = TileY(this->tile);
85 uint right1 = left1 + this->w - 1;
86 uint bottom1 = top1 + this->h - 1;
87
88 uint left2 = TileX(ta.tile);
89 uint top2 = TileY(ta.tile);
90 uint right2 = left2 + ta.w - 1;
91 uint bottom2 = top2 + ta.h - 1;
92
93 return !(
94 left2 > right1 ||
95 right2 < left1 ||
96 top2 > bottom1 ||
97 bottom2 < top1
98 );
99 }
100
106 bool OrthogonalTileArea::Contains(TileIndex tile) const
107 {
108 if (this->w == 0) return false;
109
110 assert(this->w != 0 && this->h != 0);
111
112 uint left = TileX(this->tile);
113 uint top = TileY(this->tile);
114 uint tile_x = TileX(tile);
115 uint tile_y = TileY(tile);
116
117 return IsInsideBS(tile_x, left, this->w) && IsInsideBS(tile_y, top, this->h);
118 }
119
123 void OrthogonalTileArea::ClampToMap()
124 {
125 assert(this->tile < MapSize());
126 this->w = min(this->w, MapSizeX() - TileX(this->tile));
127 this->h = min(this->h, MapSizeY() - TileY(this->tile));
128 }
129
135 DiagonalTileArea::DiagonalTileArea(TileIndex start, TileIndex end) : tile(start)
136 {
137 assert(start < MapSize());
138 assert(end < MapSize());
139
140 /* Unfortunately we can't find a new base and make all a and b positive because
141 * the new base might be a "flattened" corner where there actually is no single
142 * tile. If we try anyway the result is either inaccurate ("one off" half of the
143 * time) or the code gets much more complex;
144 *
145 * We also need to increment/decrement a and b here to have one-past-end semantics
146 * for a and b, just the way the orthogonal tile area does it for w and h. */
147
148 this->a = TileY(end) + TileX(end) - TileY(start) - TileX(start);
149 this->b = TileY(end) - TileX(end) - TileY(start) + TileX(start);
150 if (this->a > 0) {
151 this->a++;
152 } else {
153 this->a--;
154 }
155
156 if (this->b > 0) {
157 this->b++;
158 } else {
159 this->b--;
160 }
161 }
162
168 bool DiagonalTileArea::Contains(TileIndex tile) const
169 {
170 int a = TileY(tile) + TileX(tile);
171 int b = TileY(tile) - TileX(tile);
172
173 int start_a = TileY(this->tile) + TileX(this->tile);
174 int start_b = TileY(this->tile) - TileX(this->tile);
175
176 int end_a = start_a + this->a;
177 int end_b = start_b + this->b;
178
179 /* Swap if necessary, preserving the "one past end" semantics. */
180 if (start_a > end_a) {
181 int tmp = start_a;
182 start_a = end_a + 1;
183 end_a = tmp + 1;
184 }
185 if (start_b > end_b) {
186 int tmp = start_b;
187 start_b = end_b + 1;
188 end_b = tmp + 1;
189 }
190
191 return (a >= start_a && a < end_a && b >= start_b && b < end_b);
192 }
193
197 TileIterator &DiagonalTileIterator::operator++()
198 {
199 assert(this->tile != INVALID_TILE);
200
201 /* Determine the next tile, while clipping at map borders */
202 bool new_line = false;
203 do {
204 /* Iterate using the rotated coordinates. */
205 if (this->a_max == 1 || this->a_max == -1) {
206 /* Special case: Every second column has zero length, skip them completely */
207 this->a_cur = 0;
208 if (this->b_max > 0) {
209 this->b_cur = min(this->b_cur + 2, this->b_max);
210 } else {
211 this->b_cur = max(this->b_cur - 2, this->b_max);
212 }
213 } else {
214 /* Every column has at least one tile to process */
215 if (this->a_max > 0) {
216 this->a_cur += 2;
217 new_line = this->a_cur >= this->a_max;
218 } else {
219 this->a_cur -= 2;
220 new_line = this->a_cur <= this->a_max;
221 }
222 if (new_line) {
223 /* offset of initial a_cur: one tile in the same direction as a_max
224 * every second line.
225 */
226 this->a_cur = abs(this->a_cur) % 2 ? 0 : (this->a_max > 0 ? 1 : -1);
227
228 if (this->b_max > 0) {
229 ++this->b_cur;
230 } else {
231 --this->b_cur;
232 }
233 }
234 }
235
236 /* And convert the coordinates back once we've gone to the next tile. */
237 uint x = this->base_x + (this->a_cur - this->b_cur) / 2;
238 uint y = this->base_y + (this->b_cur + this->a_cur) / 2;
239 /* Prevent wrapping around the map's borders. */
240 this->tile = x >= MapSizeX() || y >= MapSizeY() ? INVALID_TILE : TileXY(x, y);
241 } while (this->tile > MapSize() && this->b_max != this->b_cur);
242
243 if (this->b_max == this->b_cur) this->tile = INVALID_TILE;
244 return *this;
245 }