1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/* $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_type.h Type for storing the 'area' of something uses on the map. */
#ifndef TILEAREA_TYPE_H
#define TILEAREA_TYPE_H
#include "map_func.h"
/** Represents the covered area of e.g. a rail station */
struct TileArea {
TileIndex tile; ///< The base tile of the area
uint16 w; ///< The width of the area
uint16 h; ///< The height of the area
/** Just construct this tile area */
TileArea() {}
/**
* Construct this tile area with some set values
* @param tile the base tile
* @param w the width
* @param h the height
*/
TileArea(TileIndex tile, uint8 w, uint8 h) : tile(tile), w(w), h(h) {}
TileArea(TileIndex start, TileIndex end);
void Add(TileIndex to_add);
/**
* Clears the 'tile area', i.e. make the tile invalid.
*/
void Clear()
{
this->tile = INVALID_TILE;
this->w = 0;
this->h = 0;
}
bool Intersects(const TileArea &ta) const;
bool Contains(TileIndex tile) const;
void ClampToMap();
/**
* Get the center tile.
* @return The tile at the center, or just north of it.
*/
TileIndex GetCenterTile() const
{
return TILE_ADDXY(this->tile, this->w / 2, this->h / 2);
}
};
/** Base class for tile iterators. */
class TileIterator {
protected:
TileIndex tile; ///< The current tile we are at.
/**
* Initialise the iterator starting at this tile.
* @param tile The tile we start iterating from.
*/
TileIterator(TileIndex tile) : tile(tile)
{
}
public:
/** Some compilers really like this. */
virtual ~TileIterator()
{
}
/**
* Get the tile we are currently at.
* @return The tile we are at, or INVALID_TILE when we're done.
*/
inline operator TileIndex () const
{
return this->tile;
}
/**
* Move ourselves to the next tile in the rectange on the map.
*/
virtual TileIterator& operator ++() = 0;
/**
* Allocate a new iterator that is a copy of this one.
*/
virtual TileIterator *Clone() const = 0;
};
/** Iterator to iterate over a tile area (rectangle) of the map. */
class OrthogonalTileIterator : public TileIterator {
private:
int w; ///< The width of the iterated area.
int x; ///< The current 'x' position in the rectangle.
int y; ///< The current 'y' position in the rectangle.
public:
/**
* Construct the iterator.
* @param ta Area, i.e. begin point and width/height of to-be-iterated area.
*/
OrthogonalTileIterator(const TileArea &ta) : TileIterator(ta.w == 0 || ta.h == 0 ? INVALID_TILE : ta.tile), w(ta.w), x(ta.w), y(ta.h)
{
}
/**
* Move ourselves to the next tile in the rectange on the map.
*/
inline TileIterator& operator ++()
{
assert(this->tile != INVALID_TILE);
if (--this->x > 0) {
this->tile++;
} else if (--this->y > 0) {
this->x = this->w;
this->tile += TileDiffXY(1, 1) - this->w;
} else {
this->tile = INVALID_TILE;
}
return *this;
}
virtual TileIterator *Clone() const
{
return new OrthogonalTileIterator(*this);
}
};
/** Iterator to iterate over a diagonal area of the map. */
class DiagonalTileIterator : public TileIterator {
private:
uint base_x; ///< The base tile x coordinate from where the iterating happens.
uint base_y; ///< The base tile y coordinate from where the iterating happens.
int a_cur; ///< The current (rotated) x coordinate of the iteration.
int b_cur; ///< The current (rotated) y coordinate of the iteration.
int a_max; ///< The (rotated) x coordinats of the end of the iteration.
int b_max; ///< The (rotated) y coordinate of the end of the iteration.
public:
DiagonalTileIterator(TileIndex begin, TileIndex end);
TileIterator& operator ++();
virtual TileIterator *Clone() const
{
return new DiagonalTileIterator(*this);
}
};
/**
* A loop which iterates over the tiles of a TileArea.
* @param var The name of the variable which contains the current tile.
* This variable will be allocated in this \c for of this loop.
* @param ta The tile area to search over.
*/
#define TILE_AREA_LOOP(var, ta) for (OrthogonalTileIterator var(ta); var != INVALID_TILE; ++var)
#endif /* TILEAREA_TYPE_H */
|
