Spider_BaseClasses.h

Go to the documentation of this file.

// Version of 5th May 2020
/*
*******************************************************************************************************
Copyright (c) 2020, Christopher John Topping, Aarhus University
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.
********************************************************************************************************
*/
// Version of 7th January 2020
//---------------------------------------------------------------------------
#include <BatchALMaSS/MovementMap.h>
#include <BatchALMaSS/PositionMap.h>
#ifndef Spider_BaseH
#define Spider_BaseH
//---------------------------------------------------------------------------
 
//#define __SpidDebug
 
// Forward Declarations
 
class Landscape;
class Spider_Population_Manager;
 
//------------------------------------------------------------------------------
 
enum TTypesOfSpiders : unsigned
{
    tspi_Egg = 0,
    tspi_Spiderling,
    tspi_Female
};
 
enum SpiderFoodQuality : unsigned
{
    sfq_Chameleon = 0,
    sfq_Lethal,
    sfq_None,
    sfq_Poor,
    sfq_Ok,
    sfq_Best,
};
 
enum TTypesOfSpiderState : unsigned
{
    // General
    tosps_Initiation = 0,
    tosps_AssessHabitat,
    tosps_Develop,
    tosps_Move,
    tosps_Dying,
    // Egg
    tosps_Hatch,
    // Juvenile
    tosps_JBalloon,
    tosps_Mature,
    tosps_JWalk,
    // Female
    tosps_Reproduce,
    tosps_FBalloon,
    tosps_FWalk,
    // Destroy
    tosps_Destroy
};
//------------------------------------------------------------------------------
 
class struct_Spider
{
public:
    int x;
    int y;
    Landscape* L;
    Spider_Population_Manager* SpPM;
    int noEggs;
};
//------------------------------------------------------------------------------
 
 class Spider_Population_Manager : public Population_Manager
 {
     // Attributes
 public:
     MovementMapUnsigned* m_MoveMap;
     SimplePositionMap* m_EggPosMap;
     SimplePositionMap* m_JuvPosMap;
     SimplePositionMap* m_AdultPosMap;
     static std::array<int, 31> m_DispDistances;
 protected:
     double m_DailyJuvMort;
     int m_DispersalDistances[10000];
     double BallooningHrs[52 * 7];
     int m_DaysSinceRain;
     int m_TodaysMonth;
     double m_TodaysDroughtScore[3];
     double m_TodaysBallooningTime;
     int m_EggSacSpread;
     int m_DoubleEggSacSpread;
     double m_BallooningMortalityPerMeter;
     bool m_EggProdThresholdPassed;
     int m_WindDirection;
     bool m_BallooningWeather;
     int m_BallooningStart;
     int m_BallooningStop;
     double m_EggDevelopmentThreshold;
     double m_EggDevelopmentThreshold2;
     double m_EggDegrees[365];
     double m_JuvDegreesGood;
     double m_JuvDegreesIntermediate;
     double m_JuvDegreesPoor;
     double m_EggProdDDegsGood;
     double m_EggProdDDegsInt;
     double m_EggProdDDegsPoor;
     bool m_WalkingOnly;
     bool m_MinWalkTemp;
     double m_MinWalkTempThreshold;
#ifdef __SpidDebug
 
     int m_Deaths[10];
     int m_JDeaths;
     int m_Mature;
#endif
     // Methods
 public:
     inline int GetEggSacSpread() {
         return m_EggSacSpread;
     }
     inline int GetDoubleEggSacSpread() {
         return m_DoubleEggSacSpread;
     }
     double GetBallooningMortalityPerMeter() {
         return m_BallooningMortalityPerMeter;
     }
     int GetDaysSinceRain() {
         return m_DaysSinceRain;
     }
     int GetTodaysMonth() { 
         return m_TodaysMonth; }
     double GetTodaysDroughtSc(int index) { 
         return m_TodaysDroughtScore[index]; }
     double GetJuvMort() { 
         return m_DailyJuvMort; }
     int GetDispDist(int chance) {
         return m_DispersalDistances[chance];
     }
     double GetBTime(int day) {
         return BallooningHrs[day];
     }
     double GetBTimeToday() { 
         return m_TodaysBallooningTime; }
     int GetWindDirection() { 
         return m_WindDirection; }
     bool IsBallooningWeather() { 
         return m_BallooningWeather; };
     double GetEggDegreesPoor() { 
         return m_EggProdDDegsPoor; }
     double GetEggDegreesInt() {
         return m_EggProdDDegsInt; }
     double GetEggDegreesGood() {
         return m_EggProdDDegsGood; }
     double GetJuvDegrees_good() { 
         return m_JuvDegreesGood; }
     double GetJuvDegrees_intermediate() { 
         return m_JuvDegreesIntermediate; }
     double GetJuvDegrees_poor() { 
         return m_JuvDegreesPoor; }
     double GetEggDevelDegrees(int day) { 
         return m_EggDegrees[day]; }
     bool CheckHumidity(int /* x */, int /* y */) { 
         return true; } // TODO
     bool GetWalking() { 
         return m_WalkingOnly; }
     bool GetMinWalkTemp() {
         return m_MinWalkTemp; }
     Spider_Population_Manager(Landscape* p_L, int N);
     virtual void Init(void);
     virtual void DoFirst(void) { ; }
     virtual ~Spider_Population_Manager();
     virtual void TheAOROutputProbe() { ; }
     virtual void TheRipleysOutputProbe(FILE* a_prb) { ; }
     bool InSquare(int p_x, int p_y, int p_sqx, int p_sqy, int p_range);
     void virtual Catastrophe() { ; }
     virtual void CreateObjects(int ob_type, TAnimal* pvo, struct_Spider* data, int number) { ; }
#ifdef __SpidDebug
 
     void RecordDeath(int a_type) { m_Deaths[a_type]++; }
     void RecordJDeath() { m_JDeaths++; }
     void RecordMature() { m_Mature++; }
#endif
};
//---------------------------------------------------------------------------
 
class Spider_Base : public TAnimal
{
    // Attributes
public:
    static int m_DenDependenceConst0;
    static int m_SimW;
    static int m_SimH;
    double m_pesticide_accum;
protected:
    double m_AgeDegrees;
    int m_Age;
    TTypesOfSpiderState m_CurrentSpState;
    unsigned m_Lifestage{ 0 };
    // Methods
public:
    Spider_Population_Manager* m_OurPopulationManager;
    Spider_Base(int x, int y, Landscape* L, Spider_Population_Manager* SpMan);
    void ReInit(int x, int y, Landscape* L, Spider_Population_Manager* SpMan);
    void Init(Spider_Population_Manager* p_spMan);
    virtual int WhatState() { return int(m_CurrentSpState); }
    virtual bool OnFarmEvent(FarmToDo /* event */) { return true; }
    virtual void KillThis() { 
        m_CurrentSpState = TTypesOfSpiderState::tosps_Dying; 
    }
protected:
    virtual bool EggPosValid(unsigned a_x, unsigned a_y);
    SimplePositionMap* m_OurPosMap;
    bool HatchDensityMort(int a_x, int a_y, int a_range);
    virtual int CheckPosMap(unsigned x, unsigned y);
    virtual bool GetPosMapPositive(unsigned x, unsigned y, unsigned range);
    virtual int GetPosMapDensity(unsigned x, unsigned y, unsigned range);
    virtual void ClearPosMap(unsigned x, unsigned y);
    virtual void SetPosMap(unsigned x, unsigned y);
};
 
class Spider_Egg : public Spider_Base
{
// Attributes
public:
    static int m_HatDensityDepMortConst;
    static int m_DailyEggMortConst;
    static double m_EggDevelConst;
protected:
    int m_DateLaid;
    int m_NoEggs;
// Methods
public:
void EndStep();
    Spider_Egg(int x, int y, Landscape* L, Spider_Population_Manager* EPM, int Eggs);
    virtual void ReInit(int x, int y, Landscape* L, Spider_Population_Manager* EPM, int Eggs);
    virtual void BeginStep();
    virtual void Step();
    void SetNoEggs(int Eggs) { m_NoEggs = Eggs; }
    int GetNoEggs() { return m_NoEggs; }
    virtual bool OnFarmEvent(FarmToDo event) { return true; }
protected:
    TTypesOfSpiderState st_Develop();
    virtual void st_Hatch() ;
    virtual void st_Die();
    virtual void Hatch(int a_eggsackspread, unsigned a_doubleeggsacspread, unsigned a_noeggs, unsigned a_range);
};
//------------------------------------------------------------------------------
 
class Spider_Juvenile : public Spider_Base
{
public:
    // Static parameter passing attributes
    static int m_JuvDensityDepMortConst;
    static std::array<int, 40> m_DispersalChance;
    static double m_JuvDevelConst;
protected:
    char m_MyDirection;
    bool m_MustBalloon;
    int m_BadHabitatDays;
    double m_droughtFactor;
public:
    void EndStep();
    Spider_Juvenile(int x, int y, Landscape* L, Spider_Population_Manager* SpPM);
    virtual void ReInit(int x, int y, Landscape* L, Spider_Population_Manager* SpPM);
    virtual void BeginStep();
    virtual void Step();
    virtual bool OnFarmEvent(FarmToDo event) { return true; }
    virtual void SpecialWinterMort();
protected:
    virtual TTypesOfSpiderState st_Develop();
    virtual TTypesOfSpiderState st_AssessHabitat() {
        return AssessHabitat();
    };
    virtual TTypesOfSpiderState st_Balloon();
    virtual TTypesOfSpiderState st_Walk();
    virtual void Maturation();
    virtual bool BallooningMortality(int dist);
    virtual int BalloonTo(int direction, int distance);
    virtual int WalkTo(int direction);
    virtual TTypesOfSpiderState AssessHabitat();
    virtual int Balloon();
    virtual int Walk();
    virtual SpiderFoodQuality AssessFood();
    virtual SpiderFoodQuality CheckToleTovIndex();
    virtual void AddToBadHabitatDays() { if (m_BadHabitatDays < 39) m_BadHabitatDays++; }
    virtual void CalcDrought() {}
};
//------------------------------------------------------------------------------
 
class Spider_Female : public Spider_Juvenile
{
// Attributes
public:
    static double m_EggProducConst;
    static int m_Max_Egg_Production;
    static int m_DailyFemaleMort;
protected:
    double m_EggSacDegrees;
    int m_EggsProduced;
    int m_lifespan;
// Methods
public:
void EndStep();
    Spider_Female(int x, int y, Landscape* L, Spider_Population_Manager* EPM);
    void ReInit(int x, int y, Landscape* L, Spider_Population_Manager* EPM);
    virtual void BeginStep();
    virtual void Step();
    virtual bool OnFarmEvent(FarmToDo event) { return true; }
    void ZeroEggSacDegrees() { m_EggSacDegrees = 0; }
protected:
    int st_Reproduce();
    bool ProduceEggSac();
    virtual int CalculateEggsPerEggSac() { return 0; }
    void CreateEggSac(int a_NoEggs);
    virtual TTypesOfSpiderState st_Balloon();
    virtual TTypesOfSpiderState st_Walk();
};
//------------------------------------------------------------------------------
 
#endif