Hunters_all.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 HuntersH
#define HuntersH
//---------------------------------------------------------------------------
class Hunter;
class Hunter_Population_Manager;
class Field;
 
//------------------------------------------------------------------------------
 
typedef enum
{
      toh_GooseHunter=0,
      toh_foobar
} TTypeOfHunters;
 
enum  TypeOfHunterState
{
      tohts_InitialState=0,
      tohts_Hunting,
          tohts_OutHunting,
      tohts_Resting,
          tohts_foobar
};
 
enum TypeOfHunterLeaderMessage
{
        hlm_shoot = 0,
        hlm_gohome,
        hlm_foobar
} ;
 
class struct_Hunter
{
 public:
         int m_ref;
         int m_HType;
         APoint m_home;
         vector <int> m_huntlocrefs;
         vector <APoint> m_huntlocs;
         unsigned m_no_hunt_locs;
         APoint m_validxy;
         vector<Farm*> m_farms;
         int m_huntingdayslimit;
         int m_weekend;
         double m_efficiency;
         double m_goosecountchance;
         Landscape* m_L;
         Population_Manager * m_preyPM;
};
 
 
struct FarmOccupcancyData
{
        int m_FarmRef;
        int m_no_hunters;
};
 
typedef vector < Hunter* > HunterList;
 
class Hunter : public TAnimal
{
protected:
    // Attributes
        int m_myname;
    TypeOfHunterState m_CurrentHState;
    Hunter_Population_Manager * m_OurPopulationManager;
    int m_clock;
        int m_bag;
        int m_myShots;
        int m_myMagazine;
        int m_huntingdays;
        int m_lasthuntday;
        int m_baglimit;
        int m_huntlimit;
        double m_efficiency;
        double m_goosecountchance;
        int m_weekend;
        vector<Farm*> m_OurFarmers;
        APoint m_Home;
        int m_huntfield_polyref;
        int m_NoHuntLocs;
        vector <int> m_HuntLocRefs;
        vector <APoint> m_HuntLocs;
        
        // Methods
        virtual TypeOfHunterState st_ShouldGoHunting( void );
        TypeOfHunterState st_OutHunting( void ); // Must be overridden in descendent classes;
        TypeOfHunterState st_Resting( void );
    virtual void Init(struct_Hunter* p_data);
        bool IsTodayAPreferredHuntDay( int a_today );
        bool IsTodayAChosenHuntDay( int a_today );
        virtual int CheckForGame( void ) {
                return false;
        }
        
public:
    Hunter(struct_Hunter* p_data, Hunter_Population_Manager* p_PPM);
    virtual ~Hunter();
        int GetHuntingDays() {
                return m_huntingdays;
        }
        int GetBag() {
                return m_bag;
        }
        int GetShots() {
                return m_myShots;
        }
        virtual void ResetBag() {
                m_bag = 0;
                m_myShots = 0;
        }
        void ResetHuntingOpportunities() {
                m_huntingdays = 0;
        }
        int GetClock() {
                return m_clock;
        }
        void ResetClock() {
                m_clock = 0;
        }
        void ResetSeasonData() {
                ResetBag();
                ResetHuntingOpportunities();
        }
        bool IsOutHunting() {
                if (m_CurrentHState == tohts_OutHunting) return true;
                return false;
        }
    void OnMorning() { m_CurrentHState = tohts_Hunting; }
        int GetRef() { return m_myname; }
        APoint GetHome() { return m_Home; }
        int GetHuntField() {
                return m_huntfield_polyref;
        }
        APoint GetHuntLoc(unsigned a_ref) { return m_HuntLocs[a_ref]; }
        Farm* GetFarmerRef(unsigned a_ref) { return m_OurFarmers[a_ref]; }
        virtual bool InSeason( int /* day */ ) {
                return false;
        }
        virtual bool IsSeasonEnd( int /* day */ ) {
                return true;
        }
        virtual int GetSeasonLengthLeft( int /* day */ ) {
                return 0;
        }
        virtual void SaveMyData( ofstream* /* a_ofile */ ) {
                ; // Base class does nothing
        }
        virtual void OnShoot() { ; }
        virtual void OnGoHome(){ ; }
 
};
 
class GooseHunter : public Hunter
{
protected:
// Attributes
        Goose_Population_Manager* m_preyPopulationManger;
        polylist* m_huntfields; 
        bool m_dugin;
        int m_goosebag[ gst_foobar ];
        int m_pinkfootbaglimit;
        int m_greylagbaglimit;
        bool m_leader;
// Methods
    virtual void Init();
        virtual bool InSeason( int day );
        virtual bool IsSeasonEnd( int day );
        virtual int GetSeasonLengthLeft( int day );
        TypeOfHunterState st_OutHunting( void );
        virtual TypeOfHunterState st_ShouldGoHunting(void);
        bool FindHuntingLocation( void );
        virtual int CheckForGame( void );
        virtual void OnShoot();
        virtual void OnGoHome();
public:
// Methods
        GooseHunter(struct_Hunter* p_data, Hunter_Population_Manager* p_PPM);
    virtual ~GooseHunter();
        virtual void Step();
        void OnShotABird( int a_birdtype, int a_poly );
        virtual void SaveMyData( ofstream* a_ofile );
        virtual void ResetBag() {
                Hunter::ResetBag();
                for (int i = 0; i < gst_foobar; i++) m_goosebag[ i ] = 0;
        }
        bool IsLeader() {
                return m_leader;
        }
};
 
class Hunter_Population_Manager : public Population_Manager
{
public:
        // Methods
        Hunter_Population_Manager(Landscape* p_L);
        virtual ~Hunter_Population_Manager (void);
        void Init(void);
        void DistributeHunters(void);
        void DistributeHuntersByRules( vector<HunterInfo> *a_hunterlist, int a_no_hunters, int a_ruleset );
        void RuleSet10Based( int a_no_hunters, vector<int>* a_farmsizes, vector<HunterInfo>* a_hunterlist, vector<APoint>* a_roostlocs, int a_ruleset );
        void SaveDistributedHunters( vector<HunterInfo>* a_hunterlist, int a_no_hunters );
        void SaveFarmHunters( vector<HunterInfo>* a_hunterlist, int a_no_hunters );
        void CreateObjects(int ob_type, TAnimal*, struct_Hunter* data,int number);
        void RecordHuntingSuccess(int poly,int birds, int a_hunter);
        APoint GetHunterHome(int a_index, int a_list);
        APoint GetHunterHuntLoc(int a_index, int a_list, unsigned a_ref);
        unsigned GetNoHuntLocs();
        bool CheckDensity(int a_ref, vector<int> *a_illegalfarms, vector<FarmOccupcancyData>* a_FarmOccupancy);
        bool AddHunterHunting( int a_polyref, Hunter* a_hunter );
        void HunterLeaderMessage(TypeOfHunterLeaderMessage a_signal, int a_polyref);
        vector<HunterList*> m_ActiveHuntingLocationsHunters;
        vector<int> m_ActiveHuntingLocationsPolyrefs;
        bool IsPolyrefOnActiveList( int a_polyref );
        void SetHuntingSeason();
        int GetHuntingSeasonStart(){ return m_HuntingSeasonStart; }
        int GetHuntingSeasonEnd(){ return m_HuntingSeasonEnd; }
 
protected:
        // Attributes
        unsigned m_daytime;
        ofstream* m_HuntingBagRecord;
        int m_HuntingSeasonStart;
        int m_HuntingSeasonEnd;
 
 
        // Methods
        virtual bool StepFinished() { return true; }
        virtual void DoFirst();
        virtual void DoBefore(){}
        virtual void DoAfter(){}
        virtual void DoLast(){}
};
 
//---------------------------------------------------------------------------
#endif