2009-10-30 00:52:05 +00:00
|
|
|
/* 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 2
|
|
|
|
* 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, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef DRACI_WALKING_H
|
|
|
|
#define DRACI_WALKING_H
|
|
|
|
|
2009-11-01 09:34:07 +00:00
|
|
|
#include "common/array.h"
|
2009-10-30 00:52:05 +00:00
|
|
|
#include "common/rect.h"
|
|
|
|
|
|
|
|
namespace Draci {
|
|
|
|
|
2009-10-30 07:26:43 +00:00
|
|
|
class Sprite;
|
|
|
|
|
2009-11-03 03:24:59 +00:00
|
|
|
typedef Common::Array<Common::Point> WalkingPath;
|
|
|
|
|
2009-10-30 00:52:05 +00:00
|
|
|
class WalkingMap {
|
|
|
|
public:
|
2009-10-30 01:41:57 +00:00
|
|
|
WalkingMap() : _realWidth(0), _realHeight(0), _deltaX(1), _deltaY(1),
|
|
|
|
_mapWidth(0), _mapHeight(0), _byteWidth(0), _data(NULL) { }
|
2009-10-30 00:52:05 +00:00
|
|
|
|
|
|
|
void load(const byte *data, uint length);
|
2009-11-01 09:34:07 +00:00
|
|
|
|
|
|
|
bool getPixel(int x, int y) const;
|
2009-11-11 00:19:23 +00:00
|
|
|
bool isWalkable(const Common::Point &p) const;
|
2009-11-01 09:34:07 +00:00
|
|
|
|
2011-04-14 12:12:27 +00:00
|
|
|
Sprite *newOverlayFromMap(byte color) const;
|
2009-11-11 00:19:23 +00:00
|
|
|
Common::Point findNearestWalkable(int x, int y) const;
|
2009-10-30 00:52:05 +00:00
|
|
|
|
2009-11-03 03:24:59 +00:00
|
|
|
bool findShortestPath(Common::Point p1, Common::Point p2, WalkingPath *path) const;
|
|
|
|
void obliquePath(const WalkingPath& path, WalkingPath *obliquedPath);
|
2011-04-14 12:12:27 +00:00
|
|
|
Sprite *newOverlayFromPath(const WalkingPath &path, byte color) const;
|
2009-11-03 21:05:26 +00:00
|
|
|
Common::Point getDelta() const { return Common::Point(_deltaX, _deltaY); }
|
2009-11-01 09:34:07 +00:00
|
|
|
|
2009-11-05 14:22:39 +00:00
|
|
|
static int pointsBetween(const Common::Point &p1, const Common::Point &p2);
|
|
|
|
static Common::Point interpolate(const Common::Point &p1, const Common::Point &p2, int i, int n);
|
|
|
|
|
2009-10-30 00:52:05 +00:00
|
|
|
private:
|
|
|
|
int _realWidth, _realHeight;
|
|
|
|
int _deltaX, _deltaY;
|
|
|
|
int _mapWidth, _mapHeight;
|
|
|
|
int _byteWidth;
|
2009-10-30 01:41:57 +00:00
|
|
|
|
|
|
|
// We don't own the pointer. It points to the BArchive cache for this room.
|
2009-10-30 00:52:05 +00:00
|
|
|
const byte *_data;
|
2009-11-01 09:34:07 +00:00
|
|
|
|
|
|
|
// 4 possible directions to walk from a pixel.
|
2009-11-11 00:19:23 +00:00
|
|
|
static const int kDirections[][2];
|
2009-11-01 10:58:34 +00:00
|
|
|
|
2011-04-14 12:12:27 +00:00
|
|
|
void drawOverlayRectangle(const Common::Point &p, byte color, byte *buf) const;
|
2009-11-03 03:24:59 +00:00
|
|
|
bool lineIsCovered(const Common::Point &p1, const Common::Point &p2) const;
|
2009-11-03 03:38:28 +00:00
|
|
|
|
|
|
|
// Returns true if the number of vertices on the path was decreased.
|
|
|
|
bool managedToOblique(WalkingPath *path) const;
|
2009-10-30 00:52:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enumerates the directions the dragon can look into when arrived.
|
|
|
|
*/
|
|
|
|
enum SightDirection {
|
|
|
|
kDirectionLast, kDirectionMouse, kDirectionUnknown,
|
|
|
|
kDirectionRight, kDirectionLeft, kDirectionIntelligent
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Enumerates the animations for the dragon's movement.
|
|
|
|
*/
|
|
|
|
enum Movement {
|
|
|
|
kMoveUndefined = -1,
|
|
|
|
kMoveDown, kMoveUp, kMoveRight, kMoveLeft,
|
2009-11-05 14:22:39 +00:00
|
|
|
|
|
|
|
kFirstTurning,
|
|
|
|
kMoveRightDown = kFirstTurning, kMoveRightUp, kMoveLeftDown, kMoveLeftUp,
|
2009-10-30 00:52:05 +00:00
|
|
|
kMoveDownRight, kMoveUpRight, kMoveDownLeft, kMoveUpLeft,
|
|
|
|
kMoveLeftRight, kMoveRightLeft, kMoveUpStopLeft, kMoveUpStopRight,
|
2009-11-05 14:22:39 +00:00
|
|
|
kLastTurning = kMoveUpStopRight,
|
|
|
|
|
2009-11-22 09:13:05 +00:00
|
|
|
kSpeakRight, kSpeakLeft, kStopRight, kStopLeft,
|
|
|
|
|
|
|
|
kFirstTemporaryAnimation
|
2009-10-30 00:52:05 +00:00
|
|
|
};
|
|
|
|
|
2009-11-03 22:13:37 +00:00
|
|
|
class DraciEngine;
|
|
|
|
struct GPL2Program;
|
|
|
|
|
2009-11-03 03:24:59 +00:00
|
|
|
class WalkingState {
|
|
|
|
public:
|
2009-11-04 00:42:37 +00:00
|
|
|
explicit WalkingState(DraciEngine *vm) : _vm(vm) { stopWalking(); }
|
2009-11-03 03:24:59 +00:00
|
|
|
~WalkingState() {}
|
|
|
|
|
2009-11-04 00:42:37 +00:00
|
|
|
void stopWalking();
|
|
|
|
void startWalking(const Common::Point &p1, const Common::Point &p2,
|
|
|
|
const Common::Point &mouse, SightDirection dir,
|
|
|
|
const Common::Point &delta, const WalkingPath& path);
|
2009-11-03 03:24:59 +00:00
|
|
|
const WalkingPath& getPath() const { return _path; }
|
|
|
|
|
2009-11-03 22:13:37 +00:00
|
|
|
void setCallback(const GPL2Program *program, uint16 offset);
|
|
|
|
void callback();
|
|
|
|
|
2009-11-04 00:42:37 +00:00
|
|
|
bool isActive() const { return _path.size() > 0; }
|
|
|
|
|
|
|
|
// Advances the hero along the path and changes animation accordingly.
|
|
|
|
// Walking MUST be active when calling this method. When the hero has
|
2009-11-08 06:30:10 +00:00
|
|
|
// arrived to the target, returns false, but leaves the callback
|
|
|
|
// untouched (the caller must call it).
|
|
|
|
// The second variant also clears the path when returning false.
|
2009-11-04 00:42:37 +00:00
|
|
|
bool continueWalking();
|
2009-11-08 06:30:10 +00:00
|
|
|
bool continueWalkingOrClearPath();
|
2009-11-04 00:42:37 +00:00
|
|
|
|
2009-11-08 05:29:12 +00:00
|
|
|
// Called when the hero's turning animation has finished.
|
2009-11-05 14:22:39 +00:00
|
|
|
void heroAnimationFinished();
|
|
|
|
|
2009-11-07 01:54:47 +00:00
|
|
|
// Returns the hero's animation corresponding to looking into given
|
|
|
|
// direction. The direction can be smart and in that case this
|
|
|
|
// function needs to know the whole last path, the current position of
|
|
|
|
// the hero, or the mouse position.
|
2009-11-08 03:16:22 +00:00
|
|
|
static Movement animationForSightDirection(SightDirection dir, const Common::Point &hero, const Common::Point &mouse, const WalkingPath &path, Movement startingDirection);
|
2009-11-05 14:22:39 +00:00
|
|
|
|
2009-11-03 03:24:59 +00:00
|
|
|
private:
|
2009-11-03 22:13:37 +00:00
|
|
|
DraciEngine *_vm;
|
|
|
|
|
2009-11-03 03:24:59 +00:00
|
|
|
WalkingPath _path;
|
2009-11-03 22:13:37 +00:00
|
|
|
Common::Point _mouse;
|
2009-11-04 00:42:37 +00:00
|
|
|
SightDirection _dir;
|
2009-11-08 03:16:22 +00:00
|
|
|
Movement _startingDirection;
|
2009-11-03 22:13:37 +00:00
|
|
|
|
2009-11-08 05:44:50 +00:00
|
|
|
uint _segment; // Index of the path vertex we are currently going to / rotation on
|
2009-11-05 14:22:39 +00:00
|
|
|
int _lastAnimPhase;
|
2009-11-08 05:29:12 +00:00
|
|
|
bool _turningFinished;
|
2009-11-05 14:22:39 +00:00
|
|
|
|
2009-11-03 22:13:37 +00:00
|
|
|
const GPL2Program *_callback;
|
|
|
|
uint16 _callbackOffset;
|
2009-11-05 00:21:54 +00:00
|
|
|
|
2009-11-08 05:29:12 +00:00
|
|
|
// Initiates turning of the dragon into the direction for the next
|
|
|
|
// segment / after walking. Returns false when there is nothing left
|
|
|
|
// to do and walking is done.
|
|
|
|
bool turnForTheNextSegment();
|
|
|
|
|
|
|
|
// Starts walking on the next edge. Returns false if we are already at
|
|
|
|
// the final vertex and walking is done.
|
|
|
|
bool walkOnNextEdge();
|
2009-11-05 14:22:39 +00:00
|
|
|
|
2009-11-05 00:21:54 +00:00
|
|
|
// Return one of the 4 animations kMove{Down,Up,Right,Left}
|
2009-11-08 05:29:12 +00:00
|
|
|
// corresponding to walking from here to there.
|
2009-11-05 00:21:54 +00:00
|
|
|
static Movement animationForDirection(const Common::Point &here, const Common::Point &there);
|
|
|
|
|
2009-11-05 14:22:39 +00:00
|
|
|
// Returns the desired facing direction to begin the next phase of the
|
|
|
|
// walk. It's either a direction for the given edge or the desired
|
|
|
|
// final direction.
|
|
|
|
Movement directionForNextPhase() const;
|
|
|
|
|
2009-11-05 00:21:54 +00:00
|
|
|
// Returns either animation that needs to be played between given two
|
|
|
|
// animations (e.g., kMoveRightDown after kMoveRight and before
|
|
|
|
// kMoveDown), or kMoveUndefined if none animation is to be played.
|
|
|
|
static Movement transitionBetweenAnimations(Movement previous, Movement next);
|
2009-11-05 14:22:39 +00:00
|
|
|
|
|
|
|
static bool isTurningMovement(Movement m) {
|
|
|
|
return m >= kFirstTurning && m <= kLastTurning;
|
|
|
|
}
|
2009-11-07 11:45:13 +00:00
|
|
|
|
2009-11-08 03:16:22 +00:00
|
|
|
// Projects hero to the given edge. Returns true when hero has reached
|
|
|
|
// at least p2. prevHero is passed so that we can compute how much to
|
|
|
|
// adjust in the other-than-walking direction.
|
|
|
|
static bool alignHeroToEdge(const Common::Point &p1, const Common::Point &p2, const Common::Point &prevHero, Common::Point *hero);
|
2009-11-03 03:24:59 +00:00
|
|
|
};
|
|
|
|
|
2009-10-30 00:52:05 +00:00
|
|
|
} // End of namespace Draci
|
|
|
|
|
|
|
|
#endif // DRACI_WALKING_H
|