hex::Grid Class Reference

#include <hex.h>

List of all members.

---

Detailed Description

A square field of hexagons that form the universe in which the other objects exist.

Definition at line 194 of file hex.h.

Public Member Functions
int	cols (void) const
int	rows (void) const
Distance	width (void) const
Distance	height (void) const
bool	is_in_range (int i, int j) const
Hex *	hex (int i, int j) const throw (hex::out_of_range)
Hex *	hex (Distance x, Distance y) const throw (hex::out_of_range)
Hex *	hex (const Point &p) const throw (hex::out_of_range)
Area	to_area (void) const
	Grid (int cols, int rows) throw (hex::out_of_range)
	Grid (const Grid &right)
virtual	~Grid ()
Hex *	hex (const std::string &s) const throw (out_of_range,invalid_argument)
	Parse strings generated by Hex::str().
std::set< Hex * >	hexes (const std::string &s) const throw (out_of_range,invalid_argument)
	Parse strings generated by set_str().
Area	area (const std::string &s) const throw (out_of_range,invalid_argument)
	Parse strings generated by Area::str().
Path	path (const std::string &s) const throw (out_of_range,invalid_argument)
	Parse strings generated by Path::str().
Boundary	boundary (const std::string &s) const throw (out_of_range,invalid_argument)
	Parse strings generated by Boundary::str().

---

Constructor & Destructor Documentation

hex::Grid::Grid	(	int	cols,
		int	rows
	)			throw (hex::out_of_range)

Definition at line 264 of file grid.cc.

  : _hexes(), _cols(cols), _rows(rows)
{
  // Perhaps it's perverse to use ints, and then restrict them to be only
  // short. I think it just makes the interface less quirky, the code a
  // bit more efficient, and using shorts wouldn't really save much memory.
  if(0>cols || cols>=0x4000)
      throw hex::out_of_range("cols");
  if(0>rows || rows>=0x4000)
      throw hex::out_of_range("rows");
}

hex::Grid::Grid

(

const Grid &

right

)

Definition at line 277 of file grid.cc.

References _hexes.

                       : _hexes(), _cols(v._cols), _rows(v._rows)
{
  using namespace std;
  for(map<int,Hex*>::const_iterator h =v._hexes.begin(); h!=v._hexes.end(); ++h)
      _hexes.insert( make_pair(h->first,new Hex(*this,*h->second)) );
}

hex::Grid::~Grid

(

)

[virtual]

Definition at line 285 of file grid.cc.

{
  using namespace std;
  for(map<int,Hex*>::const_iterator h =_hexes.begin(); h!=_hexes.end(); ++h)
      delete h->second;
}

---

Member Function Documentation

int hex::Grid::cols

(

void

)

const [inline]

Definition at line 200 of file hex.h.

{ return _cols; }

int hex::Grid::rows

(

void

)

const [inline]

Definition at line 201 of file hex.h.

{ return _rows; }

Distance hex::Grid::width

(

void

)

const [inline]

Definition at line 202 of file hex.h.

References hex::I.

{ return I/2.0 + I*cols(); }

Distance hex::Grid::height

(

void

)

const [inline]

Definition at line 203 of file hex.h.

References hex::J, and hex::K.

{ return K*2 + J*(rows()-1); }

bool hex::Grid::is_in_range	(	int	i,
		int	j
	)			const [inline]

Definition at line 204 of file hex.h.

{return 0<=i&&i<cols()&&0<=j&&j<rows();}

Hex * hex::Grid::hex	(	int	i,
		int	j
	)			const throw (hex::out_of_range)

Definition at line 71 of file grid.cc.

References hex::Hex::_key().

Referenced by hex::Area::boundary(), hex::Hex::go(), main(), hex::range(), and to_area().

{
  int key =Hex::_key(i,j);
  std::map<int,Hex*>::const_iterator pos =_hexes.find(key);
  if(pos==_hexes.end())
  {
    if(0>i || i>=_cols)
        throw hex::out_of_range("i");
    if(0>j || j>=_rows)
        throw hex::out_of_range("j");
    Hex* newhex = new Hex(*this,i,j);
    _hexes.insert( std::make_pair(key,newhex) );
    return newhex;
  }
  return pos->second;
}

Hex * hex::Grid::hex	(	Distance	x,
		Distance	y
	)			const throw (hex::out_of_range)

Definition at line 90 of file grid.cc.

References hex::B, hex::C, hex::E, hex::F, hex::go(), hex::J, and hex::K.

{
  // (Note I==1.0, so the factor of I has been omitted.)
  const static Distance K_2 =K/2.0;
  // BI is unit vector in direction B
  const static Distance BIx = 0.5;
  const static Distance BIy = 1.5 * K;
  // CI is unit vector in direction C
  const static Distance CIx = -BIx;
  const static Distance CIy =  BIy;

  // Calculate the 'simple' solution.
  y -= K;
  int j = lround( y/J );
  if(j % 2)
      x -= 1.0; // odd rows
  else
      x -= 0.5; // even rows
  int i = lround( x );                                              //   x / I
  // Now calculate the x,y offsets (in units of (I,J) )
  Distance dx = x - Distance(i);                                    //   i * I
  Distance dy = y - Distance(j) * J;
  // Only need more work if |dy| > K/2
  if( dy < -K_2 || K_2 < dy )
  {
    Distance BId = (BIx * dx) + (BIy * dy);
    Distance CId = (CIx * dx) + (CIy * dy);

    if(      BId >  0.5 )
                          go( i,j, B );
    else if( BId < -0.5 )
                          go( i,j, E );
    else if( CId >  0.5 )
                          go( i,j, C );
    else if( CId < -0.5 )
                          go( i,j, F );
  }
  return hex(i,j);
}

Hex * hex::Grid::hex

(

const Point &

p

)

const throw (hex::out_of_range)

Definition at line 132 of file grid.cc.

{
  return hex(p.x,p.y);
}

Area hex::Grid::to_area

(

void

)

const

Definition at line 139 of file grid.cc.

References hex(), and hexes().

Referenced by main().

{
  using namespace std;
  set<Hex*> hexes;
  for(int i=0; i<_cols; ++i)
      for(int j=0; j<_rows; ++j)
          hexes.insert( hex(i,j) );
  return Area(hexes);  
}

Hex * hex::Grid::hex

(

const std::string &

s

)

const throw (out_of_range,invalid_argument)

Parse strings generated by Hex::str().

Definition at line 151 of file grid.cc.

{
  // Parse strings like: / *[-+]?\d+_ *[-+]?\d+([^\d].*)?/
  // E.g.  '1_2' ' +2_ 4' '2_4 # comment'
  const char* buf =s.c_str();
  char* endptr =NULL;
  errno=0;
  int i =::strtol(buf,&endptr,10);
  if(endptr==buf || *endptr!='_')
      throw hex::invalid_argument(s);
  buf =endptr+1;
  int j =::strtol(buf,&endptr,10);
  if(endptr==buf)
      throw hex::invalid_argument(s);
  if(ERANGE==errno)
      throw hex::out_of_range(s);
  return this->hex(i,j);
}

std::set< Hex * > hex::Grid::hexes

(

const std::string &

s

)

const throw (out_of_range,invalid_argument)

Parse strings generated by set_str().

Definition at line 172 of file grid.cc.

Referenced by to_area().

{
  // Parse string of space-separated hex coordinates.
  // E.g. 1_2 2_3 3_4
  std::istringstream is(s);
  std::set<Hex*> result;
  while(is.good())
  {
    std::string tok;
    is>>tok;
    if(!tok.empty())
        result.insert( this->hex(tok) );
  }
  return result;
}

Area hex::Grid::area

(

const std::string &

s

)

const throw (out_of_range,invalid_argument)

Parse strings generated by Area::str().

Definition at line 190 of file grid.cc.

References hex::Hex::go(), and hex::steps().

{
  // Parse string of area fillpaths
  // E.g. 1,2>CDE:ABC
  std::set<Hex*> result;
  std::string::size_type pos =s.find_first_of(":>");
  if(pos==std::string::npos)
      throw hex::invalid_argument(s);
  Hex* origin =this->hex( s.substr(0,pos) );
  Hex* start  =origin;
  while(pos!=std::string::npos)
  {
    std::string::size_type next =s.find_first_of(":>",pos+1);
    std::string steps =s.substr( pos+1, (next==s.npos)?(next):(next-pos-1) );
    if(s[pos]=='>')
    {
      start=origin->go(steps);
    }
    else // ':'
    {
      std::list<Hex*> hexes =Path(start,steps).hexes();
      std::copy(hexes.begin(), hexes.end(), inserter(result,result.end()));
      start=origin;
    }
    pos=next;
  }
  return result;
}

Path hex::Grid::path

(

const std::string &

s

)

const throw (out_of_range,invalid_argument)

Parse strings generated by Path::str().

Definition at line 221 of file grid.cc.

{
  std::string::size_type colon =s.find(':');
  if(colon==std::string::npos || (colon+1)>=s.size())
      throw hex::invalid_argument(s);
  Hex* origin =this->hex( s.substr(0,colon) );
  Path result(origin,s.substr(colon+1));
  return result;
}

Boundary hex::Grid::boundary

(

const std::string &

s

)

const throw (out_of_range,invalid_argument)

Parse strings generated by Boundary::str().

Definition at line 233 of file grid.cc.

References hex::Edge::direction(), hex::Edge::hex(), hex::Edge::next_in(), hex::Edge::next_out(), and hex::to_direction().

{
  std::list<Edge*> result;
  std::string::size_type plus_minus =s.find_first_of("+-");
  if(plus_minus==std::string::npos || (plus_minus+1)>=s.size())
      throw hex::invalid_argument(s);
  bool clockwise =( '-' == s[plus_minus] );
  for(std::string::size_type pos =plus_minus+1; pos<s.size(); ++pos)
  {
    Direction d =to_direction(s[pos]);
    Edge* next;
    if(result.empty())
    {
      next = this->hex(s.substr(0,plus_minus))->edge(d);
    }
    else
    {
      next = result.back()->next_in(clockwise);
      if(next->direction() != d)
      {
        next = result.back()->next_out(clockwise);
        if(next->direction() != d)
            throw hex::invalid_argument(s);
      }
    }
    result.push_back(next);
  }
  return result;
}

---

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

• hex.h
• grid.cc

---