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
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program 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, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef ULTIMA8_MISC_RECT_H
#define ULTIMA8_MISC_RECT_H
namespace Ultima {
namespace Ultima8 {
// TODO: Replace Ultima8::Rect with Common::Rect
// The key difference between Ultima8::Rect and Common::Rect is the use of int32 for variables.
// Attempts to change this may cause the game to be unstable.
struct Rect {
int32 left, top;
int32 right, bottom;
Rect() : top(0), left(0), bottom(0), right(0) {}
Rect(int x1, int y1, int x2, int y2) : top(y1), left(x1), bottom(y2), right(x2) {}
bool operator==(const Rect &rhs) const { return equals(rhs); }
bool operator!=(const Rect &rhs) const { return !equals(rhs); }
int16 width() const { return right - left; }
int16 height() const { return bottom - top; }
void setWidth(int16 aWidth) {
right = left + aWidth;
}
void setHeight(int16 aHeight) {
bottom = top + aHeight;
}
void grow(int16 offset) {
left -= offset;
top -= offset;
right += offset;
bottom += offset;
}
// Check if the rectangle is empty (its width or length is 0) or invalid (its width or length are negative).
bool isEmpty() const {
return (left >= right || top >= bottom);
}
// Check to see if a Rectangle is 'valid'
bool isValidRect() const {
return (left <= right && top <= bottom);
}
// Check to see if a point is within the Rectangle
bool contains(int16 x, int16 y) const {
return (left <= x) && (x < right) && (top <= y) && (y < bottom);
}
// Check if the given Rect is contained inside this rectangle.
bool contains(const Rect &r) const {
return (left <= r.left) && (r.right <= right) && (top <= r.top) && (r.bottom <= bottom);
}
// Move the Rect (Relative)
void translate(int32 dx, int32 dy) {
left += dx;
right += dx;
top += dy;
bottom += dy;
}
// Move the Rect (Absolute)
void moveTo(int32 x, int32 y) {
bottom += y - top;
right += x - left;
top = y;
left = x;
}
void clip(const Rect &r) {
if (top < r.top) top = r.top;
else if (top > r.bottom) top = r.bottom;
if (left < r.left) left = r.left;
else if (left > r.right) left = r.right;
if (bottom < r.top) bottom = r.top;
else if (bottom > r.bottom) bottom = r.bottom;
if (right < r.left) right = r.left;
else if (right > r.right) right = r.right;
}
bool intersects(const Rect &r) const {
return (left < r.right) && (r.left < right) && (top < r.bottom) && (r.top < bottom);
}
bool equals(const Rect &o) const {
return left == o.left && top == o.top && right == o.right && bottom == o.bottom;
}
};
} // End of namespace Ultima8
} // End of namespace Ultima
#endif
|
