← Back to branch summary

~ubuntu-branches/ubuntu/raring/scummvm/raring

« back to all changes in this revision

Viewing changes to engines/gob/map.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Moritz Muehlenhoff
  • Date: 2011-05-25 19:02:23 UTC
  • mto: (21.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20110525190223-fiqm0oaec714xk31
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
engines/gob/map.cpp
18
18
 * along with this program; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
20
 *
21
 
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-1-2-1/engines/gob/map.cpp $
22
 
 * $Id: map.cpp 53795 2010-10-25 03:47:53Z drmccoy $
 
21
 * $URL$
 
22
 * $Id$
23
23
 *
24
24
 */
25
25
 
32
32
namespace Gob {
33
33
 
34
34
Map::Map(GobEngine *vm) : _vm(vm) {
35
 
        _widthByte = 0;
36
 
        _mapWidth = -1;
 
35
        _mapVersion = 0;
 
36
 
 
37
        _passWidth =  0;
 
38
        _mapWidth  = -1;
37
39
        _mapHeight = -1;
38
 
        _screenWidth = 0;
 
40
        _passMap   =  0;
 
41
 
 
42
        _screenWidth  = 0;
39
43
        _screenHeight = 0;
40
 
        _tilesWidth = 0;
 
44
 
 
45
        _tilesWidth  = 0;
41
46
        _tilesHeight = 0;
42
 
        _passWidth = 0;
43
 
 
44
 
        _passMap = 0;
 
47
 
 
48
        _bigTiles = false;
 
49
 
 
50
        _mapUnknownBool = false;
 
51
 
 
52
        _wayPointCount = 0;
 
53
        _wayPoints = 0;
 
54
 
 
55
        _nearestWayPoint = 0;
 
56
        _nearestDest     = 0;
 
57
 
45
58
        _itemsMap = 0;
46
 
        _wayPointsCount = 0;
47
 
        _wayPoints = 0;
48
 
        _bigTiles = false;
49
59
 
50
60
        for (int i = 0; i < 40; i++) {
51
 
                _itemPoses[i].x = 0;
52
 
                _itemPoses[i].y = 0;
 
61
                _itemPoses[i].x      = 0;
 
62
                _itemPoses[i].y      = 0;
53
63
                _itemPoses[i].orient = 0;
54
64
        }
55
65
 
56
 
        _nearestWayPoint = 0;
57
 
        _nearestDest = 0;
58
66
        _curGoblinX = 0;
59
67
        _curGoblinY = 0;
60
68
        _destX = 0;
61
69
        _destY = 0;
 
70
 
62
71
        _sourceFile[0] = 0;
63
72
 
64
73
        _loadFromAvo = false;
76
85
        delete[] _wayPoints;
77
86
}
78
87
 
 
88
uint8 Map::getVersion() const {
 
89
        return _mapVersion;
 
90
}
 
91
 
 
92
int16 Map::getMapWidth() const {
 
93
        return _mapWidth;
 
94
}
 
95
 
 
96
int16 Map::getMapHeight() const {
 
97
        return _mapHeight;
 
98
}
 
99
 
 
100
int16 Map::getScreenWidth() const {
 
101
        return _screenWidth;
 
102
}
 
103
 
 
104
int16 Map::getScreenHeight() const {
 
105
        return _screenHeight;
 
106
}
 
107
 
 
108
int16 Map::getTilesWidth() const {
 
109
        return _tilesWidth;
 
110
}
 
111
 
 
112
int16 Map::getTilesHeight() const {
 
113
        return _tilesHeight;
 
114
}
 
115
 
 
116
bool Map::hasBigTiles() const {
 
117
        return _bigTiles;
 
118
}
 
119
 
 
120
int8 Map::getPass(int x, int y, int width) const {
 
121
        if (!_passMap)
 
122
                return 0;
 
123
 
 
124
        if ((x < 0) || (y < 0) || (x >= _mapWidth) || (y >= _mapHeight))
 
125
                return 0;
 
126
 
 
127
        if (width == -1)
 
128
                width = _passWidth;
 
129
        return _passMap[y * width + x];
 
130
}
 
131
 
 
132
void Map::setPass(int x, int y, int8 pass, int width) {
 
133
        if (!_passMap)
 
134
                return;
 
135
 
 
136
        if ((x < 0) || (y < 0) || (x >= _mapWidth) || (y >= _mapHeight))
 
137
                return;
 
138
 
 
139
        if (width == -1)
 
140
                width = _passWidth;
 
141
        _passMap[y * width + x] = pass;
 
142
}
 
143
 
 
144
const WayPoint &Map::getWayPoint(int n) const {
 
145
        assert(_wayPoints);
 
146
        assert(n < _wayPointCount);
 
147
 
 
148
        return _wayPoints[n];
 
149
}
 
150
 
 
151
int16 Map::getItem(int x, int y) const {
 
152
        assert(_itemsMap);
 
153
 
 
154
        x = CLIP<int>(x, 0, _mapWidth - 1);
 
155
        y = CLIP<int>(y, 0, _mapHeight - 1);
 
156
 
 
157
        return _itemsMap[y][x];
 
158
}
 
159
 
 
160
void Map::setItem(int x, int y, int16 item) {
 
161
        assert(_itemsMap);
 
162
 
 
163
        x = CLIP<int>(x, 0, _mapWidth - 1);
 
164
        y = CLIP<int>(y, 0, _mapHeight - 1);
 
165
 
 
166
        _itemsMap[y][x] = item;
 
167
}
 
168
 
79
169
void Map::placeItem(int16 x, int16 y, int16 id) {
80
170
        if ((getItem(x, y) & 0xFF00) != 0)
81
171
                setItem(x, y, (getItem(x, y) & 0xFF00) | id);
83
173
                setItem(x, y, (getItem(x, y) & 0x00FF) | (id << 8));
84
174
}
85
175
 
86
 
enum {
87
 
        kLeft  = (1 << 0),
88
 
        kUp    = (1 << 1),
89
 
        kRight = (1 << 2),
90
 
        kDown  = (1 << 3)
91
 
};
92
 
 
93
 
Map::Direction Map::getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
 
176
Direction Map::getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
94
177
        if ((x0 == x1) && (y0 == y1))
95
178
                // Already at the destination
96
179
                return kDirNone;
99
182
                // Destination out of range
100
183
                return kDirNone;
101
184
 
102
 
        int16 dir = 0;
 
185
        RelativeDirection relDir = kRelDirNone;
103
186
 
104
187
        // Find the direct direction we want to move
105
188
        if (y1 > y0)
106
 
                dir |= kDown;
 
189
                relDir = kRelDirDown;
107
190
        else if (y1 < y0)
108
 
                dir |= kUp;
 
191
                relDir = kRelDirUp;
109
192
 
110
193
        if (x1 > x0)
111
 
                dir |= kRight;
 
194
                relDir = (RelativeDirection)(relDir | kRelDirRight);
112
195
        else if (x1 < x0)
113
 
                dir |= kLeft;
 
196
                relDir = (RelativeDirection)(relDir | kRelDirLeft);
114
197
 
115
198
 
116
199
        // Are we on ladders and can continue the ladder in the wanted direction?
117
 
        if ((getPass(x0, y0) == 3) && (dir & kUp  ) && (getPass(x0, y0 - 1) != 0))
 
200
        if ((getPass(x0, y0) == 3) && (relDir & kRelDirUp  ) && (getPass(x0, y0 - 1) != 0))
118
201
                return kDirN;
119
202
 
120
 
        if ((getPass(x0, y0) == 3) && (dir & kDown) && (getPass(x0, y0 + 1) != 0))
 
203
        if ((getPass(x0, y0) == 3) && (relDir & kRelDirDown) && (getPass(x0, y0 + 1) != 0))
121
204
                return kDirS;
122
205
 
123
 
        if ((getPass(x0, y0) == 6) && (dir & kUp  ) && (getPass(x0, y0 - 1) != 0))
 
206
        if ((getPass(x0, y0) == 6) && (relDir & kRelDirUp  ) && (getPass(x0, y0 - 1) != 0))
124
207
                return kDirN;
125
208
 
126
 
        if ((getPass(x0, y0) == 6) && (dir & kDown) && (getPass(x0, y0 + 1) != 0))
 
209
        if ((getPass(x0, y0) == 6) && (relDir & kRelDirDown) && (getPass(x0, y0 + 1) != 0))
127
210
                return kDirS;
128
211
 
129
212
 
130
213
        // Want to go left
131
 
        if (dir == kLeft) {
 
214
        if (relDir == kRelDirLeft) {
132
215
                if (getPass(x0 - 1, y0) != 0)
133
216
                        // Can go west
134
217
                        return kDirW;
138
221
        }
139
222
 
140
223
        // Want to go left
141
 
        if (dir == kRight) {
 
224
        if (relDir == kRelDirRight) {
142
225
                if (getPass(x0 + 1, y0) != 0)
143
226
                        // Can go east
144
227
                        return kDirE;
149
232
 
150
233
 
151
234
        // Want to go up
152
 
        if (dir == kUp) {
 
235
        if (relDir == kRelDirUp) {
153
236
                if (getPass(x0    , y0 - 1) != 0)
154
237
                        // Can go north
155
238
                        return kDirN;
167
250
        }
168
251
 
169
252
        // Want to go down
170
 
        if (dir == kDown) {
 
253
        if (relDir == kRelDirDown) {
171
254
                if (getPass(x0    , y0 + 1) != 0)
172
255
                        // Can go south
173
256
                        return kDirS;
186
269
 
187
270
 
188
271
        // Want to go up and right
189
 
        if (dir == (kRight | kUp)) {
 
272
        if (relDir == kRelDirRightUp) {
190
273
                if (getPass(x0 + 1, y0 - 1) != 0)
191
274
                        // Can go north-east
192
275
                        return kDirNE;
204
287
        }
205
288
 
206
289
        // Want to go down and right
207
 
        if (dir == (kRight | kDown)) {
 
290
        if (relDir == kRelDirRightDown) {
208
291
                if (getPass(x0 + 1, y0 + 1) != 0)
209
292
                        // Can go south-east
210
293
                        return kDirSE;
222
305
        }
223
306
 
224
307
        // Want to go up and left
225
 
        if (dir == (kLeft | kUp)) {
 
308
        if (relDir == kRelDirLeftUp) {
226
309
                if (getPass(x0 - 1, y0 - 1) != 0)
227
310
                        // Can go north-west
228
311
                        return kDirNW;
240
323
        }
241
324
 
242
325
        // Want to go left and down
243
 
        if (dir == (kLeft | kDown)) {
 
326
        if (relDir == kRelDirLeftDown) {
244
327
                if (getPass(x0 - 1, y0 + 1) != 0)
245
328
                        // Can go south-west
246
329
                        return kDirSW;
268
351
 
269
352
        length = 30000;
270
353
 
271
 
        for (int i = 0; i < _wayPointsCount; i++) {
 
354
        for (int i = 0; i < _wayPointCount; i++) {
272
355
                if ((_wayPoints[i].x < 0) || (_wayPoints[i].x >= _mapWidth) ||
273
356
                                (_wayPoints[i].y < 0) || (_wayPoints[i].y >= _mapHeight))
274
357
                        break;
402
485
                        // Check for a blocking waypoint
403
486
 
404
487
                        if (obj->nearestWayPoint < obj->nearestDest)
405
 
                                if ((obj->nearestWayPoint + 1) < _wayPointsCount)
 
488
                                if ((obj->nearestWayPoint + 1) < _wayPointCount)
406
489
                                        if (_wayPoints[obj->nearestWayPoint + 1].notWalkable == 1)
407
490
                                                return 3;
408
491