SkTerritories Class Reference

#include <skylarks_all.h>

Public Member Functions
void	Tick (void)
void	EvaluateAllTerritories (void)
void	PreCachePoly (int a_poly)
double	PrePoly2Qual (int a_poly)
double	PrePolyNQual (int a_poly, int *a_good_polys)
void	PreProcessLandscape2 (Landscape *L)
void	ClaimGrid (int x, int y, int range)
void	UpdateQuality ()
bool	IsGridPositionValid (int &x, int &y, int range)
bool	IsExtGridPositionValid (int &x, int &y, int range)
int	IsValid (int nx, int ny)
void	GetTerritoriesByDistance (int nx, int ny, vector< APoint > *alist)
int	Supply_quality (int ref)
int	Supply_x (int ref)
int	Supply_y (int ref)
int	Supply_size (int ref)
skTTerritory *	Supply_terr (int ref)
void	RemoveFemale (int ref)
void	RemoveMale (int ref)
void	Split (int ref)
Skylark_Male *	Supply_Owner (int ref)
Skylark_Female *	Supply_F_Owner (int ref)
void	Occupy (int ref, Skylark_Male *Male)
void	FemaleOccupy (int ref, Skylark_Female *Female)
double	EvaluateHabitatN (skTTerritory *a_terr)
int	SupplyNoTerritories ()
int	SupplyNoMaleOccupied ()
int	SupplyNoFemaleOccupied ()
bool	SupplyIsNestValid (int ref)
APoint	SupplyNestPosition (int ref)
	SkTerritories (Landscape *L)
	~SkTerritories ()

Public Attributes
int	PolyRefData [2500]
int	PolySizeData [2500]
double	PolyHeightData [2500]
TTypesOfLandscapeElement	PolyTypeData [2500]
Landscape *	TheLandscape

Private Member Functions
int	EvaluateHabitatSquare (int xmin, int xmax, int ymin, int ymax, int NoPolygons)
int	PreMakeForIterator (int a_min_incl, int a_max_excl, int *a_iter, int a_norm_max_excl)
void	PreFillTerrPolyLists (skTTerritory *a_terr)
void	PreFillQualGrid (void)
void	PreEvaluateQualGrid (SkQualGrid *a_grid, int a_x, int a_y, int a_width, int a_height)
void	PreFillQualCache (void)
int	PreEvaluateHabitat (int a_x, int a_y, int a_range_x, int a_range_y)
int	PreEvaluateHabitatStripX (int a_x, int a_y, int a_range_x)
int	PreEvaluateHabitatStripY (int a_x, int a_y, int a_range_x)
void	DumpMapGraphics (const char *a_filename, Landscape *a_map)

Private Attributes
skTTerritory *	Territories [400000]
int	NoTerritories
int	SimW
int	SimH
bool *	Grid
int	m_sim_w_div_10
int	m_sim_h_div_10
int	m_qual_grid_signal
SkQualGrid **	m_qual_grid
int	m_hash_size
int *	m_poly_seen
int *	m_poly_size
double *	m_qual_cache
bool	m_qual_cache_filled
int	m_for_iter_x [1000]
int	m_for_iter_y [1000]

Constructor & Destructor Documentation

SkTerritories()

SkTerritories::SkTerritories

(

Landscape *

L

)

                                            {
  TheLandscape = L;
  NoTerritories = 0; // must be set to zero otherwise will try to delete
  // non-existant territories on first call of PreProcessLandscape2()
  SimW = L->SupplySimAreaWidth();
  SimH = L->SupplySimAreaHeight();
  m_sim_w_div_10 = SimW / 10;
  m_sim_h_div_10 = SimH / 10;
  Grid = new bool[m_sim_w_div_10 * m_sim_h_div_10];
  m_qual_grid_signal = -1;
}

References Grid, m_qual_grid_signal, m_sim_h_div_10, m_sim_w_div_10, NoTerritories, SimH, SimW, Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), and TheLandscape.

~SkTerritories()

SkTerritories::~SkTerritories

(

)

                              {
  for ( int i = 0; i < NoTerritories; i++ ) delete Territories[ i ];
  free( m_poly_seen );
  free( m_poly_size );
  free( m_qual_cache );
 
  for ( int i = 0; i < m_sim_w_div_10 * m_sim_h_div_10; i++ ) {
    delete m_qual_grid[ i ];
  }
  free( m_qual_grid );
}

References m_poly_seen, m_poly_size, m_qual_cache, m_qual_grid, m_sim_h_div_10, m_sim_w_div_10, NoTerritories, and Territories.

Member Function Documentation

ClaimGrid()

void SkTerritories::ClaimGrid	(	int	x,
		int	y,
		int	range
	)

                                                       {
  int l_max_x = x + range;
  if ( l_max_x > m_sim_w_div_10 )
    l_max_x = m_sim_w_div_10;
 
  int l_max_y = y + range;
  if ( l_max_y > m_sim_h_div_10 )
    l_max_y = m_sim_h_div_10;
 
  for ( int i = x; i < l_max_x; i++ ) {
    for ( int j = y; j < l_max_y; j++ ) {
        Grid[i + j * m_sim_w_div_10] = true;
    }
  }
}

References Grid, m_sim_h_div_10, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

DumpMapGraphics()

void SkTerritories::DumpMapGraphics ( const char *  a_filename, Landscape *  a_map  )

private

{
  int l_width = a_map->SupplySimAreaWidth();
  int l_height = a_map->SupplySimAreaHeight();
  unsigned int linesize = l_width * 3;
  unsigned char * frame_buffer = ( unsigned char * ) malloc( sizeof( unsigned char ) * linesize * l_height );
 
  FILE * l_file;
 
  if ( frame_buffer == NULL ) {
    g_msg->Warn( WARN_FILE, "SkTerritories::DumpMapGraphics(): Out of memory!", "" );
    exit( 1 );
  }
 
  for ( int y = 0, i = 0; y < l_height; y++ ) {
    for ( int x = 0; x < l_width; x++ ) {
      int eletype = ( int )a_map->SupplyElementType( x, y );
      int localcolor = 16777215/eletype;
 
      if ( eletype == ( int )tole_Field ) {
        int category;
        double hei = a_map->SupplyVegHeight( x, y );
        if ( hei > 50.0 ) category = 0; else
          category = ( int )( 200.0 - ( hei * 4.0 ) );
        localcolor = ( ( category * 65536 ) + 65535 );
      }
 
      frame_buffer[ i++ ] = (unsigned char)(localcolor & 0xff);
      frame_buffer[ i++ ] = (unsigned char)(( localcolor >> 8 ) & 0xff);
      frame_buffer[ i++ ] = (unsigned char) (( localcolor >> 16 ) & 0xff);
    }
  }
 
  for ( int i = 0; i < NoTerritories; i++ ) {
    int l_x = Territories[ i ]->m_Location_x;
    int l_y = Territories[ i ]->m_Location_y;
    int l_s = Territories[ i ]->Size;
    // Horizontal lines of territory bounding box.
    for ( int x = l_x; x < l_x + l_s; x++ ) {
      int y = l_y;
      if ( x >= 0 && x < l_width && y >= 0 && y < l_height ) {
        int pixel_p = x * 3 + linesize * y;
        frame_buffer[ pixel_p++ ] = 200;
        frame_buffer[ pixel_p++ ] = 0;
        frame_buffer[ pixel_p ] = 0;
      }
      y = l_y + l_s - 1;
      if ( x >= 0 && x < l_width && y >= 0 && y < l_height ) {
        int pixel_p = x * 3 + linesize * y;
        frame_buffer[ pixel_p++ ] = 200;
        frame_buffer[ pixel_p++ ] = 0;
        frame_buffer[ pixel_p ] = 0;
      }
    }
    for ( int y = l_y; y < l_y + l_s; y++ ) {
      int x = l_x;
      if ( x >= 0 && x < l_width && y >= 0 && y < l_height ) {
        int pixel_p = x * 3 + linesize * y;
        frame_buffer[ pixel_p++ ] = 200;
        frame_buffer[ pixel_p++ ] = 0;
        frame_buffer[ pixel_p ] = 0;
      }
      x = l_x + l_s - 1;
      if ( x >= 0 && x < l_width && y >= 0 && y < l_height ) {
        int pixel_p = x * 3 + linesize * y;
        frame_buffer[ pixel_p++ ] = 200;
        frame_buffer[ pixel_p++ ] = 0;
        frame_buffer[ pixel_p ] = 0;
      }
    }
  }
 
  l_file = fopen(a_filename, "w" );
  if ( !l_file ) {
    g_msg->Warn( WARN_FILE, "SkTerritories::DumpMapGraphics(): ""Unable to open file for writing: %s\n", a_filename );
    exit( 1 );
  }
 
  fprintf( l_file, "P6\n%d %d %d\n", l_width, l_height, 255 );
  fwrite( frame_buffer, sizeof( unsigned char ), linesize * l_height, l_file );
  fclose( l_file );
 
  free( frame_buffer );
}

References skTTerritory::m_Location_x, skTTerritory::m_Location_y, NoTerritories, skTTerritory::Size, Landscape::SupplyElementType(), Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), Landscape::SupplyVegHeight(), Territories, and tole_Field.

EvaluateAllTerritories()

void SkTerritories::EvaluateAllTerritories

(

void

)

{
      for ( int i = 0; i < NoTerritories; i++ ) {
          EvaluateHabitatN(Territories[i]);
      }
}

References EvaluateHabitatN(), NoTerritories, and Territories.

Referenced by Skylark_Population_Manager::DoFirst().

EvaluateHabitatN()

double SkTerritories::EvaluateHabitatN

(

skTTerritory *

a_terr

)

                                                              {
  //a_good_polys = 0;
  int a_area_polys = 0;
  int l_polygons = (int) a_terr->m_polys.size();
  double l_qual = 0.0;
 
  if ( l_polygons > 2500 ) {
    g_land->Warn( "SkTerritories::EvaluateHabitat1(): - Polygons > 2500", "" );
    exit( 1 );
  }
 
  for ( int i = 0; i < l_polygons; i++ ) {
    int l_poly = a_terr->m_polys[ i ];
    l_qual += ( double )( a_terr->m_sizes[ i ] ) * PrePolyNQual( l_poly, 0 );
    //l_qual += ( double )( a_terr->m_sizes[ i ] ) * PrePoly2Qual( l_poly );
    a_area_polys += a_terr->m_sizes[ i ];
  }
 
  l_qual  *= ( a_terr->m_competitionscaler); //* a_terr->GetHeterogeneity());
  // Update territory quality
  a_terr->SetQuality((int) l_qual);
  // return the quality to calling method
  return l_qual;
}

References g_land, skTTerritory::m_competitionscaler, skTTerritory::m_polys, skTTerritory::m_sizes, PrePolyNQual(), skTTerritory::SetQuality(), and Landscape::Warn().

Referenced by EvaluateAllTerritories().

EvaluateHabitatSquare()

int SkTerritories::EvaluateHabitatSquare ( int  xmin, int  xmax, int  ymin, int  ymax, int  NoPolygons  )

private

FemaleOccupy()

void SkTerritories::FemaleOccupy	(	int	ref,
		Skylark_Female *	Female
	)

                                                                   {
  Territories[ ref ]->F_Owner = Female;
}

References skTTerritory::F_Owner, and Territories.

Referenced by Skylark_Female::EstablishTerritory(), and Skylark_Male::OnReHouse().

GetTerritoriesByDistance()

void SkTerritories::GetTerritoriesByDistance	(	int	nx,
		int	ny,
		vector< APoint > *	alist
	)

                                                                                    {
    int dist=0;
//  alist->resize(NoTerritories);
    APoint p;
    for ( int i = 0; i < NoTerritories; i++ ) {
        dist = abs(Territories[ i ]->m_Location_x-nx);
        dist += abs(Territories[ i ]->m_Location_y-ny);
        p.m_x = i;
        p.m_y = dist;
        alist->push_back(p);
    }
    sort(alist->begin(), alist->end(), CompareDist);
}

References CompareDist(), NoTerritories, and Territories.

Referenced by Skylark_Male::OnEvicted(), and Skylark_Male::st_Arriving().

IsExtGridPositionValid()

bool SkTerritories::IsExtGridPositionValid	(	int &	x,
		int &	y,
		int	range
	)

                                                                        {
  // The commented out code **CJT** below could be used if we want
  // to invalidate the whole area up to the point where we hit problems
  // However, this will lead to large territory-less holes in the
  // landscape
 
  int l_max_x = x + range;
  if ( l_max_x > m_sim_w_div_10 ) {
    // l_max_x = m_sim_w_div_10;
    return false;
  }
 
  int l_max_y = y + range;
  if ( l_max_y > m_sim_h_div_10 ) {
    //l_max_y = m_sim_h_div_10;
    return false;
  }
 
  //Needs only to check the left most column and bottom row
  // The leftmost column
  for ( int j = y; j < l_max_y; j++ ) {
      if (Grid[x + j * m_sim_w_div_10]) {
      return false;
    }
  }
  // The bottom row
  for ( int i = x; i < l_max_x; i++ ) {
      if (Grid[i + y * m_sim_w_div_10]) {
      return false;
    }
  }
  // All OK
  return true;
}

References Grid, m_sim_h_div_10, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

IsGridPositionValid()

bool SkTerritories::IsGridPositionValid	(	int &	x,
		int &	y,
		int	range
	)

                                                                     {
  int l_max_x = x + range;
  if ( l_max_x > m_sim_w_div_10 ) {
    //l_max_x = m_sim_w_div_10;
    return false;
  }
 
  int l_max_y = y + range;
  if ( l_max_y > m_sim_h_div_10 ) {
    //l_max_y = m_sim_h_div_10;
    return false;
  }
 
  for ( int i = x; i < l_max_x; i++ ) {
    for ( int j = y; j < l_max_y; j++ ) {
        if (Grid[i + j * m_sim_w_div_10]) {
        return false;
      }
    }
  }
  // No occupied squares found so
  return true;
}

References Grid, m_sim_h_div_10, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

IsValid()

int SkTerritories::IsValid	(	int	nx,
		int	ny
	)

                                           {
  int found = -1;
  for ( int i = 0; i < NoTerritories; i++ ) {
    if ( ( Territories[ i ]->m_Location_x <= nx ) && ( Territories[ i ]->m_Location_x + Territories[ i ]->Size > nx )
         && ( Territories[ i ]->m_Location_y <= ny ) && ( Territories[ i ]->m_Location_y + Territories[ i ]->Size > ny ) ) {
           found = i;
           break;
    }
  }
  return found;
}

References NoTerritories, and Territories.

Occupy()

void SkTerritories::Occupy	(	int	ref,
		Skylark_Male *	Male
	)

                                                         {
  Territories[ ref ]->Owner = Male;
}

References skTTerritory::Owner, and Territories.

Referenced by Skylark_Male::EstablishingATerritory().

PreCachePoly()

void SkTerritories::PreCachePoly

(

int

a_poly

)

{
    m_qual_cache[a_poly] = PrePoly2Qual(a_poly);
}

References m_qual_cache, and PrePoly2Qual().

Referenced by Landscape::SkylarkEvaluation().

PreEvaluateHabitat()

int SkTerritories::PreEvaluateHabitat ( int  a_x, int  a_y, int  a_range_x, int  a_range_y  )

inlineprivate

                                                                                             {
  double l_qual = 0.0;
 
  int l_max_x = a_x + a_range_x;
  int l_max_y = a_y + a_range_y;
  if ( l_max_x > m_sim_w_div_10 )
    l_max_x = m_sim_w_div_10;
  if ( l_max_y > m_sim_h_div_10 )
    l_max_y = m_sim_h_div_10;
 
  for ( int x = a_x; x < l_max_x; x++ ) {
    for ( int y = a_y; y < l_max_y; y++ ) {
      int l_i = x + y * m_sim_w_div_10;
      l_qual += m_qual_grid[ l_i ]->m_qual;
    }
  }
  return ( int )l_qual;
}

References SkQualGrid::m_qual, m_qual_grid, m_sim_h_div_10, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

PreEvaluateHabitatStripX()

int SkTerritories::PreEvaluateHabitatStripX ( int  a_x, int  a_y, int  a_range_x  )

inlineprivate

                                                                                    {
  double l_qual = 0.0;
  int l_y_fixed = a_y * m_sim_w_div_10;
 
  int l_max_x = a_x + a_range_x;
  if ( l_max_x > m_sim_w_div_10 )
    l_max_x = m_sim_w_div_10;
 
  for ( int x = a_x; x < l_max_x; x++ ) {
        int l_i = x + l_y_fixed;
        l_qual+=m_qual_grid[ l_i ]->m_qual;
/*
    int l_gmax = (int)m_qual_grid[ l_i ]->m_polys.size();
    for ( int g = 0; g < l_gmax; g++ ) {
      l_qual += ( double )( m_qual_grid[ l_i ]->m_sizes[ g ] ) * m_qual_cache[ m_qual_grid[ l_i ]->m_polys[ g ]];
    }
*/
  }
  return ( int )l_qual;
}

References SkQualGrid::m_qual, m_qual_grid, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

PreEvaluateHabitatStripY()

int SkTerritories::PreEvaluateHabitatStripY ( int  a_x, int  a_y, int  a_range_x  )

inlineprivate

                                                                                    {
  double l_qual = 0.0;
 
  int l_max_y = a_y + a_range_y;
  if ( l_max_y > m_sim_h_div_10 )    l_max_y = m_sim_h_div_10;
 
  for ( int y = a_y; y < l_max_y; y++ ) {
    int l_i = a_x + y * m_sim_w_div_10;
    l_qual += m_qual_grid[ l_i ]->m_qual;
/*
    int l_gmax = (int)m_qual_grid[ l_i ]->m_polys.size();
    for ( int g = 0; g < l_gmax; g++ ) {
      l_qual += ( double )( m_qual_grid[ l_i ]->m_sizes[ g ] ) * m_qual_cache[ m_qual_grid[ l_i ]->m_polys[ g ]];
    }
*/
  }
  return ( int )l_qual;
}

References SkQualGrid::m_qual, m_qual_grid, m_sim_h_div_10, and m_sim_w_div_10.

Referenced by PreProcessLandscape2().

PreEvaluateQualGrid()

void SkTerritories::PreEvaluateQualGrid ( SkQualGrid *  a_grid, int  a_x, int  a_y, int  a_width, int  a_height  )

private

                                                                                                          {
    int l_polygons = 0;
    double qual=0;
    if (a_grid->m_polys.size()==0) {
        for ( int y = a_y; y < a_y + a_height; y++ ) {
            for ( int x = a_x; x < a_x + a_width; x++ ) {
                int l_poly = TheLandscape->SupplyPolyRef( x, y );
                int l_i = m_poly_seen[ l_poly ];
                if ( l_i >= 0 ) {
                    a_grid->m_sizes[ l_i ] ++;
                    continue;
                }
                m_poly_seen[ l_poly ] = a_grid->Insert( l_poly );
                PolyRefData[ l_polygons++ ] = l_poly;
            }
        }
        for ( int i = 0; i < (int) a_grid->m_polys.size(); i++ ) {
            qual += ( a_grid->m_sizes[ i ] ) * m_qual_cache[ a_grid->m_polys[ i ]];
            m_poly_seen[ PolyRefData[ i ]] = -1;    // Get ready for the next square - done here because here we know how may -1s to use
        }
    }
    else
    {
        for ( int i = 0; i < (int) a_grid->m_polys.size(); i++ ) {
            qual += ( a_grid->m_sizes[ i ] ) * m_qual_cache[ a_grid->m_polys[ i ]];
        }
    }
    a_grid->m_qual=qual;
}

References SkQualGrid::Insert(), m_poly_seen, SkQualGrid::m_polys, SkQualGrid::m_qual, m_qual_cache, SkQualGrid::m_sizes, PolyRefData, Landscape::SupplyPolyRef(), and TheLandscape.

Referenced by PreFillQualGrid().

PreFillQualCache()

void SkTerritories::PreFillQualCache ( void  )

private

This method is called only once since the male cues on returning to the landscape are thought to be structural and not vegatation based (e.g. he waits in ploughed fields). Later he will use the same assessment as the females, but this is not possible early in the season before vegetation grows.

                                           {
  m_qual_cache_filled = true;
 
  for ( int i = 0; i < m_sim_w_div_10 * m_sim_h_div_10; i++ ) {
    int l_gmax = (int)m_qual_grid[ i ]->m_polys.size();
    for ( int g = 0; g < l_gmax; g++ ) {
      int l_this_poly = m_qual_grid[ i ]->m_polys[ g ];
      if ( m_poly_seen[ l_this_poly ] == -1 ) {
        m_poly_seen[ l_this_poly ] = 1;
        m_qual_cache[ l_this_poly ] = PrePoly2Qual( l_this_poly );
      }
    }
  }
  for ( int i = 0; i < m_hash_size; i++ ) {
    m_poly_seen[ i ] = -1; // m_poly_seen is used elsewhere so is reset here.
  }
}

References m_hash_size, m_poly_seen, SkQualGrid::m_polys, m_qual_cache, m_qual_cache_filled, m_qual_grid, m_sim_h_div_10, m_sim_w_div_10, and PrePoly2Qual().

PreFillQualGrid()

void SkTerritories::PreFillQualGrid ( void  )

private

                                          {
//  if ( m_qual_grid_signal == 2 )
//    return;
    if ( m_qual_grid_signal != 2 ){
        // First time we are ever called. Allocate the memory for the
        // quality computations, and fill in the 10x10m quality grid.
        m_qual_grid_signal = 2;
        m_hash_size = g_land->SupplyLargestPolyNumUsed() + 1;
        // Using malloc because this allows us to use a test of available memory
        m_qual_grid = ( SkQualGrid * * ) malloc( sizeof( SkQualGrid * ) * m_sim_w_div_10 * m_sim_h_div_10 );
        m_poly_seen = ( int * ) malloc( sizeof( int ) * m_hash_size );
        m_poly_size = ( int * ) malloc( sizeof( int ) * m_hash_size );
        m_qual_cache = ( double * ) malloc( sizeof( double ) * m_hash_size );
 
        bool l_ok = true;
        for ( int i = 0; i < m_sim_w_div_10 * m_sim_h_div_10; i++ ) {
          m_qual_grid[ i ] = new SkQualGrid;
          if ( m_qual_grid[ i ] == NULL ) {
            l_ok = false;
            break;
          }
        }
 
        if ( m_qual_grid == NULL || m_poly_seen == NULL || m_qual_cache == NULL || m_poly_size == NULL || !l_ok ) {
          g_msg->Warn( WARN_FILE, "SkTerritories::PreFillQualGrid(): ""Out of memory!\n", "" );
          exit( 1 );
        }
    }
 
    for ( int i = 0; i < m_hash_size; i++ ) {
        m_poly_seen[ i ] = -1;
    }
 
  TheLandscape->SkylarkEvaluation( this );
  int i = 0;
  for ( int y = 0; y < m_sim_h_div_10; y++ ) {
    for ( int x = 0; x < m_sim_w_div_10; x++ ) {
      PreEvaluateQualGrid( m_qual_grid[ i++ ], x * 10, y * 10, 10, 10 );
    }
  }
  //PreFillQualCache();
}

References g_land, m_hash_size, m_poly_seen, m_poly_size, m_qual_cache, m_qual_grid, m_qual_grid_signal, m_sim_h_div_10, m_sim_w_div_10, PreEvaluateQualGrid(), Landscape::SkylarkEvaluation(), Landscape::SupplyLargestPolyNumUsed(), and TheLandscape.

Referenced by PreProcessLandscape2().

PreFillTerrPolyLists()

void SkTerritories::PreFillTerrPolyLists ( skTTerritory *  a_terr )

private

                                                                {
  int x_min_inc = a_terr->m_x_div10;
  int x_max_exc = a_terr->m_x_div10 + a_terr->m_range_div10;
  int y_min_inc = a_terr->m_y_div10;
  int y_max_exc = a_terr->m_y_div10 + a_terr->m_range_div10;
  int l_polygons = 0;
 
  for ( int y = y_min_inc; y < y_max_exc; y++ ) {
    for ( int x = x_min_inc; x < x_max_exc; x++ ) {
      int l_i = x + y * m_sim_w_div_10;
      int l_gmax = (int)m_qual_grid[ l_i ]->m_polys.size();
      for ( int g = 0; g < l_gmax; g++ ) {
        int l_poly = m_qual_grid[ l_i ]->m_polys[ g ];
        if ( m_poly_seen[ l_poly ] == 1 ) {
          m_poly_size[ l_poly ] += m_qual_grid[ l_i ]->m_sizes[ g ];
          continue;
        }
        m_poly_seen[ l_poly ] = 1;
        m_poly_size[ l_poly ] = m_qual_grid[ l_i ]->m_sizes[ g ];
        PolyRefData[ l_polygons++ ] = l_poly;
      }
    }
  }
 
  a_terr->m_polys.resize( l_polygons );
  a_terr->m_sizes.resize( l_polygons );
  for ( int i = 0; i < l_polygons; i++ ) {
    int l_poly = PolyRefData[ i ];
    m_poly_seen[ l_poly ] = -1;
    a_terr->m_polys[ i ] = l_poly;
    a_terr->m_sizes[ i ] = m_poly_size[ l_poly ];
  }
 
  // Now build the same lists for the home range,
  // centered on this territory.
  int l_offset = ( a_terr->m_range_div10 ) >> 1;
  x_min_inc = a_terr->m_x_div10 + l_offset - HomeRangeDiameterDiv20;
  x_max_exc = a_terr->m_x_div10 + l_offset + HomeRangeDiameterDiv20;
  y_min_inc = a_terr->m_y_div10 + l_offset - HomeRangeDiameterDiv20;
  y_max_exc = a_terr->m_y_div10 + l_offset + HomeRangeDiameterDiv20;
 
  l_polygons = 0;
 
  int l_c = PreMakeForIterator( x_min_inc, x_max_exc, m_for_iter_x, m_sim_w_div_10 );
  PreMakeForIterator( y_min_inc, y_max_exc, m_for_iter_y, m_sim_h_div_10 );
 
  for ( int l_y = 0; l_y < l_c; l_y++ ) {
    int y = m_for_iter_y[ l_y ];
    for ( int l_x = 0; l_x < l_c; l_x++ ) {
      int l_i = m_for_iter_x[ l_x ] + y * m_sim_w_div_10;
      int l_gmax = (int)m_qual_grid[ l_i ]->m_polys.size();
      for ( int g = 0; g < l_gmax; g++ ) {
        int l_poly = m_qual_grid[ l_i ]->m_polys[ g ];
        if ( m_poly_seen[ l_poly ] == 1 ) {
          m_poly_size[ l_poly ] += m_qual_grid[ l_i ]->m_sizes[ g ];
          continue;
        }
        m_poly_seen[ l_poly ] = 1;
        m_poly_size[ l_poly ] = m_qual_grid[ l_i ]->m_sizes[ g ];
        PolyRefData[ l_polygons++ ] = l_poly;
      }
    }
  }
 
  a_terr->m_hr_polys.resize( l_polygons );
  a_terr->m_hr_sizes.resize( l_polygons );
  for ( int i = 0; i < l_polygons; i++ ) {
    int l_poly = PolyRefData[ i ];
    m_poly_seen[ l_poly ] = -1;
    a_terr->m_hr_polys[ i ] = l_poly;
    a_terr->m_hr_sizes[ i ] = m_poly_size[ l_poly ];
  }
}

References HomeRangeDiameterDiv20, m_for_iter_x, m_for_iter_y, skTTerritory::m_hr_polys, skTTerritory::m_hr_sizes, m_poly_seen, m_poly_size, skTTerritory::m_polys, SkQualGrid::m_polys, m_qual_grid, skTTerritory::m_range_div10, m_sim_h_div_10, m_sim_w_div_10, skTTerritory::m_sizes, SkQualGrid::m_sizes, skTTerritory::m_x_div10, skTTerritory::m_y_div10, PolyRefData, and PreMakeForIterator().

Referenced by PreProcessLandscape2(), and Split().

PreMakeForIterator()

int SkTerritories::PreMakeForIterator ( int  a_min_incl, int  a_max_excl, int *  a_iter, int  a_norm_max_excl  )

private

                                                                                                         {
 
  int i, index = 0;
  int med_max;
  int high_max = -1;
 
  if ( a_max_excl >= a_norm_max_excl ) {
    med_max = a_norm_max_excl;
    high_max = a_max_excl;
  } else {
    med_max = a_max_excl;
  }
 
  for ( i = a_min_incl; i < 0; i++ ) {
    a_iter[ index++ ] = i + a_norm_max_excl;
  }
  for ( ; i < med_max; i++ ) {
    a_iter[ index++ ] = i;
  }
  for ( ; i < high_max; i++ ) {
    a_iter[ index++ ] = i - a_norm_max_excl;
  }
  return index;
}

Referenced by PreFillTerrPolyLists().

PrePoly2Qual()

double SkTerritories::PrePoly2Qual ( int  a_poly )

inline

Used only on start-up when potential territories need to be determined.

{
  TTypesOfLandscapeElement l_type = TheLandscape->SupplyElementType( a_poly );
  double l_height;
  double l_score = -9999.0;
//  bool ppremium = false;
//  int l_index;
 
 
 
  switch ( l_type ) {
    case tole_YoungForest: //
      l_score = HQualityBareEarth + PatchyPremium;
      break;
    case tole_Hedges: // 130
    case tole_HedgeBank:
      l_score = HQualityHedge;
      break;
    case tole_IndividualTree:
    case tole_PlantNursery:
    case tole_WindTurbine:
    case tole_WoodyEnergyCrop:
    case tole_WoodlandMargin:
    case tole_Pylon:
    case tole_PitDisused: // 75
    case tole_RiversideTrees: // 97
    case tole_DeciduousForest: // 40
    case tole_MixedForest: // 60
    case tole_ConiferousForest: // 50
    case tole_ActivePit: // 115
    case tole_Building: // 5
    case tole_Copse:
    case tole_Orchard:
    case tole_BuiltUpWithParkland:
        l_score = HQualityTall2;
      break;
    case tole_Churchyard:
    case tole_Garden: //11
    case tole_UrbanNoVeg: // 8
      l_score = HQualityTallVeg;
      break;
    case tole_Saltmarsh:
    case tole_NaturalGrassWet:
    case tole_Marsh: // 95
    case tole_Scrub: // 70
      l_score = HQualityHedgeScrub;
      break;
    case tole_RoadsideSlope:
    case tole_Field:
    case tole_RoadsideVerge: // 13
    case tole_FieldBoundary: // 160
    case tole_UnsprayedFieldMargin:
    case tole_PermanentSetaside: // 7
    case tole_Heath:
    case tole_PermPastureLowYield:
    case tole_PermPastureTussocky:
    case tole_PermPasture: // 35
    case tole_NaturalGrassDry: // 110
    case tole_BeetleBank:
    case tole_Wasteland:
    case tole_Vildtager:
    case tole_MownGrass:
        // Must be potentially suitable vegetation element so score depends on
    // the vegetation height
    l_height = TheLandscape->SupplyVegHeight( a_poly );
    if ( l_height >= 200.0 )
    {
        l_score = HQualityTallVeg;
    } else
    {
        if ( l_height >= 110.0 )
        {
            l_score = HQualityTall;
        } else
        {
            l_score = SKOPTIMALHABITATSCORE;  // Start with a max
            if (!TheLandscape->SupplyVegPatchy( a_poly )) l_score *= 0.50;
        }
    }
   break;
 
    case tole_SmallRoad: // 120
    case tole_LargeRoad: // 121
      l_score = HQualityMetalRoad;
    break;
 
    case tole_MetalledPath:
    case tole_Carpark:
    case tole_Stream:
    case tole_HeritageSite:
    case tole_Pond:
    case tole_Freshwater: // 90
    case tole_FishFarm:
    case tole_River: // 96
    case tole_Saltwater: // 80
    case tole_Coast: // 100
    case tole_RiversidePlants: // 98
    case tole_StoneWall: // 15
    case tole_Fence: //225
    case tole_Track: // 123
    case tole_Railway: // 118
    case tole_AmenityGrass:
    case tole_Parkland:  //14
    case tole_UrbanPark:  //17
    case tole_SandDune:  //101
    case tole_UnknownGrass:
           l_score = HQualityWater; // Neutral
    break;
 
    case tole_Foobar: // 999 !! type unknown - should not happen
    default:
      static char l_errornum[ 20 ];
      sprintf( l_errornum, "%d", l_type );
      TheLandscape->Warn( "SkTerritories::PrePoly2Qual(): ""Unknown tole_type", l_errornum );
      exit( 1 );
    break;
  }
  if (TheLandscape->SupplyVegPatchy( a_poly )) l_score += PatchyPremium;
  if (l_score > SKOPTIMALHABITATSCORE) l_score = SKOPTIMALHABITATSCORE;
  return l_score;
}

References HQualityBareEarth, HQualityHedge, HQualityHedgeScrub, HQualityMetalRoad, HQualityTall, HQualityTall2, HQualityTallVeg, HQualityWater, PatchyPremium, SKOPTIMALHABITATSCORE, Landscape::SupplyElementType(), Landscape::SupplyVegHeight(), Landscape::SupplyVegPatchy(), TheLandscape, tole_ActivePit, tole_AmenityGrass, 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_FishFarm, tole_Foobar, 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_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_UnknownGrass, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_Wasteland, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, and Landscape::Warn().

Referenced by PreCachePoly(), and PreFillQualCache().

PrePolyNQual()

double SkTerritories::PrePolyNQual ( int  a_poly, int *  a_good_polys  )

inline

                                                               {
  TTypesOfLandscapeElement l_type = TheLandscape->SupplyElementType( a_poly );
  double l_height;
  double l_score = -9999.0;
  bool ppremium = false;
//  int l_index;
 
 
 
  switch ( l_type ) {
    case tole_YoungForest: //
      l_score = HQualityBareEarth + PatchyPremium;
      break;
    case tole_Hedges: // 130
    case tole_HedgeBank:
      l_score = HQualityHedge;
      break;
    case tole_IndividualTree:
    case tole_PlantNursery:
    case tole_WindTurbine:
    case tole_WoodyEnergyCrop:
    case tole_WoodlandMargin:
    case tole_Pylon:
    case tole_PitDisused: // 75
    case tole_RiversideTrees: // 97
    case tole_DeciduousForest: // 40
    case tole_MixedForest: // 60
    case tole_ConiferousForest: // 50
    case tole_ActivePit: // 115
    case tole_Building: // 5
    case tole_Copse:
    case tole_Orchard:
    case tole_BuiltUpWithParkland:
        l_score = HQualityTall2;
      break;
    case tole_Churchyard:
    case tole_Garden: //11
    case tole_UrbanNoVeg: // 8
      l_score = HQualityTallVeg;
      break;
    case tole_NaturalGrassWet:
    case tole_Saltmarsh:
    case tole_Marsh: // 95
    case tole_Scrub: // 70
      l_score = HQualityHedgeScrub;
      break;
    case tole_RoadsideSlope:
    case tole_Field:
    case tole_RoadsideVerge: // 13
    case tole_FieldBoundary: // 160
    case tole_UnsprayedFieldMargin:
    case tole_PermanentSetaside: // 7
    case tole_Heath:
    case tole_PermPastureLowYield:
    case tole_PermPastureTussocky:
    case tole_PermPasture: // 35
    case tole_NaturalGrassDry: // 110
    case tole_BeetleBank:
    case tole_Wasteland:
    case tole_Vildtager:
    case tole_MownGrass:
    // Must be potentially suitable vegetation element so score depends on
    // the vegetation height
    l_height = TheLandscape->SupplyVegHeight( a_poly );
    ppremium = TheLandscape->SupplyVegPatchy( a_poly );
    // If using skylark scrapes then we need the code below
    if ( TheLandscape->SupplySkScrapes(a_poly) && (l_height >=30) )
    {
        if ( l_height >= 200.0 )
        {
          l_score = HQualityTallVeg;
        } else
        {
            if ( l_height >= 110.0 )
            {
                l_score = HQualityTall;
            }
            else if ( l_height < 3.0 )
            {
                l_score = HQualityBareEarth;
            } else
            {
                l_score = SKOPTIMALHABITATSCORE / 2.0; // Start with standard (less some to allow for doubling territory)
                double hh;
                if (l_height>70) hh = 70; else hh = l_height;
                l_score += hh * cfg_SkScrapesPremiumII.value();
                int density = TheLandscape->SupplyVegDensity( a_poly );
                l_score += ( DensityScore[ density ] + HeightScore[ ( int )l_height ] );
            }
        }
    }
    else
    {
        // No skylark scrapes
        if ( l_height >= 200.0 )
        {
            l_score = HQualityTallVeg;
        } else
        {
            if ( l_height >= 110.0 )
            {
                l_score = HQualityTall;
                if ( ppremium ) l_score += PatchyPremium;
            }
            else if ( l_height < 3.0 )
            {
                l_score = HQualityBareEarth;
            } else
            {
                l_score = SKOPTIMALHABITATSCORE / 2.0; // Start with half standard - less some to allow doubling (taken up in the minimum territory accept score)
                int density;
                if (l_height<=30) density = 0; else density = TheLandscape->SupplyVegDensity( a_poly );
                l_score += ( DensityScore[ density ] + HeightScore[ ( int )l_height ] );
                if ( ppremium ) l_score += PatchyPremium;
                else
                {
                    if ( TheLandscape->SupplyHasTramlines( a_poly )) l_score += cfg_SkTramlinesPremium.value();
                }
            }
        }
    }
    break;
 
    case tole_SmallRoad: // 120
    case tole_LargeRoad: // 121
      l_score = HQualityMetalRoad;
    break;
 
    case tole_MetalledPath:
    case tole_Carpark:
    case tole_Stream:
    case tole_HeritageSite:
    case tole_Pond:
    case tole_Freshwater: // 90
    case tole_FishFarm:
    case tole_River: // 96
    case tole_Saltwater: // 80
    case tole_Coast: // 100
    case tole_RiversidePlants: // 98
    case tole_StoneWall: // 15
    case tole_Fence:
    case tole_Track: // 123
    case tole_Railway: // 118
    case tole_AmenityGrass:
    case tole_Parkland:  //14
    case tole_UrbanPark:  //17
    case tole_SandDune:  //101
    case tole_UnknownGrass:
      l_score = HQualityWater; // Neutral
    break;
 
    case tole_Foobar: // 999 !! type unknown - should not happen
    default:
      static char l_errornum[ 20 ];
      sprintf( l_errornum, "%d", l_type );
      TheLandscape->Warn( "SkTerritories::PrePolyNQual(): ""Unknown tole_type", l_errornum );
      exit( 1 );
    break;
  }
  if (l_score > SKOPTIMALHABITATSCORE) l_score = SKOPTIMALHABITATSCORE;
  return l_score;
}

References cfg_SkScrapesPremiumII, cfg_SkTramlinesPremium, DensityScore, HeightScore, HQualityBareEarth, HQualityHedge, HQualityHedgeScrub, HQualityMetalRoad, HQualityTall, HQualityTall2, HQualityTallVeg, HQualityWater, PatchyPremium, SKOPTIMALHABITATSCORE, Landscape::SupplyElementType(), Landscape::SupplyHasTramlines(), Landscape::SupplySkScrapes(), Landscape::SupplyVegDensity(), Landscape::SupplyVegHeight(), Landscape::SupplyVegPatchy(), TheLandscape, tole_ActivePit, tole_AmenityGrass, 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_FishFarm, tole_Foobar, 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_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_UnknownGrass, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_Wasteland, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, and Landscape::Warn().

Referenced by EvaluateHabitatN().

PreProcessLandscape2()

void SkTerritories::PreProcessLandscape2

(

Landscape *

L

)

                                                        {
  //time_t l_time = time( NULL );
  //printf("%s\n", asctime(localtime(&l_time)));
 
  // if this is not the first year then delete the old territories
  for ( int i = 0; i < NoTerritories; i++ )
    delete Territories[ i ];
  NoTerritories = 0;
 
  PreFillQualGrid();
 
  // Zero all Grid Positions
  for ( int i = 0; i < m_sim_w_div_10; i++ )
    for ( int j = 0; j < m_sim_h_div_10; j++ )
        Grid[i + j *  m_sim_w_div_10] = false;
 
  int x = random( m_sim_w_div_10 ); // was 3
  int y = random( m_sim_h_div_10 ); // was 0
  int qual;
  int range = 5; // Start with a 50m territory
  // Next start the loop
  int tries = m_sim_w_div_10 * m_sim_h_div_10;
 
  while ( tries-- ) {
    int targetqual = (int) (cfg_FemaleMinTerritoryAcceptScore.value() * (0.9 + g_rand_uni()/5.0));
    if ( !IsGridPositionValid( x, y, range ) ) {
      if ( ++x >= m_sim_w_div_10 ) {
        x = random( 3 );
        if ( ++y >= m_sim_h_div_10 ) {
          y = 0;
        }
      }
      continue;
    }
 
    // Location was OK, ie. not occupied.
 
    // Try the smallest possible territory located right at our starting
    // position.
    qual = PreEvaluateHabitat( x, y, range, range );
 
    // Is it suitable?
    if ( qual >= targetqual ) {
      // If so create it and claim the area on the grid
      // Is OK so create a territory
      if ( NoTerritories > 199999 ) {
        static char errornum[ 20 ];
        sprintf( errornum, "%d", NoTerritories );
        L->Warn( "SkTerritories::PreProcessLandscape2(): ""Too many territories!", errornum );
        exit( 1 );
      }
      Territories[ NoTerritories ] = new skTTerritory( x * 10, y * 10, range * 10, qual, x, y, range ); // Here we have some variation in the quality requirements
      Territories[ NoTerritories++ ]->TestNestPossibility();
      // Build the per-territory lists of poygons and associated
      // areas.
      PreFillTerrPolyLists( Territories[ NoTerritories - 1 ] );
 
      // Claim the territory in the grid
      ClaimGrid( x, y, range );
      x += range - 1;
      range = 5;
      continue;
    }
 
    // Not suitable too low quality, but can increase the area
    bool done = false;
    bool success = false;
    do {
      if ( ++range > 28 ) {
        // Max. allowed territory size is 280m square.
        done = true;
      } else {
        if ( IsExtGridPositionValid( x, y, range ) ) {
          // Check Quality
          // No point in rechecking the area already checked so just
          // check the new area
          qual += PreEvaluateHabitatStripX( x, y + range - 1, range );
          qual += PreEvaluateHabitatStripY( x + range - 1, y, range );
          //qual= PreEvaluateHabitat( x, y, range, range );
          if ( qual >= targetqual ) {
            // If so create it and claim the area on the grid
            // Is OK so create a territory
            if ( NoTerritories < 0 || NoTerritories > 199999 ) {
              static char errornum[ 20 ];
              sprintf( errornum, "%d", NoTerritories );
              L->Warn( "SkTerritories::PreProcessLandscape2():"" Too many territories!", errornum );
              exit( 0 );
            }
            success = true;
            done = true;
            Territories[ NoTerritories ] = new skTTerritory( x * 10, y * 10, range * 10, qual, x, y, range );
            Territories[ NoTerritories++ ]->TestNestPossibility();
            // Build the per-territory lists of poygons and associated
            // areas.
            PreFillTerrPolyLists( Territories[ NoTerritories - 1 ] );
            ClaimGrid( x, y, range );
            x += range - 1;
            range = 5;
          }
        }
      }
    } while ( !done );
 
    if ( !success ) {
        Grid[x + y * m_sim_w_div_10] = true;
      if ( ++x >= m_sim_w_div_10 ) {
        // Next line down
        x = random( 3 );
        if ( ++y >= m_sim_h_div_10 ) {
          y = 0;
        }
      }
      range = 5;
    }
  }
  if (NoTerritories < 1) {
      static char errornum[20];
      sprintf(errornum, "%d", NoTerritories);
      L->Warn("SkTerritories::PreProcessLandscape2(): ""Not enough territories! ", errornum);
      exit(1);
  }
 }

References cfg_FemaleMinTerritoryAcceptScore, ClaimGrid(), g_rand_uni, Grid, IsExtGridPositionValid(), IsGridPositionValid(), m_sim_h_div_10, m_sim_w_div_10, NoTerritories, PreEvaluateHabitat(), PreEvaluateHabitatStripX(), PreEvaluateHabitatStripY(), PreFillQualGrid(), PreFillTerrPolyLists(), Territories, skTTerritory::TestNestPossibility(), and Landscape::Warn().

Referenced by Skylark_Population_Manager::DoFirst().

RemoveFemale()

void SkTerritories::RemoveFemale

(

int

ref

)

                                          {
  Territories[ ref ]->F_Owner = NULL;
}

References skTTerritory::F_Owner, and Territories.

Referenced by Skylark_Female::OnMateDying(), Skylark_Female::st_Dying(), Skylark_Female::st_GivingUpTerritory(), and Skylark_Female::st_StoppingBreeding().

RemoveMale()

void SkTerritories::RemoveMale

(

int

ref

)

                                        {
  if ( ref != -1 ) Territories[ ref ]->Owner = NULL;
}

References skTTerritory::Owner, and Territories.

Referenced by Skylark_Male::OnEvicted(), Skylark_Male::OnMateLeaving(), Skylark_Male::st_AttractingAMate(), Skylark_Male::st_Dying(), and Skylark_Male::st_FollowingMate().

Split()

void SkTerritories::Split

(

int

ref

)

Duplicates the old territory.

Reduces the virtual size.

                                   {
    Territories[ NoTerritories++ ] = new skTTerritory( Territories[ ref]->m_Location_x, Territories[ ref]->m_Location_y,
        Territories[ ref ]->Size, Territories[ ref ]->GetQuality(), Territories[ ref ]->m_x_div10, Territories[ ref ]->m_y_div10,
            Territories[ ref ]->m_range_div10 );
    PreFillTerrPolyLists( Territories[ NoTerritories - 1 ] );
    Territories[ NoTerritories-1 ]->SetNestPossibility(Territories[ ref]->m_nest_valid,Territories[ ref]->m_nest_pos_validx,Territories[ ref]->m_nest_pos_validy);
    Territories[ ref ]->m_competitionscaler*=cfg_MaleSplitScale.value();
    Territories[ NoTerritories-1 ]->m_competitionscaler*=cfg_MaleSplitScale.value();
    double Vdir=Territories[ ref]->GetVirtualDiameter()/1.41; // 1.41 is the theoretical diameter scale when dividing one territory into two
    Territories[ ref]->SetVirtualDiameter(Vdir);
    Territories[ NoTerritories-1 ]->SetVirtualDiameter(Vdir);
    //printf("New %d\t%d\n",g_land->SupplyDayInYear(),NoTerritories);
}

References cfg_MaleSplitScale, skTTerritory::GetVirtualDiameter(), skTTerritory::m_competitionscaler, NoTerritories, PreFillTerrPolyLists(), skTTerritory::SetNestPossibility(), skTTerritory::SetVirtualDiameter(), and Territories.

Referenced by Skylark_Male::ReEvaluateTerritory().

Supply_F_Owner()

Skylark_Female * SkTerritories::Supply_F_Owner

(

int

ref

)

                                                        {
  return Territories[ ref ]->F_Owner;
}

References skTTerritory::F_Owner, and Territories.

Referenced by Skylark_Female::st_Finding_Territory().

Supply_Owner()

Skylark_Male * SkTerritories::Supply_Owner

(

int

ref

)

                                                    {
  return Territories[ ref ]->Owner;
}

References skTTerritory::Owner, and Territories.

Referenced by Skylark_Male::OnReHouse(), Skylark_Female::st_Finding_Territory(), and Skylark_Male::st_FindingTerritory().

Supply_quality()

int SkTerritories::Supply_quality

(

int

ref

)

                                           {
  return Territories[ ref ]->GetQuality();
}

References skTTerritory::GetQuality(), and Territories.

Referenced by Skylark_Male::st_FindingTerritory(), and Skylark_Population_Manager::TheSkylarkTerrsSupply_quality().

Supply_size()

int SkTerritories::Supply_size

(

int

ref

)

                                        {
  return Territories[ ref ]->Size;
}

References skTTerritory::Size, and Territories.

Referenced by Skylark_Male::OnReHouse(), Skylark_Male::st_FindingTerritory(), and Skylark_Population_Manager::TheSkylarkTerrsSupply_size().

Supply_terr()

skTTerritory * SkTerritories::Supply_terr

(

int

ref

)

                                                   {
  return Territories[ ref ];
}

References Territories.

Referenced by Skylark_Male::ConstructAHabitatTable(), Skylark_Male::OnMateLeaving(), and Skylark_Male::ReEvaluateTerritory().

Supply_x()

int SkTerritories::Supply_x

(

int

ref

)

                                     {
  return Territories[ ref ]->m_Location_x;
}

References skTTerritory::m_Location_x, and Territories.

Referenced by Skylark_Male::OnReHouse(), Skylark_Male::st_FindingTerritory(), and Skylark_Population_Manager::TheSkylarkTerrsSupply_x().

Supply_y()

int SkTerritories::Supply_y

(

int

ref

)

                                     {
  return Territories[ ref ]->m_Location_y;
}

References skTTerritory::m_Location_y, and Territories.

Referenced by Skylark_Male::OnReHouse(), Skylark_Male::st_FindingTerritory(), and Skylark_Population_Manager::TheSkylarkTerrsSupply_y().

SupplyIsNestValid()

bool SkTerritories::SupplyIsNestValid ( int  ref )

inline

                                  {
      return Territories[ref]->m_nest_valid;
  }

References skTTerritory::m_nest_valid.

Referenced by Skylark_Male::OnReHouse(), and Skylark_Male::st_FindingTerritory().

SupplyNestPosition()

APoint SkTerritories::SupplyNestPosition ( int  ref )

inline

                                     {
      APoint p(Territories[ref]->m_nest_pos_validx, Territories[ref]->m_nest_pos_validy);
      return p;
  }

SupplyNoFemaleOccupied()

int SkTerritories::SupplyNoFemaleOccupied

(

)

                                          {
  int no=0;
  for (int i=0; i<NoTerritories; i++) {
      if (Territories[i]->F_Owner != NULL) no++;
  }
  return no;
}

References NoTerritories, and Territories.

SupplyNoMaleOccupied()

int SkTerritories::SupplyNoMaleOccupied

(

)

                                        {
  int no=0;
  for (int i=0; i<NoTerritories; i++) {
      if (Territories[i]->Owner != NULL) no++;
  }
  return no;
}

References NoTerritories, and Territories.

SupplyNoTerritories()

int SkTerritories::SupplyNoTerritories

(

)

                                       {
  return NoTerritories;
}

References NoTerritories.

Referenced by Skylark_Male::OnReHouse(), Skylark_Female::st_Finding_Territory(), Skylark_Male::st_FindingTerritory(), and Skylark_Population_Manager::SupplyNoTerritories().

Tick()

void SkTerritories::Tick ( void  )

inline

  {
    m_qual_cache_filled = false;
  }

Referenced by Skylark_Population_Manager::DoFirst().

UpdateQuality()

void SkTerritories::UpdateQuality

(

)

Member Data Documentation

Grid

bool* SkTerritories::Grid

private

Referenced by ClaimGrid(), IsExtGridPositionValid(), IsGridPositionValid(), PreProcessLandscape2(), and SkTerritories().

m_for_iter_x

int SkTerritories::m_for_iter_x[1000]

private

Referenced by PreFillTerrPolyLists().

m_for_iter_y

int SkTerritories::m_for_iter_y[1000]

private

Referenced by PreFillTerrPolyLists().

m_hash_size

int SkTerritories::m_hash_size

private

Referenced by PreFillQualCache(), and PreFillQualGrid().

m_poly_seen

int* SkTerritories::m_poly_seen

private

Referenced by PreEvaluateQualGrid(), PreFillQualCache(), PreFillQualGrid(), PreFillTerrPolyLists(), and ~SkTerritories().

m_poly_size

int* SkTerritories::m_poly_size

private

Referenced by PreFillQualGrid(), PreFillTerrPolyLists(), and ~SkTerritories().

m_qual_cache

double* SkTerritories::m_qual_cache

private

Referenced by PreCachePoly(), PreEvaluateQualGrid(), PreFillQualCache(), PreFillQualGrid(), and ~SkTerritories().

m_qual_cache_filled

bool SkTerritories::m_qual_cache_filled

private

Referenced by PreFillQualCache().

m_qual_grid

SkQualGrid* * SkTerritories::m_qual_grid

private

Referenced by PreEvaluateHabitat(), PreEvaluateHabitatStripX(), PreEvaluateHabitatStripY(), PreFillQualCache(), PreFillQualGrid(), PreFillTerrPolyLists(), and ~SkTerritories().

m_qual_grid_signal

int SkTerritories::m_qual_grid_signal

private

Referenced by PreFillQualGrid(), and SkTerritories().

m_sim_h_div_10

int SkTerritories::m_sim_h_div_10

private

Referenced by ClaimGrid(), IsExtGridPositionValid(), IsGridPositionValid(), PreEvaluateHabitat(), PreEvaluateHabitatStripY(), PreFillQualCache(), PreFillQualGrid(), PreFillTerrPolyLists(), PreProcessLandscape2(), SkTerritories(), and ~SkTerritories().

m_sim_w_div_10

int SkTerritories::m_sim_w_div_10

private

Referenced by ClaimGrid(), IsExtGridPositionValid(), IsGridPositionValid(), PreEvaluateHabitat(), PreEvaluateHabitatStripX(), PreEvaluateHabitatStripY(), PreFillQualCache(), PreFillQualGrid(), PreFillTerrPolyLists(), PreProcessLandscape2(), SkTerritories(), and ~SkTerritories().

NoTerritories

int SkTerritories::NoTerritories

private

Referenced by DumpMapGraphics(), EvaluateAllTerritories(), GetTerritoriesByDistance(), IsValid(), PreProcessLandscape2(), SkTerritories(), Split(), SupplyNoFemaleOccupied(), SupplyNoMaleOccupied(), SupplyNoTerritories(), and ~SkTerritories().

PolyHeightData

double SkTerritories::PolyHeightData[2500]

PolyRefData

int SkTerritories::PolyRefData[2500]

Referenced by PreEvaluateQualGrid(), and PreFillTerrPolyLists().

PolySizeData

int SkTerritories::PolySizeData[2500]

PolyTypeData

TTypesOfLandscapeElement SkTerritories::PolyTypeData[2500]

SimH

int SkTerritories::SimH

private

Referenced by SkTerritories().

SimW

int SkTerritories::SimW

private

Referenced by SkTerritories().

Territories

skTTerritory* SkTerritories::Territories[400000]

private

Referenced by DumpMapGraphics(), EvaluateAllTerritories(), FemaleOccupy(), GetTerritoriesByDistance(), IsValid(), Occupy(), PreProcessLandscape2(), RemoveFemale(), RemoveMale(), Split(), Supply_F_Owner(), Supply_Owner(), Supply_quality(), Supply_size(), Supply_terr(), Supply_x(), Supply_y(), SupplyNoFemaleOccupied(), SupplyNoMaleOccupied(), and ~SkTerritories().

TheLandscape

Landscape* SkTerritories::TheLandscape

Referenced by PreEvaluateQualGrid(), PreFillQualGrid(), PrePoly2Qual(), PrePolyNQual(), and SkTerritories().

---

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

• C:/Repo/ALMaSS_All/Skylark/skylarks_all.h
• C:/Repo/ALMaSS_All/Skylark/skylarks_all.cpp