Rabbit.h

Go to the documentation of this file.

/*
*******************************************************************************************************
 
Copyright (c) 2015, Christopher John Topping, Faarupvej 54, DK-8410 Rønde
ADAMA Makhteshim Ltd., PO Box 60, Beer-Sheva 84100, Israel
 
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. 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 OWNER 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.
 
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
 
********************************************************************************************************
 
*/
//---------------------------------------------------------------------------
#ifndef RabbitH
#define RabbitH
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
 
class Rabbit_Population_Manager;
class Rabbit_Female;
class Rabbit_Warren;
class Rabbit_Adult;
class Landscape;
 
//------------------------------------------------------------------------------
//typedef vector<Rabbit*> TListOfRabbit;
//---------------------------------------------------------------------------
 
enum RabbitObjectTypes
{
    rob_Young = 0,
        rob_Juvenile,
        rob_Male,
        rob_Female,
        rob_Warren,
        rob_foobar
};
 
enum TTypeOfRabbitState
{
      toRabbits_InitialState=0,
      toRabbits_Develop,
      toRabbits_Mature,
      toRabbits_Explore,
      toRabbits_Gestation,
      toRabbits_Lactating,
      toRabbits_GiveBirth,
      toRabbits_Weaning,
      toRabbits_Foraging,
      toRabbits_EvaluateTerritory,
      toRabbits_UpdateBreedingStatus,
      toRabbits_Remove,
      toRabbits_Die,
      toRabbits_WarrenBeing
} ;
 
enum TTypesOfRabbitHabitat
{
    torh_Forage = 0,
    torh_TemporaryForage,
    torh_Cover,
    torh_Other,
    torh_foobar
};
 
enum TTypesOfRabbitSocialStatus {
    rabbit_socialstatus_zero = 0,
    rabbit_socialstatus_subordinate,
    rabbit_socialstatus_subdominant,
    rabbit_socialstatus_dominant,
};
 
struct RabbitWarrenLEInfo
{
    LE* m_ele;
    int m_area;
    int m_ref;
    double m_pesticide_conc;
    double m_forage;
    int m_foragearea;
    TTypesOfRabbitHabitat m_torh;
};
 
struct RabbitMemoryLocation
{
    int m_x;
    int m_y;
    int m_quality;
    int m_decay;
};
 
struct LocalWarrenNewtorkEntry
{
    Rabbit_Warren* m_aWarren;
    int m_dist;
    double m_visitprob;
};
 
class RabbitMemory
{
public:
    RabbitMemory( void );
    vector <RabbitMemoryLocation> m_MyMemory;
    void Update( void );
    void AddMemory( RabbitMemoryLocation a_mem);
    RabbitMemoryLocation GetBestLocation( void );
};
 
//************************Rabbit_Base***********************************************************************
class Rabbit_Base : public TAnimal {
    // ATTRIBUTES
public:
    RabbitObjectTypes m_RabbitType;
    static double m_dispersalmortperm;
    static double m_pesticidedegradationrate;
protected:
    int m_Age;
    TTypeOfRabbitState m_CurrentRState;
    Rabbit_Population_Manager*  m_OurPopulationManager;
    double m_MyMortChance;
    bool m_haveBurrow;
    //bool m_haveMate;
    Rabbit_Warren* m_myWarren;
    Rabbit_Female* m_Mum;
    bool m_FedToday;
    double m_weight;
    int m_weightAge;
    int m_digging;
    APoint m_born_location;
    double m_pesticide_burden;
    bool m_pesticideInfluenced1;
 
    // METHODS
public:
    TTypeOfRabbitState GetCurrentRState() {
        return m_CurrentRState;
    }
    void SetAge( int a_age ) {
        m_Age = a_age;
    }
    RabbitObjectTypes GetRabbitType( void ) {
        return m_RabbitType;
    }
    int GetAge( void ) {
        return m_Age;
    }
    void SetweightAge( int a_age ) {
        m_weightAge = a_age;
    }
    int GetweightAge( void ) {
        return m_weightAge;
    }
    Rabbit_Warren* GetWarren( void ) {
        return m_myWarren;
    }
    void SetWarren( Rabbit_Warren* a_warren ) {
        m_myWarren = a_warren;
    }
    bool GetHasBurrow( void ) {
        return m_haveBurrow;
    }
    void SetHasBurrow( bool a_status ) {
        m_haveBurrow = a_status;
    }
    void SetDigging( int a_days ) {
        m_digging = a_days;
    }
    int GetDigging() {
        return m_digging;
    }
    APoint GetBornLocation() {
        return m_born_location;
    }
    Rabbit_Base(int p_x, int p_y, int p_x2, int p_y2, Landscape* p_L, Rabbit_Population_Manager* p_NPM, Rabbit_Warren* a_warren);
    virtual ~Rabbit_Base( void );
    virtual void BeginStep( void );
    virtual void Step( void ) {
        ;
    }
    virtual void EndStep( void ) {
        ;
    }
    void OnFed( void ) {
        m_FedToday = true;
    }
    void OnMumDead( void ) {
        m_Mum = NULL;
    }
    void OnEvicted( void ) {
        m_Mum = NULL; m_CurrentRState = toRabbits_Weaning;
    }
    virtual Rabbit_Adult* GetMate( void ) {
        return NULL;
    };
protected:
    virtual void Explore( void ) {
        ;
    }
    virtual void st_Dying( void );
    bool MortalityTest( double a_prop );
    bool WalkTo( int a_x, int a_y );
    virtual void InternalPesticideHandlingAndResponse() {
        ;
    }
    virtual void GeneralEndocrineDisruptor( double /* a_pesticide_dose */ ) {
        ;
    }
    virtual void GeneralOrganoPhosphate( double /* a_pesticide_dose */ );
};
 
 
//************************Rabbit_Young***********************************************************************
class Rabbit_Young : public Rabbit_Base
{
public:
    Rabbit_Young(int p_x, int p_y, int p_x2, int p_y2, Rabbit_Female* a_mum, Landscape* p_L, Rabbit_Population_Manager* p_NPM, Rabbit_Warren* a_warren);
    virtual ~Rabbit_Young( void );
    TTypeOfRabbitState st_Develop( void );
    TTypeOfRabbitState st_BecomeJuvenile( void );
    virtual void BeingStep(void);
    virtual void Step(void);
    virtual void EndStep(void);
    virtual bool ShouldMature(void);
protected:
    virtual void st_Dying( void );
};
 
//************************Rabbit_Juvenile***********************************************************************
class Rabbit_Juvenile : public Rabbit_Young
{
public:
    Rabbit_Juvenile(int p_x, int p_y, int p_x2, int p_y2, Rabbit_Female* p_M, Landscape* p_L, Rabbit_Population_Manager* p_NPM, int a_age, int a_weightage, Rabbit_Warren* a_warren);
    virtual ~Rabbit_Juvenile( void );
    TTypeOfRabbitState st_Develop();
    TTypeOfRabbitState st_BecomeAdult( void );
    TTypeOfRabbitState st_Explore( void );
    TTypeOfRabbitState st_Forage( void );
    virtual void Step(void);
    virtual void EndStep(void);
    virtual bool ShouldMature(void);
protected:
    virtual void st_Dying( void );
    virtual void InternalPesticideHandlingAndResponse();
};
//************************Rabbit_Adult***********************************************************************
class Rabbit_Adult : public Rabbit_Base
{
public: 
// Methods
    Rabbit_Adult( int p_x, int p_y, int p_x2, int p_y2, Landscape* p_L, Rabbit_Population_Manager* p_NPM, int a_age, int a_weightage, Rabbit_Warren* a_warren );
    virtual ~Rabbit_Adult();
    TTypesOfRabbitSocialStatus GetSocialStatus( void ) {
        return m_socialstatus;
    }
    void SetSocialStatus( TTypesOfRabbitSocialStatus a_status ) {
        m_socialstatus = a_status;
    }
    void SetMate( Rabbit_Adult* a_mate );
    virtual Rabbit_Adult* GetMate( void ) { return m_myMate; };
    void OnMateFinishedDigging( Rabbit_Adult* a_mate );
    void OnMateDead( Rabbit_Adult* a_mate );
protected:
// Attributes
    TTypesOfRabbitSocialStatus m_socialstatus;
    int m_lifespan;
    Rabbit_Adult* m_myMate;
 
// Methods
    virtual void st_Dying( void );
    virtual void EndStep(void);
};
 
//************************Rabbit_Male***********************************************************************
class Rabbit_Male : public Rabbit_Adult
{
public:
    Rabbit_Male(int p_x, int p_y, int p_x2, int p_y2, Landscape* p_L, Rabbit_Population_Manager* p_NPM, int a_age, int a_weightage, Rabbit_Warren* a_warren);
    virtual ~Rabbit_Male( void );
    virtual void Step( void );
protected:
    virtual TTypeOfRabbitState st_EvaluateTerritory( void );
    virtual TTypeOfRabbitState st_Forage(void);
    virtual void InternalPesticideHandlingAndResponse();
};
//************************Rabbit_Female***********************************************************************
class Rabbit_Female : public Rabbit_Adult
{
public:
// METHODS
    Rabbit_Female(int p_x, int p_y, int p_x2, int p_y2, Landscape* p_L, Rabbit_Population_Manager* p_NPM, int a_age, int a_weightage, Rabbit_Warren* a_warren);
    virtual ~Rabbit_Female( void );
    virtual void Step( void );
    void AddYoung(Rabbit_Young* a_young) 
    { 
        m_myLitter[m_myLitterSize++] = a_young; 
    }
    void OnYoungDeath(Rabbit_Young* a_young);
    void Weaned(Rabbit_Young* a_young);
    void SetMinKits(double a_num) { m_MinKitsNo = a_num; }
    void SetMaxKits(double a_num) { m_MaxKitsNo = a_num; }
    int GetTotalOffspring() { return m_MyOffspring; }
    int GetTotalLitters() { return m_MyTotalLitters; }
    int GetLittersThisYear() {
        return static_cast<int>(m_AnnualLitters.size());
    }
 
protected:
    virtual TTypeOfRabbitState st_EvaluateTerritory( void );
    virtual TTypeOfRabbitState st_UpdateBreedingStatus( void );
    virtual TTypeOfRabbitState st_GiveBirth( void );
    virtual TTypeOfRabbitState st_Lactating( void );
    virtual TTypeOfRabbitState st_Gestating( void );
    virtual TTypeOfRabbitState st_Forage(void);
    virtual void st_Dying( void );
    int CalcLitterSize( void );
// ATTRIBUTES
    bool m_pregnant;
    bool m_lactating;
    int m_gestationcounter;
    Rabbit_Young* m_myLitter[20];
    int m_myLitterSize;
    static double m_MinKitsNo;
    static double m_MaxKitsNo;
    int m_MyOffspring;
    int m_MyTotalLitters;
    vector<int> m_AnnualLitters;
    virtual void InternalPesticideHandlingAndResponse();
    virtual void GeneralEndocrineDisruptor( double /* a_pesticide_dose */ );
};
 
//************************Rabbit_Warren***********************************************************************
class Rabbit_Warren : public TAnimal
{
public:
// ATTRIBUTES
    static double m_maxForageHeight;
    static double m_minForageDigestability;
    int m_breedingfemales;
    int m_1yrOldFemales;
    int m_littersthisyear;
    int m_nonbreedingfemales;
// METHODS
    Rabbit_Warren(int p_x, int p_y, Landscape* p_L, Rabbit_Population_Manager* p_NPM, int a_size, int a_soil);
    virtual ~Rabbit_Warren();
    virtual void Step();
    virtual void BeginStep() {
        CalcCarryingCapacityRatio1();
    }
    int Get_TL_x() { return m_TL_x; }
    int Get_TL_y() { return m_TL_y; }
    APoint GetPointTL() { APoint TL; TL.m_x=m_TL_x; TL.m_y=m_TL_y; return TL; }
    int GetActiveBurrows() { return m_NoOccupiedBurrows; }
    int GetPopulationSize() { return (int)m_InhabitantsList.size(); }
    bool GetCarryingCapacityFilled() { return (m_CarryingCapacity >= m_NoOccupiedBurrows); }
    double GetCarryingCapacityRatio() { return m_CarryingCapacityRatio; }
    int GetCarryingCapacity() { return m_CarryingCapacity; }
    double GetDiseaseConstant(void) { return m_diseaseconstant; }
    void RabbitProductionRecord(RabbitObjectTypes YoungType, int kits) { m_ThisYearsProduction[YoungType] += kits; }
    int GetRabbitProductionRecord(RabbitObjectTypes YoungType) { return m_ThisYearsProduction[YoungType]; }
    void ResetRabbitProductionRecord(RabbitObjectTypes YoungType) { m_ThisYearsProduction[YoungType] = 0; }
    void ResetAllRabbitProductionRecord(void) { for (int r = (int) rob_Young; r < (int) rob_foobar; r++)  m_ThisYearsProduction[r] = 0; }
    void AddNetworkConnection( LocalWarrenNewtorkEntry a_LWNE ) { m_LocalWarrenNetwork.push_back( a_LWNE ); }
    Rabbit_Warren* GetNetworkWarren( void );
    void NetworkEvaluation( void );
    bool IsMember( Rabbit_Base* a_rabbit );
    bool IsFreeFemale( void );
    bool IsFreeMale( void );
    void UpdateDominance( void );
    void ChooseNewDominant( void );
    int IsFreeBurrow( void );
    void Leave( Rabbit_Base* a_rabbit );
    void Join( Rabbit_Base* a_rabbit );
    void OccupyWarren( Rabbit_Adult* a_rabbit );
    void JoinNOccupy( Rabbit_Adult* a_rabbit );
    void JoinNMate(Rabbit_Adult* a_mate, RabbitObjectTypes rob_type);
    void Mate(Rabbit_Adult* a_mate, RabbitObjectTypes rob_type);
    void OccupyNewBurrow();
    void OccupyBurrow();
    int GetAllBreedingFemaleRabbits();
    int GetAllBigFemaleRabbits();
    double GetForagePesticide( void ) {
        return m_forageP;
    }
    int GetSoilType(void) { return m_soiltype; }
    //* \brief Debugging method */
    bool DEBUG_InternalTest();
    //* \brief Debugging method */
    bool DEBUG_InternalTest2();
    double Disease() { return m_diseaseconstant; }
    void CalcDisease();
    double GetAvailableForage( void ) {
        return m_availableforage;
    }
    double GetInvAvailableForage( void ) {
        return m_inv_availableforage;
    }
    double GetLitterReabsortionConst( void ) {
        return m_litterreabosorptionchance;
    }
    int GetThisYearsBreeders() {
        return m_breedingfemales;
    }
    double GetThisYearsBreedersAv() {
        double av = 0;
        if (m_runningavCount>0) av = m_runningavFemales / static_cast<double>(m_runningavCount);
        m_runningavFemales = 0;
        m_runningavCount = 0;
        return av;
    }
    int GetThisYears1yrOldFemales() {
        return m_1yrOldFemales;
    }
    int GetLittersThisYear(){
        return m_littersthisyear;
    }
    int GetThisYearsNonBreeders() {
        return m_nonbreedingfemales;
    }
    void UpdateThisYearsBreeders();
    double GetDailyMortalityChanceA() {
        return m_mortalitymultiplierA;
    }
    double GetDailyMortalityChanceJ() {
        return m_mortalitymultiplierJ;
    }
    double GetCCRabbitsR() {
        return m_BigFemaleRabbitsR;
    }
protected:
// ATTRIBUTES
    int m_size;
    int m_foragesize;
    int m_TL_x;
    int m_TL_y;
    int m_maintenence;
    int m_CarryingCapacity;
    double m_CarryingCapacityR;
    double m_CarryingCapacityR2;
    double m_BigFemaleRabbitsR;
    double m_CarryingCapacityRatio;
    int m_NoBurrows;
    int m_NoOccupiedBurrows;
    int m_BurrowsUnderConstruction;
    int m_soiltype;
    int m_rabbitdiggingtime;
    int m_permforagearea;
    int m_foragearea;
    double m_availableforage;
    double m_foragearearatio;
    double m_inv_availableforage;
    double m_litterreabosorptionchance;
    double m_forageP;
    double m_diseaseconstant;
    double m_mortalitymultiplierA;
    double m_mortalitymultiplierJ;
    int m_ThisYearsProduction[rob_foobar];
    TTypeOfRabbitState m_CurrentRState;
    vector<RabbitWarrenLEInfo> m_LEList;
    vector<LocalWarrenNewtorkEntry> m_LocalWarrenNetwork;
    vector<Rabbit_Base*> m_InhabitantsList;
    Rabbit_Population_Manager*  m_OurPopulationManager;
    int m_runningavFemales;
    int m_runningavCount;
 
// METHODS
    void st_WarrenBeing( void );
    void InitEvaluation( void );
    int GetForageArea( void ) { return m_permforagearea; }
    int CalcForageArea(void);
    int CalcPermForageArea(void);
    int GetTemporaryForageArea( void );
    int GetCoverArea( void );
    int GetTempForageAreaVeg( void );
    int GetCoverAreaVeg( void );
    void UpdateForageInformation(void);
    void UpdatePesticide(void);
    void CalcCarryingCapacityRatio1();
    double CalcCarryingCapacityRatio2();
};
 
 
#endif