Cell Struct Reference

#include <Cell.h>

Public Member Functions
	Cell ()
	Cell (Cell const &cell)
	Cell (CellCoord const &p)
	Cell (float x, float y)
void	Compute (uint32 &x, uint32 &y) const
bool	DiffCell (const Cell &cell) const
bool	DiffGrid (const Cell &cell) const
uint32	CellX () const
uint32	CellY () const
uint32	GridX () const
uint32	GridY () const
bool	NoCreate () const
void	SetNoCreate ()
CellCoord	GetCellCoord () const
Cell &	operator= (Cell const &cell)
bool	operator== (Cell const &cell) const
bool	operator!= (Cell const &cell) const
template<class T , class CONTAINER >
void	Visit (CellCoord const &, TypeContainerVisitor< T, CONTAINER > &visitor, Map &, WorldObject const &, float) const
template<class T , class CONTAINER >
void	Visit (CellCoord const &, TypeContainerVisitor< T, CONTAINER > &visitor, Map &, float, float, float) const

Static Public Member Functions
static CellArea	CalculateCellArea (float x, float y, float radius)

Public Attributes
union {
struct {
unsigned   grid_x: 6
unsigned   grid_y: 6
unsigned   cell_x: 6
unsigned   cell_y: 6
unsigned   nocreate: 1
unsigned   reserved: 7
}   Part
uint32   All
}	data
float	v9 [16 *8+1][16 *8+1]
float	v8 [16 *8][16 *8]

Private Member Functions
template<class T , class CONTAINER >
void	VisitCircle (TypeContainerVisitor< T, CONTAINER > &, Map &, CellCoord const &, CellCoord const &) const

Constructor & Destructor Documentation

Cell::Cell ( )

inline

{ data.All = 0; }

Cell::Cell ( Cell const &  cell )

inline

{ data.All = cell.data.All; }

Cell::Cell ( CellCoord const &  p )

inlineexplicit

{
 data.Part.grid_x = p.x_coord / MAX_NUMBER_OF_CELLS;
 data.Part.grid_y = p.y_coord / MAX_NUMBER_OF_CELLS;
 data.Part.cell_x = p.x_coord % MAX_NUMBER_OF_CELLS;
 data.Part.cell_y = p.y_coord % MAX_NUMBER_OF_CELLS;
 data.Part.nocreate = 0;
 data.Part.reserved = 0;
}

Cell::Cell ( float  x, float  y  )

inlineexplicit

{
 CellCoord p = Trinity::ComputeCellCoord(x, y);
 data.Part.grid_x = p.x_coord / MAX_NUMBER_OF_CELLS;
 data.Part.grid_y = p.y_coord / MAX_NUMBER_OF_CELLS;
 data.Part.cell_x = p.x_coord % MAX_NUMBER_OF_CELLS;
 data.Part.cell_y = p.y_coord % MAX_NUMBER_OF_CELLS;
 data.Part.nocreate = 0;
 data.Part.reserved = 0;
}

Here is the call graph for this function:

Member Function Documentation

CellArea Cell::CalculateCellArea ( float  x, float  y, float  radius  )

inlinestatic

{
 if (radius <= 0.0f)
 {
 CellCoord center = Trinity::ComputeCellCoord(x, y).normalize();
 return CellArea(center, center);
 }

 CellCoord centerX = Trinity::ComputeCellCoord(x - radius, y - radius).normalize();
 CellCoord centerY = Trinity::ComputeCellCoord(x + radius, y + radius).normalize();

 return CellArea(centerX, centerY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Cell::CellX ( ) const

inline

{ return data.Part.cell_x; }

Here is the caller graph for this function:

uint32 Cell::CellY ( ) const

inline

{ return data.Part.cell_y; }

Here is the caller graph for this function:

void Cell::Compute ( uint32 &  x, uint32 &  y  ) const

inline

 {
 x = data.Part.grid_x * MAX_NUMBER_OF_CELLS + data.Part.cell_x;
 y = data.Part.grid_y * MAX_NUMBER_OF_CELLS + data.Part.cell_y;
 }

bool Cell::DiffCell ( const Cell &  cell ) const

inline

 {
 return(data.Part.cell_x != cell.data.Part.cell_x ||
 data.Part.cell_y != cell.data.Part.cell_y);
 }

Here is the caller graph for this function:

bool Cell::DiffGrid ( const Cell &  cell ) const

inline

 {
 return(data.Part.grid_x != cell.data.Part.grid_x ||
 data.Part.grid_y != cell.data.Part.grid_y);
 }

Here is the caller graph for this function:

CellCoord Cell::GetCellCoord ( ) const

inline

 {
 return CellCoord(
 data.Part.grid_x * MAX_NUMBER_OF_CELLS+data.Part.cell_x,
 data.Part.grid_y * MAX_NUMBER_OF_CELLS+data.Part.cell_y);
 }

Here is the caller graph for this function:

uint32 Cell::GridX ( ) const

inline

{ return data.Part.grid_x; }

Here is the caller graph for this function:

uint32 Cell::GridY ( ) const

inline

{ return data.Part.grid_y; }

Here is the caller graph for this function:

bool Cell::NoCreate ( ) const

inline

{ return data.Part.nocreate; }

Here is the caller graph for this function:

bool Cell::operator!= ( Cell const &  cell ) const

inline

{ return !operator == (cell); }

Here is the call graph for this function:

Cell& Cell::operator= ( Cell const &  cell )

inline

 {
 this->data.All = cell.data.All;
 return *this;
 }

bool Cell::operator== ( Cell const &  cell ) const

inline

{ return (data.All == cell.data.All); }

Here is the caller graph for this function:

void Cell::SetNoCreate ( )

inline

{ data.Part.nocreate = 1; }

Here is the caller graph for this function:

template<class T , class CONTAINER >

void Cell::Visit ( CellCoord const &  standing_cell, TypeContainerVisitor< T, CONTAINER > &  visitor, Map &  map, WorldObject const &  obj, float  radius  ) const

inline

{
 //we should increase search radius by object's radius, otherwise
 //we could have problems with huge creatures, which won't attack nearest players etc
 Visit(standing_cell, visitor, map, radius + obj.GetObjectSize(), obj.GetPositionX(), obj.GetPositionY());
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class CONTAINER >

void Cell::Visit ( CellCoord const &  standing_cell, TypeContainerVisitor< T, CONTAINER > &  visitor, Map &  map, float  radius, float  x_off, float  y_off  ) const

inline

{
 if (!standing_cell.IsCoordValid())
 return;

 //no jokes here... Actually placing ASSERT() here was good idea, but
 //we had some problems with DynamicObjects, which pass radius = 0.0f (DB issue?)
 //maybe it is better to just return when radius <= 0.0f?
 if (radius <= 0.0f)
 {
 map.Visit(*this, visitor);
 return;
 }
 //lets limit the upper value for search radius
 if (radius > SIZE_OF_GRIDS)
 radius = SIZE_OF_GRIDS;

 //lets calculate object coord offsets from cell borders.
 CellArea area = Cell::CalculateCellArea(x_off, y_off, radius);
 //if radius fits inside standing cell
 if (!area)
 {
 map.Visit(*this, visitor);
 return;
 }

 //visit all cells, found in CalculateCellArea()
 //if radius is known to reach cell area more than 4x4 then we should call optimized VisitCircle
 //currently this technique works with MAX_NUMBER_OF_CELLS 16 and higher, with lower values
 //there are nothing to optimize because SIZE_OF_GRID_CELL is too big...
 if ((area.high_bound.x_coord > (area.low_bound.x_coord + 4)) && (area.high_bound.y_coord > (area.low_bound.y_coord + 4)))
 {
 VisitCircle(visitor, map, area.low_bound, area.high_bound);
 return;
 }

 //ALWAYS visit standing cell first!!! Since we deal with small radiuses
 //it is very essential to call visitor for standing cell firstly...
 map.Visit(*this, visitor);

 // loop the cell range
 for (uint32 x = area.low_bound.x_coord; x <= area.high_bound.x_coord; ++x)
 {
 for (uint32 y = area.low_bound.y_coord; y <= area.high_bound.y_coord; ++y)
 {
 CellCoord cellCoord(x, y);
 //lets skip standing cell since we already visited it
 if (cellCoord != standing_cell)
 {
 Cell r_zone(cellCoord);
 r_zone.data.Part.nocreate = this->data.Part.nocreate;
 map.Visit(r_zone, visitor);
 }
 }
 }
}

Here is the call graph for this function:

template<class T , class CONTAINER >

void Cell::VisitCircle ( TypeContainerVisitor< T, CONTAINER > &  visitor, Map &  map, CellCoord const &  begin_cell, CellCoord const &  end_cell  ) const

inlineprivate

{
 //here is an algorithm for 'filling' circum-squared octagon
 uint32 x_shift = (uint32)ceilf((end_cell.x_coord - begin_cell.x_coord) * 0.3f - 0.5f);
 //lets calculate x_start/x_end coords for central strip...
 const uint32 x_start = begin_cell.x_coord + x_shift;
 const uint32 x_end = end_cell.x_coord - x_shift;

 //visit central strip with constant width...
 for (uint32 x = x_start; x <= x_end; ++x)
 {
 for (uint32 y = begin_cell.y_coord; y <= end_cell.y_coord; ++y)
 {
 CellCoord cellCoord(x, y);
 Cell r_zone(cellCoord);
 r_zone.data.Part.nocreate = this->data.Part.nocreate;
 map.Visit(r_zone, visitor);
 }
 }

 //if x_shift == 0 then we have too small cell area, which were already
 //visited at previous step, so just return from procedure...
 if (x_shift == 0)
 return;

 uint32 y_start = end_cell.y_coord;
 uint32 y_end = begin_cell.y_coord;
 //now we are visiting borders of an octagon...
 for (uint32 step = 1; step <= (x_start - begin_cell.x_coord); ++step)
 {
 //each step reduces strip height by 2 cells...
 y_end += 1;
 y_start -= 1;
 for (uint32 y = y_start; y >= y_end; --y)
 {
 //we visit cells symmetrically from both sides, heading from center to sides and from up to bottom
 //e.g. filling 2 trapezoids after filling central cell strip...
 CellCoord cellCoord_left(x_start - step, y);
 Cell r_zone_left(cellCoord_left);
 r_zone_left.data.Part.nocreate = this->data.Part.nocreate;
 map.Visit(r_zone_left, visitor);

 //right trapezoid cell visit
 CellCoord cellCoord_right(x_end + step, y);
 Cell r_zone_right(cellCoord_right);
 r_zone_right.data.Part.nocreate = this->data.Part.nocreate;
 map.Visit(r_zone_right, visitor);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

uint32 Cell::All

unsigned Cell::cell_x

unsigned Cell::cell_y

union { ... } Cell::data

unsigned Cell::grid_x

unsigned Cell::grid_y

unsigned Cell::nocreate

struct { ... } Cell::Part

unsigned Cell::reserved

float Cell::v8[16 *8][16 *8]

float Cell::v9[16 *8+1][16 *8+1]

---

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

• src/server/game/Grids/Cells/Cell.h
• src/tools/vmap4_extractor/adtfile.h
• src/server/game/Grids/Cells/CellImpl.h