1 /* ScummVM - Graphic Adventure Engine
2 *
3 * ScummVM is the legal property of its developers, whose names
4 * are too numerous to list here. Please refer to the COPYRIGHT
5 * file distributed with this source distribution.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 *
21 */
22
23 #include "gnap/gnap.h"
24 #include "gnap/datarchive.h"
25 #include "gnap/gamesys.h"
26 #include "gnap/resource.h"
27
28 namespace Gnap {
29
initSceneGrid(int gridMinX,int gridMinY,int gridMaxX,int gridMaxY)30 void GnapEngine::initSceneGrid(int gridMinX, int gridMinY, int gridMaxX, int gridMaxY) {
31 _gridMinX = gridMinX;
32 _gridMinY = gridMinY;
33 _gridMaxX = gridMaxX;
34 _gridMaxY = gridMaxY;
35 _gnap->_gridX = 410 - gridMinX;
36 _gnap->_gridY = 450 - gridMinY;
37 _plat->_gridX = 396 - gridMinX;
38 _plat->_gridY = 347 - gridMinY;
39 }
40
isPointBlocked(Common::Point gridPos)41 bool GnapEngine::isPointBlocked(Common::Point gridPos) {
42 return isPointBlocked(gridPos.x, gridPos.y);
43 }
44
isPointBlocked(int gridX,int gridY)45 bool GnapEngine::isPointBlocked(int gridX, int gridY) {
46
47 if (gridX < 0 || gridX >= _gridMaxX || gridY < 0 || gridY >= _gridMaxY)
48 return true;
49
50 if ((_gnap->_pos == Common::Point(gridX, gridY)) || (_plat->_pos == Common::Point(gridX, gridY)))
51 return true;
52
53 Common::Point pos = Common::Point(_gridMinX + 75 * gridX, _gridMinY + 48 * gridY);
54
55 for (int i = 0; i < _hotspotsCount; ++i) {
56 if (_hotspots[i].isPointInside(pos) && !(_hotspots[i]._flags & SF_WALKABLE))
57 return true;
58 }
59
60 return false;
61 }
62
63 /******************************************************************************/
64
getWalkStopSequenceId(int deltaX,int deltaY)65 int PlayerGnap::getWalkStopSequenceId(int deltaX, int deltaY) {
66 static const int gnapWalkStopSequenceIds[9] = {
67 0x7BC, 0x7BA, 0x7BA,
68 0x7BC, 0x000, 0x7BA,
69 0x7BB, 0x7B9, 0x7B9
70 };
71
72 int id = 3 * (deltaX + 1) + deltaY + 1;
73 assert (id >= 0 && id < 9 );
74 return gnapWalkStopSequenceIds[id];
75 }
76
getWalkFacing(int deltaX,int deltaY)77 Facing PlayerGnap::getWalkFacing(int deltaX, int deltaY) {
78 static const Facing gnapWalkFacings[9] = {
79 kDirUpLeft, kDirBottomLeft, kDirBottomLeft,
80 kDirUpLeft, kDirIdleLeft, kDirBottomLeft,
81 kDirUpRight, kDirBottomRight, kDirBottomRight
82 };
83
84 int id = 3 * (deltaX + 1) + deltaY + 1;
85 assert (id >= 0 && id < 9 );
86 return gnapWalkFacings[id];
87 }
88
findPath1(int gridX,int gridY,int index)89 bool PlayerGnap::findPath1(int gridX, int gridY, int index) {
90 _walkNodesCount = index;
91 _walkDirXIncr = 0;
92 _walkDirYIncr = 0;
93 _walkDeltaX = ABS(_walkDestX - gridX);
94 _walkDeltaY = ABS(_walkDestY - gridY);
95
96 if (_walkDeltaX)
97 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
98 else
99 _walkDirX = 0;
100
101 if (_walkDeltaY)
102 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
103 else
104 _walkDirY = 0;
105
106 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
107 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
108 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
109 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
110 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
111 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
112 ++_walkDirXIncr;
113 ++_walkDirYIncr;
114 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
115 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
116 _walkNodes[_walkNodesCount]._deltaX = 0;
117 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
118 ++_walkDirYIncr;
119 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
120 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
121 _walkNodes[_walkNodesCount]._deltaY = 0;
122 ++_walkDirXIncr;
123 } else
124 return false;
125 } else {
126 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
127 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
128 _walkNodes[_walkNodesCount]._deltaY = 0;
129 ++_walkDirXIncr;
130 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
131 _walkNodes[_walkNodesCount]._deltaX = 0;
132 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
133 ++_walkDirYIncr;
134 } else
135 return false;
136 }
137 ++_walkNodesCount;
138 }
139
140 while (_walkDirXIncr < _walkDeltaX) {
141 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
142 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
143 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
144 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
145 _walkNodes[_walkNodesCount]._deltaY = 0;
146 ++_walkDirXIncr;
147 ++_walkNodesCount;
148 } else
149 return false;
150 }
151
152 while (_walkDirYIncr < _walkDeltaY) {
153 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
154 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
155 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
156 _walkNodes[_walkNodesCount]._deltaX = 0;
157 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
158 ++_walkDirYIncr;
159 ++_walkNodesCount;
160 } else
161 return false;
162 }
163
164 return true;
165 }
166
findPath2(int gridX,int gridY,int index)167 bool PlayerGnap::findPath2(int gridX, int gridY, int index) {
168 _walkNodesCount = index;
169 _walkDirXIncr = 0;
170 _walkDirYIncr = 0;
171 _walkDeltaX = ABS(_walkDestX - gridX);
172 _walkDeltaY = ABS(_walkDestY - gridY);
173
174 if (_walkDeltaX)
175 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
176 else
177 _walkDirX = 0;
178
179 if (_walkDeltaY)
180 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
181 else
182 _walkDirY = 0;
183
184 while (_walkDeltaY < _walkDeltaX - _walkDirXIncr) {
185 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
186 _walkNodes[_walkNodesCount]._gridY1 = gridY;
187 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, gridY)) {
188 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
189 _walkNodes[_walkNodesCount]._deltaY = 0;
190 ++_walkDirXIncr;
191 ++_walkNodesCount;
192 } else
193 return false;
194 }
195
196 while (_walkDeltaX < _walkDeltaY - _walkDirYIncr) {
197 _walkNodes[_walkNodesCount]._gridX1 = gridX;
198 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
199 if (!_vm->isPointBlocked(gridX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
200 _walkNodes[_walkNodesCount]._deltaX = 0;
201 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
202 ++_walkDirYIncr;
203 ++_walkNodesCount;
204 } else
205 return false;
206 }
207
208 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
209 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
210 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
211 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
212 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
213 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
214 ++_walkDirXIncr;
215 ++_walkDirYIncr;
216 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
217 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
218 _walkNodes[_walkNodesCount]._deltaX = 0;
219 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
220 ++_walkDirYIncr;
221 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
222 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
223 _walkNodes[_walkNodesCount]._deltaY = 0;
224 ++_walkDirXIncr;
225 } else
226 return false;
227 } else {
228 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
229 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
230 _walkNodes[_walkNodesCount]._deltaY = 0;
231 ++_walkDirXIncr;
232 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
233 _walkNodes[_walkNodesCount]._deltaX = 0;
234 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
235 ++_walkDirYIncr;
236 } else
237 return false;
238 }
239 ++_walkNodesCount;
240 }
241
242 while (_walkDirXIncr < _walkDeltaX) {
243 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
244 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
245 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
246 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
247 _walkNodes[_walkNodesCount]._deltaY = 0;
248 ++_walkDirXIncr;
249 ++_walkNodesCount;
250 } else
251 return false;
252 }
253
254 while (_walkDirYIncr < _walkDeltaY) {
255 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
256 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
257 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
258 _walkNodes[_walkNodesCount]._deltaX = 0;
259 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
260 ++_walkDirYIncr;
261 ++_walkNodesCount;
262 } else
263 return false;
264 }
265
266 return true;
267 }
268
findPath3(int gridX,int gridY)269 bool PlayerGnap::findPath3(int gridX, int gridY) {
270 int gridIncr = 1;
271 bool done = false;
272
273 while (!done && gridIncr < _vm->_gridMaxX) {
274 if (!_vm->isPointBlocked(gridX + gridIncr, gridY) && findPath1(gridX + gridIncr, gridY, gridIncr)) {
275 for (int i = 0; i < gridIncr; ++i) {
276 _walkNodes[i]._gridX1 = gridX + i;
277 _walkNodes[i]._gridY1 = gridY;
278 _walkNodes[i]._deltaX = 1;
279 _walkNodes[i]._deltaY = 0;
280 }
281 done = true;
282 break;
283 }
284 if (!_vm->isPointBlocked(gridX - gridIncr, gridY) && findPath1(gridX - gridIncr, gridY, gridIncr)) {
285 for (int i = 0; i < gridIncr; ++i) {
286 _walkNodes[i]._gridX1 = gridX - i;
287 _walkNodes[i]._gridY1 = gridY;
288 _walkNodes[i]._deltaX = -1;
289 _walkNodes[i]._deltaY = 0;
290 }
291 done = true;
292 break;
293 }
294 if (!_vm->isPointBlocked(gridX, gridY + gridIncr) && findPath1(gridX, gridY + gridIncr, gridIncr)) {
295 for (int i = 0; i < gridIncr; ++i) {
296 _walkNodes[i]._gridX1 = gridX;
297 _walkNodes[i]._gridY1 = gridY + i;
298 _walkNodes[i]._deltaX = 0;
299 _walkNodes[i]._deltaY = 1;
300 }
301 done = true;
302 break;
303 }
304 if (!_vm->isPointBlocked(gridX, gridY - gridIncr) && findPath1(gridX, gridY - gridIncr, gridIncr)) {
305 for (int i = 0; i < gridIncr; ++i) {
306 _walkNodes[i]._gridX1 = gridX;
307 _walkNodes[i]._gridY1 = gridY - i;
308 _walkNodes[i]._deltaX = 0;
309 _walkNodes[i]._deltaY = -1;
310 }
311 done = true;
312 break;
313 }
314 if (!_vm->isPointBlocked(gridX + gridIncr, gridY + gridIncr) && findPath1(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
315 for (int i = 0; i < gridIncr; ++i) {
316 _walkNodes[i]._gridX1 = gridX + i;
317 _walkNodes[i]._gridY1 = gridY + i;
318 _walkNodes[i]._deltaX = 1;
319 _walkNodes[i]._deltaY = 1;
320 }
321 done = true;
322 break;
323 }
324 if (!_vm->isPointBlocked(gridX - gridIncr, gridY + gridIncr) && findPath1(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
325 for (int i = 0; i < gridIncr; ++i) {
326 _walkNodes[i]._gridX1 = gridX - i;
327 _walkNodes[i]._gridY1 = gridY + i;
328 _walkNodes[i]._deltaX = -1;
329 _walkNodes[i]._deltaY = 1;
330 }
331 done = true;
332 break;
333 }
334 if (!_vm->isPointBlocked(gridX + gridIncr, gridY - gridIncr) && findPath1(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
335 for (int i = 0; i < gridIncr; ++i) {
336 _walkNodes[i]._gridX1 = gridX + i;
337 _walkNodes[i]._gridY1 = gridY - i;
338 _walkNodes[i]._deltaX = 1;
339 _walkNodes[i]._deltaY = -1;
340 }
341 done = true;
342 break;
343 }
344 if (!_vm->isPointBlocked(gridX - gridIncr, gridY - gridIncr) && findPath1(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
345 for (int i = 0; i < gridIncr; ++i) {
346 _walkNodes[i]._gridX1 = gridX - i;
347 _walkNodes[i]._gridY1 = gridY - i;
348 _walkNodes[i]._deltaX = -1;
349 _walkNodes[i]._deltaY = -1;
350 }
351 done = true;
352 break;
353 }
354 if (!_vm->isPointBlocked(gridX + gridIncr, gridY) && findPath2(gridX + gridIncr, gridY, gridIncr)) {
355 for (int i = 0; i < gridIncr; ++i) {
356 _walkNodes[i]._gridX1 = gridX + i;
357 _walkNodes[i]._gridY1 = gridY;
358 _walkNodes[i]._deltaX = 1;
359 _walkNodes[i]._deltaY = 0;
360 }
361 done = true;
362 break;
363 }
364 if (!_vm->isPointBlocked(gridX - gridIncr, gridY) && findPath2(gridX - gridIncr, gridY, gridIncr)) {
365 for (int i = 0; i < gridIncr; ++i) {
366 _walkNodes[i]._gridX1 = gridX - i;
367 _walkNodes[i]._gridY1 = gridY;
368 _walkNodes[i]._deltaX = -1;
369 _walkNodes[i]._deltaY = 0;
370 }
371 done = true;
372 break;
373 }
374 if (!_vm->isPointBlocked(gridX, gridY + gridIncr) && findPath2(gridX, gridY + gridIncr, gridIncr)) {
375 for (int i = 0; i < gridIncr; ++i) {
376 _walkNodes[i]._gridX1 = gridX;
377 _walkNodes[i]._gridY1 = gridY + i;
378 _walkNodes[i]._deltaX = 0;
379 _walkNodes[i]._deltaY = 1;
380 }
381 done = true;
382 break;
383 }
384 if (!_vm->isPointBlocked(gridX, gridY - gridIncr) && findPath2(gridX, gridY - gridIncr, gridIncr)) {
385 for (int i = 0; i < gridIncr; ++i) {
386 _walkNodes[i]._gridX1 = gridX;
387 _walkNodes[i]._gridY1 = gridY - i;
388 _walkNodes[i]._deltaX = 0;
389 _walkNodes[i]._deltaY = -1;
390 }
391 done = true;
392 break;
393 }
394 if (!_vm->isPointBlocked(gridX + gridIncr, gridY + gridIncr) && findPath2(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
395 for (int i = 0; i < gridIncr; ++i) {
396 _walkNodes[i]._gridX1 = gridX + i;
397 _walkNodes[i]._gridY1 = gridY + i;
398 _walkNodes[i]._deltaX = 1;
399 _walkNodes[i]._deltaY = 1;
400 }
401 done = true;
402 break;
403 }
404 if (!_vm->isPointBlocked(gridX - gridIncr, gridY + gridIncr) && findPath2(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
405 for (int i = 0; i < gridIncr; ++i) {
406 _walkNodes[i]._gridX1 = gridX - i;
407 _walkNodes[i]._gridY1 = gridY + i;
408 _walkNodes[i]._deltaX = -1;
409 _walkNodes[i]._deltaY = 1;
410 }
411 done = true;
412 break;
413 }
414 if (!_vm->isPointBlocked(gridX + gridIncr, gridY - gridIncr) && findPath2(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
415 for (int i = 0; i < gridIncr; ++i) {
416 _walkNodes[i]._gridX1 = gridX + i;
417 _walkNodes[i]._gridY1 = gridY - i;
418 _walkNodes[i]._deltaX = 1;
419 _walkNodes[i]._deltaY = -1;
420 }
421 done = true;
422 break;
423 }
424 if (!_vm->isPointBlocked(gridX - gridIncr, gridY - gridIncr) && findPath2(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
425 for (int i = 0; i < gridIncr; ++i) {
426 _walkNodes[i]._gridX1 = gridX - i;
427 _walkNodes[i]._gridY1 = gridY - i;
428 _walkNodes[i]._deltaX = -1;
429 _walkNodes[i]._deltaY = -1;
430 }
431 done = true;
432 break;
433 }
434 ++gridIncr;
435 }
436
437 return done;
438 }
439
findPath4(int gridX,int gridY)440 bool PlayerGnap::findPath4(int gridX, int gridY) {
441 bool result = false;
442
443 _walkNodesCount = 0;
444 _walkDirXIncr = 0;
445 _walkDirYIncr = 0;
446 _walkDeltaX = ABS(_walkDestX - gridX);
447 _walkDeltaY = ABS(_walkDestY - gridY);
448
449 if (_walkDeltaX)
450 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
451 else
452 _walkDirX = 0;
453
454 if (_walkDeltaY)
455 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
456 else
457 _walkDirY = 0;
458
459 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
460 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
461 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
462 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
463 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
464 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
465 ++_walkDirXIncr;
466 ++_walkDirYIncr;
467 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
468 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
469 _walkNodes[_walkNodesCount]._deltaX = 0;
470 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
471 ++_walkDirYIncr;
472 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
473 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
474 _walkNodes[_walkNodesCount]._deltaY = 0;
475 ++_walkDirXIncr;
476 } else {
477 _walkDeltaX = _walkDirXIncr;
478 _walkDeltaY = _walkDirYIncr;
479 --_walkNodesCount;
480 }
481 } else {
482 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
483 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
484 _walkNodes[_walkNodesCount]._deltaY = 0;
485 ++_walkDirXIncr;
486 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
487 _walkNodes[_walkNodesCount]._deltaX = 0;
488 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
489 ++_walkDirYIncr;
490 } else {
491 _walkDeltaX = _walkDirXIncr;
492 _walkDeltaY = _walkDirYIncr;
493 --_walkNodesCount;
494 }
495 }
496 ++_walkNodesCount;
497 }
498
499 while (_walkDirXIncr < _walkDeltaX) {
500 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
501 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
502 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
503 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
504 _walkNodes[_walkNodesCount]._deltaY = 0;
505 ++_walkDirXIncr;
506 ++_walkNodesCount;
507 } else {
508 _walkDeltaX = _walkDirXIncr;
509 }
510 }
511
512 while (_walkDirYIncr < _walkDeltaY) {
513 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
514 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
515 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
516 _walkNodes[_walkNodesCount]._deltaX = 0;
517 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
518 ++_walkDirYIncr;
519 ++_walkNodesCount;
520 } else {
521 _walkDeltaY = _walkDirYIncr;
522 }
523 }
524
525 if (gridX + _walkDirX * _walkDirXIncr != _walkDestX || gridY + _walkDirY * _walkDirYIncr != _walkDestY) {
526 _walkDestX = gridX + _walkDirX * _walkDirXIncr;
527 _walkDestY = gridY + _walkDirY * _walkDirYIncr;
528 result = false;
529 } else {
530 result = true;
531 }
532
533 return result;
534 }
535
536 /******************************************************************************/
537
findPath1(int gridX,int gridY,int index)538 bool PlayerPlat::findPath1(int gridX, int gridY, int index) {
539 _walkNodesCount = index;
540 _walkDirXIncr = 0;
541 _walkDirYIncr = 0;
542 _walkDeltaX = ABS(_walkDestX - gridX);
543 _walkDeltaY = ABS(_walkDestY - gridY);
544
545 if (_walkDeltaX)
546 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
547 else
548 _walkDirX = 0;
549
550 if (_walkDeltaY)
551 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
552 else
553 _walkDirY = 0;
554
555 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
556 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
557 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
558 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
559 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
560 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
561 ++_walkDirXIncr;
562 ++_walkDirYIncr;
563 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
564 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
565 _walkNodes[_walkNodesCount]._deltaX = 0;
566 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
567 ++_walkDirYIncr;
568 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
569 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
570 _walkNodes[_walkNodesCount]._deltaY = 0;
571 ++_walkDirXIncr;
572 } else
573 return false;
574 } else {
575 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
576 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
577 _walkNodes[_walkNodesCount]._deltaY = 0;
578 ++_walkDirXIncr;
579 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
580 _walkNodes[_walkNodesCount]._deltaX = 0;
581 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
582 ++_walkDirYIncr;
583 } else
584 return false;
585 }
586 ++_walkNodesCount;
587 }
588
589 while (_walkDirXIncr < _walkDeltaX) {
590 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
591 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
592 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
593 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
594 _walkNodes[_walkNodesCount]._deltaY = 0;
595 ++_walkDirXIncr;
596 ++_walkNodesCount;
597 } else
598 return false;
599 }
600
601 while (_walkDirYIncr < _walkDeltaY) {
602 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
603 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
604 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
605 _walkNodes[_walkNodesCount]._deltaX = 0;
606 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
607 ++_walkDirYIncr;
608 ++_walkNodesCount;
609 } else
610 return false;
611 }
612
613 return true;
614 }
615
findPath2(int gridX,int gridY,int index)616 bool PlayerPlat::findPath2(int gridX, int gridY, int index) {
617 _walkNodesCount = index;
618 _walkDirXIncr = 0;
619 _walkDirYIncr = 0;
620 _walkDeltaX = ABS(_walkDestX - gridX);
621 _walkDeltaY = ABS(_walkDestY - gridY);
622
623 if (_walkDeltaX)
624 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
625 else
626 _walkDirX = 0;
627
628 if (_walkDeltaY)
629 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
630 else
631 _walkDirY = 0;
632
633 while (_walkDeltaY < _walkDeltaX - _walkDirXIncr) {
634 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
635 _walkNodes[_walkNodesCount]._gridY1 = gridY;
636 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, gridY)) {
637 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
638 _walkNodes[_walkNodesCount]._deltaY = 0;
639 ++_walkDirXIncr;
640 ++_walkNodesCount;
641 } else
642 return false;
643 }
644
645 while (_walkDeltaX < _walkDeltaY - _walkDirYIncr) {
646 _walkNodes[_walkNodesCount]._gridX1 = gridX;
647 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
648 if (!_vm->isPointBlocked(gridX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
649 _walkNodes[_walkNodesCount]._deltaX = 0;
650 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
651 ++_walkDirYIncr;
652 ++_walkNodesCount;
653 } else
654 return false;
655 }
656
657 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
658 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
659 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
660 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
661 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
662 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
663 ++_walkDirXIncr;
664 ++_walkDirYIncr;
665 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
666 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
667 _walkNodes[_walkNodesCount]._deltaX = 0;
668 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
669 ++_walkDirYIncr;
670 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
671 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
672 _walkNodes[_walkNodesCount]._deltaY = 0;
673 ++_walkDirXIncr;
674 } else
675 return false;
676 } else {
677 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
678 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
679 _walkNodes[_walkNodesCount]._deltaY = 0;
680 ++_walkDirXIncr;
681 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
682 _walkNodes[_walkNodesCount]._deltaX = 0;
683 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
684 ++_walkDirYIncr;
685 } else
686 return false;
687 }
688 ++_walkNodesCount;
689 }
690
691 while (_walkDirXIncr < _walkDeltaX) {
692 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
693 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
694 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
695 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
696 _walkNodes[_walkNodesCount]._deltaY = 0;
697 ++_walkDirXIncr;
698 ++_walkNodesCount;
699 } else
700 return false;
701 }
702
703 while (_walkDirYIncr < _walkDeltaY) {
704 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
705 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
706 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
707 _walkNodes[_walkNodesCount]._deltaX = 0;
708 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
709 ++_walkDirYIncr;
710 ++_walkNodesCount;
711 } else
712 return false;
713 }
714
715 return true;
716 }
717
findPath3(int gridX,int gridY)718 bool PlayerPlat::findPath3(int gridX, int gridY) {
719 int gridIncr = 1;
720 bool done = false;
721
722 while (!done && gridIncr < _vm->_gridMaxX) {
723 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y) && findPath1(_pos.x + gridIncr, _pos.y, gridIncr)) {
724 for (int i = 0; i < gridIncr; ++i) {
725 _walkNodes[i]._gridX1 = _pos.x + i;
726 _walkNodes[i]._gridY1 = _pos.y;
727 _walkNodes[i]._deltaX = 1;
728 _walkNodes[i]._deltaY = 0;
729 }
730 done = true;
731 break;
732 }
733 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y) && findPath1(_pos.x - gridIncr, _pos.y, gridIncr)) {
734 for (int i = 0; i < gridIncr; ++i) {
735 _walkNodes[i]._gridX1 = _pos.x - i;
736 _walkNodes[i]._gridY1 = _pos.y;
737 _walkNodes[i]._deltaX = -1;
738 _walkNodes[i]._deltaY = 0;
739 }
740 done = true;
741 break;
742 }
743 if (!_vm->isPointBlocked(_pos.x, _pos.y + gridIncr) && findPath1(_pos.x, _pos.y + gridIncr, gridIncr)) {
744 for (int i = 0; i < gridIncr; ++i) {
745 _walkNodes[i]._gridX1 = _pos.x;
746 _walkNodes[i]._gridY1 = _pos.y + i;
747 _walkNodes[i]._deltaX = 0;
748 _walkNodes[i]._deltaY = 1;
749 }
750 done = true;
751 break;
752 }
753 if (!_vm->isPointBlocked(_pos.x, _pos.y - gridIncr) && findPath1(_pos.x, _pos.y - gridIncr, gridIncr)) {
754 for (int i = 0; i < gridIncr; ++i) {
755 _walkNodes[i]._gridX1 = _pos.x;
756 _walkNodes[i]._gridY1 = _pos.y - i;
757 _walkNodes[i]._deltaX = 0;
758 _walkNodes[i]._deltaY = -1;
759 }
760 done = true;
761 break;
762 }
763 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y + gridIncr) && findPath1(_pos.x + gridIncr, _pos.y + gridIncr, gridIncr)) {
764 for (int i = 0; i < gridIncr; ++i) {
765 _walkNodes[i]._gridX1 = _pos.x + i;
766 _walkNodes[i]._gridY1 = _pos.y + i;
767 _walkNodes[i]._deltaX = 1;
768 _walkNodes[i]._deltaY = 1;
769 }
770 done = true;
771 break;
772 }
773 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y + gridIncr) && findPath1(_pos.x - gridIncr, _pos.y + gridIncr, gridIncr)) {
774 for (int i = 0; i < gridIncr; ++i) {
775 _walkNodes[i]._gridX1 = _pos.x - i;
776 _walkNodes[i]._gridY1 = _pos.y + i;
777 _walkNodes[i]._deltaX = -1;
778 _walkNodes[i]._deltaY = 1;
779 }
780 done = true;
781 break;
782 }
783 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y - gridIncr) && findPath1(_pos.x + gridIncr, _pos.y - gridIncr, gridIncr)) {
784 for (int i = 0; i < gridIncr; ++i) {
785 _walkNodes[i]._gridX1 = _pos.x + i;
786 _walkNodes[i]._gridY1 = _pos.y - i;
787 _walkNodes[i]._deltaX = 1;
788 _walkNodes[i]._deltaY = -1;
789 }
790 done = true;
791 break;
792 }
793 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y - gridIncr) && findPath1(_pos.x - gridIncr, _pos.y - gridIncr, gridIncr)) {
794 for (int i = 0; i < gridIncr; ++i) {
795 _walkNodes[i]._gridX1 = _pos.x - i;
796 _walkNodes[i]._gridY1 = _pos.y - i;
797 _walkNodes[i]._deltaX = -1;
798 _walkNodes[i]._deltaY = -1;
799 }
800 done = true;
801 break;
802 }
803 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y) && findPath2(_pos.x + gridIncr, _pos.y, gridIncr)) {
804 for (int i = 0; i < gridIncr; ++i) {
805 _walkNodes[i]._gridX1 = _pos.x + i;
806 _walkNodes[i]._gridY1 = _pos.y;
807 _walkNodes[i]._deltaX = 1;
808 _walkNodes[i]._deltaY = 0;
809 }
810 done = true;
811 break;
812 }
813 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y) && findPath2(_pos.x - gridIncr, _pos.y, gridIncr)) {
814 for (int i = 0; i < gridIncr; ++i) {
815 _walkNodes[i]._gridX1 = _pos.x - i;
816 _walkNodes[i]._gridY1 = _pos.y;
817 _walkNodes[i]._deltaX = -1;
818 _walkNodes[i]._deltaY = 0;
819 }
820 done = true;
821 break;
822 }
823 if (!_vm->isPointBlocked(_pos.x, _pos.y + gridIncr) && findPath2(_pos.x, _pos.y + gridIncr, gridIncr)) {
824 for (int i = 0; i < gridIncr; ++i) {
825 _walkNodes[i]._gridX1 = _pos.x;
826 _walkNodes[i]._gridY1 = _pos.y + i;
827 _walkNodes[i]._deltaX = 0;
828 _walkNodes[i]._deltaY = 1;
829 }
830 done = true;
831 break;
832 }
833 if (!_vm->isPointBlocked(_pos.x, _pos.y - gridIncr) && findPath2(_pos.x, _pos.y - gridIncr, gridIncr)) {
834 for (int i = 0; i < gridIncr; ++i) {
835 _walkNodes[i]._gridX1 = _pos.x;
836 _walkNodes[i]._gridY1 = _pos.y - i;
837 _walkNodes[i]._deltaX = 0;
838 _walkNodes[i]._deltaY = -1;
839 }
840 done = true;
841 break;
842 }
843 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y + gridIncr) && findPath2(_pos.x + gridIncr, _pos.y + gridIncr, gridIncr)) {
844 for (int i = 0; i < gridIncr; ++i) {
845 _walkNodes[i]._gridX1 = _pos.x + i;
846 _walkNodes[i]._gridY1 = _pos.y + i;
847 _walkNodes[i]._deltaX = 1;
848 _walkNodes[i]._deltaY = 1;
849 }
850 done = true;
851 break;
852 }
853 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y + gridIncr) && findPath2(_pos.x - gridIncr, _pos.y + gridIncr, gridIncr)) {
854 for (int i = 0; i < gridIncr; ++i) {
855 _walkNodes[i]._gridX1 = _pos.x - i;
856 _walkNodes[i]._gridY1 = _pos.y + i;
857 _walkNodes[i]._deltaX = -1;
858 _walkNodes[i]._deltaY = 1;
859 }
860 done = true;
861 break;
862 }
863 if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y - gridIncr) && findPath2(_pos.x + gridIncr, _pos.y - gridIncr, gridIncr)) {
864 for (int i = 0; i < gridIncr; ++i) {
865 _walkNodes[i]._gridX1 = _pos.x + i;
866 _walkNodes[i]._gridY1 = _pos.y - i;
867 _walkNodes[i]._deltaX = 1;
868 _walkNodes[i]._deltaY = -1;
869 }
870 done = true;
871 break;
872 }
873 if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y - gridIncr) && findPath2(_pos.x - gridIncr, _pos.y - gridIncr, gridIncr)) {
874 for (int i = 0; i < gridIncr; ++i) {
875 _walkNodes[i]._gridX1 = _pos.x - i;
876 _walkNodes[i]._gridY1 = _pos.y - i;
877 _walkNodes[i]._deltaX = -1;
878 _walkNodes[i]._deltaY = -1;
879 }
880 done = true;
881 break;
882 }
883 ++gridIncr;
884 }
885
886 return done;
887 }
888
findPath4(int gridX,int gridY)889 bool PlayerPlat::findPath4(int gridX, int gridY) {
890 bool result = false;
891
892 _walkNodesCount = 0;
893 _walkDirXIncr = 0;
894 _walkDirYIncr = 0;
895 _walkDeltaX = ABS(_walkDestX - gridX);
896 _walkDeltaY = ABS(_walkDestY - gridY);
897
898 if (_walkDeltaX)
899 _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
900 else
901 _walkDirX = 0;
902
903 if (_walkDeltaY)
904 _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
905 else
906 _walkDirY = 0;
907
908 while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
909 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
910 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
911 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
912 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
913 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
914 ++_walkDirXIncr;
915 ++_walkDirYIncr;
916 } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
917 if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
918 _walkNodes[_walkNodesCount]._deltaX = 0;
919 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
920 ++_walkDirYIncr;
921 } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
922 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
923 _walkNodes[_walkNodesCount]._deltaY = 0;
924 ++_walkDirXIncr;
925 } else {
926 _walkDeltaX = _walkDirXIncr;
927 _walkDeltaY = _walkDirYIncr;
928 --_walkNodesCount;
929 }
930 } else {
931 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
932 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
933 _walkNodes[_walkNodesCount]._deltaY = 0;
934 ++_walkDirXIncr;
935 } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
936 _walkNodes[_walkNodesCount]._deltaX = 0;
937 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
938 ++_walkDirYIncr;
939 } else {
940 _walkDeltaX = _walkDirXIncr;
941 _walkDeltaY = _walkDirYIncr;
942 --_walkNodesCount;
943 }
944 }
945 ++_walkNodesCount;
946 }
947
948 while (_walkDirXIncr < _walkDeltaX) {
949 _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
950 _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
951 if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
952 _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
953 _walkNodes[_walkNodesCount]._deltaY = 0;
954 ++_walkDirXIncr;
955 ++_walkNodesCount;
956 } else {
957 _walkDeltaX = _walkDirXIncr;
958 }
959 }
960
961 while (_walkDirYIncr < _walkDeltaY) {
962 _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
963 _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
964 if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
965 _walkNodes[_walkNodesCount]._deltaX = 0;
966 _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
967 ++_walkDirYIncr;
968 ++_walkNodesCount;
969 } else {
970 _walkDeltaY = _walkDirYIncr;
971 }
972 }
973
974 if (gridX + _walkDirX * _walkDirXIncr != _walkDestX || gridY + _walkDirY * _walkDirYIncr != _walkDestY) {
975 _walkDestX = gridX + _walkDirX * _walkDirXIncr;
976 _walkDestY = gridY + _walkDirY * _walkDirYIncr;
977 result = false;
978 } else {
979 result = true;
980 }
981
982 return result;
983 }
984
makeRoom()985 void PlayerPlat::makeRoom() {
986 int rndGridX, rndGridY;
987 do {
988 rndGridY = _vm->getRandom(_vm->_gridMaxY);
989 rndGridX = _vm->getRandom(_vm->_gridMaxX);
990 } while (ABS(rndGridX - _pos.x) > 4 || ABS(rndGridY - _pos.y) > 3 ||
991 _vm->isPointBlocked(rndGridX, rndGridY));
992 walkTo(Common::Point(rndGridX, rndGridY), -1, -1, 1);
993 }
994
995 } // End of namespace Gnap
996