walking.h

/* 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 DRACI_WALKING_H
#define DRACI_WALKING_H

#include "common/array.h"
#include "common/rect.h"

namespace Draci {

class Sprite;

typedef Common::Array<Common::Point> WalkingPath;

class WalkingMap {
public:
    WalkingMap() : _realWidth(0), _realHeight(0), _deltaX(1), _deltaY(1),
        _mapWidth(0), _mapHeight(0), _byteWidth(0), _data(NULL) { }

    void load(const byte *data, uint length);

    bool getPixel(int x, int y) const;
    bool isWalkable(const Common::Point &p) const;

    Sprite *newOverlayFromMap(byte color) const;
    Common::Point findNearestWalkable(int x, int y) const;

    bool findShortestPath(Common::Point p1, Common::Point p2, WalkingPath *path) const;
    void obliquePath(const WalkingPath& path, WalkingPath *obliquedPath);
    Sprite *newOverlayFromPath(const WalkingPath &path, byte color) const;
    Common::Point getDelta() const { return Common::Point(_deltaX, _deltaY); }

    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);

private:
    int _realWidth, _realHeight;
    int _deltaX, _deltaY;
    int _mapWidth, _mapHeight;
    int _byteWidth;

    // We don't own the pointer.  It points to the BArchive cache for this room.
    const byte *_data;

    // 4 possible directions to walk from a pixel.
    static const int kDirections[][2];

    void drawOverlayRectangle(const Common::Point &p, byte color, byte *buf) const;
    bool lineIsCovered(const Common::Point &p1, const Common::Point &p2) const;

    // Returns true if the number of vertices on the path was decreased.
    bool managedToOblique(WalkingPath *path) const;
};

/*
 * Enumerates the directions the dragon can look into when arrived.
 */
enum SightDirection {
    kDirectionLast, kDirectionMouse, kDirectionUnknown,
    kDirectionRight, kDirectionLeft, kDirectionIntelligent
};

enum Movement {
    kMoveUndefined = -1,
    kMoveDown, kMoveUp, kMoveRight, kMoveLeft,

    kFirstTurning,
    kMoveRightDown = kFirstTurning, kMoveRightUp, kMoveLeftDown, kMoveLeftUp,
    kMoveDownRight, kMoveUpRight, kMoveDownLeft, kMoveUpLeft,
    kMoveLeftRight, kMoveRightLeft, kMoveUpStopLeft, kMoveUpStopRight,
    kLastTurning = kMoveUpStopRight,

    kSpeakRight, kSpeakLeft, kStopRight, kStopLeft,

    kFirstTemporaryAnimation
};

class DraciEngine;
struct GPL2Program;

class WalkingState {
public:
    explicit WalkingState(DraciEngine *vm) : _vm(vm) {
        _dir = kDirectionLast;
        _startingDirection = kMoveUndefined;
        _segment = 0;
        _lastAnimPhase = 0;
        _turningFinished = 0;
        _callbackOffset = 0;
        _callbackOffsetLast = 0;
        _callbackLast = 0;

        stopWalking();
    }

    ~WalkingState() {}

    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);
    const WalkingPath& getPath() const { return _path; }

    void setCallback(const GPL2Program *program, uint16 offset);
    void callback();
    void callbackLast();

    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
    // 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.
    bool continueWalking();
    bool continueWalkingOrClearPath();

    // Called when the hero's turning animation has finished.
    void heroAnimationFinished();

    // 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.
    static Movement animationForSightDirection(SightDirection dir, const Common::Point &hero, const Common::Point &mouse, const WalkingPath &path, Movement startingDirection);

private:
    DraciEngine *_vm;

    WalkingPath _path;
    Common::Point _mouse;
    SightDirection _dir;
    Movement _startingDirection;

    uint _segment;      // Index of the path vertex we are currently going to / rotation on
    int _lastAnimPhase;
    bool _turningFinished;

    const GPL2Program *_callback;
    const GPL2Program *_callbackLast;
    uint16 _callbackOffset;
    uint16 _callbackOffsetLast;

    // 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();

    // Return one of the 4 animations kMove{Down,Up,Right,Left}
    // corresponding to walking from here to there.
    static Movement animationForDirection(const Common::Point &here, const Common::Point &there);

    // 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;

    // 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);

    static bool isTurningMovement(Movement m) {
        return m >= kFirstTurning && m <= kLastTurning;
    }

    // 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);
};

} // End of namespace Draci

#endif // DRACI_WALKING_H