character.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 CHARACTER_H
#define CHARACTER_H

#include "common/hashmap.h"
#include "common/ptr.h"
#include "common/rect.h"
#include "common/scummsys.h"

namespace Common {
class SeekableReadStream;
class ReadStream;
class WriteStream;
} // namespace Common
namespace Graphics {
struct Surface;
class ManagedSurface;
} // namespace Graphics

namespace AGDS {

class AGDSEngine;
class Object;
using ObjectPtr = Common::SharedPtr<Object>;
class Animation;
using AnimationPtr = Common::SharedPtr<Animation>;

class Character {
    using FogPtr = Common::ScopedPtr<Graphics::ManagedSurface>;
    AGDSEngine *_engine;
    ObjectPtr _object;
    AnimationPtr _animation;
    FogPtr _fog;
    bool _jokes;
    Common::String _name;
    Common::String _processName;
    Common::Point _pos;
    Common::Point _animationPos;
    bool _enabled;
    bool _visible;
    bool _stopped;
    bool _shown;
    int _phase;
    int _frames;
    int _direction;
    int _jokesDirection;
    int _movementDirections;
    int _fogMinZ, _fogMaxZ;

    struct AnimationDescription {
        struct Frame {
            int x, y;
            uint w, h;
        };

        Common::String filename;
        Common::Array<Frame> frames;
    };
    Common::HashMap<uint, AnimationDescription> _animations;
    const AnimationDescription *_description;

    bool animate(int direction, int speed, bool jokes);
    Common::Point animationPosition() const;

public:
    Character(AGDSEngine *engine, const Common::String &name);
    ~Character();

    void associate(const Common::String &name);

    const AnimationDescription *animationDescription(uint index) const {
        auto it = _animations.find(index);
        return it != _animations.end() ? &it->_value : nullptr;
    }

    const Common::String &name() const {
        return _name;
    }

    const ObjectPtr &object() const {
        return _object;
    }

    void load(Common::SeekableReadStream &stream);
    void loadState(Common::ReadStream &stream);
    void saveState(Common::WriteStream &stream) const;

    void enable(bool enabled = true) {
        _enabled = enabled;
    }

    void visible(bool visible);
    bool visible() const {
        return _visible && _shown;
    }

    bool active() const {
        return _enabled && _visible;
    }

    bool animate(Common::Point pos, int direction, int speed);

    void stop();
    void leave(const Common::String &processName);

    int phase() const {
        return _jokes ? _phase : -1;
    }
    void phase(int phase) {
        _phase = phase;
    }

    void position(Common::Point pos) {
        _pos = pos;
    }

    Common::Point position() const {
        return _pos;
    }
    bool pointIn(Common::Point pos) const;

    void notifyProcess(const Common::String &processName);
    bool moveTo(const Common::String &processName, Common::Point dst, int direction);
    void pointTo(const Common::String &processName, Common::Point dst);

    bool direction(int dir);

    int direction() const {
        return _jokes ? _jokesDirection : _direction;
    }

    void tick(bool reactivate);
    void paint(Graphics::Surface &backbuffer, Common::Point pos) const;

    int getDirectionForMovement(Common::Point delta);

    int z() const;

    void reset();
    void setFog(Graphics::ManagedSurface *surface, int minZ, int maxZ);
};

} // End of namespace AGDS

#endif /* AGDS_CHARACTER_H */