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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
/* $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 tile_map.cpp Global tile accessors. */
#include "stdafx.h"
#include "tile_map.h"
#include "safeguards.h"
/**
* Returns the tile height for a coordinate outside map. Such a height is
* needed for painting the area outside map using completely black tiles.
* The idea is descending to heightlevel 0 as fast as possible.
* @param x The X-coordinate (same unit as TileX).
* @param y The Y-coordinate (same unit as TileY).
* @return The height in the same unit as TileHeight.
*/
uint TileHeightOutsideMap(int x, int y)
{
/* In all cases: Descend to heightlevel 0 as fast as possible.
* So: If we are at the 0-side of the map (x<0 or y<0), we must
* subtract the distance to coordinate 0 from the heightlevel at
* coordinate 0.
* In other words: Subtract e.g. -x. If we are at the MapMax
* side of the map, we also need to subtract the distance to
* the edge of map, e.g. MapMaxX - x.
*
* NOTE: Assuming constant heightlevel outside map would be
* simpler here. However, then we run into painting problems,
* since whenever a heightlevel change at the map border occurs,
* we would need to repaint anything outside map.
* In contrast, by doing it this way, we can localize this change,
* which means we may assume constant heightlevel for all tiles
* at more than <heightlevel at map border> distance from the
* map border.
*/
if (x < 0) {
if (y < 0) {
return max((int)TileHeight(TileXY(0, 0)) - (-x) - (-y), 0);
} else if (y < (int)MapMaxY()) {
return max((int)TileHeight(TileXY(0, y)) - (-x), 0);
} else {
return max((int)TileHeight(TileXY(0, (int)MapMaxY())) - (-x) - (y - (int)MapMaxY()), 0);
}
} else if (x < (int)MapMaxX()) {
if (y < 0) {
return max((int)TileHeight(TileXY(x, 0)) - (-y), 0);
} else if (y < (int)MapMaxY()) {
return TileHeight(TileXY(x, y));
} else {
return max((int)TileHeight(TileXY(x, (int)MapMaxY())) - (y - (int)MapMaxY()), 0);
}
} else {
if (y < 0) {
return max((int)TileHeight(TileXY((int)MapMaxX(), 0)) - (x - (int)MapMaxX()) - (-y), 0);
} else if (y < (int)MapMaxY()) {
return max((int)TileHeight(TileXY((int)MapMaxX(), y)) - (x - (int)MapMaxX()), 0);
} else {
return max((int)TileHeight(TileXY((int)MapMaxX(), (int)MapMaxY())) - (x - (int)MapMaxX()) - (y - (int)MapMaxY()), 0);
}
}
}
/**
* Get a tile's slope given the heigh of its four corners.
* @param hnorth The height at the northern corner in the same unit as TileHeight.
* @param hwest The height at the western corner in the same unit as TileHeight.
* @param heast The height at the eastern corner in the same unit as TileHeight.
* @param hsouth The height at the southern corner in the same unit as TileHeight.
* @param[out] h The lowest height of the four corners.
* @return The slope.
*/
static Slope GetTileSlopeGivenHeight(int hnorth, int hwest, int heast, int hsouth, int *h)
{
/* Due to the fact that tiles must connect with each other without leaving gaps, the
* biggest difference in height between any corner and 'min' is between 0, 1, or 2.
*
* Also, there is at most 1 corner with height difference of 2.
*/
int hminnw = min(hnorth, hwest);
int hmines = min(heast, hsouth);
int hmin = min(hminnw, hmines);
if (h != NULL) *h = hmin;
int hmaxnw = max(hnorth, hwest);
int hmaxes = max(heast, hsouth);
int hmax = max(hmaxnw, hmaxes);
Slope r = SLOPE_FLAT;
if (hnorth != hmin) r |= SLOPE_N;
if (hwest != hmin) r |= SLOPE_W;
if (heast != hmin) r |= SLOPE_E;
if (hsouth != hmin) r |= SLOPE_S;
if (hmax - hmin == 2) r |= SLOPE_STEEP;
return r;
}
/**
* Return the slope of a given tile inside the map.
* @param tile Tile to compute slope of
* @param h If not \c NULL, pointer to storage of z height
* @return Slope of the tile, except for the HALFTILE part
*/
Slope GetTileSlope(TileIndex tile, int *h)
{
assert(tile < MapSize());
uint x = TileX(tile);
uint y = TileY(tile);
if (x == MapMaxX() || y == MapMaxY()) {
if (h != NULL) *h = TileHeight(tile);
return SLOPE_FLAT;
}
int hnorth = TileHeight(tile); // Height of the North corner.
int hwest = TileHeight(tile + TileDiffXY(1, 0)); // Height of the West corner.
int heast = TileHeight(tile + TileDiffXY(0, 1)); // Height of the East corner.
int hsouth = TileHeight(tile + TileDiffXY(1, 1)); // Height of the South corner.
return GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth, h);
}
/**
* Return the slope of a given tile outside the map.
*
* @param x X-coordinate of the tile outside to compute height of.
* @param y Y-coordinate of the tile outside to compute height of.
* @param h If not \c NULL, pointer to storage of z height.
* @return Slope of the tile outside map, except for the HALFTILE part.
*/
Slope GetTilePixelSlopeOutsideMap(int x, int y, int *h)
{
int hnorth = TileHeightOutsideMap(x, y); // N corner.
int hwest = TileHeightOutsideMap(x + 1, y); // W corner.
int heast = TileHeightOutsideMap(x, y + 1); // E corner.
int hsouth = TileHeightOutsideMap(x + 1, y + 1); // S corner.
Slope s = GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth, h);
if (h != NULL) *h *= TILE_HEIGHT;
return s;
}
/**
* Check if a given tile is flat
* @param tile Tile to check
* @param h If not \c NULL, pointer to storage of z height (only if tile is flat)
* @return Whether the tile is flat
*/
bool IsTileFlat(TileIndex tile, int *h)
{
assert(tile < MapSize());
if (!IsInnerTile(tile)) {
if (h != NULL) *h = TileHeight(tile);
return true;
}
uint z = TileHeight(tile);
if (TileHeight(tile + TileDiffXY(1, 0)) != z) return false;
if (TileHeight(tile + TileDiffXY(0, 1)) != z) return false;
if (TileHeight(tile + TileDiffXY(1, 1)) != z) return false;
if (h != NULL) *h = z;
return true;
}
/**
* Get bottom height of the tile
* @param tile Tile to compute height of
* @return Minimum height of the tile
*/
int GetTileZ(TileIndex tile)
{
if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY()) return 0;
int h = TileHeight(tile); // N corner
h = min(h, TileHeight(tile + TileDiffXY(1, 0))); // W corner
h = min(h, TileHeight(tile + TileDiffXY(0, 1))); // E corner
h = min(h, TileHeight(tile + TileDiffXY(1, 1))); // S corner
return h;
}
/**
* Get top height of the tile inside the map.
* @param t Tile to compute height of
* @return Maximum height of the tile
*/
int GetTileMaxZ(TileIndex t)
{
if (TileX(t) == MapMaxX() || TileY(t) == MapMaxY()) return TileHeightOutsideMap(TileX(t), TileY(t));
int h = TileHeight(t); // N corner
h = max<int>(h, TileHeight(t + TileDiffXY(1, 0))); // W corner
h = max<int>(h, TileHeight(t + TileDiffXY(0, 1))); // E corner
h = max<int>(h, TileHeight(t + TileDiffXY(1, 1))); // S corner
return h;
}
|