GooseMemoryMap.h

Go to the documentation of this file.

 
 
/*
*******************************************************************************************************
Copyright (c) 2013, Christopher John Topping, University of Aarhus
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.
 
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 COPYRIGHT HOLDER 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.
********************************************************************************************************
*/
 
 
//---------------------------------------------------------------------------
#ifndef goosememorymapH
#define goosememorymapH
//----------------------------------------------------------------------------
 
#define __DEBUG_GOOSE
 
 
class Goose_Base;
 
class GooseMemoryLocation
{
public:
        int m_age;
        int m_x;
        int m_y;
        int m_polygonid;
        double m_grain;
        double m_maize;
        double m_grazing;
        double m_foodresource;
        double m_threat;
        double m_score;
        static int m_infinitememorystop;
        
// Methods
        GooseMemoryLocation() {
                m_age = 0;  m_x = -1; m_y = -1; m_polygonid = -1, m_threat = 0, m_grain = 0; m_maize = 0.0; m_grazing = 0.0; m_foodresource = 0.0; m_infinitememorystop = 0;
        }
        bool operator<(const GooseMemoryLocation& gml)
        {
                return m_polygonid < gml.m_polygonid;
        }
        void CalcScore(int a_dist, double a_flightcost, int a_expectedforagingtime)
        {
                double cost = a_dist * a_flightcost;
                double score = (m_foodresource * a_expectedforagingtime) - cost;
                m_score = score * (1 - m_threat);
        }
        bool ShouldDelete() { return (m_age > m_infinitememorystop); }
 
        //-------------------------------------------------------------------------------------------------------
 
};
//----------------------------------------------------------------------------
 
class GooseMemoryMap
{
protected:
        Goose_Base* m_myOwner;
        double m_threatdecayrate;
        int m_expectedforagingtime;
        std::vector<GooseMemoryLocation> m_memorylocations;
public:
        GooseMemoryMap(Goose_Base* a_owner);
        ~GooseMemoryMap() { 
                m_memorylocations.erase(m_memorylocations.begin(),m_memorylocations.end());
        }
        void MemAdd(GooseMemoryLocation a_gml);
 
        bool MemDel(int a_polyid);
 
        bool ChangeAddFoodRes(int a_polyid, double a_foodres);
 
        bool ChangeAddThreat(int a_polyid, double a_threat);
 
        bool ChangeMultFoodRes(int a_polyid, double a_foodres);
 
        bool ChangeSetFoodRes(int a_polyid, double a_grain, double a_maize, double a_grazing);
 
        bool ChangeMultThreat(int a_polyid, double a_threat);
 
        double GetFoodRes( int a_polyid );
 
        double GetThreat( int a_polyid );
 
        GooseMemoryLocation GetBestFeedingScore();
                
        double CalcScore(int a_dist, double a_foodresource, double a_threat);
 
        bool IsKnownArea( int a_polyid );
 
        void DecayAllMemory();
        double GetTotalThreats( void );
        void ClearAllMemory(void);
protected:
        void GooseMemoryError(std::string a_str, int a_value);
};
//----------------------------------------------------------------------------
 
 
#endif