rails.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 MADS_RAILS_H
#define MADS_RAILS_H

#include "common/scummsys.h"
#include "common/array.h"
#include "common/rect.h"
#include "common/serializer.h"
#include "common/stack.h"
#include "mads/nebular/core/msurface.h"

namespace MADS {
namespace Nebular {

class WalkNode {
public:
    Common::Point _walkPos;
    uint16 _distances[MAX_ROUTE_NODES];
    bool _active;

    WalkNode();

    void load(Common::SeekableReadStream *f);
};
typedef Common::Array<WalkNode> WalkNodeList;

class Rails {
private:
    WalkNodeList _nodes;
    DepthSurface *_depthSurface;
    int _depthStyle;
    int _routeLength;
    int _next;
    int _tempRoute[MAX_ROUTE_NODES];
    Common::Stack<int> _routeIndexes;
private:
    void setNodePosition(int nodeIndex, const Common::Point &pt);

    int getRouteFlags(const Common::Point &src, const Common::Point &dest);
public:
    Rails();

    void load(const WalkNodeList &nodes, DepthSurface *depthSurface, int depthStyle);

    void setupRoute(bool bitFlag, const Common::Point &srcPos, const Common::Point &destPos);

    void setupRouteNode(int *routeIndexP, int nodeIndex, int flags, int routeLength);

    void resetRoute();

    int scanPath(const Common::Point &srcPos, const Common::Point &destPos);

    /*
     * Return the number of walk nodes in the calculated route
     */
    int size() const {
        return _routeIndexes.size();
    }

    bool empty() const {
        return _routeIndexes.empty();
    }

    const WalkNode &operator[](int idx) {
        return _nodes[_routeIndexes[idx]];
    }

    const WalkNode &popNode();

    void resetNext() {
        _next = 0;
    }
    int  getNext() {
        return _next;
    }

    void synchronize(Common::Serializer &s);

    void disableNode(int idx);
    void disableLine(int from, int to);

};

} // namespace Nebular
} // namespace MADS

#endif