The collective for a family of partridges
More...

#include <Partridge_Covey.h>

Inheritance diagram for Partridge_Covey:

Public Member Functions
bool	NestFindSlow (int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl)
	Find nest location (wrap around) More...

bool	CoveyEmigrate ()
	Test for covey emigration. More...

void	CoveyIndividualEmigrate ()
	Test for individuals from covey emigrating. More...

bool	TooClose ()
	Test for another covey too close. More...

bool	HaveWeChicks (void)
	Check if covey contains chicks. More...

int	GetUncleNumber ()
	Returns the number of uncles. More...

int	GetmaxAllowedMove ()
	Return the max possible move distance today. More...

double	GetmaxFoodNeedToday ()
	Return the maximum food need today. More...

void	OnAddChick (Partridge_Female *a_pf)
	Add a chick. More...

void	OnChickDeath ()
	Remove a dead chick. More...

void	OnChickMature ()
	Remove a matured chick. More...

void	ChickExtraMortality ()
	Apply extra chick mortality. More...

void	SetCoveyDissolveDate (int date)
	Set the dissolve date. More...

Partridge_Female *	FindMeAMateInCovey (int a_family_counter)
	Is their a suitable female mate in the covey? More...

Partridge_Female *	GetUnpairedFemale ()
	Finds the first unpaired female in the covey. More...

Partridge_Female *	GetUnpairedFemale_virgin ()
	Finds the first never paired female in the covey. More...

Partridge_Male *	GetMaleInCovey ()
	Find a male in the covey. More...

Partridge_Base *	GetMember (int a_member)
	Returns pointer to a_member. More...

Partridge_Base *	GetAMember ()
	Returns a random member. More...

Partridge_Covey *	FindNeighbour ()
	Finds the closest other covey. More...

void	OnDissolve (int date)
	Dissolve message handler. More...

bool	AllFlocking ()
	Debug method. More...

bool	AllFlocking2 ()
	Debug method. More...

bool	ArePaired ()
	Debug method. More...

void	SanityCheck ()
	Debug method. More...

void	SanityCheck3 ()
	Debug method. More...

void	SanityCheck4 ()
	Debug method. More...

void	SanityCheck2 (int no_chicks)
	Debug method. More...

void	RemoveExtraChick ()
	Decrement the chick number. More...

int	GetOurChicks ()
	Return the number of chicks. More...

unsigned int	GetCoveySize ()
	Return the covey size. More...

void	SetChickAge (int age)
	Set chick age. More...

int	GetChickAge ()
	Return chick age. More...

bool	CanWeMerge (int a_NoUncles)
	Merging test. More...

bool	ManagerCheckMerge (int a_noOfUncles)
	Merging test for uncle number. More...

void	SetUncle ()
	Swap uncle to alhpha. More...

void	KillExcessChicks (int remaining)
	Kill extra chicks. More...

void	ActOnParentDeath ()
	Determine the chick mortality on parent death. More...

bool	NestFindLocation (void)
	Try to locate a suitable nesting location. More...

bool	NestOnNest (void)
	Are we nesting? More...

void	NestLeave (void)
	Leave the nest More...

int	NestGetX (void)
	Return nest x-coord. More...

int	NestGetY (void)
	Return nest y-coord. More...

double	SupplyFoodToday (void)
	Return the food obtained today. More...

double	SupplyDistanceMoved (void)
	Return the distance moved today. More...

double	AssessHabitatQuality (int &a_sz)
	Assess habitat quality (with checks) More...

double	AssessHabitatQualityFaster ()
	Assess habitat quality (efficient) More...

int	AssessGetSize (void)
	Get the size ('radius') used during territory evaluation. More...

void	FixHabitat (void)
	Accept this breeding location. More...

double	SupplyHabitatQuality ()
	Return habitat quality at our location. More...

void	SetFixed (bool a_is_fixed)
	Prevent/enable peg drift. More...

bool	IsFixed (void)
	Wonder whether the peg is fixed? More...

Partridge_Object	GetObjectType (void)
	Return object type. More...

void	MoveDistance (int a_max_distance, int a_step_size, double a_food_density_needed)
	Entry point for movement. More...

int	MoveCanMove (int a_x, int a_y)
	Test of movement step. More...

bool	FlyTo (int a_distance)
	Fly to More...

void	MoveTo (int a_x, int a_y)
	unused More...

Partridge_Male *	FindMeAHusband (Partridge_Female *a_female)
	Find mate in covey. More...

Partridge_Female *	FindMeAWife (Partridge_Male *a_male)
	Find mate in covey. More...

Partridge_Base *	GetUncle ()
	Find uncle in covey. More...

Partridge_Female *	FindMateInArea (int a_max_distance)
	Find mate in area. More...

void	BeginStep (void)
	Covey BeginStep. More...

void	Step (void)
	Covey Step. More...

void	EndStep (void)
	Covey EndStep. More...

void	AddMember (Partridge_Base *a_new_member)
	More...

bool	IsMember (Partridge_Base *a_possible_member)
	More...

int	RemoveMember (Partridge_Base *a_former_member)
	Remove a member from the covey. More...

unsigned int	Memberships (void)
	Get covey size. More...

bool	LifeEssenceLow (void)
	More...

bool	ForceLow (void)
	More...

unsigned int	X (void)
	More...

unsigned int	Y (void)
	More...

unsigned int	XCenter (void)
	More...

unsigned int	YCenter (void)
	More...

double	XCenterF (void)
	More...

double	YCenterF (void)
	More...

unsigned int	ID (void)
	More...

void	ManagerCheckMerge (void)
	More...

void	ManagerRethinkPos (void)
	More...

void	ManagerDriftPos (void)
	More...

void	ManagerUpdatePos (void)
	More...

void	ManagerSetPermanent (void)
	Unused More...

bool	ManagerIsPermanant (void)
	Unused More...

	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)
	Constructor. More...

virtual	~Partridge_Covey (void)
	Destructor. More...

Public Member Functions inherited from TAnimal
unsigned	SupplyFarmOwnerRef ()

AnimalPosition	SupplyPosition ()

APoint	SupplyPoint ()

int	SupplyPolygonRef ()

int	Supply_m_Location_x ()

int	Supply_m_Location_y ()

virtual void	KillThis ()

virtual void	CopyMyself ()

void	SetX (int a_x)

void	SetY (int a_y)

	TAnimal (int x, int y, Landscape *L)

virtual void	ReinitialiseObject (int x, int y, Landscape *L)
	Used to re-use an object - must be implemented in descendent classes. More...

virtual int	WhatState ()

virtual void	Dying ()

void	CheckManagement (void)

void	CheckManagementXY (int x, int y)

virtual bool	OnFarmEvent (FarmToDo)

Public Member Functions inherited from TALMaSSObject
int	GetCurrentStateNo ()
	Returns the current state number. More...

void	SetCurrentStateNo (int a_num)
	Sets the current state number. More...

bool	GetStepDone ()
	Returns the step done indicator flag. More...

void	SetStepDone (bool a_bool)
	Sets the step done indicator flag. More...

virtual void	ReinitialiseObject ()
	Used to re-use an object - must be implemented in descendent classes. More...

	TALMaSSObject ()
	The constructor for TALMaSSObject. More...

virtual	~TALMaSSObject ()
	The destructor for TALMaSSObject. More...

void	OnArrayBoundsError ()
	Used for debugging only, tests basic object properties. More...

Public Attributes
Partridge_Covey *	m_neighbourlist [50]
	List of coveys close to this covey. More...

int	m_neighbourlist_size
	Number of coveys close to this covey. More...

Protected Member Functions
void	CoveyUpdateMemberPositions (int a_x, int a_y)
	Update all covey members x,y coords. More...

bool	NestGoodSpot (int a_x, int a_y)
	Evaluate x,y as a nest location. More...

bool	NestFindFast (int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl)
	Find nest location. More...

int	Norm (int a_coord, int a_size)
	Wrap-around utility function. More...

int	NormInc (int a_coord, int a_size)
	Wrap-around utility function. More...

int	NormDec (int a_coord, int a_size)
	Wrap-around utility function. More...

bool	NestNearBadAreas (int a_x, int a__y)
	Test for proximity to unacceptable areas. More...

bool	NestBadArea (int a_x, int a__y)
	Nest location evaluation function. More...

bool	NestNearNests (int a_x, int a_y, int a_min_dist_sq)
	Nest location evaluation function. More...

bool	NestBadAreasScanSlow (int a_min_x, int a_min_y, int a_length, int a_x, int a_y)
	Nest location evaluation function. More...

bool	NestBadAreasScanFast (int a_min_x, int a_min_y, int a_length, int a_x, int a_y)
	Nest location evaluation function. More...

bool	FlyToFast (int a_distance)
	Move a_distance from current covey position. More...

bool	FlyToSlow (int a_distance)
	Move a_distance from current covey position (wraparound) More...

double	Pressure (double a_distance)
	Get the pressure force. More...

bool	PressureLimitExceeded (double a_pressure)
	Test for exceedence of pressure limit. More...

void	DistanceUpdate (void)
	Updates distance to nearest covey. More...

void	DistanceUpdate2 (void)
	Updates distance to fixed nearest covey. More...

double	DistanceToCovey (Partridge_Covey *a_covey)
	Get distance too covey. More...

double	HabitatEvaluate (int a_center_x, int a_center_y, int *a_size_used, bool a_rethink_size)
	Entry point for habitat evaluation. More...

double	HabitatEvaluateFaster (int a_center_x, int a_center_y)
	Evaluate habitat fast. More...

double	HabitatEvaluateFast (int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl)
	Evaluate habitat (wrap around) More...

double	HabitatEvaluateSlow (int a_min_x_incl, int a_max_x_excl, int a_min_y_incl, int a_max_y_excl)
	More...

double	HabitatEvalPoly (TTypesOfLandscapeElement a_cet, int a_poly)
	More...

int	HabitatEvalPolyField (int a_field)
	Evaluate a field's habitat quality. More...

bool	MoveTryExclude (int a_dist_sq)
	Uses the peg force to exclude possible movement directions. More...

bool	MoveTryExcludeHarder (int a_dist_sq)
	Uses the peg force to exclude possible movement directions. More...

void	MoveDirectionsAllowed (int a_x, int a_y)
	Test possible movement directions. More...

void	MoveOptimalDirectionSlow (int a_x, int a_y)
	Choose best foraging direction. More...

void	MoveOptimalDirectionFast (int a_x, int a_y)
	Choose best foraging direction (wrap around) More...

int	MoveWeighDirection (int a_x, int a_y)
	Weighted foraging walk. More...

void	MoveQualMemory (int a_qual)
	Make a move based on memory of quality. More...

double	MoveDoIt (int a_x, int a_y, int a_dir, int a_step_size)
	We know where we want to go. Now do it! More...

int	MoveCanMove (TTypesOfLandscapeElement a_ele)
	Test if we can go there. More...

double	MoveMagicVegToFood (int a_polygon)
	Move optimising food intake. More...

int	MoveEvalEdgesAndQual (int a_edges, double a_qual)
	Move evaluation taking edges into account. More...

int	MoveSelectFuzzy (void)
	Fuzzdy movement selection. More...

bool	MoveSelectLimit (int a_limit, int a_x, int a_y)
	Part of movement evaluation. More...

int	MoveSelect (void)
	Part of movement evaluation. More...

void	MoveVegConstInit (void)
	Part of movement evaluation. More...

void	OntheDadDead ()
	Behaviour when alpha male is killed. More...

void	OntheMumDead ()
	Behaviour when alpha female is killed. More...

void	KillChicks (int percent)
	Kill a proportion of the chicks. More...

int	SupplyChickAge (void)
	Returns the age of the chicks. More...

Protected Member Functions inherited from TAnimal
void	CorrectWrapRound ()
	Corrects wrap around co-ordinate problems. More...

Protected Attributes
int	m_flyto_steps
	costly intermediate variable More...

int	m_flyto_dist
	costly intermediate variable More...

double	m_flyto_ts
	costly intermediate variable More...

bool	m_essence_low
	flag for excess density - unused More...

bool	m_peg_is_fixed
	flag for fixed homerange More...

bool	m_permanent_marker
	Unused More...

unsigned int	m_id
	Unique ID no- More...

Partridge_Base *	m_members [100]
	List of covey members More...

unsigned int	m_members_size
	Size of covey More...

bool	m_step_done
	Signals Step is done for today More...

bool	m_dist_done
	Signals distance updating is done for today More...

double	m_nearest_covey_dist
	Closest covey distance More...

bool	m_terr_done
	Signals homerange evaluation done More...

double	m_terr_qual
	Homerange evaluation score More...

bool	m_force_low
	unused More...

Partridge_State	m_state
	The current behavioural state. More...

Landscape *	m_map
	A pointer to the landscape. More...

int	m_width
	Landscape width. More...

int	m_height
	Landscape height. More...

Partridge_Population_Manager *	m_manager
	Covey's population manager. More...

double	m_center_x_float
	Covey centre as float. More...

double	m_center_y_float
	Covey centre as float. More...

double	m_new_center_x_float
	Covey centre as float. More...

double	m_new_center_y_float
	Covey centre as float. More...

int	m_center_x
	Covey centre. More...

int	m_center_y
	Covey centre. More...

int	m_covey_x
	Covey x-coord. More...

int	m_covey_y
	Covey y-coord. More...

int	m_terr_size
	Homerange width. More...

bool	m_nest_on_nest
	Nesting flag. More...

int	m_nest_x
	Nest coord-x. More...

int	m_nest_y
	Nest coord-y. More...

bool	m_assess_done
	Have assessed habitat quality? More...

double	m_assess_qual
	Habitat quality. More...

bool	m_move_done
	Have moved? More...

double	m_dist_moved
	Distance moved. More...

double	m_food_today
	Food collected. More...

int	m_assess_size
	Current homerange assessment radius. More...

int	m_move_get_index
	Internal variable. More...

int	m_move_get_size
	Internal variable. More...

int	m_move_qual_memory [4]
	Steps remembered. More...

int	m_move_qual_hist [4][MOVE_QUAL_HIST_SIZE]
	Internal variable. More...

int	m_move_whence_we_came
	Internal variable. More...

int	m_move_step_size
	Internal variable. More...

double	m_move_step_size_inv
	Internal variable. More...

Partridge_Female *	m_theMum
	Pointer to the alpha male. More...

Partridge_Male *	m_theDad
	Pointer to the alpha female. More...

int	m_ourChicks
	No chicks in covey. More...

int	m_CoveyDissolveDate
	Date for covey dissolve. More...

int	m_maxAllowedMove
	Max move distance today. More...

double	m_maxFoodNeedToday
	Food needed today. More...

int	m_ChickAge
	Age of chicks. More...

Protected Attributes inherited from TAnimal
int	m_Location_x

int	m_Location_y

Landscape *	m_OurLandscape

Protected Attributes inherited from TALMaSSObject
int	m_CurrentStateNo
	The basic state number for all objects - '-1' indicates death. More...

bool	m_StepDone
	Indicates whether the iterative step code is done for this timestep. More...

Detailed Description

The collective for a family of partridges

The partridge covey is contains all behaviour that is performed as a group of birds. In fact this group can be as small as 1 bird, but if the behaviour is the same as a family group it will appear here.
Note that the covey is treated just like a life-stage, and is handled by the Partridge_Population_Manager.

Each covey has a 'peg' position, which starts out as the center of a newly established territory. It also has a covey location, which may or may not coincide with the peg position. The covey can move some distance away from the peg, given by an 'elastic' function of distance between covey (physical) and the virtual territory center 'peg'. If a partridge would like to assess the quality of a hypothetial territory centeret at its current (covey) position, it will call Partridge_Covey::AssessHabitatQuality and make decisions on suitability depending on the value returned. The size of the potential territory evaluated is the minimum of the distance to the closest neighbour peg and a configurable maximum territory radius, Partridge_All.cpp::cfg_par_terr_max_width.

Definition at line 90 of file Partridge_Covey.h.

Constructor & Destructor Documentation

◆ Partridge_Covey()

Partridge_Covey::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
	)

Constructor.

Definition at line 1977 of file Partridge_Covey.cpp.

                                                                            : TAnimal( a_center_x, a_center_y, a_map ) {
        m_id = g_covey_id_counter++;
        m_map = a_map;
        m_width = a_map->SupplySimAreaWidth();
        m_height = a_map->SupplySimAreaHeight();
  
        m_maxAllowedMove = 1000; // default values
        m_maxFoodNeedToday = 10000; // default values
  
        m_manager = a_manager;
        m_center_x = a_center_x;
        m_center_y = a_center_y;
        m_center_x_float = ( double )m_center_x;
        m_center_y_float = ( double )m_center_y;
        m_covey_x = a_center_x;
        m_covey_y = a_center_y;
  
        m_nest_on_nest = false, m_nest_x = m_center_x; // Shouldn't matter.
        m_nest_y = m_center_y; //       "
  
        m_step_done = false;
        m_permanent_marker = false;
        m_move_done = false;
        m_dist_moved = 0.0; // Shouldn't matter.
        m_food_today = 0.0; //       "
        m_flyto_dist = -1;
  
        m_assess_done = false;
        //m_assess_qual  = 0.0;          // Shouldn't matter.
        m_assess_size = 0;
  
        m_terr_done = false;
        //m_terr_qual    = 0.0;          // Shouldn't matter.
        // Actually this matters if we start moving before
        // choosing a territory.
        m_terr_size = g_par_terr_max_width.value();
  
        m_dist_done = false;
        m_nearest_covey_dist = sqrt( ( double )m_width * m_height );
        m_peg_is_fixed = false;
        m_essence_low = false;
        m_force_low = true;
  
        //m_move_get_enable = false;
  
        /* m_members.resize( 1 ); */
        if ( a_first_member ) {
          m_members_size = 1;
          m_members[ 0 ] = a_first_member;
        } else {
          m_members_size = 0;
        }
  
        for ( int i = 0; i < MOVE_QUAL_HIST_SIZE; i++ ) {
          m_move_qual_hist[ 0 ] [ i ] = 0;
          m_move_qual_hist[ 1 ] [ i ] = 0;
          m_move_qual_hist[ 2 ] [ i ] = 0;
          m_move_qual_hist[ 3 ] [ i ] = 0;
        }
  
        m_move_qual_memory[ 0 ] = 0;
        m_move_qual_memory[ 1 ] = 0;
        m_move_qual_memory[ 2 ] = 0;
        m_move_qual_memory[ 3 ] = 0;
  
        MoveVegConstInit();
        CoveyUpdateMemberPositions( a_center_x, a_center_y );
  
        if ( g_covey_manager == NULL ) {
          g_covey_manager = new CoveyManager( m_map->SupplySimAreaWidth(), m_map->SupplySimAreaHeight(), m_map );
        }
        g_covey_manager->AddCovey( this );
  
        if ( a_manager )
          a_manager->AddObject( pob_Covey, this );
  
        m_state = pars_CoveyBeing;
        m_move_whence_we_came = random( 8 );
        m_move_step_size = 1;
        m_move_step_size_inv = 1.0;
        m_CoveyDissolveDate = -1; // never do it
        m_ourChicks = 0; // don't start with chicks or parents
        m_theDad = NULL;
        m_theMum = NULL;
 }

References CoveyManager::AddCovey(), Partridge_Population_Manager::AddObject(), CoveyUpdateMemberPositions(), g_covey_id_counter, g_covey_manager, g_par_terr_max_width, m_assess_done, m_assess_size, m_center_x, m_center_x_float, m_center_y, m_center_y_float, m_covey_x, m_covey_y, m_CoveyDissolveDate, m_dist_done, m_dist_moved, m_essence_low, m_flyto_dist, m_food_today, m_force_low, m_height, m_id, m_manager, m_map, m_maxAllowedMove, m_maxFoodNeedToday, m_members, m_members_size, m_move_done, m_move_qual_hist, m_move_qual_memory, m_move_step_size, m_move_step_size_inv, m_move_whence_we_came, m_nearest_covey_dist, m_nest_on_nest, m_nest_x, m_nest_y, m_ourChicks, m_peg_is_fixed, m_permanent_marker, m_state, m_step_done, m_terr_done, m_terr_size, m_theDad, m_theMum, m_width, MoveVegConstInit(), pars_CoveyBeing, pob_Covey, Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), and CfgInt::value().

◆ ~Partridge_Covey()

Partridge_Covey::~Partridge_Covey ( void )

virtual

Destructor.

Definition at line 1971 of file Partridge_Covey.cpp.

                                         {
   g_covey_manager->DelCovey( this );
 }

References CoveyManager::DelCovey(), and g_covey_manager.

Member Function Documentation

◆ ActOnParentDeath()

void Partridge_Covey::ActOnParentDeath ( void )

Determine the chick mortality on parent death.

Determines the probability of mortality following the death of a parent. This will depend on the age of the chicks and whether it is one or both parents that die and whether there are aunts or uncles present.

If we need to use aunts and uncles or if there is only one parent left then we assume only 8 chicks max can be brooded. The rest die, and the 8 are subject to a mortality probability.

Definition at line 2516 of file Partridge_Covey.cpp.

                                              {
   int age = SupplyChickAge(); // depends on the fact that only one set of chicks
   if ( age >= cfg_par_parentdead_age2.value() ) return; // Old enough to cope
   if ( ( !m_theMum ) && ( !m_theDad ) ) {
     // Both parents dead - so need to look for uncles
     if ( GetUncleNumber()  > 0 ) { // Can use an uncle or aunt
         SetUncle();
     } else
         KillChicks( 100 );
         return;
   }
   // depends on the fact that only one set of chicks
   // can be in the covey at any one time.
   if ( age < cfg_par_parentdead_age1.value() ) {
     KillExcessChicks( 8 ); // removes any chicks in excess of 8
     KillChicks( cfg_par_parentdead_mort.value() );
   } else if ( age < cfg_par_parentdead_age2.value() )
     KillChicks( cfg_par_parentdead_mort.value() );
 }

References cfg_par_parentdead_age1, cfg_par_parentdead_age2, cfg_par_parentdead_mort, GetUncleNumber(), KillChicks(), KillExcessChicks(), m_theDad, m_theMum, SetUncle(), SupplyChickAge(), and CfgInt::value().

Referenced by OntheDadDead(), and OntheMumDead().

◆ AddMember()

void Partridge_Covey::AddMember ( Partridge_Base * a_new_member )

Definition at line 1644 of file Partridge_Covey.cpp.

                                                                {
   if ( m_CurrentStateNo == -1 ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::AddMember(): ""Attempting to add a member to non-existent flock!", "" );
     exit( 1 );
   }
   if ( IsMember( a_new_member ) ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::AddMember(): ""Attempting to add a member already belonging to the flock!", "" );
     exit( 1 );
   }
   if ( m_members_size>=99 ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::AddMember(): ""Covey too big!", "" );
     exit( 1 );
   }
   //m_members.resize( m_members.size() + 1 );
   m_members_size++;
   m_members[ m_members_size - 1 ] = a_new_member;
 }

References g_msg, IsMember(), TALMaSSObject::m_CurrentStateNo, m_members, m_members_size, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by ManagerCheckMerge(), Partridge_Base::Partridge_Base(), and Partridge_Base::SwitchCovey().

◆ AllFlocking()

bool Partridge_Covey::AllFlocking ( )

Debug method.

Definition at line 2362 of file Partridge_Covey.cpp.

                                   {
   for ( unsigned i = 0; i < m_members_size; i++ ) {
     if ( ( m_members[ i ]->GetState() != pars_MFlocking ) && ( m_members[ i ]->GetState() != pars_FFlocking ) ) {
       return false;
     }
   }
   return true;
 }

References m_members, m_members_size, pars_FFlocking, and pars_MFlocking.

Referenced by CanWeMerge().

◆ AllFlocking2()

bool Partridge_Covey::AllFlocking2 ( )

Debug method.

Definition at line 2373 of file Partridge_Covey.cpp.

                                    {
   for ( unsigned i = 0; i < m_members_size; i++ ) {
     if ( ( m_members[ i ]->GetState() != pars_MFlocking ) && ( m_members[ i ]->GetState() != pars_FFlocking ) ) {
       return false;
     }
   }
   return true;
 }

References m_members, m_members_size, pars_FFlocking, and pars_MFlocking.

Referenced by Partridge_Population_Manager::DissolveCovey().

◆ ArePaired()

bool Partridge_Covey::ArePaired ( )

Debug method.

Definition at line 2384 of file Partridge_Covey.cpp.

                                 {
   Partridge_Male * MP;
   Partridge_Female * FP;
   for ( unsigned i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Male ) {
       MP = dynamic_cast < Partridge_Male * > ( m_members[ i ] );
       if ( MP->GetMate() )
         return false;
     } else if ( m_members[ i ]->GetObjectType() == pob_Female ) {
       FP = dynamic_cast < Partridge_Female * > ( m_members[ i ] );
       if ( FP->GetMate() )
         return false;
     }
   }
   return true;
 }

References Partridge_Male::GetMate(), Partridge_Female::GetMate(), GetObjectType(), m_members, m_members_size, pob_Female, and pob_Male.

Referenced by CoveyIndividualEmigrate(), and Partridge_Population_Manager::DissolveCovey().

◆ AssessGetSize()

int Partridge_Covey::AssessGetSize ( void )

inline

Get the size ('radius') used during territory evaluation.

Definition at line 554 of file Partridge_Covey.h.

                             {
     return m_assess_size;
   }

References m_assess_size.

◆ AssessHabitatQuality()

double Partridge_Covey::AssessHabitatQuality ( int & a_sz )

Assess habitat quality (with checks)

Definition at line 1059 of file Partridge_Covey.cpp.

                                                          {
   if ( !m_assess_done ) {
     m_assess_qual = HabitatEvaluate( m_covey_x, m_covey_y, & m_assess_size, true );
     m_assess_done = true;
   }
   a_sz = m_assess_size;
   return m_assess_qual;
 }

References HabitatEvaluate(), m_assess_done, m_assess_qual, m_assess_size, m_covey_x, and m_covey_y.

Referenced by FixHabitat().

◆ AssessHabitatQualityFaster()

double Partridge_Covey::AssessHabitatQualityFaster ( )

Assess habitat quality (efficient)

Definition at line 1068 of file Partridge_Covey.cpp.

                                                    {
   m_assess_qual = HabitatEvaluateFaster( m_covey_x, m_covey_y );
   m_assess_done = true;
   return m_assess_qual;
 }

References HabitatEvaluateFaster(), m_assess_done, m_assess_qual, m_covey_x, and m_covey_y.

Referenced by Partridge_Female::FFindingTerritory().

◆ BeginStep()

void Partridge_Covey::BeginStep ( void )

virtual

Covey BeginStep.

Reimplemented from TAnimal.

Definition at line 1583 of file Partridge_Covey.cpp.

                                       {
   if ( m_CurrentStateNo == -1 ) return;
   // Determine the movement distances and food requirements
   // Depends on the age of the chick
   //
   int age;
   // do we have any chicks?
   if ( GetOurChicks() > 0 ) {
     // if so then food requiremtns are dependent upon them
     age = m_ChickAge; // This set daily by the chicks
   }
   // otherwise then it is adult requirements
   age = cfg_par_mature_threshold.value();
   m_maxFoodNeedToday = g_FoodNeed[ age ];
  
   if ( m_state == pars_CoveyDissolve ) {
     if ( m_OurLandscape->SupplyDayInYear() >= m_CoveyDissolveDate ) {
       m_manager->DissolveCovey( this );
       m_state = pars_CoveyBeing;
       m_CoveyDissolveDate = -1;
     }
   }
 }

References cfg_par_mature_threshold, Partridge_Population_Manager::DissolveCovey(), g_FoodNeed, GetOurChicks(), m_ChickAge, m_CoveyDissolveDate, TALMaSSObject::m_CurrentStateNo, m_manager, m_maxFoodNeedToday, TAnimal::m_OurLandscape, m_state, pars_CoveyBeing, pars_CoveyDissolve, Landscape::SupplyDayInYear(), and CfgInt::value().

◆ CanWeMerge()

bool Partridge_Covey::CanWeMerge ( int a_NoUncles )

Merging test.

Definition at line 1833 of file Partridge_Covey.cpp.

                                                    {
     // The rules are that if we have no chicks then we can have up to 8 'uncles'
     // Otherwise only 4 are allowed.
     // The answer is no if we are still busy
     if ( !AllFlocking() ) return false;
     // Otherwise it depends on the number of uncles etc.
     int UncleNumber = GetUncleNumber();
     if ( m_ourChicks > 0 ) {
         if ( (UncleNumber + a_noOfUncles) > 4 ) return false;
     }
     else
         if ( m_map->SupplyDayInYear() < June ) {
             if ( (UncleNumber + a_noOfUncles) > 4 ) {
                 return false;
             }
         } else if ( (UncleNumber + a_noOfUncles) > 8 ) return false;
     // This code is not perfect - it would allow up to 8 Uncles after all chicks have
     // matured. To stop this merging to >4 is only allowed between June and Dec 31st
     return true;
 }

References AllFlocking(), GetUncleNumber(), June, m_map, m_ourChicks, and Landscape::SupplyDayInYear().

Referenced by ManagerCheckMerge().

◆ ChickExtraMortality()

void Partridge_Covey::ChickExtraMortality ( )

Apply extra chick mortality.

Definition at line 2671 of file Partridge_Covey.cpp.

                                           {
   for ( int i = m_members_size - 1; i >= 0; i-- ) {
     if ( m_members[ i ]->GetObjectType() == pob_Chick ) {
       if (random(10000) <cfg_par_chick_extra_mort.value()) {
         dynamic_cast < Partridge_Chick * > ( m_members[ i ] )->OnYouAreDead();
     }
   }
 }
 }

References cfg_par_chick_extra_mort, GetObjectType(), m_members, m_members_size, pob_Chick, and CfgInt::value().

Referenced by Partridge_Chick::BeginStep().

◆ CoveyEmigrate()

bool Partridge_Covey::CoveyEmigrate ( void )

Test for covey emigration.

Emigration is a loss to the system, so this just kills everyone in the covey.

Definition at line 2642 of file Partridge_Covey.cpp.

                                           {
     for ( unsigned i = m_members_size; i >0; i-- ) {
         m_members[i-1]->Dying();
     }
     return true;
 }

References TAnimal::Dying(), m_members, and m_members_size.

◆ CoveyIndividualEmigrate()

void Partridge_Covey::CoveyIndividualEmigrate ( void )

Test for individuals from covey emigrating.

Chance of each individual emigrating if they are not paired (emigration kills them just to remove them from the system - this is safe because if unpaired there will be no knock-on effects).

Definition at line 2655 of file Partridge_Covey.cpp.

                                                     {
     for ( unsigned i = m_members_size; i >0; i-- ) {
         if (!m_members[i-1]->ArePaired()) {
             if (random(10000)<cfg_IndividualEmigration.value()) {
                 m_members[i-1]->Dying();
             }
         }
     }
 }

References ArePaired(), cfg_IndividualEmigration, TAnimal::Dying(), m_members, m_members_size, and CfgInt::value().

◆ CoveyUpdateMemberPositions()

void Partridge_Covey::CoveyUpdateMemberPositions	(	int	a_x,
		int	a_y
	)

protected

Update all covey members x,y coords.

Sets all covey members to the location a_x, a_y and sets the covey x,y coords to this too.

Definition at line 1093 of file Partridge_Covey.cpp.

                                                                    {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     m_members[ i ]->SetX( a_x );
     m_members[ i ]->SetY( a_y );
   }
   m_Location_x = a_x;
   m_Location_y = a_y;
 }

References TAnimal::m_Location_x, TAnimal::m_Location_y, m_members, m_members_size, TAnimal::SetX(), and TAnimal::SetY().

Referenced by FlyTo(), MoveDistance(), MoveTo(), NestFindFast(), NestFindSlow(), and Partridge_Covey().

◆ DistanceToCovey()

double Partridge_Covey::DistanceToCovey ( Partridge_Covey * a_covey )

protected

Get distance too covey.

Definition at line 1319 of file Partridge_Covey.cpp.

                                                                    {
   double dx = m_center_x_float - a_covey->XCenterF();
   double dy = m_center_y_float - a_covey->YCenterF();
   // Divide by two becuase the maximum distance we can be away is half the world
   // in our wrap-around world
   double wf = ( double )( m_width >> 1 );
   double hf = ( double )( m_height >> 1 );
   // We need positive numbers
   if ( dx < 0 )
     dx = -dx;
   if ( dy < 0 )
     dy = -dy;
   // but we don't need numbers bigger than half the world
   if ( dx > wf )
     dx = m_width - dx;
   if ( dy > hf )
     dy = m_height - dy;
   // The next bit just makes sure that nothing goes out of whack by being too
   //small
   if ( dx < MIN_MATH_DIST_SQ ) {
     dx = MIN_MATH_DIST_SQ + ( double )( random( 100 ) ) / 100.0;
   }
   if ( dy < MIN_MATH_DIST_SQ ) {
     dy = MIN_MATH_DIST_SQ + ( double )( random( 100 ) ) / 100.0;
   }
   // Returns the squasre of the short sides or 0.0001, whichever is bigger
   return max( dx * dx + dy * dy, MIN_MATH_DIST_SQ );
 }

References m_center_x_float, m_center_y_float, m_height, m_width, XCenterF(), and YCenterF().

Referenced by DistanceUpdate(), and DistanceUpdate2().

◆ DistanceUpdate()

void Partridge_Covey::DistanceUpdate ( void )

protected

Updates distance to nearest covey.

Sorts through the list of nearby coveys and finds the distance to the nearest. Stores the square root of this value.

Definition at line 1301 of file Partridge_Covey.cpp.

                                            {
   m_nearest_covey_dist = ( double )( m_width * m_height );
  
   for ( unsigned int i = 0; i < g_covey_list.size(); i++ ) {
     if ( m_id == g_covey_list[ i ]->ID() ) {
       continue;
     }
     double dist = DistanceToCovey( g_covey_list[ i ] );
     if ( dist < m_nearest_covey_dist ) {
       m_nearest_covey_dist = dist;
     }
   }
   m_nearest_covey_dist = sqrt( m_nearest_covey_dist );
 }

References DistanceToCovey(), g_covey_list, ID(), m_height, m_id, m_nearest_covey_dist, and m_width.

Referenced by HabitatEvaluate(), and MoveDistance().

◆ DistanceUpdate2()

void Partridge_Covey::DistanceUpdate2 ( void )

protected

Updates distance to fixed nearest covey.

Sorts through the list of nearby coveys and finds the distance to the nearest that is fixed. Stores the square root of this value.

Definition at line 1281 of file Partridge_Covey.cpp.

                                             {
   m_nearest_covey_dist = ( double )( m_width * m_height );
  
   for ( unsigned int i = 0; i < g_covey_list.size(); i++ ) {
     if ( m_id == g_covey_list[ i ]->ID() ) {
       continue;
     }
     if ( g_covey_list[ i ]->IsFixed() ) {
       double dist = DistanceToCovey( g_covey_list[ i ] );
       if ( dist < m_nearest_covey_dist ) {
         m_nearest_covey_dist = dist;
       }
     }
   }
   m_nearest_covey_dist = sqrt( m_nearest_covey_dist );
 }

References DistanceToCovey(), g_covey_list, ID(), IsFixed(), m_height, m_id, m_nearest_covey_dist, and m_width.

Referenced by TooClose().

◆ EndStep()

void Partridge_Covey::EndStep ( void )

virtual

Covey EndStep.

Reimplemented from TAnimal.

Definition at line 1616 of file Partridge_Covey.cpp.

                                     {
   if ( m_CurrentStateNo == -1 ) return;
   m_step_done = false;
   m_move_done = false;
   m_assess_done = false;
   m_terr_done = false;
 }

References m_assess_done, TALMaSSObject::m_CurrentStateNo, m_move_done, m_step_done, and m_terr_done.

◆ FindMateInArea()

Partridge_Female * Partridge_Covey::FindMateInArea ( int a_max_distance )

Find mate in area.

Loops through the males in the simulation, find first one in state pars_FAttractingMate and within distance a_max_distance, NULL if none.

Definition at line 1561 of file Partridge_Covey.cpp.

                                                                        {
   int l_dsq = a_max_distance * a_max_distance;
  
   TAnimal * l_candidate;
  
   m_manager->ObjectLoopInit( pob_Female );
  
   l_candidate = m_manager->ObjectLoopFetch();
   while ( l_candidate ) {
     if ( dynamic_cast < Partridge_Base * > ( l_candidate )->GetState() == pars_FAttractingMate ) {
       int l_dx = m_covey_x - l_candidate->Supply_m_Location_x();
       int l_dy = m_covey_y - l_candidate->Supply_m_Location_y();
       if ( ( l_dx * l_dx + l_dy * l_dy ) < l_dsq ) {
         return dynamic_cast < Partridge_Female * > ( l_candidate );
       }
     }
     l_candidate = m_manager->ObjectLoopFetch();
   }
   return NULL;
 }

References m_covey_x, m_covey_y, m_manager, Partridge_Population_Manager::ObjectLoopFetch(), Partridge_Population_Manager::ObjectLoopInit(), pars_FAttractingMate, pob_Female, TAnimal::Supply_m_Location_x(), and TAnimal::Supply_m_Location_y().

Referenced by Partridge_Male::MFindingMate().

◆ FindMeAHusband()

Partridge_Male * Partridge_Covey::FindMeAHusband ( Partridge_Female * a_female )

Find mate in covey.

Find mate within the covey (if possible). Return NULL if not.

Definition at line 1534 of file Partridge_Covey.cpp.

                                                                               {
   Partridge_Male * l_male;
 #ifdef __PAR_DEBUG2
   if ( a_male->GetMate() ) {
     int rubbish = 0;
   }
 #endif
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( (m_members[ i ]->GetFamily() != a_female->GetFamily()) && (m_members[ i ]->GetObjectType() == pob_Male )) {
       l_male = dynamic_cast < Partridge_Male * > ( m_members[ i ] );
       if ( !l_male->GetMate() ) return l_male;
     }
   }
   return NULL;
 }

References Partridge_Base::GetFamily(), Partridge_Male::GetMate(), GetObjectType(), m_members, m_members_size, and pob_Male.

◆ FindMeAMateInCovey()

Partridge_Female * Partridge_Covey::FindMeAMateInCovey ( int a_family_counter )

Is their a suitable female mate in the covey?

Definition at line 2334 of file Partridge_Covey.cpp.

                                                                              {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Female ) {
       Partridge_Female * pf = dynamic_cast < Partridge_Female * > ( m_members[ i ] );
       // Does she have an oldMate
       if ( pf->GetMate() == NULL ) {
         if ( pf->GetFamily() != a_family_counter )
           return pf;
       }
     }
   }
   return NULL;
 }

References Partridge_Base::GetFamily(), Partridge_Female::GetMate(), GetObjectType(), m_members, m_members_size, and pob_Female.

Referenced by Partridge_Male::MFindingMate().

◆ FindMeAWife()

Partridge_Female * Partridge_Covey::FindMeAWife ( Partridge_Male * a_male )

Find mate in covey.

Find mate within the covey (if possible). Return NULL if not.

Definition at line 1518 of file Partridge_Covey.cpp.

                                                                          {
   Partridge_Female * l_female;
 #ifdef __PAR_DEBUG2
   if ( a_female->GetMate() ) {
     int rubbish = 0;
   }
 #endif
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( ( m_members[ i ]->GetFamily() != a_male->GetFamily() ) && ( m_members[ i ]->GetObjectType() == pob_Female ) ) {
       l_female = dynamic_cast < Partridge_Female * > ( m_members[ i ] );
       if ( !l_female->GetMate() ) return l_female;
     }
   }
   return NULL;
 }

References Partridge_Base::GetFamily(), Partridge_Female::GetMate(), GetObjectType(), m_members, m_members_size, and pob_Female.

◆ FindNeighbour()

Partridge_Covey * Partridge_Covey::FindNeighbour ( )

Finds the closest other covey.

Definition at line 2290 of file Partridge_Covey.cpp.

                                                  {
   // If there are no neighbours then do nothing
   if ( m_neighbourlist_size < 1 ) return NULL;
   int neighbour = random( m_neighbourlist_size );
   /* DEBUG
   if ( m_neighbourlist[ neighbour ]->m_CurrentStateNo == -1 ) {
     int rubbish = 0;
   }
   // END DEBUG */
   return m_neighbourlist[ neighbour ];
 }

References m_neighbourlist, and m_neighbourlist_size.

Referenced by Partridge_Male::MFindingMate().

◆ FixHabitat()

void Partridge_Covey::FixHabitat ( void )

Accept this breeding location.

If the quality is found to be good enough, the animal can decide to use it for its own by calling this method.
This updates the peg position to that of the animal, and updates internal state in accordance with it. After FixTerritory() any subsequent calls to Partridge_Covey::SupplyHabitatQuality() will give the quality on the basis of the same size but possibly drifted pushed peg location from the values used in the recent call to Partridge_Covey::AssessTerritoryQuality.

Definition at line 1074 of file Partridge_Covey.cpp.

                                        {
   int sz = 0;
   if ( !m_assess_done ) {
     AssessHabitatQuality( sz );
   }
   m_center_x = m_covey_x;
   m_center_y = m_covey_y;
   m_center_x_float = ( double )m_covey_x;
   m_center_y_float = ( double )m_covey_y;
   m_terr_done = true;
   m_terr_size = m_assess_size;
   m_terr_qual = m_assess_qual;
   m_move_done = false;
 }

References AssessHabitatQuality(), m_assess_done, m_assess_qual, m_assess_size, m_center_x, m_center_x_float, m_center_y, m_center_y_float, m_covey_x, m_covey_y, m_move_done, m_terr_done, m_terr_qual, and m_terr_size.

Referenced by Partridge_Female::FFindingTerritory().

◆ FlyTo()

bool Partridge_Covey::FlyTo ( int a_distance )

Fly to

Fly to a random, new location a_distance away. Only allowed if the size of the covey is 1.

Definition at line 1484 of file Partridge_Covey.cpp.

                                             {
   // New version, 4/8-2003.
  
   if ( a_distance <= 0 )
     return false;
  
   bool l_did_move = false;
  
   // The additional '2' is to ensure that rounding
   // in the calculations to follow will not cause
   // problems.
   if ( m_covey_x - a_distance - 2 >= 0 && m_covey_x + a_distance + 2 < m_width && m_covey_y - a_distance - 2 >= 0
        && m_covey_y + a_distance + 2 < m_height ) {
          l_did_move = FlyToFast( a_distance );
   } else {
     l_did_move = FlyToSlow( a_distance );
   }
  
   if ( l_did_move ) {
     m_covey_x = m_center_x;
     m_covey_y = m_center_y;
     m_terr_done = false;
     m_move_done = false;
     m_assess_done = false;
     m_dist_done = false;
     m_center_x_float = ( double )m_center_x;
     m_center_y_float = ( double )m_center_y;
  
     CoveyUpdateMemberPositions( m_center_x, m_center_y );
     return true;
   }
   else return false;
 }

References CoveyUpdateMemberPositions(), FlyToFast(), FlyToSlow(), m_assess_done, m_center_x, m_center_x_float, m_center_y, m_center_y_float, m_covey_x, m_covey_y, m_dist_done, m_height, m_move_done, m_terr_done, and m_width.

Referenced by Partridge_Female::FFindingTerritory(), and Partridge_Male::MFindingMate().

◆ FlyToFast()

bool Partridge_Covey::FlyToFast ( int a_distance )

protected

Move a_distance from current covey position.

Definition at line 1349 of file Partridge_Covey.cpp.

                                                 {
     // The distance we want to move as a double.
     double l_dist = ( double )a_distance;
  
   // Table Step size, as a double. Calculated so that
   // the difference in distance between points
   // around the perimeter of our scanning circle
   // are approximately 1 meter apart.
   // Eeewww... divisions... Avoid as far as possible.
   if ( a_distance != m_flyto_dist ) {
     m_flyto_dist = a_distance;
     m_flyto_steps = ( int )( floor( l_dist * TWO_PI ) );
     if ( cfg_par_flyto_stepsize.value() > 1 )
       m_flyto_steps /= cfg_par_flyto_stepsize.value();
  
     m_flyto_ts = ( double )cfg_par_flyto_stepsize.value() * ( double )TRIG_TABLE_LENGTH / ( l_dist * TWO_PI );
   }
  
   // Table Step Sum. Set to random start value, corresponding
   // to a random angle around the circle.
   double l_tss = ( double )random( TRIG_TABLE_LENGTH );
  
   bool l_found = false;
   int l_new_x = -1;
   int l_new_y = -1;
   int l_poly_cache = -1;
   int l_dx_cache = -20000;
   int l_dy_cache = -20000;
  
   for ( int i = 0; i < m_flyto_steps; i++ ) {
     if ( l_tss > ( double )( TRIG_TABLE_LENGTH - 1 ) ) {
       l_tss = 0.000001;
     }
     int index = ( int )floor( l_tss );
     l_tss += m_flyto_ts;
  
     int dx = ( int )floor( l_dist * g_trig_cos[ index ] + 0.5 );
     int dy = ( int )floor( l_dist * g_trig_sin[ index ] + 0.5 );
  
     if ( dx == l_dx_cache && dy == l_dy_cache )
       continue;
     l_dx_cache = dx;
     l_dy_cache = dy;
     int x = m_covey_x + dx;
     int y = m_covey_y - dy;
  
     int l_poly = m_map->SupplyPolyRef( x, y );
     if ( l_poly != l_poly_cache ) {
       l_poly_cache = l_poly;
       int l_geo = MoveCanMove( m_map->SupplyElementType( l_poly ) );
       if ( l_geo == 1 ) {
         // Excellent terrain found. Stop immediately.
         m_center_x = x;
         m_center_y = y;
         return true;
       } else if ( l_geo == 0 && l_new_x == -1 ) {
         // Remember first acceptable location if we cannot do better.
         l_new_x = x;
         l_new_y = y;
         l_found = true;
       }
     }
   }
  
   // If we get this far, then we only might have found something
   // acceptable place to move, though not good.
   if ( l_found ) {
     m_center_x = l_new_x;
     m_center_y = l_new_y;
   }
   return l_found;
 }

References cfg_par_flyto_stepsize, g_trig_cos, g_trig_sin, m_center_x, m_center_y, m_covey_x, m_covey_y, m_flyto_dist, m_flyto_steps, m_flyto_ts, m_map, MoveCanMove(), Landscape::SupplyElementType(), Landscape::SupplyPolyRef(), TRIG_TABLE_LENGTH, and CfgInt::value().

Referenced by FlyTo().

◆ FlyToSlow()

bool Partridge_Covey::FlyToSlow ( int a_distance )

protected

Move a_distance from current covey position (wraparound)

Definition at line 1422 of file Partridge_Covey.cpp.

                                                 {
   double l_dist = ( double )a_distance;
  
   if ( a_distance != m_flyto_dist ) {
     m_flyto_dist = a_distance;
     m_flyto_steps = ( int )( floor( l_dist * TWO_PI ) );
     if ( cfg_par_flyto_stepsize.value() > 1 )
       m_flyto_steps /= cfg_par_flyto_stepsize.value();
  
     m_flyto_ts = ( double )cfg_par_flyto_stepsize.value() * ( double )TRIG_TABLE_LENGTH / ( l_dist * TWO_PI );
   }
  
   double l_tss = ( double )random( TRIG_TABLE_LENGTH );
  
   bool l_found = false;
   int l_new_x = -1;
   int l_new_y = -1;
   int l_poly_cache = -1;
   int l_dx_cache = -20000;
   int l_dy_cache = -20000;
  
   for ( int i = 0; i < m_flyto_steps; i++ ) {
     if ( l_tss > ( double )( TRIG_TABLE_LENGTH - 1 ) ) {
       l_tss = 0.000001;
     }
     int index = ( int )floor( l_tss );
     l_tss += m_flyto_ts;
  
     int dx = ( int )floor( l_dist * g_trig_cos[ index ] + 0.5 );
     int dy = ( int )floor( l_dist * g_trig_sin[ index ] + 0.5 );
  
     if ( dx == l_dx_cache && dy == l_dy_cache )
       continue;
     l_dx_cache = dx;
     l_dy_cache = dy;
     int x = Norm( m_covey_x + dx, m_width );
     int y = Norm( m_covey_y - dy, m_height );
  
     int l_poly = m_map->SupplyPolyRef( x, y );
     if ( l_poly != l_poly_cache ) {
       l_poly_cache = l_poly;
       int l_geo = MoveCanMove( m_map->SupplyElementType( l_poly ) );
       if ( l_geo == 1 ) {
         m_center_x = x;
         m_center_y = y;
         return true;
       } else if ( l_geo == 0 && l_new_x == -1 ) {
         l_new_x = x;
         l_new_y = y;
         l_found = true;
       }
     }
   }
  
   if ( l_found ) {
     m_center_x = l_new_x;
     m_center_y = l_new_y;
   }
   return l_found;
 }

References cfg_par_flyto_stepsize, g_trig_cos, g_trig_sin, m_center_x, m_center_y, m_covey_x, m_covey_y, m_flyto_dist, m_flyto_steps, m_flyto_ts, m_height, m_map, m_width, MoveCanMove(), Norm(), Landscape::SupplyElementType(), Landscape::SupplyPolyRef(), TRIG_TABLE_LENGTH, and CfgInt::value().

Referenced by FlyTo().

◆ ForceLow()

bool Partridge_Covey::ForceLow ( void )

inline

Definition at line 703 of file Partridge_Covey.h.

                       {
     return m_force_low;
 }

References m_force_low.

◆ GetAMember()

Partridge_Base * Partridge_Covey::GetAMember ( )

Returns a random member.

Definition at line 1634 of file Partridge_Covey.cpp.

                                              {
   return m_members[ 0 ];
 }

References m_members.

Referenced by ManagerCheckMerge().

◆ GetChickAge()

int Partridge_Covey::GetChickAge ( )

inline

Return chick age.

Definition at line 486 of file Partridge_Covey.h.

                     {
     return m_ChickAge;
   }

References m_ChickAge.

Referenced by Partridge_Female::FCaringForYoung(), and Partridge_Male::MCaringForYoung().

◆ GetCoveySize()

unsigned int Partridge_Covey::GetCoveySize ( )

inline

Return the covey size.

Definition at line 476 of file Partridge_Covey.h.

                               {
     return m_members_size;
   }

References m_members_size.

Referenced by Partridge_Male::DailyMortality(), Partridge_Female::DailyMortality(), Partridge_Population_Manager::DissolveCovey(), ManagerCheckMerge(), and Partridge_Male::MFindingMate().

◆ GetMaleInCovey()

Partridge_Male * Partridge_Covey::GetMaleInCovey ( )

Find a male in the covey.

Definition at line 2323 of file Partridge_Covey.cpp.

                                                  {
     for ( unsigned int i = 0; i < m_members_size; i++ ) {
         if ( m_members[ i ]->GetObjectType() == pob_Male ) {
             Partridge_Male * pm = dynamic_cast < Partridge_Male * > ( m_members[ i ] );
             return pm;
         }
     }
     return NULL;
 }

References GetObjectType(), m_members, m_members_size, and pob_Male.

Referenced by Partridge_Population_Manager::DissolveCovey().

◆ GetmaxAllowedMove()

int Partridge_Covey::GetmaxAllowedMove ( )

inline

Return the max possible move distance today.

Definition at line 411 of file Partridge_Covey.h.

                           {
     return m_maxAllowedMove;
   }

References m_maxAllowedMove.

Referenced by Partridge_Female::FFlocking().

◆ GetmaxFoodNeedToday()

double Partridge_Covey::GetmaxFoodNeedToday ( )

inline

Return the maximum food need today.

Definition at line 416 of file Partridge_Covey.h.

                                {
     return m_maxFoodNeedToday;
   }

References m_maxFoodNeedToday.

Referenced by Partridge_Female::FFlocking().

◆ GetMember()

Partridge_Base * Partridge_Covey::GetMember ( int a_member )

Returns pointer to a_member.

Definition at line 1638 of file Partridge_Covey.cpp.

                                                           {
   return m_members[ a_member ];
 }

References m_members.

Referenced by Partridge_Population_Manager::DissolveCovey().

◆ GetObjectType()

Partridge_Object Partridge_Covey::GetObjectType ( void )

inline

Return object type.

Definition at line 582 of file Partridge_Covey.h.

                                          {
     return pob_Covey;
   }

References pob_Covey.

Referenced by ArePaired(), ChickExtraMortality(), FindMeAHusband(), FindMeAMateInCovey(), FindMeAWife(), GetMaleInCovey(), GetUnpairedFemale(), GetUnpairedFemale_virgin(), HaveWeChicks(), KillChicks(), KillExcessChicks(), SanityCheck2(), SanityCheck4(), SetUncle(), and SupplyChickAge().

◆ GetOurChicks()

int Partridge_Covey::GetOurChicks ( )

inline

Return the number of chicks.

Definition at line 471 of file Partridge_Covey.h.

                      {
     return m_ourChicks;
   }

References m_ourChicks.

Referenced by BeginStep(), and Partridge_Male::OnMateDying().

◆ GetUncle()

Partridge_Base* Partridge_Covey::GetUncle ( )

Find uncle in covey.

Searches the covey for any bird with the UncleStatus set as true. Or returns NULL if none.

◆ GetUncleNumber()

int Partridge_Covey::GetUncleNumber ( void )

Returns the number of uncles.

Definition at line 2560 of file Partridge_Covey.cpp.

                                           {
     int noUncs=0;
     for ( unsigned i = 0; i < m_members_size; i++ ) {
         if ( m_members[ i ]->GetUncleStatus() ) {
             noUncs++;
         }
     }
     return noUncs;
 }

References m_members, and m_members_size.

Referenced by ActOnParentDeath(), and CanWeMerge().

◆ GetUnpairedFemale()

Partridge_Female * Partridge_Covey::GetUnpairedFemale ( )

Finds the first unpaired female in the covey.

Definition at line 2304 of file Partridge_Covey.cpp.

                                                       {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Female ) {
       Partridge_Female * pf = dynamic_cast < Partridge_Female * > ( m_members[ i ] );
       // Does she have an oldMate
       if ( pf->GetOldMate() ) {
         if ( IsMember( pf->GetOldMate() ) ) {
           return pf;
         } else {
           pf->RemoveOldMate(false);
         }
       }
     }
   }
   return NULL;
 }

References GetObjectType(), Partridge_Female::GetOldMate(), IsMember(), m_members, m_members_size, pob_Female, and Partridge_Female::RemoveOldMate().

Referenced by Partridge_Population_Manager::DissolveCovey().

◆ GetUnpairedFemale_virgin()

Partridge_Female * Partridge_Covey::GetUnpairedFemale_virgin ( )

Finds the first never paired female in the covey.

Definition at line 2350 of file Partridge_Covey.cpp.

                                                              {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Female ) {
       Partridge_Female * pf = dynamic_cast < Partridge_Female * > ( m_members[ i ] );
       return pf;
     }
   }
   return NULL;
 }

References GetObjectType(), m_members, m_members_size, and pob_Female.

◆ HabitatEvalPoly()

double Partridge_Covey::HabitatEvalPoly	(	TTypesOfLandscapeElement	a_cet,
		int	a_poly
	)

protected

Definition at line 2769 of file Partridge_Covey.cpp.

                                                                                     {
   int st;
   switch ( a_cet ) {
  
     // Terrible stuff
   case tole_IndividualTree:
   case tole_PlantNursery:
   case tole_WindTurbine:
   case tole_WoodyEnergyCrop:
   case tole_WoodlandMargin:
   case tole_Pylon:
   case tole_DeciduousForest:
     case tole_MixedForest:
     case tole_ConiferousForest:
     case tole_Building:
     case tole_UrbanNoVeg:
     case tole_AmenityGrass:
       return -2.0;
  
       // Bad stuff.
     case tole_MetalledPath:
     case tole_Carpark:
     case tole_Churchyard:
     case tole_Saltmarsh:
     case tole_Stream:
     case tole_HeritageSite:
     case tole_RiversidePlants:
     case tole_RiversideTrees:
     case tole_Garden:
     case tole_Track:
     case tole_SmallRoad:
     case tole_LargeRoad:
     case tole_ActivePit:
     case tole_Pond:
     case tole_Freshwater:
     case tole_River:
     case tole_Saltwater:
     case tole_Coast:
     case tole_BareRock:
     case tole_Parkland:
     case tole_UrbanPark:
     case tole_BuiltUpWithParkland:
     case tole_SandDune:
     case tole_Copse:
         return -1.0;
  
       // Questionable.
     case tole_NaturalGrassWet:
     case tole_StoneWall:
     case tole_Fence:
     case tole_Hedges:
     case tole_Marsh:
     case tole_PitDisused:
     case tole_OrchardBand:
       return 0.0;
  
       // OK stuff
     case tole_RoadsideSlope:
     case tole_PermPasture:
     case tole_PermPastureLowYield:
       return 2.0;
     // Good Stuff
     case tole_PermPastureTussocky:
     case tole_RoadsideVerge:
     case tole_Railway:
     case tole_FieldBoundary:
     case tole_PermanentSetaside:
     case tole_NaturalGrassDry:
     case tole_YoungForest: // ?
     case tole_Heath:
     case tole_Orchard:
     case tole_MownGrass:
     case tole_Scrub:
     case tole_Vildtager:
         return cfg_terr_qual_good.value();
  
       // Really good stuff!
     case tole_BeetleBank:
         return (double) cfg_nest_hedgebank1.value();
     case tole_HedgeBank:
     st = m_OurLandscape->SupplyElementSubType( a_cet );
     switch ( st ) {
       case 0:
         return (double) cfg_nest_hedgebank0.value();
       case 1:
          return (double) cfg_nest_hedgebank1.value();
      case 2:
         return (double) cfg_nest_hedgebank2.value();
       default:
         return 100;
     }
       // Variable, depending on vegetation and condition of same.
     case tole_Field:
     case tole_UnsprayedFieldMargin:
       return (double) HabitatEvalPolyField( a_poly );
  
     default:
     g_msg->Warn( WARN_BUG, "Partridge_Covey::TerrEvalPoly(): Unknown tole type", "" );
     exit( 1 );
   }
 }

References cfg_nest_hedgebank0, cfg_nest_hedgebank1, cfg_nest_hedgebank2, cfg_terr_qual_good, g_msg, HabitatEvalPolyField(), TAnimal::m_OurLandscape, Landscape::SupplyElementSubType(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, CfgInt::value(), CfgFloat::value(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by HabitatEvaluateFast(), and HabitatEvaluateSlow().

◆ HabitatEvalPolyField()

int Partridge_Covey::HabitatEvalPolyField ( int a_field )

protected

Evaluate a field's habitat quality.

Definition at line 3028 of file Partridge_Covey.cpp.

                                                        {
  
   TTypesOfVegetation l_tov = m_map->SupplyVegType( a_field );
   int score;
   switch ( l_tov ) {
     case tov_OFirstYearDanger:
     case tov_OGrazingPigs:
     case tov_OPermanentGrassGrazed:
     case tov_PermanentGrassGrazed:
     case tov_PermanentGrassLowYield:
       score = 0;
     break;
  
     case tov_Carrots:
     case tov_FieldPeas:
     case tov_FodderBeet:
     case tov_SugarBeet:
     case tov_OFodderBeet:
     case tov_Maize:
     case tov_MaizeSilage:
     case tov_OMaizeSilage:
     case tov_NoGrowth:
     case tov_None:
     case tov_OPotatoes:
     case tov_WinterRape:
     case tov_Potatoes:
     case tov_PotatoesIndustry:
       score = 1;
     break;
  
     case tov_PermanentGrassTussocky:
     case tov_PermanentSetaside:
     case tov_FodderGrass:
     case tov_CloverGrassGrazed1:
     case tov_CloverGrassGrazed2:
     case tov_Oats:
     case tov_OOats:
     case tov_OSeedGrass1:
     case tov_OSeedGrass2:
     case tov_OSpringBarley:
     case tov_OSpringBarleyExt:
     case tov_OSpringBarleyClover:
     case tov_OSpringBarleyGrass:
     case tov_OSpringBarleyPigs:
     case tov_OTriticale:
     case tov_OWinterBarley:
     case tov_OWinterBarleyExt:
     case tov_OWinterRape:
     case tov_OWinterRye:
     case tov_OWinterWheatUndersown:
     case tov_OWinterWheat:
     case tov_SeedGrass1:
     case tov_SeedGrass2:
     case tov_SpringBarley:
     case tov_SpringBarleySpr:
     case tov_SpringBarleyPTreatment:
     case tov_SpringBarleySKManagement:
     case tov_SpringBarleyCloverGrass:
     case tov_SpringBarleyGrass:
     case tov_SpringBarleySeed:
     case tov_SpringBarleySilage:
     case tov_SpringRape:
     case tov_SpringWheat:
     case tov_Triticale:
     case tov_WinterBarley:
     case tov_WinterRye:
     case tov_WinterWheat:
     case tov_WWheatPControl:
     case tov_WWheatPToxicControl:
     case tov_WWheatPTreatment:
     case tov_AgroChemIndustryCereal:
     case tov_WinterWheatShort:
     case tov_OCloverGrassGrazed1:
     case tov_OCloverGrassGrazed2:
     case tov_OBarleyPeaCloverGrass:
     case tov_OSBarleySilage:
     case tov_OCarrots:
     case tov_OCloverGrassSilage1:
     case tov_OFieldPeas:
     case tov_OFieldPeasSilage:
     case tov_YoungForest:
     case tov_Heath:
     case tov_BroadBeans:
  
         score = 2;
     break;
  
       /*  case tov_OGrassClover1: case tov_OGrassClover2: case tov_OBarleyPeaCloverGrass: case tov_OCarrots:
       case tov_OCloverGrassGrazed1: case tov_OCloverGrassGrazed2: case tov_OCloverGrassSilage1: case tov_OFieldPeas:
       case tov_OPermanentGrassGrazed: case tov_PermanentGrassGrazed: case tov_PermanentGrassTussocky: return 3.0; */
  
     case tov_Setaside:
     case tov_NaturalGrass:
     case tov_OSetaside:
       score = 4;
     break;
  
     case tov_Undefined:
     default:
       return 0;
   }
   return score;
 }

References m_map, Landscape::SupplyVegType(), tov_AgroChemIndustryCereal, tov_BroadBeans, tov_Carrots, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FodderBeet, tov_FodderGrass, tov_Heath, tov_Maize, tov_MaizeSilage, tov_NaturalGrass, tov_NoGrowth, tov_None, tov_Oats, tov_OBarleyPeaCloverGrass, tov_OCarrots, tov_OCloverGrassGrazed1, tov_OCloverGrassGrazed2, tov_OCloverGrassSilage1, tov_OFieldPeas, tov_OFieldPeasSilage, tov_OFirstYearDanger, tov_OFodderBeet, tov_OGrazingPigs, tov_OMaizeSilage, tov_OOats, tov_OPermanentGrassGrazed, tov_OPotatoes, tov_OSBarleySilage, tov_OSeedGrass1, tov_OSeedGrass2, tov_OSetaside, tov_OSpringBarley, tov_OSpringBarleyClover, tov_OSpringBarleyExt, tov_OSpringBarleyGrass, tov_OSpringBarleyPigs, tov_OTriticale, tov_OWinterBarley, tov_OWinterBarleyExt, tov_OWinterRape, tov_OWinterRye, tov_OWinterWheat, tov_OWinterWheatUndersown, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleyCloverGrass, tov_SpringBarleyGrass, tov_SpringBarleyPTreatment, tov_SpringBarleySeed, tov_SpringBarleySilage, tov_SpringBarleySKManagement, tov_SpringBarleySpr, tov_SpringRape, tov_SpringWheat, tov_SugarBeet, tov_Triticale, tov_Undefined, tov_WinterBarley, tov_WinterRape, tov_WinterRye, tov_WinterWheat, tov_WinterWheatShort, tov_WWheatPControl, tov_WWheatPToxicControl, tov_WWheatPTreatment, and tov_YoungForest.

Referenced by HabitatEvalPoly().

◆ HabitatEvaluate()

double Partridge_Covey::HabitatEvaluate	(	int	a_center_x,
		int	a_center_y,
		int *	a_size_used,
		bool	a_rethink_size
	)

protected

Entry point for habitat evaluation.

Makes sure we have taken other covies into account then figures out which of the habitat evaluation functions to call depending how close to the edge of the world we are.
This way of doing things is used when we need to take other covies into account and cannot rely on the pre-assessed 10mgrid qualities of Partridge_Population_Manager::UpdateNestingCoverMap.

Definition at line 991 of file Partridge_Covey.cpp.

                                                                                                                 {
   if ( !m_dist_done && a_rethink_size ) {
     DistanceUpdate();
     m_dist_done = true;
   }
   // l_width_height_half
   int l_whh;
   if ( a_rethink_size ) {
     l_whh = ( ( int )m_nearest_covey_dist ) >> 1;
     if ( g_par_terr_max_width.value() < l_whh ) {
       l_whh = g_par_terr_max_width.value();
     } else if ( l_whh < 50 ) {
       l_whh = 50; // 100x100 = minimum possible size
     }
     * a_size_used = l_whh;
   } else {
     l_whh = * a_size_used;
   }
  
   int l_min_x_incl = a_center_x - l_whh;
   int l_max_x_excl = a_center_x + l_whh;
   int l_min_y_incl = a_center_y - l_whh;
   int l_max_y_excl = a_center_y + l_whh;
  
   if ( l_min_x_incl < 0 || l_max_x_excl > m_width || l_min_y_incl < 0 || l_max_y_excl > m_height ) {
     return HabitatEvaluateSlow( l_min_x_incl, l_max_x_excl, l_min_y_incl, l_max_y_excl );
   }
   return HabitatEvaluateFast( l_min_x_incl, l_max_x_excl, l_min_y_incl, l_max_y_excl );
 }

References DistanceUpdate(), g_par_terr_max_width, HabitatEvaluateFast(), HabitatEvaluateSlow(), m_dist_done, m_height, m_nearest_covey_dist, m_width, and CfgInt::value().

Referenced by AssessHabitatQuality(), and SupplyHabitatQuality().

◆ HabitatEvaluateFast()

double Partridge_Covey::HabitatEvaluateFast	(	int	a_min_x_incl,
		int	a_max_x_excl,
		int	a_min_y_incl,
		int	a_max_y_excl
	)

protected

Evaluate habitat (wrap around)

Definition at line 926 of file Partridge_Covey.cpp.

                                                                                                                     {
   int l_poly_cache = -1;
   double l_poly_value = 0.0;
   double l_qual = 0.0;
  
   for ( int y = a_min_y_incl; y < a_max_y_excl; y++ ) {
     for ( int x = a_min_x_incl; x < a_max_x_excl; x++ ) {
       // l_current_element_type
       TTypesOfLandscapeElement l_cet;
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         // New polygon. Reevaluate the
         // value of the current coordinate.
         l_cet = m_map->SupplyElementType( x, y );
         l_poly_value = HabitatEvalPoly( l_cet, l_poly );
         l_poly_cache = l_poly;
       }
       l_qual += l_poly_value;
     }
   }
   return l_qual;
 }

References HabitatEvalPoly(), m_map, Landscape::SupplyElementType(), and Landscape::SupplyPolyRef().

Referenced by HabitatEvaluate().

◆ HabitatEvaluateFaster()

double Partridge_Covey::HabitatEvaluateFaster	(	int	a_center_x,
		int	a_center_y
	)

protected

Evaluate habitat fast.

The search pattern for finding a territory is to find a place where the territory criteria are OK, then check that we are not too close to other coveys. This way of doing things is called when we want to do the job quickly using the pre-assessed qualmap array updated every week by Partridge_Population_Manager::UpdateNestingCoverMap.

Definition at line 1027 of file Partridge_Covey.cpp.

                                                                               {
   //This simply returns the territory value at a_center_x,a_center_y with a
   //radius of 50m.\n
   a_center_x =  a_center_x  / 10;
   a_center_y =  a_center_y  / 10;
   int l_min_x_incl = a_center_x - 5;
   int l_max_x_excl = a_center_x + 5;
   int l_min_y_incl = a_center_y - 5;
   int l_max_y_excl = a_center_y + 5;
  
   double qual = 0;
   if ((l_min_x_incl<0) || (l_min_y_incl<0) || (l_max_x_excl >= (m_width/10)) || (l_max_y_excl >= (m_height /10)) ) return 0; // ignore near the edge - speed fudge
   for ( int i = l_min_x_incl; i < l_min_x_incl + 5; i++ )
   {
       for ( int j = l_min_y_incl; j < l_min_y_incl + 5; j++ )
       {
         qual += m_manager->m_territoryqualmap->GetQualIndexed(i,j);
       }
   }
   return qual;
 }

References CoverTempMap::GetQualIndexed(), m_height, m_manager, Partridge_Population_Manager::m_territoryqualmap, and m_width.

Referenced by AssessHabitatQualityFaster().

◆ HabitatEvaluateSlow()

double Partridge_Covey::HabitatEvaluateSlow	(	int	a_min_x_incl,
		int	a_max_x_excl,
		int	a_min_y_incl,
		int	a_max_y_excl
	)

protected

Definition at line 952 of file Partridge_Covey.cpp.

                                                                                                                     {
   int l_poly_cache = -1;
   double l_poly_value = 0.0;
   double l_qual = 0.0;
  
   ForIterator * l_fx = new ForIterator( a_min_x_incl, a_max_x_excl, 1, 0, m_width );
   int * l_lx = l_fx->GetList();
  
   ForIterator * l_fy = new ForIterator( a_min_y_incl, a_max_y_excl, 1, 0, m_height );
   int * l_ly = l_fy->GetList();
  
   for ( int iy = 0; iy < l_fy->GetLimit(); iy++ ) {
     int y = l_ly[ iy ];
     for ( int ix = 0; ix < l_fx->GetLimit(); ix++ ) {
       int x = l_lx[ ix ];
  
       // l_current_element_type
       TTypesOfLandscapeElement l_cet;
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         // New polygon. Reevaluate the
         // value of the current coordinate.
         l_cet = m_map->SupplyElementType( x, y );
         l_poly_value = HabitatEvalPoly( l_cet, l_poly );
         l_poly_cache = l_poly;
       }
       l_qual += l_poly_value;
     }
   }
   delete l_fy;
   delete l_fx;
   return l_qual;
 }

References ForIterator::GetLimit(), ForIterator::GetList(), HabitatEvalPoly(), m_height, m_map, m_width, Landscape::SupplyElementType(), and Landscape::SupplyPolyRef().

Referenced by HabitatEvaluate().

◆ HaveWeChicks()

bool Partridge_Covey::HaveWeChicks ( void )

Check if covey contains chicks.

Relies on the fact that a covey can only have one set of chicks at a time.

Definition at line 2626 of file Partridge_Covey.cpp.

                                          {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Chick ) {
       return true;
     }
   }
   return false;
 }

References GetObjectType(), m_members, m_members_size, and pob_Chick.

◆ ID()

unsigned int Partridge_Covey::ID ( void )

inline

Definition at line 738 of file Partridge_Covey.h.

                           {
     return m_id;
   }

References m_id.

Referenced by CoveyManager::DelCovey(), DistanceUpdate(), DistanceUpdate2(), ManagerCheckMerge(), ManagerRethinkPos(), and NestNearNests().

◆ IsFixed()

bool Partridge_Covey::IsFixed ( void )

inline

Wonder whether the peg is fixed?

Definition at line 577 of file Partridge_Covey.h.

                        {
     return m_peg_is_fixed;
   }

References m_peg_is_fixed.

Referenced by DistanceUpdate2().

◆ IsMember()

bool Partridge_Covey::IsMember ( Partridge_Base * a_possible_member )

Definition at line 1709 of file Partridge_Covey.cpp.

                                                                    {
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
  
     //    if ( a_possible_member->GetID() == m_members[ i ]->GetID() ) {
     if ( a_possible_member == m_members[ i ] ) {
       return true;
     }
   }
  
   return false;
 }

References m_members, and m_members_size.

Referenced by AddMember(), Partridge_Male::AmIaMember(), GetUnpairedFemale(), and RemoveMember().

◆ KillChicks()

void Partridge_Covey::KillChicks ( int percent )

protected

Kill a proportion of the chicks.

Kills each chick if they fail a probability test.

Definition at line 2595 of file Partridge_Covey.cpp.

                                               {
   //SanityCheck2(m_ourChicks );
   for ( int i = m_members_size - 1; i >= 0; i-- ) {
     if ( m_members[ i ]->GetObjectType() == pob_Chick ) {
       if ( random( 100 ) < percent )
         dynamic_cast < Partridge_Chick * > ( m_members[ i ] )->OnYouAreDead();
     }
   }
   //SanityCheck2(m_ourChicks );
 }

References GetObjectType(), m_members, m_members_size, and pob_Chick.

Referenced by ActOnParentDeath().

◆ KillExcessChicks()

void Partridge_Covey::KillExcessChicks ( int remaining )

Kill extra chicks.

Kills chicks so that remaining remain.

Definition at line 2573 of file Partridge_Covey.cpp.

                                                       {
   // Need to figure out if we need to kill any chicks
   if ( m_ourChicks < remaining ) return;
   Partridge_Chick * pc;
   int tokill = m_ourChicks - remaining;
   for ( int decimate = 0; decimate < tokill; decimate++ ) {
     for ( unsigned i = 0; i < m_members_size; i++ ) {
       if ( m_members[ i ]->GetObjectType() == pob_Chick ) {
         pc = dynamic_cast < Partridge_Chick * > ( m_members[ i ] );
         pc->OnYouAreDead();
         break;
       }
     }
   }
   //SanityCheck2(m_ourChicks );
 }

References GetObjectType(), m_members, m_members_size, m_ourChicks, Partridge_Chick::OnYouAreDead(), and pob_Chick.

Referenced by ActOnParentDeath().

◆ LifeEssenceLow()

bool Partridge_Covey::LifeEssenceLow ( void )

inline

Definition at line 698 of file Partridge_Covey.h.

                               {
     return m_essence_low;
   }

References m_essence_low.

◆ ManagerCheckMerge() [1/2]

bool Partridge_Covey::ManagerCheckMerge ( int a_noOfUncles )

Merging test for uncle number.

◆ ManagerCheckMerge() [2/2]

void Partridge_Covey::ManagerCheckMerge ( void )

Definition at line 1794 of file Partridge_Covey.cpp.

                                               {
     // This is called by the Tick function once a day between certain dates
     // for coveys that are not doing anything special and are only 1 or 2 birds
     // Test for merging
     if ( random( 100 ) >= cfg_par_merging_chance.value() ) return; // Only one chance per day
     unsigned int sz = unsigned(g_covey_list.size());
     for ( unsigned int i = 0; i < sz; i++ ) {
         Partridge_Covey* p_pc = g_covey_list[ i ];
         // Skip ourselves.
         if ( m_id == p_pc->ID() ) {
             continue;
         }
         if ( -1 == p_pc->m_CurrentStateNo ) {
             continue;
         }
         // Are we close to someone else?
         double dx = abs( m_center_x_float - p_pc->XCenterF() );
         double dy = abs( m_center_y_float - p_pc->YCenterF() );
         if ( ( dx < cfg_min_merge_dist.value() ) && ( dy < cfg_min_merge_dist.value() ) ) {
             // OK we feel like merging - will we be allowed to?
             // First find out if the target covey is full
             if ( p_pc->CanWeMerge( m_members_size ) ) {
                 // Takes each member of a_covey and tells it to change covey
                 Partridge_Base * pb;
                 //unsigned int nu = g_covey_list[ i ]->GetCoveySize();
                 unsigned int nu = GetCoveySize(); // are we one or two or three?
                 for ( unsigned int k = 0; k < nu; k++ ) {
                     pb = GetAMember();
                     RemoveMember( pb ); //when the last is removed this covey will vanish
                     pb->SetUncleStatus( true );
                     pb->SetCovey( p_pc );
                     p_pc->AddMember( pb );
                  }
                  return; // Done
             } // Not allowed to merge if we get here
         } // end of in-distance test
     } // loop each covey (this must be optimised!)
 }

References AddMember(), CanWeMerge(), cfg_min_merge_dist, cfg_par_merging_chance, g_covey_list, GetAMember(), GetCoveySize(), ID(), m_center_x_float, m_center_y_float, TALMaSSObject::m_CurrentStateNo, m_id, m_members_size, RemoveMember(), Partridge_Base::SetCovey(), Partridge_Base::SetUncleStatus(), CfgInt::value(), CfgFloat::value(), XCenterF(), and YCenterF().

◆ ManagerDriftPos()

void Partridge_Covey::ManagerDriftPos ( void )

Definition at line 1745 of file Partridge_Covey.cpp.

                                             {
   if ( !cfg_par_covey_drift_enable.value() || m_peg_is_fixed || m_permanent_marker )
     return;
  
   double dx = ( double )m_covey_x - m_center_x_float;
   double dy = ( double )m_covey_y - m_center_y_float;
  
   double l_x_sign = 1.0;
   double l_y_sign = 1.0;
   double wf = ( double )( m_width >> 1 );
   double hf = ( double )( m_height >> 1 );
  
   if ( dx < 0.0 ) {
     dx = -dx;
     if ( dx > wf ) {
       dx = ( double )m_width - dx;
     } else {
       l_x_sign = -1.0;
     }
   } else {
     // dx > 0
     if ( dx > wf ) {
       dx = ( double )m_width - dx;
       l_x_sign = -1.0;
     }
   }
  
   if ( dy < 0.0 ) {
     dy = -dy;
     if ( dy > hf ) {
       dy = ( double )m_height - dy;
     } else {
       l_y_sign = -1.0;
     }
   } else {
     if ( dy > hf ) {
       dy = ( double )m_height - dy;
       l_y_sign = -1.0;
     }
   }
  
   double dsum = sqrt( dx * dx + dy * dy );
   if ( dsum > 0.0 ) {
     m_new_center_x_float += l_x_sign * cfg_par_covey_drift_speed.value() * dx / ( dsum );
     m_new_center_y_float += l_y_sign * cfg_par_covey_drift_speed.value() * dy / ( dsum );
   }
 }

References cfg_par_covey_drift_enable, cfg_par_covey_drift_speed, m_center_x_float, m_center_y_float, m_covey_x, m_covey_y, m_height, m_new_center_x_float, m_new_center_y_float, m_peg_is_fixed, m_permanent_marker, m_width, CfgFloat::value(), and CfgBool::value().

◆ ManagerIsPermanant()

bool Partridge_Covey::ManagerIsPermanant ( void )

inline

Unused

Is peg permanent
Not used at present

Definition at line 767 of file Partridge_Covey.h.

                                   {
     return m_permanent_marker;
   }

References m_permanent_marker.

Referenced by CoveyManager::DelCovey().

◆ ManagerRethinkPos()

void Partridge_Covey::ManagerRethinkPos ( void )

Definition at line 1855 of file Partridge_Covey.cpp.

                                               {
   m_force_low = false;
   m_new_center_x_float = m_center_x_float;
   m_new_center_y_float = m_center_y_float;
  
   if ( !cfg_par_force_enable.value() || m_peg_is_fixed || m_permanent_marker )
     return;
  
   double l_force_x = 0.0;
   double l_force_y = 0.0;
   double l_pressure_sum = 0.0;
   double wf = ( double )( m_width >> 1 );
   double hf = ( double )( m_height >> 1 );
   double l_x_sign = 1.0;
   double l_y_sign = 1.0;
  
   // Can anyone see this is a doubly nested for() loop?
   // Nah, nobody is looking... ;-)
   for ( unsigned int i = 0; i < g_covey_list.size(); i++ ) {
  
     // Skip ourselves.
     if ( m_id == g_covey_list[ i ]->ID() ) {
       continue;
     }
  
     double dx = m_center_x_float - g_covey_list[ i ]->XCenterF();
     double dy = m_center_y_float - g_covey_list[ i ]->YCenterF();
  
     if ( dx < 0.0 ) {
       dx = -dx;
       if ( dx > wf ) {
         dx = ( double )m_width - dx;
         l_x_sign = 1.0;
       } else {
         l_x_sign = -1.0;
       }
     } else {
       // dx > 0
       if ( dx > wf ) {
         dx = ( double )m_width - dx;
         l_x_sign = -1.0;
       } else {
         l_x_sign = 1.0;
       }
     }
  
     if ( dy < 0.0 ) {
       dy = -dy;
       if ( dy > hf ) {
         dy = ( double )m_height - dy;
         l_y_sign = 1.0;
       } else {
         l_y_sign = -1.0;
       }
     } else {
       if ( dy > hf ) {
         dy = ( double )m_height - dy;
         l_y_sign = -1.0;
       } else {
         l_y_sign = 1.0;
       }
     }
  
     if ( dx < MIN_MATH_DIST_SQ ) {
       dx = MIN_MATH_DIST_SQ;
     }
     if ( dy < MIN_MATH_DIST_SQ ) {
       dy = MIN_MATH_DIST_SQ;
     }
     double dist = max( dx * dx + dy * dy, MIN_MATH_DIST_SQ );
  
     if ( dist < cfg_par_force_ignore_dist_sq.value() ) {
       l_pressure_sum += Pressure( sqrt( dist ) ); // Eeewww....
       l_force_x += l_x_sign * dx / dist; // 'Hurt me plenty.'
       l_force_y += l_y_sign * dy / dist;
     }
   } // End of covey loop
  
   double l_vector_force = sqrt( l_force_x * l_force_x + l_force_y * l_force_y );
  
   if ( ( l_vector_force > g_covey_manager->Getpar_force_ignore_below() ) && ( !m_peg_is_fixed ) && ( !m_permanent_marker ) ) {
     m_new_center_x_float = m_center_x_float + l_force_x * cfg_par_force_speed.value();
     m_new_center_y_float = m_center_y_float + l_force_y * cfg_par_force_speed.value();
   }
  
   if ( l_vector_force < cfg_par_force_below.value() )
     m_force_low = true;
  
   m_essence_low = PressureLimitExceeded( l_pressure_sum );
 }

References cfg_par_force_below, cfg_par_force_enable, cfg_par_force_ignore_dist_sq, cfg_par_force_speed, g_covey_list, g_covey_manager, CoveyManager::Getpar_force_ignore_below(), ID(), m_center_x_float, m_center_y_float, m_essence_low, m_force_low, m_height, m_id, m_new_center_x_float, m_new_center_y_float, m_peg_is_fixed, m_permanent_marker, m_width, Pressure(), PressureLimitExceeded(), CfgFloat::value(), and CfgBool::value().

◆ ManagerSetPermanent()

void Partridge_Covey::ManagerSetPermanent ( void )

inline

Unused

This peg is not associated with a family entity and can never be be moved, nor deleted. It is, well, permanent.
Not used at present

Definition at line 758 of file Partridge_Covey.h.

   {
     m_permanent_marker = true;
   }

References m_permanent_marker.

◆ ManagerUpdatePos()

void Partridge_Covey::ManagerUpdatePos ( void )

Definition at line 1948 of file Partridge_Covey.cpp.

                                              {
   if ( m_peg_is_fixed || m_permanent_marker )
     return;
  
   if ( m_new_center_x_float < 0.0 )
     m_new_center_x_float += ( double )m_width; else if ( m_new_center_x_float > ( double )m_width - 1.0 )
     m_new_center_x_float -= ( double )m_width;
  
   if ( m_new_center_y_float < 0.0 )
     m_new_center_y_float += ( double )m_height; else if ( m_new_center_y_float > ( double )m_height - 1.0 )
     m_new_center_y_float -= ( double )m_height;
  
   m_center_x_float = m_new_center_x_float;
   m_center_y_float = m_new_center_y_float;
   m_center_x = ( int )m_center_x_float;
   m_center_y = ( int )m_center_y_float;
   m_terr_done = false;
   m_assess_done = false;
   m_dist_done = false;
 }

References m_assess_done, m_center_x, m_center_x_float, m_center_y, m_center_y_float, m_dist_done, m_height, m_new_center_x_float, m_new_center_y_float, m_peg_is_fixed, m_permanent_marker, m_terr_done, and m_width.

◆ Memberships()

unsigned int Partridge_Covey::Memberships ( void )

inline

Get covey size.

Definition at line 691 of file Partridge_Covey.h.

                                       {
         return m_members_size;
     }

References m_members_size.

◆ MoveCanMove() [1/2]

int Partridge_Covey::MoveCanMove	(	int	a_x,
		int	a_y
	)

Test of movement step.

Returns:
     -1: Cannot move here due to element type.
     0: OK to go here.
     1: Exceptionally favorable terrain (for detecting hedges etc.)

Definition at line 857 of file Partridge_Covey.cpp.

                                                    {
   return MoveCanMove( m_map->SupplyElementType( a_x, a_y ) );
 }

References m_map, MoveCanMove(), and Landscape::SupplyElementType().

◆ MoveCanMove() [2/2]

int Partridge_Covey::MoveCanMove ( TTypesOfLandscapeElement a_ele )

protected

Test if we can go there.

Returns a code for whether the partridges can take chicks onto this polygon type at all (-1), if necessary (0) or by choice (1).

Definition at line 3221 of file Partridge_Covey.cpp.

                                                                  {
   switch ( a_ele ) {
     case tole_StoneWall:
     case tole_Fence:
     case tole_Garden:
     case tole_Building:
     case tole_Pond:
     case tole_Freshwater:
     case tole_River:
     case tole_Saltwater:
     case tole_Coast:
     case tole_Churchyard:
     case tole_Stream:
       return -1;
  
     case tole_IndividualTree:
     case tole_PlantNursery:
     case tole_WindTurbine:
     case tole_WoodyEnergyCrop:
     case tole_WoodlandMargin:
     case tole_Pylon:
     case tole_PermPasture:
     case tole_Scrub:
     case tole_RiversidePlants:
     case tole_RiversideTrees:
     case tole_DeciduousForest:
     case tole_MixedForest:
     case tole_ConiferousForest:
     case tole_Marsh:
     case tole_PitDisused:
     case tole_Track:
     case tole_SmallRoad:
     case tole_LargeRoad:
     case tole_ActivePit:
     case tole_Hedges:
     case tole_Railway:
     case tole_Field:
     case tole_UnsprayedFieldMargin:
     case tole_PermPastureTussocky:
     case tole_PermPastureLowYield:
     case tole_PermanentSetaside:
     case tole_YoungForest:
     case tole_NaturalGrassDry:
     case tole_Heath:
     case tole_OrchardBand:
     case tole_MownGrass:
     case tole_Orchard:
     case tole_BareRock:
     case tole_AmenityGrass:
     case tole_Parkland:
     case tole_UrbanNoVeg:
     case tole_UrbanPark:
     case tole_BuiltUpWithParkland:
     case tole_SandDune:
     case tole_Copse:
     case tole_NaturalGrassWet:
     case tole_RoadsideSlope:
     case tole_MetalledPath:
     case tole_Carpark:
     case tole_Saltmarsh:
     case tole_HeritageSite:
       return 0;
  
     case tole_RoadsideVerge:
     case tole_FieldBoundary:
     case tole_HedgeBank:
     case tole_BeetleBank:
     case tole_Vildtager:
         return 1;
  
     default:
     g_msg->Warn( WARN_BUG, "Partridge_Covey::MoveCanMove(): Unknown tole type", "" );
     exit( 1 );
     break;
   }
 }

References g_msg, tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by FlyToFast(), FlyToSlow(), MoveCanMove(), MoveOptimalDirectionFast(), and MoveOptimalDirectionSlow().

◆ MoveDirectionsAllowed()

void Partridge_Covey::MoveDirectionsAllowed	(	int	a_x,
		int	a_y
	)

protected

Test possible movement directions.

Definition at line 397 of file Partridge_Covey.cpp.

                                                               {
   // Finding the possible directions allowed by the location of the
   // peg is slightly complicated, because the actual covey position
   // may be on the other side of a map boundary.
  
   int l_dx = m_center_x - a_x;
   int l_dy = m_center_y - a_y;
  
   if ( l_dx < 0 ) {
     if ( -l_dx > ( m_width >> 1 ) ) {
       l_dx += m_width;
     }
   } else {
     if ( l_dx > ( m_width >> 1 ) ) {
       l_dx -= m_width;
     }
   }
  
   if ( l_dy < 0 ) {
     if ( -l_dy > ( m_height >> 1 ) ) {
       l_dy += m_height;
     }
   } else {
     if ( l_dy > ( m_height >> 1 ) ) {
       l_dy -= m_height;
     }
   }
  
 #ifdef PAR_DEBUG
   printf( "dX, dY  : %d %d\n", l_dx, l_dy );
 #endif
  
   // We now have l_dx and l_dy normalized wrt. to the map borders.
   // Finding the true distance and direction to the peg is now trivial.
   int l_dist_sq = l_dx * l_dx + l_dy * l_dy;
  
   if ( l_dx >= 0 ) {
     // The peg is in 1st or 2nd quadrant as seen from the covey.
     if ( l_dy < 0 ) {
       // 1st quadrant. Check octant!
       if ( -l_dy > l_dx ) {
         // 1st octant.
         m_move_allowed[ direction_n ] = true;
         m_move_allowed[ direction_ne ] = true;
         m_move_allowed[ direction_e ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_se ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_s ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExcludeHarder( l_dist_sq );
       } else {
         // 2nd octant.
         m_move_allowed[ direction_ne ] = true;
         m_move_allowed[ direction_e ] = true;
         m_move_allowed[ direction_n ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_se ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_s ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExcludeHarder( l_dist_sq );
       }
     } else {
       // 2nd quadrant clockwise from north.
       if ( l_dx > l_dy ) {
         // 3rd octant.
         m_move_allowed[ direction_e ] = true;
         m_move_allowed[ direction_se ] = true;
         m_move_allowed[ direction_ne ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_s ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_n ] = MoveTryExcludeHarder( l_dist_sq );
       } else {
         // 4th octant.
         m_move_allowed[ direction_se ] = true;
         m_move_allowed[ direction_s ] = true;
         m_move_allowed[ direction_e ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_n ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_ne ] = MoveTryExcludeHarder( l_dist_sq );
       }
     }
   } else {
     // l_dx < 0
     // The peg is in the 3rd or the 4th quadrant, clockwise from north.
     if ( l_dy >= 0 ) {
       // 3rd quadrant.
       if ( l_dy > -l_dx ) {
         // 5th octant.
         m_move_allowed[ direction_s ] = true;
         m_move_allowed[ direction_sw ] = true;
         m_move_allowed[ direction_se ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_n ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_ne ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_e ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExcludeHarder( l_dist_sq );
       } else {
         // 6th octant.
         m_move_allowed[ direction_sw ] = true;
         m_move_allowed[ direction_w ] = true;
         m_move_allowed[ direction_s ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_nw ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_n ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_ne ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_e ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_se ] = MoveTryExcludeHarder( l_dist_sq );
       }
     } else {
       // l_dy < 0
       // 4th quadrant.
       if ( l_dx < l_dy ) {
         // 7th octant.
         m_move_allowed[ direction_w ] = true;
         m_move_allowed[ direction_nw ] = true;
         m_move_allowed[ direction_n ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_ne ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_e ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_se ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_s ] = MoveTryExcludeHarder( l_dist_sq );
       } else {
         // 8th octant.
         m_move_allowed[ direction_nw ] = true;
         m_move_allowed[ direction_n ] = true;
         m_move_allowed[ direction_ne ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_w ] = MoveTryExclude( l_dist_sq );
         m_move_allowed[ direction_e ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_se ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_s ] = MoveTryExcludeHarder( l_dist_sq );
         m_move_allowed[ direction_sw ] = MoveTryExcludeHarder( l_dist_sq );
       }
     }
   }
 }

References direction_e, direction_n, direction_ne, direction_nw, direction_s, direction_se, direction_sw, direction_w, m_center_x, m_center_y, m_height, m_move_allowed, m_width, MoveTryExclude(), and MoveTryExcludeHarder().

Referenced by MoveDistance(), and MoveTo().

◆ MoveDistance()

void Partridge_Covey::MoveDistance	(	int	a_max_distance,
		int	a_step_size,
		double	a_food_density_needed
	)

Entry point for movement.

Move distance needs to take into accound the moves possible, the food available, the peg location, and the history of moves.

This is where the partridge model spends much of its time (when there are chicks to feed). It is possible that these routines could be optimised, but they are also the most likely to be modified in the future, so too much optimisation may be a waste of time.

Definition at line 652 of file Partridge_Covey.cpp.

                                                                                                       {
   if ( m_move_done )
     return;
  
   if ( !m_dist_done ) {
     m_dist_done = true;
     DistanceUpdate();
   }
  
   if ( m_nest_on_nest ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::MoveDistance(): ", "Asked to move while on nest." );
     exit( 1 );
   }
  
   m_dist_moved = 0.0;
   m_food_today = 0.0;
   int l_x = m_covey_x;
   int l_y = m_covey_y;
  
   if ( a_step_size != m_move_step_size ) {
     m_move_step_size = a_step_size;
     m_move_step_size_inv = 1.0 / ( double )a_step_size;
   }
  
 /*
     if ( m_move_get_enable ) {
     m_move_get_index = 0;
     m_move_get_size = 0;
   }
 */
   while ( m_dist_moved < ( double )a_max_distance && m_food_today < a_food_density_needed ) {
  
     // Build list of possible directions, given the location
     // of the peg.
     MoveDirectionsAllowed( l_x, l_y );
  
 #ifdef PAR_DEBUG
     printf( "Allowed : %d %d %d %d %d %d %d %d\n", m_move_allowed[ 0 ], m_move_allowed[ 1 ], m_move_allowed[ 2 ],
          m_move_allowed[ 3 ], m_move_allowed[ 4 ], m_move_allowed[ 5 ], m_move_allowed[ 6 ], m_move_allowed[ 7 ] );
 #endif
  
     // Build list of movement evaluations in
     // m_move_list[] from our present location.
     if ( l_x - a_step_size >= 0 && l_x + a_step_size < m_width && l_y - a_step_size >= 0 && l_y + a_step_size < m_height ) {
       MoveOptimalDirectionFast( l_x, l_y );
     } else {
       MoveOptimalDirectionSlow( l_x, l_y );
     }
  
 #ifdef PAR_DEBUG
     printf( "DirQual : %d %d %d %d %d %d %d %d\n", m_move_list[ 0 ], m_move_list[ 1 ], m_move_list[ 2 ], m_move_list[ 3 ],
          m_move_list[ 4 ], m_move_list[ 5 ], m_move_list[ 6 ], m_move_list[ 7 ] );
 #endif
  
     // Take peg location and possibly past history/memory into
     // account.
     int l_dir = MoveWeighDirection( l_x, l_y );
     MoveQualMemory( m_move_list[ l_dir ] );
  
 #ifdef PAR_DEBUG
     printf( "QualMemo: 1: %d 2: %d 3: %d\n", m_move_qual_memory[ 1 ], m_move_qual_memory[ 2 ], m_move_qual_memory[ 3 ] );
     printf( "Selected: %d\n", l_dir );
 #endif
     m_move_whence_we_came = Norm( l_dir - 4, 8 );
  
     // We now have the direction that we want to move in l_dir.
     m_food_today += m_move_dir_qual[ l_dir ];
  
     // This call also updates l_x and l_y. Nasty, nasty. ;-)
     m_dist_moved += MoveDoIt( & l_x, & l_y, l_dir, a_step_size );
 #ifdef PAR_DEBUG
     //printf("Dist Sum: %f\n", m_dist_moved );
     printf( "Coords  : %d %d\n\n", l_x, l_y );
 #endif
  
     // Collect movement reports.
 /*
 if ( m_move_get_enable ) {
       m_move_get_size++;
       m_move_get_x.resize( m_move_get_size );
       m_move_get_y.resize( m_move_get_size );
       m_move_get_x[ m_move_get_index ] = l_x;
       m_move_get_y[ m_move_get_index ] = l_y;
       m_move_get_index++;
     }
 */
   }
  
   CoveyUpdateMemberPositions( l_x, l_y );
   m_move_get_index = 0;
   m_covey_x = l_x;
   m_covey_y = l_y;
   m_assess_done = false;
   m_move_done = true;
 }

References CoveyUpdateMemberPositions(), DistanceUpdate(), g_msg, m_assess_done, m_covey_x, m_covey_y, m_dist_done, m_dist_moved, m_food_today, m_height, m_move_allowed, m_move_dir_qual, m_move_done, m_move_get_index, m_move_list, m_move_qual_memory, m_move_step_size, m_move_step_size_inv, m_move_whence_we_came, m_nest_on_nest, MoveDirectionsAllowed(), MoveDoIt(), MoveOptimalDirectionFast(), MoveOptimalDirectionSlow(), MoveQualMemory(), MoveWeighDirection(), Norm(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Partridge_Chick::BeginStep(), Partridge_Chick2::BeginStep(), Partridge_Female::FCaringForYoung(), Partridge_Female::FFlocking(), Partridge_Male::MCaringForYoung(), and Partridge_Male::MFlocking().

◆ MoveDoIt()

double Partridge_Covey::MoveDoIt	(	int *	a_x,
		int *	a_y,
		int	a_dir,
		int	a_step_size
	)

protected

We know where we want to go. Now do it!

Definition at line 811 of file Partridge_Covey.cpp.

                                                                                    {
   int l_diag_length = ( int )( ( double )a_step_size * 0.71 );
   double l_length = ( double )a_step_size;
  
   switch ( a_dir ) {
     case direction_n:
       * a_y -= a_step_size;
     break;
  
     case direction_ne:
       * a_y -= l_diag_length;
       * a_x += l_diag_length;
     break;
     case direction_e:
       * a_x += a_step_size;
     break;
     case direction_se:
       * a_y += l_diag_length;
       * a_x += l_diag_length;
     break;
     case direction_s:
       * a_y += a_step_size;
     break;
     case direction_sw:
       * a_y += l_diag_length;
       * a_x -= l_diag_length;
     break;
     case direction_w:
       * a_x -= a_step_size;
     break;
     case direction_nw:
       * a_y -= l_diag_length;
       * a_x -= l_diag_length;
     break;
   }
  
   * a_x = Norm( * a_x, m_width );
   * a_y = Norm( * a_y, m_height );
   return l_length;
 }

References direction_e, direction_n, direction_ne, direction_nw, direction_s, direction_se, direction_sw, direction_w, m_height, m_width, and Norm().

Referenced by MoveDistance(), and MoveTo().

◆ MoveEvalEdgesAndQual()

int Partridge_Covey::MoveEvalEdgesAndQual	(	int	a_edges,
		double	a_qual
	)

protected

Move evaluation taking edges into account.

This method must do an evaluation of this particular step given:

a_edges: Number of 'edge' squares encountered if moving down this path. See Partridge_Covey::MoveCanMove() below.
m_move_step_size: You guessed it. An int.
m_move_step_size_inv: The inverse of m_move_step_size as a double. Both of these are updated automatically.
a_qual: The sum of the values returned by MoveMagicVegToFood() above times the length of the segments with those values.

a_edges must be taken into account to ensure a preference of moving along field edges, hedges etc.
Values returned should be within the range of [1:3], 3 being most preferable.

Definition at line 2684 of file Partridge_Covey.cpp.

                                                                       {
 #ifdef MOVE_EVAL_KLUDGE
   if ( a_edges > 2 )
     return 3;
   if ( a_edges > 0 )
     return 2;
   return 1;
  
 #else
   int result = 2;
   double score = m_move_step_size_inv * a_qual;
   //  if (score<cfg_par_lowqualthreshold.value())
   //    result=1; //
   if ( score > cfg_par_highqualthreshold.value() )
     result = 3;
   // Result is 1 or 3 before edge evaluation
   // We have one special case, where food is 3 and edges are 2
   // correcting for this gives an even distributed result of 1,2,3
   if ( a_edges > 2 ) result += 3; else if ( a_edges > 0 ) {
     // The special case, where food is 3 and edges are 2
     if ( result == 3 ) result += 3; else result += 2;
   } else
     result += 1;
   // Result is now 2, 4 or 6
   result = result >> 1;
   return result;
 #endif
 }

References cfg_par_highqualthreshold, m_move_step_size_inv, and CfgInt::value().

Referenced by MoveOptimalDirectionFast(), and MoveOptimalDirectionSlow().

◆ MoveMagicVegToFood()

double Partridge_Covey::MoveMagicVegToFood ( int a_polygon )

protected

Move optimising food intake.

This is the primary method responsible for generating food intake and local movement when chicks are present. The idea is to take each step optimally dependent on food availability, with occaisional mis-steps, and if no one direction is optimal then pick randomly. If there is no choice we can back-track.

This section determine the effect of modern landscapes on food availability. Here the problem is that we asume fields are low in food due to a lower insect biomass. The effects of structure should be the same as in the 1950s. However, the question is whether we should treat all habitats as impoverished or just the fields, all fields or just arable fields. The default position is all fields and then allow a scaling factor for patchiness, and assume non-field habitats are not affected - this is not perfect an may need to be revisited in future versions

Definition at line 3147 of file Partridge_Covey.cpp.

                                                           {
     double l_magic = m_map->SupplyInsects( a_polygon ) * cfg_parinsectScaler.value();
 #ifdef __P1950s
     // ***CJT***
     // Problem was that 1950s were calibrated with cfg_1950sinsects set to 1.0
     // we have therefore to scale the insects values we get for non-1950s to be lower somehow - preferably without making it run slow
     // Line removed
 #else
  
     TTypesOfLandscapeElement Type = m_map->SupplyElementType(a_polygon);
     //if ( (!m_map->SupplyVegPatchy(a_polygon)) ||  (Type == tole_Field || Type == tole_PermPastureTussocky || Type == tole_PermPasture || Type == tole_PermanentSetaside || Type == tole_PermPastureLowYield)) {
     if ((!m_map->SupplyVegPatchy(a_polygon)) ) {
             if ((Type == tole_Field || Type == tole_PermPastureTussocky || Type == tole_PermPasture || Type == tole_PermanentSetaside || Type == tole_PermPastureLowYield)) {       l_magic*=(cfg_NOT1950sinsects.value());
             if (m_map->SupplyHasTramlines( a_polygon )) l_magic*=1.5; // extra for tramlines
         }
     } // otherwise we assume it is like the 1950s
 #endif
     /* **CJT** 20/7/2010
     double height = m_map->SupplyVegHeight( a_polygon );
     int l_height_bin = ( int )( height * cfg_par_hei_hindrance_inv.value() );
     if ( l_height_bin > 3 ) l_height_bin = 3;
     */
     // *** CJT *** 1 July 2010 Code below relies on biomass - but this is skylark based code and should be altered to
     // density. At the same time some alteration of the height response was required - hence change to HB_Impedence.txt
     /*
     double bio = m_map->SupplyVegBiomass( a_polygon );
     int l_biomass_bin = ( int )( bio * cfg_par_bio_hindrance_inv.value() );;
     if ( l_biomass_bin > 3 ) l_biomass_bin = 3;
     return l_magic * g_move_veg_structure[ l_height_bin ] [ l_biomass_bin ];
  
     /*/
     /*
     double dens = m_map->SupplyVegDensity( a_polygon );
     int l_density_bin = ( int )( dens * cfg_par_bio_hindrance_inv.value() );;
     if ( l_density_bin > 3 ) l_density_bin = 3;
     return l_magic * g_move_veg_structure[ l_height_bin ] [ l_density_bin ];
     */
     // This section calculates the hindrance based on linear interpolation after the first height category
     // The slope (0.25) is scaled by cfg_par_hei_hindrance_inv and cfg_par_bio_hindrance_inv
     double height = m_map->SupplyVegHeight( a_polygon );
     double l_height_bin = ( height * cfg_par_hei_hindrance_inv.value() ) - 1.0;
     if (l_height_bin < 0.0 ) return l_magic; // So short there is no hindrance
     double dens = m_map->SupplyVegDensity( a_polygon );
     double l_density_bin = ( dens * cfg_par_bio_hindrance_inv.value() );
     // We need to restrict the upper end to avoid one factor outweighing the other e.g. if density is very high but height is only just >0.0
     if (l_density_bin > 4.0 ) l_density_bin = 4.0;
     if (l_height_bin > 4.0 ) l_height_bin = 4.0;
     double l_intermediate = 1.0 -(( l_density_bin + l_height_bin - 2.0 ) * 0.25);
     if (l_intermediate <0.0) return 0.0;
     if (l_intermediate >= 1.0) return l_magic;
     return l_magic * l_intermediate;
  
 }

References cfg_NOT1950sinsects, cfg_par_bio_hindrance_inv, cfg_par_hei_hindrance_inv, cfg_parinsectScaler, m_map, Landscape::SupplyElementType(), Landscape::SupplyHasTramlines(), Landscape::SupplyInsects(), Landscape::SupplyVegDensity(), Landscape::SupplyVegHeight(), Landscape::SupplyVegPatchy(), tole_Field, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, and CfgFloat::value().

Referenced by MoveOptimalDirectionFast(), and MoveOptimalDirectionSlow().

◆ MoveOptimalDirectionFast()

void Partridge_Covey::MoveOptimalDirectionFast	(	int	a_x,
		int	a_y
	)

protected

Choose best foraging direction (wrap around)

See MoveOptimalDirectionSlow for details

Rule: Preferred direction is the one, which gives the best food return.

Sum of distance times 'magic' vegetation2foodvaluepersitance() method.
Each tov type has a constant, which we can use to multiply the insect biomass with (default is now that all are 1.0). We then have to modify this value with some function() of vegetation structure. function() is a precalculated value from 0.0 to 1.0, given as a 4x4 array from vegetation height and biomass.
Also need to ensure the covey moves along the hedges etc.

Definition at line 3667 of file Partridge_Covey.cpp.

                                                                  {
   int l_diag_length = ( int )( ( double )m_move_step_size * 0.71 );
  
   int l_geo_cache = 0;
   double l_quality = 0.0;
   double l_qual_cache = 0.0;
   int l_fantastic = 0;
   int l_poly_cache = -1;
  
   // North.
   m_move_list[ direction_n ] = m_move_allowed[ direction_n ];
  
   if ( m_move_allowed[ direction_n ] ) {
     for ( int y = a_y - 1; y >= a_y - m_move_step_size; y-- ) {
       int l_poly = m_map->SupplyPolyRef( a_x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_n ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_n ] = l_quality;
   if ( m_move_list[ direction_n ] ) {
     m_move_list[ direction_n ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Northeast.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_ne ] = m_move_allowed[ direction_ne ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_ne ] ) {
     for ( int y = a_y - 1, x = a_x + 1; y >= a_y - l_diag_length; y--, x++ ) {
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_ne ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_ne ] = l_quality;
   if ( m_move_list[ direction_ne ] ) {
     m_move_list[ direction_ne ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // East.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_e ] = m_move_allowed[ direction_e ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_e ] ) {
     for ( int x = a_x + 1; x <= a_x + m_move_step_size; x++ ) {
       int l_poly = m_map->SupplyPolyRef( x, a_y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_e ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_e ] = l_quality;
   if ( m_move_list[ direction_e ] ) {
     m_move_list[ direction_e ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Southeast.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_se ] = m_move_allowed[ direction_se ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_se ] ) {
     for ( int x = a_x + 1, y = a_y + 1; x <= a_x + l_diag_length; x++, y++ ) {
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_se ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_se ] = l_quality;
   if ( m_move_list[ direction_se ] ) {
     m_move_list[ direction_se ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // South.
   l_quality = 0.0;
   l_fantastic = 0;
   l_qual_cache = 0.0;
   l_poly_cache = -1;
   m_move_list[ direction_s ] = m_move_allowed[ direction_s ];
  
   if ( m_move_allowed[ direction_s ] ) {
     for ( int y = a_y + 1; y <= a_y + m_move_step_size; y++ ) {
       int l_poly = m_map->SupplyPolyRef( a_x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_s ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_s ] = l_quality;
   if ( m_move_list[ direction_s ] ) {
     m_move_list[ direction_s ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Southwest.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_sw ] = m_move_allowed[ direction_sw ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_sw ] ) {
     for ( int x = a_x - 1, y = a_y + 1; x >= a_x - l_diag_length; x--, y++ ) {
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_sw ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_sw ] = l_quality;
   if ( m_move_list[ direction_sw ] ) {
     m_move_list[ direction_sw ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // West.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_w ] = m_move_allowed[ direction_w ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_w ] ) {
     for ( int x = a_x - 1; x >= a_x - m_move_step_size; x-- ) {
       int l_poly = m_map->SupplyPolyRef( x, a_y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_w ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_w ] = l_quality;
   if ( m_move_list[ direction_w ] ) {
     m_move_list[ direction_w ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Northwest.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_nw ] = m_move_allowed[ direction_nw ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_nw ] ) {
     for ( int y = a_y - 1, x = a_x - 1; y >= a_y - l_diag_length; y--, x-- ) {
       int l_poly = m_map->SupplyPolyRef( x, y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_nw ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_nw ] = l_quality;
   if ( m_move_list[ direction_nw ] ) {
     m_move_list[ direction_nw ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
 }

References direction_e, direction_n, direction_ne, direction_nw, direction_s, direction_se, direction_sw, direction_w, m_map, m_move_allowed, m_move_dir_qual, m_move_list, m_move_step_size, MoveCanMove(), MoveEvalEdgesAndQual(), MoveMagicVegToFood(), Landscape::SupplyElementType(), and Landscape::SupplyPolyRef().

Referenced by MoveDistance(), and MoveTo().

◆ MoveOptimalDirectionSlow()

void Partridge_Covey::MoveOptimalDirectionSlow	(	int	a_x,
		int	a_y
	)

protected

Choose best foraging direction.

Rule: Preferred direction is the one, which gives the best food return.

Sum of distance times 'magic' vegetation2foodvaluepersitance() method.
Each tov type has a constant, which we can use to multiply the insect biomass with (default is now that all are 1.0). We then have to modify this value with some function() of vegetation structure. function() is a precalculated value from 0.0 to 1.0, given as a 4x4 array from vegetation height and biomass.
Also need to ensure the covey moves along the hedges etc.
All this is done whilst checking for wrap-around - therefore SLOW!

Definition at line 3404 of file Partridge_Covey.cpp.

                                                                  {
   // The number of steps for a diagonal move is less than step size
   // by 1/sqrt(2), as each step is sqrt(2) meters long.
   int l_diag_length = ( int )( ( double )m_move_step_size * 0.71 );
  
   double l_quality = 0.0;
   double l_qual_cache = 0.0;
   int l_fantastic = 0;
   int l_poly_cache = -1;
   int l_geo_cache = 0;
  
   // Current pos to the north (decreasing y).
  
   // Use current spot in movement list as a temporary flag.
   m_move_list[ direction_n ] = m_move_allowed[ direction_n ];
  
   // Notice: y is allowed to grow negative, this is OK!
   // We normalize to the height of the map before using it.
   if ( m_move_allowed[ direction_n ] ) {
     for ( int y = a_y - 1; y >= a_y - m_move_step_size; y-- ) {
       int l_poly = m_map->SupplyPolyRef( a_x, NormDec( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         // Crossed into new polygon. Compute new values for
         // cache etc.
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           // This direction is blocked.
           m_move_list[ direction_n ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
     }
     // Sum up number of especially good edge squares.
     l_fantastic += l_geo_cache;
     // Sum up food quality.
     l_quality += l_qual_cache;
   }
   m_move_dir_qual[ direction_n ] = l_quality;
   if ( m_move_list[ direction_n ] ) {
     // This direction isn't blocked, so evaluate and assign
     // priority in movement list.
     m_move_list[ direction_n ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Northeast.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_ne ] = m_move_allowed[ direction_ne ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_ne ] ) {
     for ( int y = a_y - 1, x = a_x + 1; y >= a_y - l_diag_length; y--, x++ ) {
       int l_poly = m_map->SupplyPolyRef( NormInc( x, m_width ), NormDec( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_ne ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_ne ] = l_quality;
   if ( m_move_list[ direction_ne ] ) {
     m_move_list[ direction_ne ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // East.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_e ] = m_move_allowed[ direction_e ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_e ] ) {
     for ( int x = a_x + 1; x <= a_x + m_move_step_size; x++ ) {
       int l_poly = m_map->SupplyPolyRef( NormInc( x, m_width ), a_y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_e ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_e ] = l_quality;
   if ( m_move_list[ direction_e ] ) {
     m_move_list[ direction_e ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Southeast.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_se ] = m_move_allowed[ direction_se ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_se ] ) {
     for ( int x = a_x + 1, y = a_y + 1; x <= a_x + l_diag_length; x++, y++ ) {
       int l_poly = m_map->SupplyPolyRef( NormInc( x, m_width ), NormInc( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_se ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_se ] = l_quality;
   if ( m_move_list[ direction_se ] ) {
     m_move_list[ direction_se ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // South.
   l_quality = 0.0;
   l_fantastic = 0;
   l_qual_cache = 0.0;
   l_poly_cache = -1;
   m_move_list[ direction_s ] = m_move_allowed[ direction_s ];
  
   if ( m_move_allowed[ direction_s ] ) {
     for ( int y = a_y + 1; y <= a_y + m_move_step_size; y++ ) {
       int l_poly = m_map->SupplyPolyRef( a_x, NormInc( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_s ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_s ] = l_quality;
   if ( m_move_list[ direction_s ] ) {
     m_move_list[ direction_s ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Southwest.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_sw ] = m_move_allowed[ direction_sw ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_sw ] ) {
     for ( int x = a_x - 1, y = a_y + 1; x >= a_x - l_diag_length; x--, y++ ) {
       int l_poly = m_map->SupplyPolyRef( NormDec( x, m_width ), NormInc( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_sw ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_sw ] = l_quality;
   if ( m_move_list[ direction_sw ] ) {
     m_move_list[ direction_sw ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // West.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_w ] = m_move_allowed[ direction_w ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_w ] ) {
     for ( int x = a_x - 1; x >= a_x - m_move_step_size; x-- ) {
       int l_poly = m_map->SupplyPolyRef( NormDec( x, m_width ), a_y );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_w ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly );
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_w ] = l_quality;
   if ( m_move_list[ direction_w ] ) {
     m_move_list[ direction_w ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
  
   // Northwest.
   l_quality = 0.0;
   l_fantastic = 0;
   m_move_list[ direction_nw ] = m_move_allowed[ direction_nw ];
   l_qual_cache = 0.0;
   l_poly_cache = -1;
  
   if ( m_move_allowed[ direction_nw ] ) {
     for ( int y = a_y - 1, x = a_x - 1; y >= a_y - l_diag_length; y--, x-- ) {
       int l_poly = m_map->SupplyPolyRef( NormDec( x, m_width ), NormDec( y, m_height ) );
       if ( l_poly != l_poly_cache ) {
         l_geo_cache = MoveCanMove( m_map->SupplyElementType( l_poly ) );
         if ( l_geo_cache == -1 ) {
           m_move_list[ direction_nw ] = 0;
           break;
         }
         l_poly_cache = l_poly;
         l_qual_cache = MoveMagicVegToFood( l_poly ) * 1.41;
       }
       l_fantastic += l_geo_cache;
       l_quality += l_qual_cache;
     }
   }
   m_move_dir_qual[ direction_nw ] = l_quality;
   if ( m_move_list[ direction_nw ] ) {
     m_move_list[ direction_nw ] = MoveEvalEdgesAndQual( l_fantastic, l_quality );
   }
 }

References direction_e, direction_n, direction_ne, direction_nw, direction_s, direction_se, direction_sw, direction_w, m_height, m_map, m_move_allowed, m_move_dir_qual, m_move_list, m_move_step_size, m_width, MoveCanMove(), MoveEvalEdgesAndQual(), MoveMagicVegToFood(), NormDec(), NormInc(), Landscape::SupplyElementType(), and Landscape::SupplyPolyRef().

Referenced by MoveDistance(), and MoveTo().

◆ MoveQualMemory()

void Partridge_Covey::MoveQualMemory ( int a_qual )

protected

Make a move based on memory of quality.

Definition at line 538 of file Partridge_Covey.cpp.

                                                  {
   // Shift down the history array.
   for ( int i = 0; i < MOVE_QUAL_HIST_SIZE - 1; i++ ) {
     m_move_qual_hist[ 1 ] [ i ] = m_move_qual_hist[ 1 ] [ i + 1 ];
     m_move_qual_hist[ 2 ] [ i ] = m_move_qual_hist[ 2 ] [ i + 1 ];
     m_move_qual_hist[ 3 ] [ i ] = m_move_qual_hist[ 3 ] [ i + 1 ];
   }
  
   // Zero top of history.
   m_move_qual_hist[ 1 ] [ MOVE_QUAL_HIST_SIZE - 1 ] = 0;
   m_move_qual_hist[ 2 ] [ MOVE_QUAL_HIST_SIZE - 1 ] = 0;
   m_move_qual_hist[ 3 ] [ MOVE_QUAL_HIST_SIZE - 1 ] = 0;
   m_move_qual_memory[ 1 ] = 0;
   m_move_qual_memory[ 2 ] = 0;
   m_move_qual_memory[ 3 ] = 0;
  
   // Set top of qurrent qual
   m_move_qual_hist[ a_qual ] [ MOVE_QUAL_HIST_SIZE - 1 ] = 1;
  
   // Sum up the array.
   for ( int i = 0; i < MOVE_QUAL_HIST_SIZE; i++ ) {
     if ( m_move_qual_hist[ 1 ] [ i ] )
       m_move_qual_memory[ 1 ] ++;
     if ( m_move_qual_hist[ 2 ] [ i ] )
       m_move_qual_memory[ 2 ] ++;
     if ( m_move_qual_hist[ 3 ] [ i ] )
       m_move_qual_memory[ 3 ] ++;
   }
 }

References m_move_qual_hist, and m_move_qual_memory.

Referenced by MoveDistance(), and MoveTo().

◆ MoveSelect()

int Partridge_Covey::MoveSelect ( void )

protected

Part of movement evaluation.

These methods:
bool MoveSelectLimit( int a_limit, int a_x, int a_y );
int MoveSelect( void );
void MoveVegConstInit( void );
build a list of possible directions we can move to from our present location, given we are only interested in directions with a quality evaluation equal to a_limit.

Definition at line 330 of file Partridge_Covey.cpp.

                                       {
   int l_rnd;
   if ( m_move_select_size > 1 )
     l_rnd = random( m_move_select_size ); else
     l_rnd = 0;
  
 #ifdef PAR_DEBUG
   printf( "l_rnd   : %d\n", l_rnd );
 #endif
   return m_move_select_list[ l_rnd ];
 }

References m_move_select_list, and m_move_select_size.

Referenced by MoveWeighDirection().

◆ MoveSelectFuzzy()

int Partridge_Covey::MoveSelectFuzzy ( void )

protected

Fuzzdy movement selection.

Select either 1 or -1 or fuzzy chance 0

Definition at line 244 of file Partridge_Covey.cpp.

                                            {
   if ( random( 10000 ) >= cfg_par_move_fuzzy_chance.value() )
     return 0;
  
   if ( random( 100 ) < 50 )
     return -1;
  
   return 1;
 }

References cfg_par_move_fuzzy_chance, and CfgInt::value().

Referenced by MoveWeighDirection().

◆ MoveSelectLimit()

bool Partridge_Covey::MoveSelectLimit	(	int	a_limit,
		int	a_x,
		int	a_y
	)

protected

Part of movement evaluation.

These methods:
bool MoveSelectLimit( int a_limit, int a_x, int a_y );
int MoveSelect( void );
void MoveVegConstInit( void );
build a list of possible directions we can move to from our present location, given we are only interested in directions with a quality evaluation equal to a_limit.
Select either 1 or -1 or fuzzy chance 0

Definition at line 261 of file Partridge_Covey.cpp.

                                                                  {
   bool l_found = false;
   m_move_select_size = 0;
  
   int l_goto = NormInc( m_move_whence_we_came + 4, 8 );
   int l_goto_sub = NormDec( l_goto - 1, 8 );
   int l_goto_add = NormInc( l_goto + 1, 8 );
  
   if ( m_move_list[ l_goto ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto;
     l_found = true;
   }
   if ( m_move_list[ l_goto_sub ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_sub;
     l_found = true;
   }
   if ( m_move_list[ l_goto_add ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_add;
     l_found = true;
   }
   if ( l_found ) {
     return true;
   }
  
   l_goto_sub = NormDec( l_goto_sub - 1, 8 );
   l_goto_add = NormInc( l_goto_add + 1, 8 );
   if ( m_move_list[ l_goto_sub ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_sub;
     l_found = true;
   }
   if ( m_move_list[ l_goto_add ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_add;
     l_found = true;
   }
   if ( l_found ) {
     return true;
   }
  
   l_goto_sub = NormDec( l_goto_sub - 1, 8 );
   l_goto_add = NormInc( l_goto_add + 1, 8 );
   if ( m_move_list[ l_goto_sub ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_sub;
     l_found = true;
   }
   if ( m_move_list[ l_goto_add ] == a_limit ) {
     m_move_select_list[ m_move_select_size++ ] = l_goto_add;
     l_found = true;
   }
   if ( l_found ) {
     return true;
   }
  
   // None of the 7 previous directions matched our current quality
   // limit. Consider backtracking if our previous quality history
   // seems reasonable.
   if ( m_move_list[ m_move_whence_we_came ] == a_limit
        && m_move_qual_memory[ a_limit ] >= cfg_par_movequal_histlimit.value() ) {
          m_move_select_list[ m_move_select_size++ ] = m_move_whence_we_came;
          l_found = true;
   }
  
   return l_found;
 }

References cfg_par_movequal_histlimit, m_move_list, m_move_qual_memory, m_move_select_list, m_move_select_size, m_move_whence_we_came, NormDec(), NormInc(), and CfgInt::value().

Referenced by MoveWeighDirection().

◆ MoveTo()

void Partridge_Covey::MoveTo	(	int	a_x,
		int	a_y
	)

unused

Definition at line 570 of file Partridge_Covey.cpp.

                                                                   {
  
   m_dist_moved = 0.0;
   int l_x = m_covey_x;
   int l_y = m_covey_y;
  
   if ( a_step_size != m_move_step_size ) {
     m_move_step_size = a_step_size;
     m_move_step_size_inv = 1.0 / ( double )a_step_size;
   }
  
 /*
     if ( m_move_get_enable ) {
         m_move_get_index = 0;
         m_move_get_size = 0;
     }
 */
   while ( m_dist_moved < ( double )a_max_distance ) {
  
     // Build list of possible directions, given the location
     // of the peg.
     MoveDirectionsAllowed( l_x, l_y );
  
 #ifdef PAR_DEBUG
     printf( "Allowed : %d %d %d %d %d %d %d %d\n", m_move_allowed[ 0 ], m_move_allowed[ 1 ], m_move_allowed[ 2 ],
          m_move_allowed[ 3 ], m_move_allowed[ 4 ], m_move_allowed[ 5 ], m_move_allowed[ 6 ], m_move_allowed[ 7 ] );
 #endif
  
     // Build list of movement evaluations in
     // m_move_list[] from our present location.
     if ( l_x - a_step_size >= 0 && l_x + a_step_size < m_width && l_y - a_step_size >= 0 && l_y + a_step_size < m_height ) {
       MoveOptimalDirectionFast( l_x, l_y );
     } else {
       MoveOptimalDirectionSlow( l_x, l_y );
     }
  
 #ifdef PAR_DEBUG
     printf( "DirQual : %d %d %d %d %d %d %d %d\n", m_move_list[ 0 ], m_move_list[ 1 ], m_move_list[ 2 ], m_move_list[ 3 ],
          m_move_list[ 4 ], m_move_list[ 5 ], m_move_list[ 6 ], m_move_list[ 7 ] );
 #endif
  
     // Take peg location and possibly past history/memory into
     // account.
     int l_dir = MoveWeighDirection( l_x, l_y );
     MoveQualMemory( m_move_list[ l_dir ] );
  
 #ifdef PAR_DEBUG
     printf( "QualMemo: 1: %d 2: %d 3: %d\n", m_move_qual_memory[ 1 ], m_move_qual_memory[ 2 ], m_move_qual_memory[ 3 ] );
     printf( "Selected: %d\n", l_dir );
 #endif
     m_move_whence_we_came = Norm( l_dir - 4, 8 );
  
     // We now have the direction that we want to move in l_dir.
     m_food_today += m_move_dir_qual[ l_dir ];
  
     // This call also updates l_x and l_y. Nasty, nasty. ;-)
     m_dist_moved += MoveDoIt( & l_x, & l_y, l_dir, a_step_size );
 #ifdef PAR_DEBUG
     //printf("Dist Sum: %f\n", m_dist_moved );
     printf( "Coords  : %d %d\n\n", l_x, l_y );
 #endif
  
     // Collect movement reports.
     /*
     if ( m_move_get_enable ) {
       m_move_get_size++;
       m_move_get_x.resize( m_move_get_size );
       m_move_get_y.resize( m_move_get_size );
       m_move_get_x[ m_move_get_index ] = l_x;
       m_move_get_y[ m_move_get_index ] = l_y;
       m_move_get_index++;
     }
     */
 }
  
   CoveyUpdateMemberPositions( l_x, l_y );
   m_move_get_index = 0;
   m_covey_x = l_x;
   m_covey_y = l_y;
   m_assess_done = false;
 }

References CoveyUpdateMemberPositions(), m_assess_done, m_covey_x, m_covey_y, m_dist_moved, m_food_today, m_height, m_move_allowed, m_move_dir_qual, m_move_get_index, m_move_list, m_move_qual_memory, m_move_step_size, m_move_step_size_inv, m_move_whence_we_came, MoveDirectionsAllowed(), MoveDoIt(), MoveOptimalDirectionFast(), MoveOptimalDirectionSlow(), MoveQualMemory(), MoveWeighDirection(), and Norm().

◆ MoveTryExclude()

bool Partridge_Covey::MoveTryExclude ( int a_dist_sq )

protected

Uses the peg force to exclude possible movement directions.

MoveTryExclude() should return a boolean distribution depending on the squared distance from the current location and the covey 'peg'. It is used when determining which directions we are allowed in, given the current location, and is called on for quadrants 'perpendicular' to the direction of the peg. Ie. moves toward the peg are always allowed, perpendicular is determined by this method, and those away by Partridge_Covey::MoveTryExcludeHarder().
If both methods always return true for distances below a certain threshold, the covey is allowed to roam freely within a circle of sqrt(threshold).
Note that in these methods a_dist_sq is treated linearly, meaning that the 'force' against moves away from the peg will automatically be a second order polynomial.
The implementation of these methods are currently quite rudimentary. One might want to incorporate such variables as the age of the chicks, size of the territory etc.

Definition at line 2735 of file Partridge_Covey.cpp.

                                                     {
   // Half Radius Squared
   int l_hrs = ( int )m_nearest_covey_dist >> 1;
   l_hrs = l_hrs * l_hrs;
   if ( a_dist_sq < l_hrs || ( random( 100 ) < 50 ) )
     return true;
  
   return false;
 }

References m_nearest_covey_dist.

Referenced by MoveDirectionsAllowed().

◆ MoveTryExcludeHarder()

bool Partridge_Covey::MoveTryExcludeHarder ( int a_dist_sq )

protected

Uses the peg force to exclude possible movement directions.

Called for quadrants facing away from the peg - see Partridge_Covey::MoveTryExclude

Definition at line 2750 of file Partridge_Covey.cpp.

                                                           {
   // Half Radius Squared
   int l_hrs = ( int )m_nearest_covey_dist >> 1;
   l_hrs = l_hrs * l_hrs;
   if ( a_dist_sq < l_hrs )
     return true;
  
   if ( a_dist_sq < l_hrs * 1.6 && random( 100 ) < 10 )
     return true;
  
   return false;
 }

References m_nearest_covey_dist.

Referenced by MoveDirectionsAllowed().

◆ MoveVegConstInit()

void Partridge_Covey::MoveVegConstInit ( void )

protected

Part of movement evaluation.

These methods:
bool MoveSelectLimit( int a_limit, int a_x, int a_y );
int MoveSelect( void );
void MoveVegConstInit( void );
build a list of possible directions we can move to from our present location, given we are only interested in directions with a quality evaluation equal to a_limit.
This was intended to be used to modify movement characteristics dependent on vegetation type, but lacking data all values are set to 1.0.

Definition at line 3304 of file Partridge_Covey.cpp.

                                            {
     if (m_move_veg_const_init_done)
         return;
     m_move_veg_const_init_done = true;
  
     m_move_veg_const[tov_Carrots] = 1.0;
     m_move_veg_const[tov_FodderGrass] = 1.0;
     m_move_veg_const[tov_CloverGrassGrazed1] = 1.0;
     m_move_veg_const[tov_CloverGrassGrazed2] = 1.0;
     m_move_veg_const[ tov_BroadBeans ] = 1.0;
     m_move_veg_const[ tov_FieldPeas ] = 1.0;
     m_move_veg_const[ tov_FodderBeet ] = 1.0;
     m_move_veg_const[tov_SugarBeet] = 1.0;
     m_move_veg_const[tov_OFodderBeet] = 1.0;
     m_move_veg_const[tov_Maize] = 1.0;
     m_move_veg_const[tov_MaizeSilage] = 1.0;
     m_move_veg_const[tov_NaturalGrass] = 1.0;
     m_move_veg_const[tov_NoGrowth] = 1.0;
     m_move_veg_const[tov_None] = 1.0;
     m_move_veg_const[tov_Oats] = 1.0;
  
     // 10
     m_move_veg_const[tov_OBarleyPeaCloverGrass] = 1.0;
     m_move_veg_const[tov_OSBarleySilage] = 1.0;
     m_move_veg_const[tov_OCarrots] = 1.0;
     m_move_veg_const[tov_OCloverGrassGrazed1] = 1.0;
     m_move_veg_const[tov_OCloverGrassGrazed2] = 1.0;
     m_move_veg_const[tov_OCloverGrassSilage1] = 1.0;
     m_move_veg_const[tov_OFieldPeas] = 1.0;
     m_move_veg_const[tov_OFieldPeasSilage] = 1.0;
     m_move_veg_const[tov_OFirstYearDanger] = 1.0;
     m_move_veg_const[tov_OCloverGrassGrazed1] = 1.0;
     m_move_veg_const[tov_OCloverGrassGrazed2] = 1.0;
     m_move_veg_const[tov_OGrazingPigs] = 1.0;
  
     // 20
     m_move_veg_const[tov_OOats] = 1.0;
     m_move_veg_const[tov_OPermanentGrassGrazed] = 1.0;
     m_move_veg_const[tov_OPotatoes] = 1.0;
     m_move_veg_const[tov_OSeedGrass1] = 1.0;
     m_move_veg_const[tov_OSeedGrass2] = 1.0;
     m_move_veg_const[tov_OSetaside] = 1.0;
     m_move_veg_const[tov_OSpringBarley] = 1.0;
     m_move_veg_const[tov_OSpringBarleyClover] = 1.0;
     m_move_veg_const[tov_OSpringBarleyGrass] = 1.0;
     m_move_veg_const[tov_OSpringBarleyPigs] = 1.0;
  
     // 30
     m_move_veg_const[tov_OTriticale] = 1.0;
     m_move_veg_const[tov_OWinterBarley] = 1.0;
     m_move_veg_const[tov_OWinterRape] = 1.0;
     m_move_veg_const[tov_OWinterRye] = 1.0;
     m_move_veg_const[ tov_OWinterWheatUndersown ] = 1.0;
     m_move_veg_const[ tov_OWinterWheat ] = 1.0;
     m_move_veg_const[ tov_PermanentGrassGrazed ] = 1.0;
     m_move_veg_const[tov_PermanentGrassLowYield] = 1.0;
     m_move_veg_const[tov_PermanentGrassTussocky] = 1.0;
     m_move_veg_const[tov_PermanentSetaside] = 1.0;
     m_move_veg_const[tov_Potatoes] = 1.0;
     m_move_veg_const[tov_PotatoesIndustry] = 1.0;
  
     // 40
     m_move_veg_const[tov_SeedGrass1] = 1.0;
     m_move_veg_const[tov_SeedGrass2] = 1.0;
     m_move_veg_const[tov_Setaside] = 1.0;
     m_move_veg_const[tov_SpringBarley] = 1.0;
     m_move_veg_const[tov_SpringBarleySpr] = 1.0;
     m_move_veg_const[tov_SpringBarleyCloverGrass] = 1.0;
     m_move_veg_const[tov_SpringBarleyGrass] = 1.0;
     m_move_veg_const[tov_SpringBarleySeed] = 1.0;
     m_move_veg_const[tov_SpringBarleySilage] = 1.0;
     m_move_veg_const[tov_SpringRape] = 1.0;
     m_move_veg_const[tov_SpringWheat] = 1.0;
  
     // 50
     m_move_veg_const[tov_Triticale] = 1.0;
     m_move_veg_const[tov_WinterBarley] = 1.0;
     m_move_veg_const[tov_WinterRape] = 1.0;
     m_move_veg_const[tov_WinterRye] = 1.0;
     m_move_veg_const[tov_WinterWheat] = 1.0;
     m_move_veg_const[tov_WWheatPControl] = 1.0;
     m_move_veg_const[tov_WWheatPToxicControl] = 1.0;
     m_move_veg_const[tov_WWheatPTreatment] = 1.0;
     m_move_veg_const[tov_AgroChemIndustryCereal] = 1.0;
     m_move_veg_const[tov_WinterWheatShort] = 1.0;
     m_move_veg_const[tov_PermanentGrassGrazed] = 1.0;
     m_move_veg_const[tov_OSpringBarleyExt] = 1.0;
     m_move_veg_const[tov_SpringBarleyPTreatment] = 1.0;
     m_move_veg_const[tov_SpringBarleySKManagement] = 1.0;
     m_move_veg_const[tov_OMaizeSilage] = 1.0;
     m_move_veg_const[tov_Heath] = 1.0;
  
     // Must be here. tov_Undefined is returned by polygons
     // without growth.
     m_move_veg_const[tov_Undefined] = 1.0;
 }

References m_move_veg_const, m_move_veg_const_init_done, tov_AgroChemIndustryCereal, tov_BroadBeans, tov_Carrots, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FodderBeet, tov_FodderGrass, tov_Heath, tov_Maize, tov_MaizeSilage, tov_NaturalGrass, tov_NoGrowth, tov_None, tov_Oats, tov_OBarleyPeaCloverGrass, tov_OCarrots, tov_OCloverGrassGrazed1, tov_OCloverGrassGrazed2, tov_OCloverGrassSilage1, tov_OFieldPeas, tov_OFieldPeasSilage, tov_OFirstYearDanger, tov_OFodderBeet, tov_OGrazingPigs, tov_OMaizeSilage, tov_OOats, tov_OPermanentGrassGrazed, tov_OPotatoes, tov_OSBarleySilage, tov_OSeedGrass1, tov_OSeedGrass2, tov_OSetaside, tov_OSpringBarley, tov_OSpringBarleyClover, tov_OSpringBarleyExt, tov_OSpringBarleyGrass, tov_OSpringBarleyPigs, tov_OTriticale, tov_OWinterBarley, tov_OWinterRape, tov_OWinterRye, tov_OWinterWheat, tov_OWinterWheatUndersown, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleyCloverGrass, tov_SpringBarleyGrass, tov_SpringBarleyPTreatment, tov_SpringBarleySeed, tov_SpringBarleySilage, tov_SpringBarleySKManagement, tov_SpringBarleySpr, tov_SpringRape, tov_SpringWheat, tov_SugarBeet, tov_Triticale, tov_Undefined, tov_WinterBarley, tov_WinterRape, tov_WinterRye, tov_WinterWheat, tov_WinterWheatShort, tov_WWheatPControl, tov_WWheatPToxicControl, and tov_WWheatPTreatment.

Referenced by Partridge_Covey().

◆ MoveWeighDirection()

int Partridge_Covey::MoveWeighDirection	(	int	a_x,
		int	a_y
	)

protected

Weighted foraging walk.

Given our current location and m_move_list[], decide the direction to go next.
Do this by:
A) Remove directions from whence we came by calling Partridge_Coveh::MoveExcludedByPast()
B) Build list of possible move directions at a given limit (3 == best moves etc.)
C) Of those directions in the temporary select list, choose the previous direction we went to, or, if not present, a random direction.
D) If no valid directions could be found even at limit 1, try backtracking down the patch from where we came.
E) Try to fuzzy move from the choosen path (if not blocked).

Definition at line 344 of file Partridge_Covey.cpp.

                                                           {
   int l_dir = -1;
   bool loop=false;  // This is only needed to stop compiler warnings
   // The next section of code finds a direction with the best quality, medium then worst, then gives up if nothing
   do {  // This loop does not do anything except it prevents the MoveSelectLimit from being called unnecessarily
     if ( MoveSelectLimit( 3, a_x, a_y ) ) {
       l_dir = MoveSelect();
       break;
     }
  
     if ( MoveSelectLimit( 2, a_x, a_y ) ) {
       l_dir = MoveSelect();
       break;
     }
  
     if ( MoveSelectLimit( 1, a_x, a_y ) ) {
       l_dir = MoveSelect();
     }
   } while ( loop );
  
 #ifdef PAR_DEBUG
   printf( "Select  : %d %d %d %d %d %d %d %d  :: %d\n", m_move_select_list[ 0 ], m_move_select_list[ 1 ],
        m_move_select_list[ 2 ], m_move_select_list[ 3 ], m_move_select_list[ 4 ], m_move_select_list[ 5 ],
        m_move_select_list[ 6 ], m_move_select_list[ 7 ], m_move_select_size );
  
 #endif
  
   // If we couldn't find an useful direction so far, then
   // we just have to backtrack down the path from which we came.
   // Do try to sidestep just a little in a random direction though.
   if ( l_dir == -1 ) {
     if ( random( 100 ) < 50 ) {
       if ( m_move_list[ NormDec( m_move_whence_we_came - 1, 8 ) ] > 0 )
         l_dir = NormDec( m_move_whence_we_came - 1, 8 ); else if ( m_move_list[ NormInc( m_move_whence_we_came + 1, 8 ) ] > 0 )
         l_dir = NormInc( m_move_whence_we_came + 1, 8 ); else
         l_dir = m_move_whence_we_came;
     } else {
       if ( m_move_list[ NormInc( m_move_whence_we_came + 1, 8 ) ] > 0 )
         l_dir = NormInc( m_move_whence_we_came + 1, 8 ); else if ( m_move_list[ NormDec( m_move_whence_we_came - 1, 8 ) ] > 0 )
         l_dir = NormDec( m_move_whence_we_came - 1, 8 ); else
         l_dir = m_move_whence_we_came;
     }
   }
   // Move fuzzy if allowed to do so.
   int l_fuzzy = Norm( l_dir + MoveSelectFuzzy(), 8 );
   if ( m_move_list[ l_fuzzy ] > 0 )
     return l_fuzzy;
  
   return l_dir;
 }

References m_move_list, m_move_select_list, m_move_select_size, m_move_whence_we_came, MoveSelect(), MoveSelectFuzzy(), MoveSelectLimit(), Norm(), NormDec(), and NormInc().

Referenced by MoveDistance(), and MoveTo().

◆ NestBadArea()

bool Partridge_Covey::NestBadArea	(	int	a_x,
		int	a__y
	)

protected

Nest location evaluation function.

Definition at line 2947 of file Partridge_Covey.cpp.

                                                     {
   TTypesOfLandscapeElement l_cet = m_map->SupplyElementType( a_x, a_y );
  
   switch ( l_cet ) {
     case tole_PermPasture:
     case tole_Scrub:
     case tole_RiversidePlants:
     case tole_RiversideTrees:
     case tole_DeciduousForest:
     case tole_MixedForest:
     case tole_ConiferousForest:
     case tole_StoneWall:
     case tole_Fence:
     case tole_Track:
     case tole_SmallRoad:
     case tole_LargeRoad:
     case tole_ActivePit:
     case tole_Hedges:
     case tole_Marsh:
     case tole_PitDisused:
     case tole_RoadsideVerge:
     case tole_Railway:
     case tole_FieldBoundary:
     case tole_PermPastureLowYield:
     case tole_PermPastureTussocky:
     case tole_PermanentSetaside:
     case tole_NaturalGrassDry:
     case tole_Heath:
     case tole_Orchard:
     case tole_YoungForest:
     case tole_HedgeBank:
     case tole_BeetleBank:
     case tole_UnsprayedFieldMargin:
     case tole_Field:
     case tole_OrchardBand:
     case tole_MownGrass:
     case tole_NaturalGrassWet:
     case tole_RoadsideSlope:
     case tole_Vildtager:
         return false;
  
     case tole_MetalledPath:
     case tole_Carpark:
     case tole_Churchyard:
     case tole_Saltmarsh:
     case tole_Stream:
     case tole_HeritageSite:
     case tole_Garden:
     case tole_Building:
     case tole_Pond:
     case tole_Freshwater:
     case tole_River:
     case tole_Saltwater:
     case tole_Coast:
     case tole_BareRock:
     case tole_AmenityGrass:
     case tole_Parkland:
     case tole_UrbanNoVeg:
     case tole_UrbanPark:
     case tole_BuiltUpWithParkland:
     case tole_SandDune:
     case tole_Copse:
     case tole_IndividualTree:
     case tole_PlantNursery:
     case tole_WindTurbine:
     case tole_WoodyEnergyCrop:
     case tole_WoodlandMargin:
     case tole_Pylon:
         return true;
  
     default:
     g_msg->Warn( WARN_BUG, "Partridge_Covey::NestBadArea(): Unknown tole type", "" );
     exit( 1 );
   }
 }

References g_msg, m_map, Landscape::SupplyElementType(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by NestBadAreasScanFast(), and NestBadAreasScanSlow().

◆ NestBadAreasScanFast()

bool Partridge_Covey::NestBadAreasScanFast	(	int	a_min_x,
		int	a_min_y,
		int	a_length,
		int	a_x,
		int	a_y
	)

protected

Nest location evaluation function.

Definition at line 1170 of file Partridge_Covey.cpp.

                                                                                                      {
   for ( int i = 0; i < a_length; i++ ) {
     int x_inc = a_min_x + i;
     int y_inc = a_min_y + i;
     if ( NestBadArea( x_inc, y_inc ) || NestBadArea( x_inc, a_min_y + a_length - i ) || NestBadArea( x_inc, a_y )
          || NestBadArea( a_x, y_inc ) ) {
            return true;
     }
   }
  
   return false;
 }

References NestBadArea().

Referenced by NestNearBadAreas().

◆ NestBadAreasScanSlow()

bool Partridge_Covey::NestBadAreasScanSlow	(	int	a_min_x,
		int	a_min_y,
		int	a_length,
		int	a_x,
		int	a_y
	)

protected

Nest location evaluation function.

Definition at line 1150 of file Partridge_Covey.cpp.

                                                                                                      {
   int y_dec_base = NormInc( a_min_y + a_length, m_height );
  
   for ( int i = 0; i < a_length; i++ ) {
     int x_inc = Norm( a_min_x + i, m_width );
     int y_inc = Norm( a_min_y + i, m_height );
     int y_dec = Norm( y_dec_base - i, m_height );
     if ( NestBadArea( x_inc, y_inc ) || NestBadArea( x_inc, y_dec ) || NestBadArea( x_inc, a_y )
          || NestBadArea( a_x, y_inc ) ) {
            return true;
     }
   }
  
   return false;
 }

References m_height, m_width, NestBadArea(), Norm(), and NormInc().

Referenced by NestNearBadAreas().

◆ NestFindFast()

bool Partridge_Covey::NestFindFast	(	int	a_min_x_incl,
		int	a_max_x_excl,
		int	a_min_y_incl,
		int	a_max_y_excl
	)

protected

Find nest location.

Definition at line 1207 of file Partridge_Covey.cpp.

                                                                                                            {
   int l_poly_cache = -1;
   int l_min_dist_sq = g_par_nest_min_dist_other_nest.value() * g_par_nest_min_dist_other_nest.value();
   for ( int loops = 0; loops < 10; loops++ ) {
     // Allows us 10 goes at finding a site
     for ( int x = a_min_x_incl; x < a_max_x_excl; x++ ) {
       for ( int y = a_min_y_incl; y < a_max_y_excl; y++ ) {
         int l_poly = m_map->SupplyPolyRef( x, y );
         if ( l_poly == l_poly_cache )
           continue;
  
         l_poly_cache = l_poly;
  
         if ( NestGoodSpot( x, y ) && !NestNearBadAreas( x, y ) && !NestNearNests( x, y, l_min_dist_sq ) ) {
           CoveyUpdateMemberPositions( x, y );
           m_nest_on_nest = true;
           return true;
         }
       }
     }
     a_min_x_incl++;
     a_max_x_excl--;
     a_min_y_incl++;
     a_max_y_excl--;
   }
   return false;
 }

References CoveyUpdateMemberPositions(), g_par_nest_min_dist_other_nest, m_map, m_nest_on_nest, NestGoodSpot(), NestNearBadAreas(), NestNearNests(), Landscape::SupplyPolyRef(), and CfgInt::value().

Referenced by NestFindLocation().

◆ NestFindLocation()

bool Partridge_Covey::NestFindLocation ( void )

Try to locate a suitable nesting location.

Update covey position if we can find a suitable location and return true, or false if we failed to find a good spot.

Definition at line 1107 of file Partridge_Covey.cpp.

                                              {
   // This algorithm can definitely be improved, time permitting!
   // FN, 16/6-2003.
  
   int l_whh = ( ( int )m_nearest_covey_dist ) >> 1;
   if ( g_par_terr_max_width.value() < l_whh ) {
     l_whh = g_par_terr_max_width.value();
   }
  
   int l_min_x_incl = m_center_x - l_whh;
   int l_max_x_excl = m_center_x + l_whh;
   int l_min_y_incl = m_center_y - l_whh;
   int l_max_y_excl = m_center_y + l_whh;
  
   if ( l_min_x_incl < 0 || l_max_x_excl > m_width || l_min_y_incl < 0 || l_max_y_excl > m_height ) {
     return NestFindSlow( l_min_x_incl, l_max_x_excl, l_min_y_incl, l_max_y_excl );
   }
  
   return NestFindFast( l_min_x_incl, l_max_x_excl, l_min_y_incl, l_max_y_excl );
 }

References g_par_terr_max_width, m_center_x, m_center_y, m_height, m_nearest_covey_dist, m_width, NestFindFast(), NestFindSlow(), and CfgInt::value().

Referenced by Partridge_Female::FMakingNest().

◆ NestFindSlow()

bool Partridge_Covey::NestFindSlow	(	int	a_min_x_incl,
		int	a_max_x_excl,
		int	a_min_y_incl,
		int	a_max_y_excl
	)

Find nest location (wrap around)

Definition at line 1236 of file Partridge_Covey.cpp.

                                                                                                            {
   int l_poly_cache = -1;
   int l_min_dist_sq = g_par_nest_min_dist_other_nest.value() * g_par_nest_min_dist_other_nest.value();
  
   ForIterator * l_fx = new ForIterator( a_min_x_incl, a_max_x_excl, 1, 0, m_width );
   int * l_lx = l_fx->GetList();
  
   ForIterator * l_fy = new ForIterator( a_min_y_incl, a_max_y_excl, 1, 0, m_height );
   int * l_ly = l_fy->GetList();
   for ( int loop = 0; loop < 10; loop++ ) {
     for ( int iy = loop; iy < l_fy->GetLimit(); iy++ ) {
       int y = l_ly[ iy ];
       for ( int ix = loop; ix < l_fx->GetLimit(); ix++ ) {
         int x = l_lx[ ix ];
  
         int l_poly = m_map->SupplyPolyRef( x, y );
         if ( l_poly != l_poly_cache ) {
           l_poly_cache = l_poly;
  
           if ( NestGoodSpot( x, y ) && !NestNearBadAreas( x, y ) && !NestNearNests( x, y, l_min_dist_sq ) ) {
             CoveyUpdateMemberPositions( x, y );
             m_nest_on_nest = true;
             delete l_fy;
             delete l_fx;
             return true;
           }
         }
       }
     }
   }
   delete l_fy;
   delete l_fx;
   return false;
 }

References CoveyUpdateMemberPositions(), g_par_nest_min_dist_other_nest, ForIterator::GetLimit(), ForIterator::GetList(), m_height, m_map, m_nest_on_nest, m_width, NestGoodSpot(), NestNearBadAreas(), NestNearNests(), Landscape::SupplyPolyRef(), and CfgInt::value().

Referenced by NestFindLocation().

◆ NestGetX()

int Partridge_Covey::NestGetX ( void )

inline

Return nest x-coord.

Definition at line 521 of file Partridge_Covey.h.

                        {
     return m_nest_x;
   }

References m_nest_x.

Referenced by NestNearNests().

◆ NestGetY()

int Partridge_Covey::NestGetY ( void )

inline

Return nest y-coord.

Definition at line 526 of file Partridge_Covey.h.

                        {
     return m_nest_y;
   }

References m_nest_y.

◆ NestGoodSpot()

bool Partridge_Covey::NestGoodSpot	(	int	a_x,
		int	a_y
	)

protected

Evaluate x,y as a nest location.

Evaluate the given x,y, coord in terms of nesting quality. These qualities are set as configuration variables.

Definition at line 2876 of file Partridge_Covey.cpp.

                                                      {
     TTypesOfLandscapeElement l_cet = m_map->SupplyElementType( a_x, a_y );
   int score, st;
   switch ( l_cet ) {
     case tole_Field:
       score = cfg_nest_field.value();
       // Need to add something about patchy and tramlines
       // TO SIMULATE 1950s SITUATION WITH ALL ACCESS GRANTED
 #ifndef __P1950s
       if (m_map->SupplyVegPatchy( a_x, a_y )) score*=4; // doubled for patchy
       //else if (m_map->SupplyHasTramlines( a_x, a_y )) score*=2; // doubled for tramlines
 #else
       score *=4;
 #endif
     break;
     case tole_RoadsideVerge:
       score = cfg_nest_roadside.value();
     break;
     case tole_Railway:
       score = cfg_nest_railway.value();
     break;
     case tole_FieldBoundary:
       score = cfg_nest_fieldboundary.value();
     break;
     case tole_PermPastureLowYield:
       score = cfg_nest_permpastlowyield.value();
     break;
     case tole_PermPastureTussocky:
       score = cfg_nest_permpasttussocky.value();
     break;
     case tole_PermanentSetaside:
       score = cfg_nest_permsetaside.value();
     break;
     case tole_Heath:
     case tole_NaturalGrassDry:
       score = cfg_nest_naturalgrass.value();
     break;
     case tole_BeetleBank:
         score = cfg_nest_hedgebank1.value();
         break;
     case tole_HedgeBank:
       st = m_OurLandscape->SupplyElementSubType( a_x, a_y );
       switch ( st ) {
         case 0:
           score = cfg_nest_hedgebank0.value();
           break;
         case 1:
           score = cfg_nest_hedgebank1.value();
           break;
         case 2:
           score = cfg_nest_hedgebank2.value();
           break;
      default:
           score = 100;
       }
     break;
     default:
       return false;
   }
   if ( score > random( 1000 ) ) return true;
   return false;
 }

References cfg_nest_field, cfg_nest_fieldboundary, cfg_nest_hedgebank0, cfg_nest_hedgebank1, cfg_nest_hedgebank2, cfg_nest_naturalgrass, cfg_nest_permpastlowyield, cfg_nest_permpasttussocky, cfg_nest_permsetaside, cfg_nest_railway, cfg_nest_roadside, m_map, TAnimal::m_OurLandscape, Landscape::SupplyElementSubType(), Landscape::SupplyElementType(), Landscape::SupplyVegPatchy(), tole_BeetleBank, tole_Field, tole_FieldBoundary, tole_Heath, tole_HedgeBank, tole_NaturalGrassDry, tole_PermanentSetaside, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_Railway, tole_RoadsideVerge, and CfgInt::value().

Referenced by NestFindFast(), and NestFindSlow().

◆ NestLeave()

void Partridge_Covey::NestLeave ( void )

inline

Leave the nest

Definition at line 516 of file Partridge_Covey.h.

                          {
     m_nest_on_nest = false;
   }

References m_nest_on_nest.

Referenced by Partridge_Clutch::ClDeveloping(), Partridge_Female::FDying(), Partridge_Female::FIncubating(), Partridge_Female::FLaying(), Partridge_Female::OnClutchDeath(), Partridge_Female::OnEggsHatch(), and Partridge_Female::OnMateDying().

◆ NestNearBadAreas()

bool Partridge_Covey::NestNearBadAreas	(	int	a_x,
		int	a__y
	)

protected

Test for proximity to unacceptable areas.

Determines if the x,y, positon is too close to something unacceptable

Definition at line 1131 of file Partridge_Covey.cpp.

                                                          {
     int l_min_x = a_x - g_par_nest_min_dist_bad_areas.value();
     int l_max_x = a_x + g_par_nest_min_dist_bad_areas.value() + 1;
     int l_min_y = a_y - g_par_nest_min_dist_bad_areas.value();
     int l_max_y = a_y + g_par_nest_min_dist_bad_areas.value() + 1;
  
     if ( l_min_x < 0 || l_max_x >= m_width || l_min_y < 0 || l_max_y >= m_height ) {
     return NestBadAreasScanSlow( l_min_x, l_min_y, l_max_x - l_min_x, a_x, a_y );
     }
  
     return NestBadAreasScanFast( l_min_x, l_min_y, l_max_x - l_min_x, a_x, a_y );
 }

References g_par_nest_min_dist_bad_areas, m_height, m_width, NestBadAreasScanFast(), NestBadAreasScanSlow(), and CfgInt::value().

Referenced by NestFindFast(), and NestFindSlow().

◆ NestNearNests()

bool Partridge_Covey::NestNearNests	(	int	a_x,
		int	a_y,
		int	a_min_dist_sq
	)

protected

Nest location evaluation function.

Definition at line 1188 of file Partridge_Covey.cpp.

                                                                          {
   for ( unsigned int i = 0; i < g_covey_list.size(); i++ ) {
     Partridge_Covey * l_covey = g_covey_list[ i ];
     // Skip coveys not on nest and ourselves.
     if ( !l_covey->NestOnNest() || l_covey->ID() == m_id ) {
       continue;
     }
     // Found covey on nest. See if this location is too close.
     int dx = l_covey->NestGetX() - a_x;
     int dy = l_covey->NestGetX() - a_y;
  
     if ( dx * dx + dy * dy < a_min_dist_sq ) {
       return true;
     }
   }
   return false;
 }

References g_covey_list, ID(), m_id, NestGetX(), and NestOnNest().

Referenced by NestFindFast(), and NestFindSlow().

◆ NestOnNest()

bool Partridge_Covey::NestOnNest ( void )

inline

Are we nesting?

Definition at line 511 of file Partridge_Covey.h.

                           {
     return m_nest_on_nest;
   }

References m_nest_on_nest.

Referenced by NestNearNests().

◆ Norm()

int Partridge_Covey::Norm	(	int	a_coord,
		int	a_size
	)

protected

Wrap-around utility function.

A function to normalise co-ordinates that may have wrapped around and exceeded the landscape size (+/-)

Definition at line 866 of file Partridge_Covey.cpp.

                                                    {
     while ( a_coord < 0 ) {
         a_coord += a_size;
     }
     while ( a_coord >= a_size ) {
         a_coord -= a_size;
     }
     return a_coord;
 }

Referenced by FlyToSlow(), MoveDistance(), MoveDoIt(), MoveTo(), MoveWeighDirection(), and NestBadAreasScanSlow().

◆ NormDec()

int Partridge_Covey::NormDec	(	int	a_coord,
		int	a_size
	)

protected

Wrap-around utility function.

A function to normalise co-ordinates that may have wrapped around and become negative

Definition at line 882 of file Partridge_Covey.cpp.

                                                       {
   if ( a_coord < 0 )
     return a_coord + a_size;
  
   return a_coord;
 }

Referenced by MoveOptimalDirectionSlow(), MoveSelectLimit(), and MoveWeighDirection().

◆ NormInc()

int Partridge_Covey::NormInc	(	int	a_coord,
		int	a_size
	)

protected

Wrap-around utility function.

A function to normalise co-ordinates that may have wrapped around and exceeded the landscape maximum coord

Definition at line 895 of file Partridge_Covey.cpp.

                                                       {
   if ( a_coord >= a_size )
     return a_coord - a_size;
  
   return a_coord;
 }

Referenced by MoveOptimalDirectionSlow(), MoveSelectLimit(), MoveWeighDirection(), and NestBadAreasScanSlow().

◆ OnAddChick()

void Partridge_Covey::OnAddChick ( Partridge_Female * a_pf )

Add a chick.

Definition at line 2451 of file Partridge_Covey.cpp.

                                                           {
   if ( ++m_ourChicks == 1 ) {
     m_theMum = a_pf;
     m_theDad = m_theMum->GetMate();
   }
 }

References Partridge_Female::GetMate(), m_ourChicks, m_theDad, and m_theMum.

Referenced by Partridge_Chick::Partridge_Chick().

◆ OnChickDeath()

void Partridge_Covey::OnChickDeath ( void )

Remove a dead chick.

Definition at line 2477 of file Partridge_Covey.cpp.

                                          {
   if ( --m_ourChicks == 0 ) {
     //Tell Both Parents
     // The line below is really debug information, this identifies the caller
     m_manager->m_comms_data->m_covey = this;
     //  Call the mother via the message centre
     m_manager->m_comms_data->m_female = m_theMum;
     m_manager->m_comms_data->m_male = m_theDad;
     m_manager->m_messagecentre.PassMessage( m_manager->m_comms_data, pcomm_AllChicksDead );
     m_theDad = NULL;
     m_theMum = NULL;
     SetFixed( false );
   }
 }

References Partridge_Population_Manager::m_comms_data, PartridgeCommunicationData::m_covey, PartridgeCommunicationData::m_female, PartridgeCommunicationData::m_male, m_manager, Partridge_Population_Manager::m_messagecentre, m_ourChicks, m_theDad, m_theMum, Partridge_Communication::PassMessage(), pcomm_AllChicksDead, and SetFixed().

Referenced by Partridge_Chick::ChDying().

◆ OnChickMature()

void Partridge_Covey::OnChickMature ( void )

Remove a matured chick.

Definition at line 2460 of file Partridge_Covey.cpp.

                                           {
   if ( --m_ourChicks == 0 ) {
     //Tell Both Parents
     // The line below is really debug information, this identifies the caller
     m_manager->m_comms_data->m_covey = this;
     //  Call the mother via the message centre
     m_manager->m_comms_data->m_female = m_theMum;
     m_manager->m_comms_data->m_male = m_theDad;
     m_manager->m_messagecentre.PassMessage( m_manager->m_comms_data, pcomm_ChicksMature );
     m_theDad = NULL;
     m_theMum = NULL;
     SetFixed( false );
   }
 }

References Partridge_Population_Manager::m_comms_data, PartridgeCommunicationData::m_covey, PartridgeCommunicationData::m_female, PartridgeCommunicationData::m_male, m_manager, Partridge_Population_Manager::m_messagecentre, m_ourChicks, m_theDad, m_theMum, Partridge_Communication::PassMessage(), pcomm_ChicksMature, and SetFixed().

Referenced by Partridge_Chick2::ChMaturing().

◆ OnDissolve()

void Partridge_Covey::OnDissolve ( int date )

Dissolve message handler.

Definition at line 1624 of file Partridge_Covey.cpp.

                                            {
   m_state = pars_CoveyDissolve;
   SetCoveyDissolveDate( date );
 }

References m_state, pars_CoveyDissolve, and SetCoveyDissolveDate().

◆ OntheDadDead()

void Partridge_Covey::OntheDadDead ( void )

protected

Behaviour when alpha male is killed.

Definition at line 2502 of file Partridge_Covey.cpp.

                                          {
   //SanityCheck2(m_ourChicks );
   m_theDad = NULL;
   ActOnParentDeath();
 }

References ActOnParentDeath(), and m_theDad.

Referenced by RemoveMember().

◆ OntheMumDead()

void Partridge_Covey::OntheMumDead ( void )

protected

Behaviour when alpha female is killed.

Definition at line 2494 of file Partridge_Covey.cpp.

                                          {
   //SanityCheck2(m_ourChicks );
   m_theMum = NULL;
   ActOnParentDeath();
 }

References ActOnParentDeath(), and m_theMum.

Referenced by RemoveMember().

◆ Pressure()

double Partridge_Covey::Pressure ( double a_distance )

protected

Get the pressure force.

Returns the reciprocal of a_distance above a threshold given by MIN_MATH_DIST_SQ. Note that the calling function is responsible for ensuring a_distance is transformed correctly (sqrt()).

Definition at line 1724 of file Partridge_Covey.cpp.

                                                     {
     return 1.0 / max( a_distance, MIN_MATH_DIST_SQ );
 }

Referenced by ManagerRethinkPos().

◆ PressureLimitExceeded()

bool Partridge_Covey::PressureLimitExceeded ( double a_pressure )

protected

Test for exceedence of pressure limit.

Definition at line 1737 of file Partridge_Covey.cpp.

                                                                {
   if ( a_pressure > cfg_par_force_abs_limit.value() )
     return true;
  
   return false;
 }

References cfg_par_force_abs_limit, and CfgFloat::value().

Referenced by ManagerRethinkPos().

◆ RemoveExtraChick()

void Partridge_Covey::RemoveExtraChick ( )

inline

Decrement the chick number.

Definition at line 466 of file Partridge_Covey.h.

                           {
     m_ourChicks--;
   }

References m_ourChicks.

Referenced by Partridge_Chick2::Partridge_Chick2().

◆ RemoveMember()

int Partridge_Covey::RemoveMember ( Partridge_Base * a_former_member )

Remove a member from the covey.

RemoveMember() causes the current Covey instance to be deleted! if a_former_member was the last one.

Definition at line 1664 of file Partridge_Covey.cpp.

                                                                     {
   if ( !IsMember( a_former_member ) ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::RemoveMember(): "
          "Attempting to remove a member not belonging to the flock!", "" );
     exit( 1 );
   }
  
   if ( a_former_member == m_theDad ) {
     OntheDadDead();
   } else if ( a_former_member == m_theMum ) {
     OntheMumDead();
   }
  
   if ( m_members_size == 1 ) {
     g_covey_manager->DelCovey( this );
     // Tell the population manager to delete us.
     m_members_size=0;
     m_CurrentStateNo = -1;
     m_StepDone = true;
     return 0;
   }
  
   //vector<Partridge_Base*> l_members;
   Partridge_Base * l_members[ 100 ];
  
   unsigned int j = 0;
   //l_members.resize( m_members.size() - 1 );
  
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetID() == a_former_member->GetID() ) {
       continue;
     }
     l_members[ j++ ] = m_members[ i ];
   }
  
   //m_members.resize( m_members.size() -1 );
   m_members_size--;
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     m_members[ i ] = l_members[ i ];
   }
  
   return m_members_size;
 }

References CoveyManager::DelCovey(), g_covey_manager, g_msg, Partridge_Base::GetID(), IsMember(), TALMaSSObject::m_CurrentStateNo, m_members, m_members_size, TALMaSSObject::m_StepDone, m_theDad, m_theMum, OntheDadDead(), OntheMumDead(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Partridge_Chick::ChDying(), Partridge_Chick::ChMaturing(), Partridge_Chick2::ChMaturing(), Partridge_Clutch::ClDeveloping(), Partridge_Clutch::ClDying(), Partridge_Population_Manager::DissolveCovey(), Partridge_Female::FDying(), ManagerCheckMerge(), Partridge_Male::MDying(), Partridge_Male::MFindingMate(), and Partridge_Base::SwitchCovey().

◆ SanityCheck()

void Partridge_Covey::SanityCheck ( )

Debug method.

Definition at line 2403 of file Partridge_Covey.cpp.

                                   {
     if (m_CurrentStateNo==-1) return;
     for ( unsigned i = 0; i < m_members_size; i++ ) {
     // Checks that all members have pointers to here
     if ( m_members[ i ]->GetCovey() != this ) {
       g_msg->Warn( WARN_BUG, "Partridge_Covey::SanityCheck(): ""Non-mutual pointers", "" );
       exit( 1 );
     }
   }
 }

References g_msg, TALMaSSObject::m_CurrentStateNo, m_members, m_members_size, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Partridge_Population_Manager::DissolveCovey().

◆ SanityCheck2()

void Partridge_Covey::SanityCheck2 ( int no_chicks )

Debug method.

Definition at line 2416 of file Partridge_Covey.cpp.

                                                   {
   // this one checks that the number of chicks in the covey
   // is the same as the number no_chicks
   int count = 0;
   for ( unsigned i = 0; i < m_members_size; i++ )
     if ( ( m_members[ i ]->GetObjectType() == pob_Chick ) || ( m_members[ i ]->GetObjectType() == pob_Chick2 ) ) count++;
   if ( count != no_chicks ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::SanityCheck2(): ""wrong number of chicks", "" );
     exit( 1 );
   }
 }

References g_msg, GetObjectType(), m_members, m_members_size, pob_Chick, pob_Chick2, MapErrorMsg::Warn(), and WARN_BUG.

◆ SanityCheck3()

void Partridge_Covey::SanityCheck3 ( )

Debug method.

Definition at line 2430 of file Partridge_Covey.cpp.

                                    {
     if ( m_move_list[ 0 ] > 7 ) {
       g_msg->Warn( WARN_BUG, "Partridge_Covey::SanityCheck3(): ""m_move_list illegal", "" );
       exit( 1 );
     }
 }

References g_msg, m_move_list, MapErrorMsg::Warn(), and WARN_BUG.

◆ SanityCheck4()

void Partridge_Covey::SanityCheck4 ( )

Debug method.

Definition at line 2439 of file Partridge_Covey.cpp.

                                    {
   for ( unsigned i = 0; i < m_members_size; i++ ) {
     // Checks that there are no clutches
     if ( m_members[ i ]->GetObjectType()==pob_Clutch ) {
       g_msg->Warn( WARN_BUG, "Partridge_Covey::SanityCheck(): ""Clutch present when it should not be!", "" );
       exit( 1 );
     }
   }
 }

References g_msg, GetObjectType(), m_members, m_members_size, pob_Clutch, MapErrorMsg::Warn(), and WARN_BUG.

◆ SetChickAge()

void Partridge_Covey::SetChickAge ( int age )

inline

Set chick age.

Definition at line 481 of file Partridge_Covey.h.

                               {
     m_ChickAge = age;
   }

References m_ChickAge.

Referenced by Partridge_Chick::BeginStep(), and Partridge_Chick2::BeginStep().

◆ SetCoveyDissolveDate()

void Partridge_Covey::SetCoveyDissolveDate ( int date )

inline

Set the dissolve date.

Definition at line 430 of file Partridge_Covey.h.

                                         {
     m_CoveyDissolveDate = date;
   }

References m_CoveyDissolveDate.

Referenced by OnDissolve().

◆ SetFixed()

void Partridge_Covey::SetFixed ( bool a_is_fixed )

inline

Prevent/enable peg drift.

Definition at line 572 of file Partridge_Covey.h.

                                    {
     m_peg_is_fixed = a_is_fixed;
   }

References m_peg_is_fixed.

Referenced by Partridge_Female::FAttractingMate(), Partridge_Female::FFindingTerritory(), Partridge_Female::FMakingNest(), Partridge_Female::FStartingNewBrood(), Partridge_Male::MFindingMate(), OnChickDeath(), OnChickMature(), Partridge_Male::OnFemaleGivingUp(), Partridge_Female::OnMateDying(), and Partridge_Female::OnWaitForMale().

◆ SetUncle()

void Partridge_Covey::SetUncle ( void )

Swap uncle to alhpha.

Called when both parents are dead but an uncle or aunt exist to take over the role.

Definition at line 2540 of file Partridge_Covey.cpp.

                                      {
   for ( unsigned i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetUncleStatus() ) {
       if ( m_members[ i ]->GetObjectType() == pob_Male ) {
         m_theDad = dynamic_cast<Partridge_Male*>( m_members[ i ]);
         m_theDad->SetState( pars_MCaringForYoung );
       } else {
         m_theMum = dynamic_cast<Partridge_Female*>( m_members[ i ]);
         m_theMum->SetState( pars_FCaringForYoung );
       }
       m_members[ i ]->SetUncleStatus(false);
       return;
     }
   }
   // If we reach here there is an error
   g_msg->Warn( WARN_BUG, "Partridge_Covey::SetUncle(): ""Called but no uncles found", "" );
   exit( 1 );
 }

References g_msg, GetObjectType(), m_members, m_members_size, m_theDad, m_theMum, pars_FCaringForYoung, pars_MCaringForYoung, pob_Male, Partridge_Base::SetState(), Partridge_Base::SetUncleStatus(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by ActOnParentDeath().

◆ Step()

void Partridge_Covey::Step ( void )

virtual

Covey Step.

Reimplemented from TAnimal.

Definition at line 1607 of file Partridge_Covey.cpp.

                                  {
   if ( m_StepDone ) {
     return;
   }
   m_StepDone = true;
 }

References TALMaSSObject::m_StepDone.

◆ SupplyChickAge()

int Partridge_Covey::SupplyChickAge ( void )

protected

Returns the age of the chicks.

Definition at line 2608 of file Partridge_Covey.cpp.

                                           {
   // Relies on the fact that a covey can only have one set of chicks at a time
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Chick ) {
       return m_members[ i ]->GetAge();
     }
   }
   for ( unsigned int i = 0; i < m_members_size; i++ ) {
     if ( m_members[ i ]->GetObjectType() == pob_Chick2 ) {
       return m_members[ i ]->GetAge();
     }
   }
   g_msg->Warn( WARN_BUG, "Partridge_Covey::SupplyChickAge(): ""no chicks", "" );
   exit( 1 );
 }

References g_msg, Partridge_Base::GetAge(), GetObjectType(), m_members, m_members_size, pob_Chick, pob_Chick2, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by ActOnParentDeath().

◆ SupplyDistanceMoved()

double Partridge_Covey::SupplyDistanceMoved ( void )

Return the distance moved today.

Definition at line 914 of file Partridge_Covey.cpp.

                                                   {
   if ( !m_move_done ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::SupplyDistanceMoved: Move not done yet!", "" );
     exit( 1 );
   }
   return m_dist_moved;
 }

References g_msg, m_dist_moved, m_move_done, MapErrorMsg::Warn(), and WARN_BUG.

◆ SupplyFoodToday()

double Partridge_Covey::SupplyFoodToday ( void )

Return the food obtained today.

Definition at line 905 of file Partridge_Covey.cpp.

                                               {
   if ( !m_move_done ) {
     g_msg->Warn( WARN_BUG, "Partridge_Covey::SupplyFoodToday: Move not done yet!", "" );
     exit( 1 );
   }
   return m_food_today;
 }

References g_msg, m_food_today, m_move_done, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Partridge_Chick::ChDeveloping().

◆ SupplyHabitatQuality()

double Partridge_Covey::SupplyHabitatQuality ( void )

Return habitat quality at our location.

Definition at line 1050 of file Partridge_Covey.cpp.

                                                    {
   if ( !m_terr_done ) {
     m_terr_qual = HabitatEvaluate( m_center_x, m_center_y, & m_terr_size, false );
     m_terr_done = true;
   }
   return m_terr_qual;
 }

References HabitatEvaluate(), m_center_x, m_center_y, m_terr_done, m_terr_qual, and m_terr_size.

◆ TooClose()

bool Partridge_Covey::TooClose ( )

Test for another covey too close.

Definition at line 1271 of file Partridge_Covey.cpp.

                                {
   // Returns true if the covey centre peg of any fixed covey is too close
   DistanceUpdate2();
   if ( m_nearest_covey_dist > 50 ) return false; // was 50 23/04/2008
   return true;
 }

References DistanceUpdate2(), and m_nearest_covey_dist.

Referenced by Partridge_Female::FFindingTerritory().

◆ X()

unsigned int Partridge_Covey::X ( void )

inline

Definition at line 708 of file Partridge_Covey.h.

                          {
     return m_covey_x;
   }

References m_covey_x.

Referenced by Partridge_Female::FIncubating().

◆ XCenter()

unsigned int Partridge_Covey::XCenter ( void )

inline

Definition at line 718 of file Partridge_Covey.h.

                                {
     return m_center_x;
   }

References m_center_x.

◆ XCenterF()

double Partridge_Covey::XCenterF ( void )

inline

Definition at line 728 of file Partridge_Covey.h.

                           {
     return m_center_x_float;
   }

References m_center_x_float.

Referenced by DistanceToCovey(), and ManagerCheckMerge().

◆ Y()

unsigned int Partridge_Covey::Y ( void )

inline

Definition at line 713 of file Partridge_Covey.h.

                          {
     return m_covey_y;
   }

References m_covey_y.

Referenced by Partridge_Female::FIncubating().

◆ YCenter()

unsigned int Partridge_Covey::YCenter ( void )

inline

Definition at line 723 of file Partridge_Covey.h.

                                {
     return m_center_y;
   }

References m_center_y.

◆ YCenterF()

double Partridge_Covey::YCenterF ( void )

inline

Definition at line 733 of file Partridge_Covey.h.

                           {
     return m_center_y_float;
   }

Max move distance today.

Determined at the end of the begin step and depending on the age of the chicks. If MoveDistance is called in the BeginStep then it will use yesterdays values.

Definition at line 390 of file Partridge_Covey.h.

Referenced by GetmaxAllowedMove(), and Partridge_Covey().

◆ m_maxFoodNeedToday

double Partridge_Covey::m_maxFoodNeedToday

protected

Food needed today.

Determined at the end of the begin step and depending on the age of the chicks. If MoveDistance is called in the BeginStep then it will use yesterdays values.

Definition at line 395 of file Partridge_Covey.h.

Referenced by BeginStep(), GetmaxFoodNeedToday(), and Partridge_Covey().

◆ m_members

Partridge_Base* Partridge_Covey::m_members[100]

protected

List of covey members

Definition at line 108 of file Partridge_Covey.h.

Referenced by AddMember(), AllFlocking(), AllFlocking2(), ArePaired(), ChickExtraMortality(), CoveyEmigrate(), CoveyIndividualEmigrate(), CoveyUpdateMemberPositions(), FindMeAHusband(), FindMeAMateInCovey(), FindMeAWife(), GetAMember(), GetMaleInCovey(), GetMember(), GetUncleNumber(), GetUnpairedFemale(), GetUnpairedFemale_virgin(), HaveWeChicks(), IsMember(), KillChicks(), KillExcessChicks(), Partridge_Covey(), RemoveMember(), SanityCheck(), SanityCheck2(), SanityCheck4(), SetUncle(), and SupplyChickAge().

◆ m_members_size

unsigned int Partridge_Covey::m_members_size

protected

Size of covey

Definition at line 110 of file Partridge_Covey.h.

Referenced by AddMember(), AllFlocking(), AllFlocking2(), ArePaired(), ChickExtraMortality(), CoveyEmigrate(), CoveyIndividualEmigrate(), CoveyUpdateMemberPositions(), FindMeAHusband(), FindMeAMateInCovey(), FindMeAWife(), GetCoveySize(), GetMaleInCovey(), GetUncleNumber(), GetUnpairedFemale(), GetUnpairedFemale_virgin(), HaveWeChicks(), IsMember(), KillChicks(), KillExcessChicks(), ManagerCheckMerge(), Memberships(), Partridge_Covey(), RemoveMember(), SanityCheck(), SanityCheck2(), SanityCheck4(), SetUncle(), and SupplyChickAge().

◆ m_move_done

bool Partridge_Covey::m_move_done

protected

Have moved?

Definition at line 162 of file Partridge_Covey.h.

Referenced by EndStep(), FixHabitat(), FlyTo(), MoveDistance(), Partridge_Covey(), SupplyDistanceMoved(), and SupplyFoodToday().

◆ m_move_get_index

int Partridge_Covey::m_move_get_index

protected

Internal variable.

Definition at line 304 of file Partridge_Covey.h.

Referenced by MoveDistance(), and MoveTo().

int Partridge_Covey::m_move_whence_we_came

protected

Internal variable.

The direction we came from in the previous move. Remembered across daily steps.

Definition at line 316 of file Partridge_Covey.h.

Referenced by MoveDistance(), MoveSelectLimit(), MoveTo(), MoveWeighDirection(), and Partridge_Covey().

◆ m_nearest_covey_dist

double Partridge_Covey::m_nearest_covey_dist

protected

Closest covey distance

Definition at line 116 of file Partridge_Covey.h.

Referenced by DistanceUpdate(), DistanceUpdate2(), HabitatEvaluate(), MoveTryExclude(), MoveTryExcludeHarder(), NestFindLocation(), Partridge_Covey(), and TooClose().

◆ m_neighbourlist

Partridge_Covey* Partridge_Covey::m_neighbourlist[50]

List of coveys close to this covey.

Definition at line 284 of file Partridge_Covey.h.

Referenced by Partridge_Population_Manager::FillCoveyNeigbourList(), and FindNeighbour().

int Partridge_Covey::m_width

protected

Landscape width.

Definition at line 128 of file Partridge_Covey.h.

Referenced by DistanceToCovey(), DistanceUpdate(), DistanceUpdate2(), FlyTo(), FlyToSlow(), HabitatEvaluate(), HabitatEvaluateFaster(), HabitatEvaluateSlow(), ManagerDriftPos(), ManagerRethinkPos(), ManagerUpdatePos(), MoveDirectionsAllowed(), MoveDoIt(), MoveOptimalDirectionSlow(), NestBadAreasScanSlow(), NestFindLocation(), NestFindSlow(), NestNearBadAreas(), and Partridge_Covey().

The documentation for this class was generated from the following files:

C:/Repo/ALMaSS_All/Partridge/Partridge_Covey.h
C:/Repo/ALMaSS_All/Partridge/Partridge_Covey.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Partridge_Covey()

◆ ~Partridge_Covey()

Member Function Documentation

◆ ActOnParentDeath()

◆ AddMember()

◆ AllFlocking()

◆ AllFlocking2()

◆ ArePaired()

◆ AssessGetSize()

◆ AssessHabitatQuality()

◆ AssessHabitatQualityFaster()

◆ BeginStep()

◆ CanWeMerge()

◆ ChickExtraMortality()

◆ CoveyEmigrate()

◆ CoveyIndividualEmigrate()

◆ CoveyUpdateMemberPositions()

◆ DistanceToCovey()

◆ DistanceUpdate()

◆ DistanceUpdate2()

◆ EndStep()

◆ FindMateInArea()

◆ FindMeAHusband()

◆ FindMeAMateInCovey()

◆ FindMeAWife()

◆ FindNeighbour()

◆ FixHabitat()

◆ FlyTo()

◆ FlyToFast()

◆ FlyToSlow()

◆ ForceLow()

◆ GetAMember()

◆ GetChickAge()

◆ GetCoveySize()

◆ GetMaleInCovey()

◆ GetmaxAllowedMove()

◆ GetmaxFoodNeedToday()

◆ GetMember()

◆ GetObjectType()

◆ GetOurChicks()

◆ GetUncle()

◆ GetUncleNumber()

◆ GetUnpairedFemale()

◆ GetUnpairedFemale_virgin()

◆ HabitatEvalPoly()

◆ HabitatEvalPolyField()

◆ HabitatEvaluate()

◆ HabitatEvaluateFast()

◆ HabitatEvaluateFaster()

◆ HabitatEvaluateSlow()

◆ HaveWeChicks()

◆ ID()

◆ IsFixed()

◆ IsMember()

◆ KillChicks()

◆ KillExcessChicks()

◆ LifeEssenceLow()

◆ ManagerCheckMerge() [1/2]

◆ ManagerCheckMerge() [2/2]

◆ ManagerDriftPos()

◆ ManagerIsPermanant()

◆ ManagerRethinkPos()

◆ ManagerSetPermanent()

◆ ManagerUpdatePos()

◆ Memberships()

◆ MoveCanMove() [1/2]

◆ MoveCanMove() [2/2]

◆ MoveDirectionsAllowed()

◆ MoveDistance()

◆ MoveDoIt()

◆ MoveEvalEdgesAndQual()

◆ MoveMagicVegToFood()

◆ MoveOptimalDirectionFast()

◆ MoveOptimalDirectionSlow()