Partridge_Covey.h

Go to the documentation of this file.

/* 
*******************************************************************************************************
Copyright (c) 2011, 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 Partridge_CoveyH
#define Partridge_CoveyH
//---------------------------------------------------------------------------
 
extern class CoveyManager * g_covey_manager;
class Partridge_Base;
class Partridge_Male;
class Partridge_Female;
 
class ForIterator {
  int * m_list;
  int m_limit;
 
public:
  int * GetList( void ) {
    return m_list;
  }
 
  int GetLimit( void ) {
    return m_limit;
  }
 
  ForIterator( int a_min_incl, int a_max_excl, int a_step_size, int a_norm_min_incl, int a_norm_max_excl );
  ~ForIterator( void );
};
 
 
class Partridge_Covey : public TAnimal {
protected:
// Attributes
    int m_flyto_steps;
    int m_flyto_dist;
    double m_flyto_ts;
    bool m_essence_low;
    bool m_peg_is_fixed;
    bool m_permanent_marker;
    unsigned int m_id;
    Partridge_Base * m_members[ 100 ];
    unsigned int m_members_size;
    bool m_step_done;
    bool m_dist_done;
    double m_nearest_covey_dist;
    bool m_terr_done;
    double m_terr_qual;
    bool m_force_low;
    Partridge_State m_state;
    Landscape * m_map;
    int m_width;
    int m_height;
    Partridge_Population_Manager * m_manager;
    double m_center_x_float;
    double m_center_y_float;
    double m_new_center_x_float;
    double m_new_center_y_float;
    int m_center_x;
    int m_center_y;
    int m_covey_x;
    int m_covey_y;
    int m_terr_size;
    bool m_nest_on_nest;
    int m_nest_x;
    int m_nest_y;
    bool m_assess_done;
    double m_assess_qual;
    bool m_move_done;
    double m_dist_moved;
    double m_food_today;
 
// Methods
    void CoveyUpdateMemberPositions( int a_x, int a_y );
    bool NestGoodSpot( int a_x, int a_y );
    bool NestFindFast( int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl );
    int Norm( int a_coord, int a_size );
    int NormInc( int a_coord, int a_size );
    int NormDec( int a_coord, int a_size );
    bool NestNearBadAreas( int a_x, int a__y );
    bool NestBadArea( int a_x, int a__y );
    bool NestNearNests( int a_x, int a_y, int a_min_dist_sq );
    bool NestBadAreasScanSlow( int a_min_x, int a_min_y, int a_length, int a_x, int a_y );
    bool NestBadAreasScanFast( int a_min_x, int a_min_y, int a_length, int a_x, int a_y );
    bool FlyToFast( int a_distance );
    bool FlyToSlow( int a_distance );
    double Pressure( double a_distance );
    bool PressureLimitExceeded( double a_pressure );
    void DistanceUpdate( void );
    void DistanceUpdate2( void );
    double DistanceToCovey( Partridge_Covey * a_covey );
  double HabitatEvaluate( int a_center_x, int a_center_y, int * a_size_used, bool a_rethink_size );
  double HabitatEvaluateFaster( int a_center_x, int a_center_y );
  double HabitatEvaluateFast( int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl );
  double HabitatEvaluateSlow( int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl );
  double HabitatEvalPoly( TTypesOfLandscapeElement a_cet, int a_poly );
  int HabitatEvalPolyField( int a_field );
 
    bool MoveTryExclude( int a_dist_sq );
    bool MoveTryExcludeHarder( int a_dist_sq );
 
    /*
    Builds an array, m_move_allowed[8], from the current covey
    location and the MoveTryExclude*() methods, mapping
    from directions and into booleans. We calculate this array
    *before* evaluating the actual moves, because it would be pointless
    to make an expensive loop in MoveOptimalDirection*() below if
    we already know we will never use said value calculated. \n
    */
    void MoveDirectionsAllowed( int a_x, int a_y );
 
    /*
    Given the array of possible directions we might want to move in,
    calculate a rough evaluation [0:3] of the possible directions
    in the array m_move_list[8]. The actual food quality summed
    up during this evaluation is collected in m_move_dir_qual[8].
    The result of the values in m_move_list[] and m_move_dir_qual[]
    are assigned the values 0 and 0.0 respectively for those
    directions, which are blocked by the entries in m_move_allowed[]. \n
    */
    void MoveOptimalDirectionSlow( int a_x, int a_y );
    void MoveOptimalDirectionFast( int a_x, int a_y );
 
    int MoveWeighDirection( int a_x, int a_y );
 
 
public:
    Partridge_Covey* m_neighbourlist[50];
    int m_neighbourlist_size;
    bool NestFindSlow( int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl );
/*  double TerrEvalaPoly( TTypesOfLandscapeElement a_cet, int a_poly )  {
        return TerrEvalPoly( a_cet, a_poly );
    }
*/
 
protected:
    int m_assess_size;
/*
    // Optional reporting variables - look for m_move_get_enable in comments
    bool m_move_get_enable;
    vector < int > m_move_get_x;
    vector < int > m_move_get_y;
*/
    int m_move_get_index;
    int m_move_get_size;
    int m_move_qual_memory[ 4 ];
    int m_move_qual_hist[ 4 ] [ MOVE_QUAL_HIST_SIZE ];
    void MoveQualMemory( int a_qual );
 
  int m_move_whence_we_came;
  int m_move_step_size;
  double m_move_step_size_inv;
 
  double MoveDoIt( int * a_x, int * a_y, int a_dir, int a_step_size );
  int MoveCanMove( TTypesOfLandscapeElement a_ele );
 
  double MoveMagicVegToFood( int a_polygon );
  int MoveEvalEdgesAndQual( int a_edges, double a_qual );
  int MoveSelectFuzzy( void );
 
  bool MoveSelectLimit( int a_limit, int a_x, int a_y );
  int MoveSelect( void );
  void MoveVegConstInit( void );
  
  // Misc and tuning functions
    void OntheDadDead();
    void OntheMumDead();
    void KillChicks( int percent );
 
    Partridge_Female * m_theMum;
    Partridge_Male * m_theDad;
  int m_ourChicks;
  int m_CoveyDissolveDate;
  int SupplyChickAge( void );
  int m_maxAllowedMove;
  double m_maxFoodNeedToday;
  int m_ChickAge;
 
public:
  bool CoveyEmigrate();
  void CoveyIndividualEmigrate();
  bool TooClose();
  bool HaveWeChicks( void );
  int GetUncleNumber(); // {  return m_UncleNumber; }
  int GetmaxAllowedMove() {
    return m_maxAllowedMove;
  }
 
  double GetmaxFoodNeedToday() {
    return m_maxFoodNeedToday;
  }
 
  void OnAddChick( Partridge_Female * a_pf );
  void OnChickDeath();
  void OnChickMature();
  void ChickExtraMortality();
 
  void SetCoveyDissolveDate( int date ) {
    m_CoveyDissolveDate = date;
  }
 
  Partridge_Female * FindMeAMateInCovey( int a_family_counter );
  Partridge_Female * GetUnpairedFemale();
  Partridge_Female * GetUnpairedFemale_virgin();
  Partridge_Male * GetMaleInCovey();
  Partridge_Base * GetMember(int a_member);
  Partridge_Base * GetAMember();
  Partridge_Covey* FindNeighbour();
  void OnDissolve( int date );
  bool AllFlocking();
  bool AllFlocking2();
  bool ArePaired();
  void SanityCheck();
  void SanityCheck3();
  void SanityCheck4();
  void SanityCheck2( int no_chicks );
 
  void RemoveExtraChick() {
    m_ourChicks--;
  }
 
  int GetOurChicks() {
    return m_ourChicks;
  }
 
  unsigned int GetCoveySize() {
    return m_members_size;
  }
 
  void SetChickAge( int age ) {
    m_ChickAge = age;
  }
 
  int GetChickAge() {
    return m_ChickAge;
  }
 
  bool CanWeMerge(int a_NoUncles);
  bool ManagerCheckMerge( int a_noOfUncles );
  void SetUncle();
  void KillExcessChicks(int remaining);
  void ActOnParentDeath();
  
 
  // End CJT section.
 
  bool NestFindLocation( void );
 
  bool NestOnNest( void ) {
    return m_nest_on_nest;
  }
 
  void NestLeave( void ) {
    m_nest_on_nest = false;
  }
 
  int NestGetX( void ) {
    return m_nest_x;
  }
 
  int NestGetY( void ) {
    return m_nest_y;
  }
 
  double SupplyFoodToday( void );
  double SupplyDistanceMoved( void );
 
 
  // *********
  // CJT note: Using references in parameters to return
  // values is a *very bad* coding habit due to what is commonly
  // known as 'side effects', a really nasty class of 'invisible'
  // bugs. Using pointers to the same effect is OK, as
  // you can see in the call that something might be happening
  // to your parameter variable.
  double AssessHabitatQuality( int & a_sz );
 
  // If we only care about elements or we have managed an update to the
  // TerrQualMap in PartridgePopulationManager, then we can use this much
  // faster method instead with a constant size of 50m (need to replace this
  // with a config variable - ***CJT***
  double AssessHabitatQualityFaster( );
 
  int AssessGetSize( void ) {
    return m_assess_size;
  }
 
  void FixHabitat( void );
  double SupplyHabitatQuality();
 
 
  void SetFixed( bool a_is_fixed ) {
    m_peg_is_fixed = a_is_fixed;
  }
 
  bool IsFixed( void ) {
    return m_peg_is_fixed;
  }
 
  Partridge_Object GetObjectType( void ) {
    return pob_Covey;
  }
 
 
    // Remember to set locations in members through SetX(),
    // SetY() upon moving the covey, including FlyTo().
    void MoveDistance( int a_max_distance, int a_step_size, double a_food_density_needed );
 
    int MoveCanMove( int a_x, int a_y );
 
  /* 
  // Optional methods used for inspecting the covey's daily movements
  // due to MoveDistance(). Intended for demonstration/plotting/debugging
  // purposes. Can be safely ignored if not needed.
 
    // Enable/disable the movement collection engine in MoveDistance().
      void MoveGetEnable( bool a_state );
 
    // Report number of steps taken today.
    int MoveGetSteps( void );
 
    // Prepare for daily loop of fetching movement data.
    void MoveGetPrepare( void );
 
    // Fetch the data in tight loop.
    bool MoveGet( int * a_x, int * a_y );
 
  // Calling MoveGetPrepare(), MoveGetSteps() or MoveGet() with the
  // movement collecting engine disabled is an error and will result
  // in a bug being reported, and the program execution will
  // be terminated.
 
  // // Example usage:
  //
  // l_covey->MoveGetEnable( true );
  //
  // ...
  //
  // l_covey->MoveDistance( 200, 10, 1234.0 );
  // printf( "Steps today: %d\n",
  //         l_covey->MoveGetSteps() );
  //
  // l_covey->MoveGetPrepare();
  //
  // int x, y;
  // while ( l_covey->MoveGet( &x, &y )) {
  //   printf( "X: %4d Y: %4d\n", x, y );
  // }
 
  */
 
    bool FlyTo( int a_distance );
 
    void MoveTo( int a_x, int a_y );
    
 
    Partridge_Male * FindMeAHusband( Partridge_Female * a_female );
    Partridge_Female * FindMeAWife( Partridge_Male * a_male );
    Partridge_Base * GetUncle();
 
    Partridge_Female * FindMateInArea( int a_max_distance );
 
    void BeginStep( void );
    void Step( void );
    void EndStep( void );
 
  void AddMember( Partridge_Base * a_new_member );
  bool IsMember( Partridge_Base * a_possible_member );
 
    int RemoveMember( Partridge_Base * a_former_member );
 
    unsigned int  Memberships( void ) {
        return m_members_size;
    }
 
  // Methods associated with the territory functionality of a covey.
 
  bool LifeEssenceLow( void ) {
    return m_essence_low;
  }
 
bool ForceLow( void ) {
    return m_force_low;
}
 
  unsigned int X( void ) {
    return m_covey_x;
  }
 
  unsigned int Y( void ) {
    return m_covey_y;
  }
 
  unsigned int XCenter( void ) {
    return m_center_x;
  }
 
  unsigned int YCenter( void ) {
    return m_center_y;
  }
 
  double XCenterF( void ) {
    return m_center_x_float;
  }
 
  double YCenterF( void ) {
    return m_center_y_float;
  }
 
  unsigned int ID( void ) {
    return m_id;
  }
 
  // The following methods exists solely for the benefit of the manager
  // class and its friends, eyes only. That includes the con/destructor
  // pair.
  void ManagerCheckMerge( void );
  void ManagerRethinkPos( void );
  void ManagerDriftPos( void );
  void ManagerUpdatePos( void );
 
  void ManagerSetPermanent( void )
  {
    m_permanent_marker = true;
  }
 
  bool ManagerIsPermanant( void ) {
    return m_permanent_marker;
  }
 
  Partridge_Covey( Partridge_Base * a_first_member, Partridge_Population_Manager * a_manager, unsigned int a_center_x,
       unsigned int a_center_y, Landscape * a_map );
  virtual ~Partridge_Covey( void );
 
};
 
 
 
// For the benefit of the Covey_Manager.
static vector < Partridge_Covey * > g_covey_list;
 
 
class CoveyManager {
    int m_id_counter;
    int m_world_width;
    int m_world_height;
    int m_world_width_div2;
    int m_world_height_div2;
    Landscape * m_map;
    double m_par_force_ignore_below;
public:
    void SanityCheck1();
 
    void AddCovey( Partridge_Covey * a_covey );
    bool DelCovey( Partridge_Covey * a_covey );
    int CoveyDensity(int x, int y, int radius);
    double BroodGeoMean();
    void Setpar_force_ignore_below(double ff);
    double Getpar_force_ignore_below() {
        return m_par_force_ignore_below;
    }
    void Tick( void );
 
    CoveyManager( unsigned int a_world_width, unsigned int a_world_height, Landscape * a_map );
    ~CoveyManager( void );
};
#endif