Turtle.h

/*
 *   Repast for High Performance Computing (Repast HPC)
 *
 *   Copyright (c) 2010 Argonne National Laboratory
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with
 *   or without modification, are permitted provided that the following
 *   conditions are met:
 *
 *     Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *     Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 *     Neither the name of the Argonne National Laboratory nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *  Turtle.h
 *
 *  Created on: Jul 15, 2010
 *      Author: nick
 */
 
#ifndef TURTLE_H_
#define TURTLE_H_
 
#include "AbstractRelogoAgent.h"
#include "relogo.h"
#include "Observer.h"
#include "utility.h"
 
namespace repast {
 
namespace relogo {
 
class RelogoLink;
class Patch;
 
class Turtle: public AbstractRelogoAgent {
 
public:
 
        using RelogoAgent::xCor;
        using RelogoAgent::yCor;
 
        Turtle(repast::AgentId id, Observer* observer);
        virtual ~Turtle() {
        }
 
        // Doc from RelogoAgent.h
        virtual void hatchCopy(RelogoAgent* parent){
          Turtle* parentTurtle = (Turtle*)parent;
          _heading = parentTurtle->heading();
        }
 
        void xCor(double x);
 
        void yCor(double y);
 
        void setxy(double x, double y);
 
        virtual int pxCor() const;
 
        virtual int pyCor() const;
 
        void die();
 
        void createLinkWith(Turtle* turtle, const std::string& network = DEFAULT_UNDIR_NET);
 
        template<typename LinkCreator>
        void createLinkWithLC(Turtle* turtle, LinkCreator& creator, const std::string& network = DEFAULT_UNDIR_NET);
 
        template<typename AgentType>
        void createLinksWith(AgentSet<AgentType>& agents, const std::string& network = DEFAULT_UNDIR_NET);
 
        template<typename AgentType, typename LinkCreator>
        void createLinksWithLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network =
                        DEFAULT_UNDIR_NET);
 
        void createLinkFrom(Turtle* turtle, const std::string& network = DEFAULT_DIR_NET);
 
        template<typename LinkCreator>
        void createLinkFromLC(Turtle* turtle, LinkCreator& linkCreator, const std::string& network = DEFAULT_DIR_NET);
 
        template<typename AgentType>
        void createLinksFrom(AgentSet<AgentType>& agents, const std::string& network = DEFAULT_DIR_NET);
 
        template<typename AgentType, typename LinkCreator>
        void createLinksFromLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network =
                        DEFAULT_DIR_NET);
 
        template<typename AgentType>
        void createLinksTo(AgentSet<AgentType>& agents, const std::string& network = DEFAULT_DIR_NET);
 
        template<typename AgentType, typename LinkCreator>
        void
        createLinksToLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network = DEFAULT_DIR_NET);
 
        void createLinkTo(Turtle* turtle, const std::string& network = DEFAULT_DIR_NET);
 
        template<typename LinkCreator>
        void createLinkToLC(Turtle* turtle, LinkCreator& linkCreator, const std::string& network = DEFAULT_DIR_NET);
 
        boost::shared_ptr<RelogoLink> inLinkFrom(Turtle* turtle, const std::string& name = DEFAULT_DIR_NET);
 
        boost::shared_ptr<RelogoLink> outLinkTo(Turtle* turtle, const std::string& name = DEFAULT_DIR_NET);
 
        boost::shared_ptr<RelogoLink> linkWith(Turtle* turtle, const std::string& name = DEFAULT_UNDIR_NET);
 
        bool linkNeighborQ(Turtle* turtle, const std::string& name = DEFAULT_UNDIR_NET);
 
        template<typename AgentType>
        void linkNeighbors(AgentSet<AgentType>& out, const std::string& name = DEFAULT_UNDIR_NET);
 
        bool inLinkNeighborQ(Turtle* turtle, const std::string& name = DEFAULT_DIR_NET);
 
        template<typename AgentType>
        void inLinkNeighbors(AgentSet<AgentType>& out, const std::string& name = DEFAULT_DIR_NET);
 
        bool outLinkNeighborQ(Turtle* turtle, const std::string& name = DEFAULT_DIR_NET);
 
        template<typename AgentType>
        void outLinkNeighbors(AgentSet<AgentType>& out, const std::string& name = DEFAULT_DIR_NET);
 
        void moveTo(Turtle* turtle);
 
        void moveTo(Patch* patch);
 
        void move(double distance);
 
        void mv(double distance) {
                move(distance);
        }
 
        void jump(double distance) {
                if (canMoveQ(distance))
                        forward(distance);
        }
 
        void forward(double distance) {
                move(distance);
        }
 
        void backward(double distance) {
                move(-distance);
        }
 
        void fd(double distance) {
                forward(distance);
        }
 
        void bk(double distance) {
                backward(-distance);
        }
 
        template<typename PatchType, typename ValueGetter>
        void downhill(ValueGetter& getter);
 
        template<typename PatchType, typename ValueGetter>
        void downhill4(ValueGetter& getter);
 
        template<typename PatchType, typename ValueGetter>
        void uphill(ValueGetter& getter);
 
        template<typename PatchType, typename ValueGetter>
        void uphill4(ValueGetter& getter);
 
        double dx() const;
 
        double dy() const;
 
        bool canMoveQ(double distance) const;
 
        float towards(RelogoAgent* agent) const;
 
        float towardsxy(double x, double y) const;
 
        float towards(const Point<double>& location) const;
 
        double distance(Turtle* turtle) const;
 
        float heading() const {
                return _heading;
        }
 
        void heading(float heading);
 
        template<typename PatchType>
        PatchType* patchHere() const;
 
        void face(Turtle* turtle);
 
        void face(Patch* patch);
 
        void facexy(double nx, double ny);
 
        void left(float degrees);
 
        void lt(float degrees);
 
        template<typename PatchType>
        PatchType* patchLeftAndAhead(float angleInDegrees, double distance);
 
        template<typename PatchType>
        PatchType* patchRightAndAhead(float angleInDegrees, double distance);
 
private:
        float _heading;
        bool moved;
 
        // contains the "tied" turtles
        typedef boost::unordered_set<Turtle*, AgentHashId<Turtle> > TiedSetType;
        TiedSetType fixedLeaves, freeLeaves;
 
        /*
         * Moves tied turtles vector diff between oldLocation and this
         * turtles current location
         */
        void moveTiedTurtles(const Point<double>& oldLocation);
        /*
         * Moves a tied turtle as the result of this turtle changing its heading.
         */
        void moveTiedTurtle(Turtle* t, float angleTurned);
 
};
 
template<typename LinkCreator>
void Turtle::createLinkFromLC(Turtle* turtle, LinkCreator& linkCreator, const std::string& network) {
        _observer->createLink(turtle, this, network, linkCreator);
}
 
template<typename LinkCreator>
void Turtle::createLinkToLC(Turtle* turtle, LinkCreator& linkCreator, const std::string& network) {
        _observer->createLink(this, turtle, network, linkCreator);
}
 
template<typename LinkCreator>
void Turtle::createLinkWithLC(Turtle* turtle, LinkCreator& linkCreator, const std::string& network) {
        _observer->createLink(this, turtle, network, linkCreator);
}
 
template<typename AgentType>
void Turtle::createLinksWith(AgentSet<AgentType>& agents, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(this, agents[i], network);
        }
}
 
template<typename AgentType, typename LinkCreator>
void Turtle::createLinksWithLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(this, agents[i], network, creator);
        }
}
 
template<typename AgentType>
void Turtle::createLinksFrom(AgentSet<AgentType>& agents, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(agents[i], this, network);
        }
}
 
template<typename AgentType, typename LinkCreator>
void Turtle::createLinksFromLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(agents[i], this, network, creator);
        }
}
 
template<typename AgentType>
void Turtle::createLinksTo(AgentSet<AgentType>& agents, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(this, agents[i], network);
        }
}
 
template<typename AgentType, typename LinkCreator>
void Turtle::createLinksToLC(AgentSet<AgentType>& agents, LinkCreator& creator, const std::string& network) {
        for (size_t i = 0, n = agents.size(); i < n; i++) {
                _observer->createLink(this, agents[i], network, creator);
        }
}
 
template<typename AgentType>
void Turtle::linkNeighbors(AgentSet<AgentType>& out, const std::string& name) {
        _observer->predecessors(this, name, out);
}
 
template<typename AgentType>
void Turtle::inLinkNeighbors(AgentSet<AgentType>& out, const std::string& name) {
        _observer->predecessors(this, name, out);
}
 
template<typename AgentType>
void Turtle::outLinkNeighbors(AgentSet<AgentType>& out, const std::string& name) {
        _observer->successors(this, name, out);
}
 
template<typename PatchType>
PatchType* Turtle::patchHere() const {
        return _observer->patchAt<PatchType> (doubleCoordToInt(_location[0]), doubleCoordToInt(_location[1]));
}
 
template<typename PatchType, typename ValueGetter>
void Turtle::uphill(ValueGetter& getter) {
        PatchType* myPatch = patchHere<PatchType> ();
        moveTo(myPatch);
        // ".template" is needed to tell the compiler that "<" is
        // a template and not a less than.
        AgentSet<PatchType> patches = (*myPatch).template neighbors<PatchType> ();
        PatchType* max = patches.maxOneOf(getter);
        if (getter(max) > getter(myPatch)) {
                face(max);
                moveTo(max);
        }
}
 
template<typename PatchType, typename ValueGetter>
void Turtle::uphill4(ValueGetter& getter) {
        PatchType* myPatch = patchHere<PatchType> ();
        moveTo(myPatch);
        // ".template" is needed to tell the compiler that "<" is
        // a template and not a less than.
        AgentSet<PatchType> patches = (*myPatch).template neighbors4<PatchType> ();
        PatchType* max = patches.maxOneOf(getter);
        if (getter(max) > getter(myPatch)) {
                face(max);
                moveTo(max);
        }
}
 
template<typename PatchType, typename ValueGetter>
void Turtle::downhill(ValueGetter& getter) {
        PatchType* myPatch = patchHere<PatchType> ();
        moveTo(myPatch);
        // ".template" is needed to tell the compiler that "<" is
        // a template and not a less than.
        AgentSet<PatchType> patches = (*myPatch).template neighbors<PatchType> ();
        PatchType* min = patches.minOneOf(getter);
        if (getter(min) < getter(myPatch)) {
                face(min);
                moveTo(min);
        }
}
 
template<typename PatchType, typename ValueGetter>
void Turtle::downhill4(ValueGetter& getter) {
        PatchType* myPatch = patchHere<PatchType> ();
        moveTo(myPatch);
        // ".template" is needed to tell the compiler that "<" is
        // a template and not a less than.
        AgentSet<PatchType> patches = (*myPatch).template neighbors4<PatchType> ();
        PatchType* min = patches.minOneOf(getter);
        if (getter(min) < getter(myPatch)) {
                face(min);
                moveTo(min);
        }
}
 
template<typename PatchType>
PatchType* Turtle::patchLeftAndAhead(float angleInDegrees, double distance) {
        float heading = fmodf(_heading - angleInDegrees, 360);
        if (heading < 0)
                heading += 360;
        std::vector<double> disp = calcDisplacementFromHeadingDistance(heading, distance);
        return static_cast<PatchType*> (_observer->patchAt(_location, disp[0], disp[1]));
}
 
template<typename PatchType>
PatchType* Turtle::patchRightAndAhead(float angleInDegrees, double distance) {
        float heading = fmodf(angleInDegrees + _heading, 360);
        if (heading < 0)
                heading += 360;
        std::vector<double> disp = calcDisplacementFromHeadingDistance(heading, distance);
        return static_cast<PatchType*> (_observer->patchAt(_location, disp[0], disp[1]));
}
 
}
}
 
#endif /* TURTLE_H_ */