Hunters_all.cpp

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.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
 
#define __DEBUG_DENSITY
 
 
#include <math.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <list>
#include "../Landscape/ls.h"
#include "../BatchALMaSS/PopulationManager.h"
#include "../GooseManagement/GooseMemoryMap.h"
#include "../GooseManagement/Goose_Base.h"
#include "../BatchALMaSS/CurveClasses.h"
#include "../Hunters/Hunters_all.h"
#include "../GooseManagement/Goose_Population_Manager.h"
#include "../GooseManagement/GoosePinkFooted_All.h"
#include "../GooseManagement/GooseGreylag_All.h"
#include "../GooseManagement/GooseBarnacle_All.h"
 
#include "../BatchALMaSS/BoostRandomGenerators.h"
 
 
extern boost::variate_generator<base_generator_type&, boost::uniform_real<> > g_rand_uni;
extern boost::variate_generator<base_generator_type&, boost::uniform_int<> > g_rand_uni2; // 0-9999
 
/* Links to globals */
extern PopulationManagerList g_PopulationManagerList;
 
/* Links to the goose population */
extern CfgFloat cfg_goose_MinForageOpenness;
extern CfgInt cfg_goose_pinkfootopenseasonstart;
extern CfgInt cfg_goose_pinkfootopenseasonend;
extern CfgInt cfg_goose_greylagopenseasonstart;
extern CfgInt cfg_goose_greylagopenseasonend;
 
/* Here we have the input variable for hunting seasons on our game species */
static CfgInt cfg_gooseopenseasonstart("GOOSE_OPENSEASON_START", CFG_CUSTOM, 243);
static CfgInt cfg_gooseopenseasonend("GOOSE_OPENSEASON_END", CFG_CUSTOM, 364); // 30
static CfgFloat cfg_huntermaxprotectedpct( "HUNTER_MAXPROTECTECTEDPCT" , CFG_CUSTOM, 0.1);
static CfgInt cfg_hunter_magazinecapacity("HUNTER_MAGAZINECAPACITY", CFG_CUSTOM, 2);
static CfgInt cfg_huntlength("GOOSE_HUNTER_HUNT_LENGTH", CFG_CUSTOM, 180); // default is 3 hours
static CfgBool cfg_Hunters_RecordBag("HUNTERS_RECORDBAG", CFG_CUSTOM, false);
static CfgBool cfg_Hunters_Distribute("HUNTERS_DISTRIBUTE", CFG_CUSTOM, false);
static CfgInt cfg_Hunters_Distribute_Ruleset("HUNTERS_DISTRIBUTE_RULESET", CFG_CUSTOM, 0);
static CfgInt cfg_Hunters_Distribute_NonResRuleset("HUNTERS_DISTRIBUTE_NONRESRULESET", CFG_CUSTOM, 0);
static CfgInt cfg_Hunters_NonresidentPct("HUNTERS_NONRESIDENTPCT", CFG_CUSTOM, 30);
static CfgFloat cfg_Hunters_MaxDensity("HUNTERS_MAXDENSITY", CFG_CUSTOM, 0.1);
static CfgFloat cfg_Hunters_MaxDensityPower("HUNTERS_MAXDENSITYPOWER", CFG_CUSTOM, 0.741); // 1.0 here will give linear, e.g. with 0.2 will allow 1 hunter per 5ha, 0.741 with 0.3 will do the same but only allow 30 hunters in 500 ha (instead of 100).
static CfgFloat cfg_hunterlocONE("HUNTERS_HUNTERLOCPROB_ONE", CFG_CUSTOM, 0.297);
static CfgFloat cfg_hunterlocTWO("HUNTERS_HUNTERLOCPROB_TWO", CFG_CUSTOM, 0.616);
static CfgFloat cfg_hunterlocTHREE("HUNTERS_HUNTERLOCPROB_THREE", CFG_CUSTOM, 0.806);
static CfgFloat cfg_hunterlocFOUR("HUNTERS_HUNTERLOCPROB_FOUR", CFG_CUSTOM, 0.854);
static CfgFloat cfg_hunterhuntdayprobscaler( "HUNTER_HUNTDAYPROBSCALER", CFG_CUSTOM, 2.0 );
static CfgFloat cfg_largefieldgooseproximity("HUNTER_LARGEFIELDGOOSEPROXIMITYCHANCE", CFG_CUSTOM, 0.5);
static CfgInt cfg_largefieldgooseproximitysizecutoff("HUNTER_LARGEFIELDGOOSEPROXIMITYCHANCESIZECUTOFF", CFG_CUSTOM, 20000);
static CfgInt cfg_hunterrefractionperiod("HUNTER_REFRACTIONPERIOD", CFG_CUSTOM, 7);
static CfgInt cfg_hunter_pinkfootbaglimit("HUNTER_PINKFOOTBAGLIMIT", CFG_CUSTOM, 9999);
static CfgInt cfg_hunter_greylagbaglimit("HUNTER_GREYLAGBAGLIMIT", CFG_CUSTOM, 9999);
 
//*******************************************************************************************************************/
//                                        Class Hunter_Population_Manager
//*******************************************************************************************************************/
 
Hunter_Population_Manager::Hunter_Population_Manager(Landscape* p_L) : Population_Manager(p_L)
{
    // Load List of Animal Classes
        m_ListNames[0] = "Goose Hunter";
        m_ListNameLength = 1;
        // We need one vector for each life stage
        for (unsigned i=0; i<(10-m_ListNameLength); i++)
        {
                TheArray.pop_back();
        }
        BeforeStepActions[ 0 ] = 4; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
        if (!cfg_Hunters_Distribute.value()) Init(); else DistributeHunters();
        m_HuntingSeasonStart = -1;
        m_HuntingSeasonEnd = -1;
        SetHuntingSeason();
}
 
Hunter_Population_Manager::~Hunter_Population_Manager (void)
{
        // close down output
        if (cfg_Hunters_RecordBag.value())
        {
                m_HuntingBagRecord->close();
                delete m_HuntingBagRecord;
        }
}
 
void Hunter_Population_Manager::DistributeHunters()
{
//      FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
        ifstream huntercoords("./HunterHomeLocations.txt", ios::in);
        if (!huntercoords.is_open()) {
                m_TheLandscape->Warn( "Hunter_Population_Manager::DistributeHunters()", "HunterHomeLocations.txt missing" );
                exit( 1 );
        }
        int no_hunters;
        huntercoords >> no_hunters;
        vector<HunterInfo>* OurHunters = new vector<HunterInfo>;
        OurHunters->resize( no_hunters );
        for (int i = 0; i < no_hunters; i++)
        {
                huntercoords >> (*OurHunters)[ i ].refID >> (*OurHunters)[ i ].homeX >> (*OurHunters)[ i ].homeY;
                (*OurHunters)[ i ].FarmHuntRef.resize( GetNoHuntLocs() );
                for (int hl = 0; hl<(*OurHunters)[i].FarmHuntRef.size(); hl++) (*OurHunters)[i].FarmHuntRef[hl] = -1;
                //(*OurHunters)[ i ].CheckedFarms.resize( FManager->GetNoFarms() );
        }
        huntercoords.close();
        // Do the distribution
        DistributeHuntersByRules(OurHunters, no_hunters, cfg_Hunters_Distribute_Ruleset.value());
        // Now save the results
        SaveDistributedHunters(OurHunters, no_hunters);
        SaveFarmHunters(OurHunters, no_hunters);
        g_msg->Warn("Normal exit after hunter distribution. No of records written to Hunter_Hunting_Locations.txt was: ", no_hunters);
        exit(0);
}
 
unsigned Hunter_Population_Manager::GetNoHuntLocs()
{
        double chance = g_rand_uni();
        if (chance < cfg_hunterlocONE.value())   return 1;
        if (chance < cfg_hunterlocTWO.value())   return 2;
        if (chance < cfg_hunterlocTHREE.value()) return 3;
        if (chance < cfg_hunterlocFOUR.value())  return 4;
        return 5;
 
}
 
void Hunter_Population_Manager::SaveDistributedHunters( vector<HunterInfo>* a_hunterlist, int a_no_hunters )
{
        ofstream huntlocs("./Hunter_Hunting_Locations.txt", ios::out);
        huntlocs << a_no_hunters << endl;
        huntlocs << "HunterID" << '\t' << "HunterType" << '\t' << "HuntingDays" << '\t' << "WeekdayHunterChance" << '\t' << "GooseLookChance" << '\t' << "Efficiency" << '\t';
        huntlocs << "HomeX" << '\t' << "HomeY" << '\t';
        huntlocs << "NoFarmrefs" << '\t' << "FarmRef1" << '\t' << "FarmRef2" << '\t' << "FarmRef3" << '\t' << "FarmRef4" << '\t' << "FarmRef5" << '\t' << "FarmRef6" << '\t' << "FarmRef7" << '\t' << "FarmRef8" << '\t' << "FarmRef9" << '\t' << "FarmRef10" << endl;
                
                //<< '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmTotalSize" << '\t' << "FarmArableSize" << '\t' << "FarmType" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' << "ValidFarmX" << '\t' << "ValidFarmY" << endl;
        /*FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();*/
        for (int i = 0; i < a_no_hunters; i++)
        {
                int nolocs = int((*a_hunterlist)[i].FarmHuntRef.size());
                huntlocs << (*a_hunterlist)[ i ].refID << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t';
                huntlocs << (*a_hunterlist)[ i ].homeX << '\t' << (*a_hunterlist)[ i ].homeY << '\t' << nolocs;
                for (int j = 0; j < nolocs; j++)
                {
                        int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
                        /* 
                        APoint pt = FManager->GetFarmCentroid(ref);
                        int FarmASize = FManager->GetFarmArableSize(ref);
                        int FarmTSize = FManager->GetFarmTotalSize(ref);
                        int FarmType = FManager->GetFarmType(ref);
                        int OpenFields = FManager->GetFarmNoOpenFields(ref, (int)cfg_GooseMinForageOpenness.value());
                        int NoFields = FManager->GetFarmNoFields(ref);
                        APoint valid = FManager->GetFarmValidCoords(ref);*/
                        huntlocs << '\t' << ref;
                }
                for (int j = 10; j > nolocs; j--) huntlocs << '\t' << "NA";
                huntlocs << endl;
        }
        huntlocs.close();
}
 
 
void Hunter_Population_Manager::SaveFarmHunters( vector<HunterInfo>* a_hunterlist, int a_no_hunters ) {
        FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
        ofstream huntlocs("./Hunter_Hunting_Locations_Farms.txt", ios::out);
        huntlocs << "FarmRef" << '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmType" << '\t' << "FarmSize" << '\t'
                << "FarmArableSize" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' <<"AreaOpenFields" << '\t' << "NoHunters" << endl;
        vector<farminfo*> FarmList;
        for (int i = 0; i < a_no_hunters; i++)
        {
                for (int j = 0; j < (*a_hunterlist)[ i ].FarmHuntRef.size(); j++)
                {
                        int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
                        int found = -1;
                        for (int f = 0; f < (int)FarmList.size(); f++) {
                                if (FarmList[f]->m_farmref == ref) {
                                        found = f;
                                        break;
                                }
                        }
                        if (found == -1) {
                                farminfo* fi = new farminfo;
                                fi->m_farmcentroid = FManager->GetFarmCentroid( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_farmvalid = FManager->GetFarmValidCoords( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_farmarable = FManager->GetFarmArableSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_farmsize = FManager->GetFarmTotalSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_farmtype = FManager->GetFarmType( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_openfields = FManager->GetFarmNoOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
                                fi->m_areaopenfields = FManager->GetFarmAreaOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
                                fi->m_nofields = FManager->GetFarmNoFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                                fi->m_farmref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
                                fi->m_NoHunters = 1;
                                FarmList.push_back(fi);
                        }
                        else FarmList[found]->m_NoHunters++;
                }
        }
        // Now we don't want any gaps so check all farms and then check them against our list of hunted farms
        int nofarms = FManager->GetNoFarms();
        for (int fa = 0; fa < nofarms; fa++) {
                int found = -1;
                Farm* farmp = FManager->GetFarmPtrIndex(fa);
                int ref = farmp->GetFarmNumber();
                cout << ref << '\t';
                for (int hf = 0; hf < FarmList.size( ); hf++) 
                {
                        if (FarmList[hf]->m_farmref == ref) {
                                found = hf;
                                cout << ref << '\t' << found << endl;
                                break;
                        }
                }
                if (found == -1) {
                        APoint pt = FManager->GetFarmCentroid( ref );
                        huntlocs << ref << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << FManager->GetFarmType(ref) << '\t' << FManager->GetFarmTotalSize(ref) << '\t'
                                << FManager->GetFarmArableSize(ref) << '\t' << FManager->GetFarmNoFields(ref) << '\t' 
                                << FManager->GetFarmNoOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << FManager->GetFarmAreaOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << 0 << endl;
                }
                else {
                        huntlocs << ref << '\t' << FarmList[found]->m_farmcentroid.m_x << '\t' << FarmList[found]->m_farmcentroid.m_y << '\t' << FarmList[found]->m_farmtype << '\t' << FarmList[found]->m_farmsize << '\t'
                                << FarmList[found]->m_farmarable << '\t' << FarmList[found]->m_nofields << '\t' << FarmList[found]->m_openfields << '\t' << FarmList[found]->m_areaopenfields << '\t' << FarmList[found]->m_NoHunters << endl;
                }
 
        }
        huntlocs.close();
}
 
 
 
bool Hunter_Population_Manager::CheckDensity(int a_ref, vector<int> * a_illegalfarms, vector<FarmOccupcancyData>* a_FarmOccupancy)
{
        FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
        //double area = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmTotalSize( a_ref ) / 10000.0;
        double area = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmAreaOpenFields( a_ref, (int)cfg_goose_MinForageOpenness.value()) / 10000.0;
        for (int f = 0; f < a_FarmOccupancy->size(); f++) {
                // test if we have this one
                if ((*a_FarmOccupancy)[f].m_FarmRef == a_ref) {
                        double newhunters = (*a_FarmOccupancy)[f].m_no_hunters + 1.0;
                        if ( (newhunters/ area) < cfg_Hunters_MaxDensity.value()) {
                                (*a_FarmOccupancy)[f].m_no_hunters++; // Add ourselves
                                return true; // The farm was OK
                        }
                        else {
                                FManager->AddToIllegalList(a_ref, a_illegalfarms);
                                return false;
                        }
                }
        }
        // If we reach here it must be a new farm
        // New farm, so is it big enough for one hunter?
        if (1.0 / area > cfg_Hunters_MaxDensity.value())
        {
                // Need to add to the illegal list
                FManager->AddToIllegalList(a_ref, a_illegalfarms);
                return false;
        }
        else {
                FarmOccupcancyData pt;
                pt.m_FarmRef = a_ref;
                pt.m_no_hunters = 1;
                a_FarmOccupancy->push_back(pt);
                return true;
        }
}
 
 
void Hunter_Population_Manager::DistributeHuntersByRules(vector<HunterInfo>* a_hunterlist, int a_no_hunters, int a_ruleset)
{
        FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
        // Now we distribute the hunters to farms depending on which rule set we are using
 
 
        FManager->CalcCentroids(); // Makes sure that farm centres are calculated
        if (a_ruleset == 0)
        {
                for (int i = 0; i < a_no_hunters; i++)
                {
                        // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                int theref = -1;
                                do {
                                        // The line below actuall does the interesting bit
                                        theref = FManager->GetRandomFarmRefnum();
                                } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
                        }
                }
        }
        else if (a_ruleset == 1)
        {
                vector<int>* list = new vector<int>;
                list->resize(1);
                (*list)[0] = 0;
                for (int i = 0; i < a_no_hunters; i++)
                {
                        // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                // The line below actuall does the interesting bit
                                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarm((*a_hunterlist)[i], &list[0]);
                        }
                }
        }
        else if (a_ruleset == 2)
        {
                for (int i = 0; i < a_no_hunters; i++)
                {
                        // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                int theref = -1;
                                do {
                                        // The line below actually does the interesting bit
                                        theref = FManager->FindOpennessFarm((int)cfg_goose_MinForageOpenness.value());
                                } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
                        }
                }
        }
        else if (a_ruleset == 3)
        {
                vector<int>* illegalfarms = new vector<int>;
                vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
                for (int i = 0; i < a_no_hunters; i++)
                {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                bool found1 = false;
                                int theref = -1;
                                // While a farm is not allocated
                                int iteration = 0;
                                while (!found1) {
                                        if (++iteration > FManager->GetNoFarms())
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                        // Choose a new farm ref to test
                                        theref = FManager->FindFarmWithRandom(illegalfarms);
                                        found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
 
                                }
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                                double nohunters = 0;
                                for (int g = 0; g < a_no_hunters; g++)
                                {
 
                                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                        {
                                                if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                                        }
                                }
                                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                                {
                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                        exit(0);
                                }
                                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                                {
 
                                        nohunters = 0;
                                        for (int g = 0; g < a_no_hunters; g++)
                                        {
 
                                                for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                                {
                                                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                                                }
                                        }
                                        if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                }
#endif                          
 
                        }
                }
        }
        else if (a_ruleset == 4)
        {
                vector<int>* list = new vector<int>;
                list->resize(1);
                (*list)[0] = 0;
                for (int i = 0; i < a_no_hunters; i++)
                {
                        for (int f = 0; f < int((*a_hunterlist)[i].FarmHuntRef.size()); f++)
                        {
                                (*a_hunterlist)[i].FarmHuntRef[f] = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], list, (int)cfg_goose_MinForageOpenness.value());
                        }
                }
        }
        else if (a_ruleset == 5) {
                // First calculate the hunter densities
                // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
                // Both ways are listed here.
                vector<int>* illegalfarms = new vector<int>;
                vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
                // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
                // For each hunter
                for (int i = 0; i < a_no_hunters; i++) {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                bool found1 = false;
                                // While a farm is not allocated
                                int iteration = 0;
                                int theref = -1;
                                while (!found1)
                                {
                                        if (++iteration > FManager->GetNoFarms())
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                        // Choose a new farm ref to test
                                        theref = FManager->FindClosestFarm((*a_hunterlist)[i], illegalfarms);
                                        found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                                }
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                                double nohunters = 0;
                                for (int g = 0; g < a_no_hunters; g++)
                                {
 
                                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                        {
                                                if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                                        }
                                }
                                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                                {
                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                        exit(0);
                                }
                                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                                {
 
                                        nohunters = 0;
                                        for (int g = 0; g < a_no_hunters; g++)
                                        {
 
                                                for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                                {
                                                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                                                }
                                        }
                                        if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                }
#endif                          
                        }
                }
        }
        else if (a_ruleset == 6) {
                vector<int>* illegalfarms = new vector<int>;
                vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
                int TheOpenness = (int)cfg_goose_MinForageOpenness.value();
                // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
                // For each hunter
                for (int i = 0; i < a_no_hunters; i++) {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                                int Farms = FManager->GetNoFarms();
                                bool found1 = false;
                                int iteration = 0;
                                int theref = -1;
                                do {
                                        if (++iteration > Farms) {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                        // Choose a new farm ref to test
                                        do {
                                                // The line below actually does the interesting bit
                                                theref = FManager->FindFarmWithOpenness(illegalfarms, TheOpenness);
                                                if (theref == -1) {
                                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, in openness, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                        exit(0);
                                                }
                                                if (illegalfarms->size() >= Farms - ((*a_hunterlist)[ i ].FarmHuntRef.size())) {
                                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, all farms illegal, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                        exit(0);
                                                }
                                        } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                                        found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                                } while (!found1);
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                                double nohunters = 0;
                                for (int g = 0; g < a_no_hunters; g++)
                                {
 
                                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                        {
                                                if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                                        }
                                }
                                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                                {
                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                        exit(0);
                                }
                                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                                {
 
                                        nohunters = 0;
                                        for (int g = 0; g < a_no_hunters; g++)
                                        {
 
                                                for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                                {
                                                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                                                }
                                        }
                                        if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                }
#endif                          
                        }
                }
                delete illegalfarms;
        }
        else if (a_ruleset == 7) {
                // First calculate the hunter densities
                // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
                // Both ways are listed here.
                vector<int>* illegalfarms = new vector<int>;
                vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
                // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
                // For each hunter
                for (int i = 0; i < a_no_hunters; i++)
                {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
                        {
                                bool found1 = false;
                                int theref = -1;
                                // While a farm is not allocated
                                int iteration = 0;
                                while (!found1)
                                {
                                        if (++iteration > FManager->GetNoFarms())
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                        // Choose a new farm ref to test
                                        theref = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], illegalfarms, (int)cfg_goose_MinForageOpenness.value());
                                        found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                                }
                                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                                double nohunters = 0;
                                for (int g = 0; g < a_no_hunters; g++)
                                {
 
                                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                        {
                                                if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                                        }
                                }
                                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                                {
                                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                        exit(0);
                                }
                                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                                {
 
                                        nohunters = 0;
                                        for (int g = 0; g < a_no_hunters; g++)
                                        {
 
                                                for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                                                {
                                                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                                                }
                                        }
                                        if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                                        {
                                                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                                                exit(0);
                                        }
                                }
#endif
                        }
                }
        }
        else if (a_ruleset == 8) {
                vector<int>* list = new vector<int>;
                list->resize(1);
                (*list)[0] = 0;
                for (int i = 0; i < a_no_hunters; i++) {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], -1); // -1 means no openness will be used
                        }
                }
        }
        else if (a_ruleset == 9) {
                vector<int>* list = new vector<int>;
                list->resize(1);
                (*list)[0] = 0;
                for (int i = 0; i < a_no_hunters; i++) {
                        for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], (int)cfg_goose_MinForageOpenness.value());
                        }
                }
        }
        else if (a_ruleset == 10) {
                RuleSet10Based( a_no_hunters, NULL, a_hunterlist, NULL, 10 );
        }
        else if (a_ruleset == 11) {
                // Need to read in the areas real areas for the farms
                vector<int>* farmsizes = new vector<int>;
                //read the input file
                ifstream ifile( "FarmTotalSizeData.txt", ios::in );
                //check if there is an input file
                if (!ifile.is_open()) {
                        cout << "Cannot open input file " << "FarmTotalSizeData.txt" << endl;
                        char ch;
                        cin >> ch; //so that it doesn't close immediately
                        exit( 1 );
                }
                //get the number of farms
                int noFarms;
                ifile >> noFarms; // Could do a check here that this is the right number of farms
                if (noFarms != m_TheLandscape->SupplyNumberOfFarms()) {
                        cout << "Number of farms does not match farm number in ALMaSS " << noFarms << " != " << m_TheLandscape->SupplyNumberOfFarms() << endl;
                        char ch;
                        cin >> ch; //so that it doesn't close immediately
                        exit( 1 );
                }
                //read the data and assign values to the farm's variables
                for (int f = 0; f < noFarms; f++) {
                        int data;
                        ifile >> data; // this is the farm number
                        ifile >> data;
                        farmsizes->push_back( data );
                }
                ifile.close();
                // OK farm size data read in, lets continue
                RuleSet10Based( a_no_hunters, farmsizes, a_hunterlist, NULL, 11 );
                delete farmsizes;
        }
        else if (a_ruleset == 12) {
                // Need to read in the areas real areas for the farms
                vector<APoint>* roostlocs = new vector<APoint>;
                //read the input file
                ifstream ifile( "GooseRoosts.txt", ios::in );
                //check if there is an input file
                if (!ifile.is_open()) {
                        cout << "Cannot open input file " << "GooseRoosts.txt" << endl;
                        char ch;
                        cin >> ch; //so that it doesn't close immediately
                        exit( 1 );
                }
                //get the number of farms
                int noroosts;
                ifile >> noroosts; // Could do a check here that this is the right number of farms
                //read the data and assign values to the roost locs
                for (int r = 0; r < noroosts; r++) {
                        APoint data; 
                        int species;
                        ifile >> species >> data.m_x >> data.m_y;
                        roostlocs->push_back( data );
                }
                ifile.close();
                // OK farm size data read in, lets continue
                RuleSet10Based( a_no_hunters, NULL, a_hunterlist, roostlocs, 12 );
                delete roostlocs;
        }
        else {
                g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - Unknown hunter distribution rule set", cfg_Hunters_Distribute_Ruleset.value());
                exit(0);
        }
}
 
void Hunter_Population_Manager::RuleSet10Based( int a_no_hunters, vector<int>* a_farmsizes, vector<HunterInfo>* a_hunterlist, vector<APoint>* a_roostlocs, int a_ruleset ) {
        FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
        vector<int>* illegalfarms = new vector<int>;
        vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
        for (int i = 0; i < a_no_hunters; i++) {
                for (int h = 0; h < int( (*a_hunterlist)[ i ].FarmHuntRef.size() ); h++) {
                        bool found1 = false;
                        int theref = -1;
                        // While a farm is not allocated
                        int iteration = 0;
                        while (!found1) {
                                if (++iteration > FManager->GetNoFarms()) {
                                        g_msg->Warn( "Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value() );
                                        exit( 0 );
                                }
                                // Choose a new farm ref to test
                                if (a_ruleset == 10) {
                                        theref = FManager->FindClosestFarmOpennessProb( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value() );
                                        found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                                }
                                else if (a_ruleset == 11) {
                                        // Choose a new farm ref to test
                                        theref = FManager->FindClosestFarmOpennessProbSmallIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_farmsizes );
                                        found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                                }
                                else if (a_ruleset == 12) {
                                        // Choose a new farm ref to test
                                        theref = FManager->FindClosestFarmOpennessProbNearRoostIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_roostlocs );
                                        found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                                }
                        }
                        (*a_hunterlist)[ i ].FarmHuntRef[ h ] = theref;
                }
        }
        delete illegalfarms;
}
 
void Hunter_Population_Manager::Init(void)
{
        int no_hunters;
        struct_Hunter sh;
        sh.m_L = m_TheLandscape;
        ifstream        hunterinifile("./Hunter_Hunting_Locations.txt", ios::in);
        if (!hunterinifile.is_open()) {
                m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Hunter_Hunting_Locations.txt missing" );
                exit( 1 );
        }
        hunterinifile >> no_hunters;
        // Now we skip the header line:
        string line;
        for (int i = 0; i < 19; i++) hunterinifile >> line;
        if (line != "FarmRef10") {
                m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Header line missing from Hunter_Hunting_Locations.txt" );
                exit( 1 );
        }
        /*
        * Reads the hunter data line by hunter line.\n
        * Each hunter entry is of the following format:\n
        * - Hunter type (0 = Goose Hunter) (int) 
        * - x/y home location (int) 
        * - Hunting day limit, ie how many days the hunter will go out (int) 
        * - Active hunting days of the week, 1 = everyday, 0 weekends only (int) 
        * - Efficiency (% hits) when geese are present (double) 
        * - Daily chance of checking for geese (prob 0.0-1.0) (double) 
        * - Number of hunting locations (int)
        * - Farm reference numbers where they hunt (up to 10).
        *
        */
        for (int h = 0; h < no_hunters; h++)
        {
                int no_huntlocs;
                hunterinifile >> sh.m_ref >> sh.m_HType >> sh.m_huntingdayslimit >> sh.m_weekend >> sh.m_goosecountchance >> sh.m_efficiency >> sh.m_home.m_x >> sh.m_home.m_y >> no_huntlocs;
                // resize our vectors
                // TODO one day - create another struct to make this a single vector - just to make the code a little more tidy
                sh.m_farms.resize(no_huntlocs);
                sh.m_huntlocrefs.resize(no_huntlocs);
                sh.m_huntlocs.resize(no_huntlocs);
                for (int i = 0; i < no_huntlocs; i++)
                {
                        hunterinifile >> sh.m_huntlocrefs[i];
                        APoint fp = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmCentroid( sh.m_huntlocrefs[ i ] );
                        sh.m_huntlocs[ i ].m_x = fp.m_x;
                        sh.m_huntlocs[ i ].m_y = fp.m_y;
                        // Need to get the farm* from farmref
                        sh.m_farms[i] = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmPtr(sh.m_huntlocrefs[i]);
                }
                for (int i = 0; i < 10-no_huntlocs; i++) 
                {
                        hunterinifile >> line; // Skip the NA's
                }
                if (sh.m_HType == toh_GooseHunter) sh.m_preyPM = g_PopulationManagerList.GetPopulation(TOP_Goose);
                else
                {
                        g_msg->Warn("Hunter_Population_Manager::Init unknown hunter type: ", sh.m_HType);
                        exit(0);
                }
                CreateObjects( sh.m_HType, NULL, &sh, 1 );
        }
        hunterinifile.close();
                
        m_daytime = 0; // Make sure we start the simulation at dawn (as the geese do).
        // Initialise output
        if (cfg_Hunters_RecordBag.value())
        {
                m_HuntingBagRecord = new ofstream("HuntingBagRecord.txt", ios::out);
                (*m_HuntingBagRecord) << "Year" << '\t' << "Day" << '\t' << "Hour" << '\t' << "Minute" << '\t' << "Season" << '\t' <<
                        "HunterRef" << '\t' << "PolygonRef" << '\t' << "x-coord" << '\t' << "y-coord" << '\t' << "GameType" << endl;
        }
        ofstream ofile("HuntingOpportunities.txt", ios::out);
        ofile << "Year" << '\t' << "HunterRef" << '\t' << "HuntingDays" << '\t' << "TotalBag" << '\t' << "NumberOfShots" << '\t' <<
                "GameType0" << '\t' << "GameType1" << '\t' << "GameType2" << '\t' << "GameType3" << '\t' << "GameType4" << '\t' << "GameType5" << endl;
        ofile.close();
}
 
void Hunter_Population_Manager::CreateObjects(int a_ob_type, TAnimal* /* pvo */, struct_Hunter* p_data,int a_number)
{
        GooseHunter* GHunter = NULL;
        for (int i=0; i<a_number; i++)
        {
                switch (a_ob_type)
                {
                case toh_GooseHunter:
                        if (g_PopulationManagerList.GetPopulation(TOP_Goose) == NULL) break; // Don't make goose hunters if we are not running geese
                        GHunter = new GooseHunter(p_data, this);
                    TheArray[a_ob_type].push_back(GHunter);
                    break;
                default:
            char ob[ 255 ];
            sprintf( ob, "%d", (int) a_ob_type);
                        m_TheLandscape->Warn("Goose_Population_Manager::CreateObjects() unknown object type - ", ob);
                        exit(1);
                    break;
                }
        }
}
 
void Hunter_Population_Manager::DoFirst()
{
        int today = m_TheLandscape->SupplyDayInYear();
        if (m_daytime == 0)
        {
                // Start of day so do some housekeeping.
                // Reset all clocks
                for (unsigned i=0; i<m_ListNameLength; i++)
                {
                        int sz = (int) TheArray[i].size();
                        for (int j=0; j<sz; j++)
                        {
                                GooseHunter* h = (GooseHunter*) TheArray[i][j];
                                h->ResetClock();
                                h->OnMorning();
                                if (h->IsOutHunting()) {
                                        g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter out hunting at midnight at ref ", h->GetHuntField());
                                        g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter clock is  ", h->GetClock());
                                        g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter is leader ", h->IsLeader());
                                        g_msg->Warn("Day in year is: ", m_TheLandscape->SupplyDayInYear());
                                        g_msg->Warn("Year is: ", m_TheLandscape->SupplyYearNumber());
                                        exit(0);
                                }
                        }
                }
                // Clear all active hunting location information
                for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
                        delete m_ActiveHuntingLocationsHunters[ i ];
                }
                m_ActiveHuntingLocationsHunters.clear();
                m_ActiveHuntingLocationsPolyrefs.clear();
                // If end of season, reset bags etc. 
                // Here we only need to ask the first hunter in each list, the answer is the same for the rest 
                for (unsigned i = 0; i < m_ListNameLength; i++) {
                        if ((int)TheArray[ i ].size() > 0) {
                                Hunter* h = (Hunter*)TheArray[ i ][ 0 ];
                                if (h->IsSeasonEnd( today ) && m_SeasonNumber > 0) {
                                        ofstream ofile( "HuntingOpportunities.txt", ios::app | ios::out);
                                        int year = m_TheLandscape->SupplyYearNumber()-1; // This makes it zero based and cuts out the hidden year. 
                                        int sz = (int)TheArray[ i ].size();
                                        for (int j = 0; j < sz; j++) {
                                                h = (Hunter*)TheArray[ i ][ j ];
                                                ofile << year << '\t';
                                                h->SaveMyData( &ofile );
                                                h->ResetSeasonData();
                                        }
                                        ofile.close();
                                }
                        }
                }
        }
        m_daytime = ( m_daytime + 10 ) % 1440; // We have 10 minutes timesteps
        if (today == 183 && m_daytime == 1430) m_SeasonNumber++;
}
 
void Hunter_Population_Manager::RecordHuntingSuccess(int a_poly, int a_birds, int a_hunter)
{
        APoint pt = m_TheLandscape->SupplyCentroid(a_poly);
        (*m_HuntingBagRecord) << m_TheLandscape->SupplyYear() << '\t' << m_TheLandscape->SupplyDayInYear() << '\t' << g_date->GetHour() << '\t' <<
                g_date->GetMinute() << '\t' << GetSeasonNumber() << '\t' << a_hunter << '\t' << a_poly << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << a_birds << endl;
 
        
}
 
 
APoint Hunter_Population_Manager::GetHunterHome(int a_index, int a_list)
{
        return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHome();
}
 
APoint Hunter_Population_Manager::GetHunterHuntLoc(int a_index, int a_list, unsigned a_ref)
{
        return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHuntLoc(a_ref);
}
 
 
void Hunter_Population_Manager::HunterLeaderMessage(TypeOfHunterLeaderMessage a_signal, int a_polyref)
{
        for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
                if (a_polyref == m_ActiveHuntingLocationsPolyrefs[i])
                {
                        for (int h = 1; h < m_ActiveHuntingLocationsHunters[i]->size(); h++)
                        {
                                switch (a_signal)
                                {
                                case hlm_shoot:
                                        (*m_ActiveHuntingLocationsHunters[i])[h]->OnShoot();
                                        break;
                                case hlm_gohome:
                                        (*m_ActiveHuntingLocationsHunters[i])[h]->OnGoHome();
                                        break;
                                default:
                                        g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage unknown leader message: ", a_signal);
                                        exit(0);
                                }
                        }
                        return;
                }
        }
        g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage polyref does not match any of the active polygons in list: ", a_polyref);
        exit(0);
}
 
bool Hunter_Population_Manager::IsPolyrefOnActiveList( int a_polyref ) 
{
        bool found = false;
        for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
                if (a_polyref == m_ActiveHuntingLocationsPolyrefs[ i ]) {
                        found = true;
                        break;
                }
        }
        return found;
}
 
//*******************************************************************************************************************/
//                                              Class Hunter
//*******************************************************************************************************************/
 
Hunter::Hunter(struct_Hunter* p_data, Hunter_Population_Manager* p_PPM) : TAnimal(p_data->m_home.m_x, p_data->m_home.m_y, p_data->m_L)
{
        m_OurPopulationManager = p_PPM;
        Init(p_data);
}
 
Hunter::~Hunter()
{
        ;
}
 
void Hunter::Init(struct_Hunter* p_data)
{
        m_Home = p_data->m_home;
        m_HuntLocs = p_data->m_huntlocs;
        m_HuntLocRefs = p_data->m_huntlocrefs;
        m_NoHuntLocs = int( m_HuntLocs.size() );
        m_CurrentHState = tohts_InitialState;
        m_bag = 0;
        m_myShots = 0;
        m_huntingdays = 0;
        m_baglimit = 999999999; // p_data->m_baglimit;
        m_huntlimit = p_data->m_huntingdayslimit;
        m_goosecountchance = p_data->m_goosecountchance;
        m_efficiency = p_data->m_efficiency;
        m_OurFarmers = p_data->m_farms;
        m_weekend = p_data->m_weekend;
    m_myname = p_data->m_ref;
        m_clock = 0;
        m_lasthuntday = 0;
        m_myMagazine = cfg_hunter_magazinecapacity.value();
        //m_AnnualHuntingAttempts = 0;
}
 
TypeOfHunterState Hunter::st_ShouldGoHunting( void )
{
        if ((m_bag >= m_baglimit) || (m_huntingdays >= m_huntlimit)) return tohts_Resting;
        int day = m_OurLandscape->SupplyDayInYear();
        if (!InSeason( day )) return tohts_Resting;
        // is it a weekday?
        if (IsTodayAPreferredHuntDay(day)) {
                if (IsTodayAChosenHuntDay( day )) {
                        return tohts_OutHunting;
                }
        }
        return tohts_Resting; // This is important that it returns resting and not hunting - resting stops the hunter doing anything until the next day.
}
 
inline bool Hunter::IsTodayAPreferredHuntDay( int a_today ) {
        if (m_weekend == 0) // 0 means only hunt at weekend
        {
                // 5 & 6 are assumed to be weekends
                if (a_today % 7 > 4)    return true; else return false;
        }
        if (m_weekend == 2) // 2 means leave cfg_hunterrefractionperiod days between hunts
        {
 
                if (m_OurLandscape->SupplyGlobalDate() - m_lasthuntday >= cfg_hunterrefractionperiod.value())   return true; else return false;
        }
        return true;
}
 
inline bool Hunter::IsTodayAChosenHuntDay( int a_today ) {
        double seasonleft = double( GetSeasonLengthLeft( a_today ) );
        if (m_weekend == 0) seasonleft *= 2.0 / 7.0;
        double prob = cfg_hunterhuntdayprobscaler.value()*(m_huntlimit - m_huntingdays) / seasonleft;
        if (g_rand_uni() < prob) return true;
        return false;
}
 
TypeOfHunterState Hunter::st_OutHunting( void )
{
        return tohts_foobar;
}
 
TypeOfHunterState Hunter::st_Resting( void )
{
        return tohts_Resting;
}
 
//*******************************************************************************************************************/
//                                              Class Goose Hunter
//*******************************************************************************************************************/
 
GooseHunter::GooseHunter(struct_Hunter* p_data, Hunter_Population_Manager* p_PPM) : Hunter(p_data, p_PPM)
{
        m_preyPopulationManger = dynamic_cast<Goose_Population_Manager*>(p_data->m_preyPM);
        m_OurFarmers = p_data->m_farms;
        m_leader = false;
        m_pinkfootbaglimit = cfg_hunter_pinkfootbaglimit.value();
        m_greylagbaglimit = cfg_hunter_greylagbaglimit.value();
        Init();
}
 
GooseHunter::~GooseHunter()
{
        if (m_huntfields != NULL) delete m_huntfields;
}
 
void GooseHunter::Init()
{
        m_huntfields = new polylist;
        for (int i = 0; i < m_NoHuntLocs; i++)
        {
                polylist* pl = m_OurFarmers[i]->ListOpenFields((int)cfg_goose_MinForageOpenness.value());
                m_huntfields->insert(m_huntfields->begin(), pl->begin(), pl->end()); // add the new one to the main polylist
                delete pl;
        }
        ResetClock();
        ResetSeasonData();
}
 
 
int GooseHunter::CheckForGame() {
        int sz = int(m_huntfields->size());
        if (g_rand_uni() >= m_goosecountchance) {
                int thepolyref = (*m_huntfields)[int(g_rand_uni()*sz)]; // returns 0 to sz-1;
                return thepolyref;
        }
        else {
                // We are checking today, so check out hunting fields
                int polyref = -1;
                int maxgeese = 0;
                        for (int hfield = 0; hfield < sz; hfield++) {
                                int geese = m_OurLandscape->GetQuarryNumbers((*m_huntfields)[hfield]);
                                if (geese > maxgeese) {
                                        maxgeese = geese;
                                        polyref = (*m_huntfields)[hfield];
                                }
                        }
                return polyref;
        }
}
 
bool GooseHunter::IsSeasonEnd(int day) {
        int end = m_OurPopulationManager->GetHuntingSeasonEnd();
        if (end == 365){
                m_OurLandscape->Warn("GooseHunter::IsSeasonEnd()", "Hunting season end at day 365. First day of the year is 0 hence last day of year is 364");
                exit(1);
        }
        if (day == 1 + end) return true;
        if (day == 0 && end == 364) return true; // if the hunting season ends at the end of the year, then day 0 is after it.
        return false;
}
 
bool GooseHunter::InSeason(int day) {
        int start = m_OurPopulationManager->GetHuntingSeasonStart();
        int end = m_OurPopulationManager->GetHuntingSeasonEnd();
        if (m_OurPopulationManager->GetSeasonNumber() == 0) {
 
                return false;  // We don't want them to start in January in the first year of the sim.
        }
        if (start > end) {
                if ((day < start) && (day > end)) return false;
                else {
                        return true;  // must be in the first year after the start of season
                }
        }
        else {
                // Season all in one year
                if (day < start || day > end) return false;
                else {
                        return true;
                }
        }
}
int GooseHunter::GetSeasonLengthLeft(int day) {
        if (m_OurPopulationManager->GetSeasonNumber() == 0) return 0;  // We don't want them to start in January in the first year of the sim.
        int left;
        int start = m_OurPopulationManager->GetHuntingSeasonStart();
        int end = m_OurPopulationManager->GetHuntingSeasonEnd();
        if (start > end) {
                // We have a year boundary issue, if the day is in the autumn then we have til the end of year + next year, otherwise we must be in next year already.
                if (day >= start) left = (365 - day) + end;
                else left = end - day;
        }
        else {
                left = end - day;
        }
        // We don't want to return a negative number of days, so rather want to say no days left, i.e. 0
        if (left < 0) return 0;
        return left;
}
 
TypeOfHunterState GooseHunter::st_ShouldGoHunting(void)
{
        if ((m_goosebag[gst_PinkfootFamilyGroup] + m_goosebag[gst_PinkfootNonBreeder]) >= m_pinkfootbaglimit) return tohts_Resting;
        else
        {
                return(Hunter::st_ShouldGoHunting());
        }
        
}
 
 
TypeOfHunterState GooseHunter::st_OutHunting(void)
{
        m_clock += 10;  // this is not strictly necessary, but makes useful debug info (only leader cares)
        if (!m_dugin) {
                m_huntfield_polyref = CheckForGame();
                if (m_huntfield_polyref == -1) return tohts_Resting;
                else {
                        m_huntingdays++;
                        m_dugin = true;
                        m_leader = m_OurPopulationManager->AddHunterHunting(m_huntfield_polyref, this);
                        m_lasthuntday = m_OurLandscape->SupplyGlobalDate();
                        return tohts_OutHunting;
                }
        }
        if (m_leader) {
                // Only the leader assesses this 
                if (m_clock > cfg_huntlength.value())
                {
                        m_dugin = false;
                        m_OurPopulationManager->HunterLeaderMessage(hlm_gohome, m_huntfield_polyref);
                        m_huntfield_polyref = -1;
                        return tohts_Resting; // Come home
                }
                double fieldsize = m_OurLandscape->SupplyPolygonArea( m_huntfield_polyref );
                double shootingchance = 1.0;
                if (fieldsize > cfg_largefieldgooseproximitysizecutoff.value()) {
                        shootingchance = cfg_largefieldgooseproximity.value();
                }
                /*double pct = 0.0;*/
                int birds = m_preyPopulationManger->BirdsToShootAtPoly(m_huntfield_polyref /*, pct */);
                
                if ((birds > 0) && (g_rand_uni() < shootingchance)  /* && (pct<cfg_huntermaxprotectedpct.value())*/     ) {
                        int numbershot = 0;
                        for (int i = 0; i < m_myMagazine; ++i) {
                                if ((birds > i) || (numbershot == 0))
                                {
                                        if (g_rand_uni() < m_efficiency) numbershot++;
                                        m_myShots++;
                                }
                        }
                        if (numbershot > 0) {
                                m_preyPopulationManger->BirdsShot(m_huntfield_polyref, numbershot, this);
                        }
                        m_OurPopulationManager->HunterLeaderMessage(hlm_shoot, m_huntfield_polyref);
                        // All shots are fired then make some sound
                        // Must scare any birds off that are near here and get them to remember the event
                        m_preyPopulationManger->BangAtPoly(m_huntfield_polyref);
                }
        }
        return tohts_OutHunting;
}
 
void GooseHunter::OnShotABird(int a_birdtype, int a_poly) {
        m_bag++;
        m_goosebag[a_birdtype]++;
        if (cfg_Hunters_RecordBag.value()) m_OurPopulationManager->RecordHuntingSuccess(a_poly, a_birdtype, m_myname);
}
 
void GooseHunter::OnShoot() {
        int birds = m_preyPopulationManger->BirdsToShootAtPoly(m_huntfield_polyref /*, pct */);
        int numbershot = 0;
        m_myShots++;
        if (g_rand_uni() < m_efficiency) numbershot++;
        if (birds > 1){
                if (g_rand_uni() < m_efficiency) numbershot++;
                m_myShots++;
        }
        if (numbershot > 0) {
                m_preyPopulationManger->BirdsShot(m_huntfield_polyref, numbershot, this);
        }
}
 
void GooseHunter::OnGoHome() {
        m_dugin = false;  // End of the hunt, so no longer dugin
        m_leader = false;  // Hunt is over, so nothing to lead.
        m_huntfield_polyref = -1;  // This has to be reset. We find a new one next time we go hunting.
        m_CurrentHState = tohts_Resting; // Come home
}
 
 
void GooseHunter::Step( void )
{
        if (m_StepDone || m_CurrentStateNo == -1) return;
        switch (m_CurrentHState)
        {
        case tohts_InitialState: // Initial state always starts by setting the behaviour to tohts_Hunting
                m_CurrentHState = tohts_Hunting;
                break;
        case tohts_Hunting:
                m_CurrentHState = st_ShouldGoHunting();
                break;
        case tohts_OutHunting:
                m_CurrentHState = st_OutHunting();
                break;
        case tohts_Resting:
                m_CurrentHState = st_Resting();
                break;
        default:
                m_OurLandscape->Warn("GooseHunter::Step()","unknown state - default");
                exit(1);
        }
}
 
void GooseHunter::SaveMyData( ofstream* a_ofile ) {
        (*a_ofile) << m_myname << '\t' << GetHuntingDays() << '\t' << GetBag() << '\t' << GetShots();
        for (int i = 0; i < gst_foobar; i++) {
                (*a_ofile) << '\t' << m_goosebag[ i ];
        }
        (*a_ofile) << endl;
 
}
 
bool Hunter_Population_Manager::AddHunterHunting( int a_polyref, Hunter* a_hunter ) {
        for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
                if (m_ActiveHuntingLocationsPolyrefs[ i ] == a_polyref) {
                        m_ActiveHuntingLocationsHunters[ i ]->push_back( a_hunter );
                        return false;
                }
        }
        HunterList* p_newhunterlist = new HunterList;
        p_newhunterlist->push_back( a_hunter );
        m_ActiveHuntingLocationsHunters.push_back( p_newhunterlist );
        m_ActiveHuntingLocationsPolyrefs.push_back( a_polyref );
        return true;
}
 
void Hunter_Population_Manager::SetHuntingSeason() {
        int start1 = cfg_goose_pinkfootopenseasonstart.value();
        int end1 = cfg_goose_pinkfootopenseasonend.value();
        int start2 = cfg_goose_greylagopenseasonstart.value();
        int end2 = cfg_goose_greylagopenseasonend.value();
        /*Both start and end in the same year*/
        if (end1 > start1 && end2 > start2) {
                m_HuntingSeasonEnd = end1;
                if (m_HuntingSeasonEnd < end2)
                {
                        m_HuntingSeasonEnd = end2;
                }
        }
        /*1 end in the second year*/
        if (start1 > end1 && start2 < end2)
        {
                m_HuntingSeasonEnd = end1;
        }
        /*2 end in the second year*/
        if (start1 < end1 && start2 > end2)
        {
                m_HuntingSeasonEnd = end2;
        }
        /*Both end in the second year*/
        if (start1 > end1 && start2 > end2)
        {
                m_HuntingSeasonEnd = end1;
                if (m_HuntingSeasonEnd < end2)
                {
                        m_HuntingSeasonEnd = end2;
                }
        }
        if (start1 > start2)
        {
                m_HuntingSeasonStart = start2;
        }
        else m_HuntingSeasonStart = start1;
        if (m_HuntingSeasonStart < 0)
        {
                g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() Start of hunting season:", m_HuntingSeasonStart);
                exit(1);
        }
        if (m_HuntingSeasonEnd < 0)
        {
                g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() End of hunting season:", m_HuntingSeasonEnd);
                exit(1);
        }
}