PointFunctions Class Reference

#include <PointFunctions.hxx>

Collaboration diagram for PointFunctions:

Static Public Member Functions
static std::vector< Point >	getLine (Point isoCoordinatesStart, Point isoCoordinatesEnd)
	Creates a line between two points using the Bresenham Line algorithm. More...
static std::vector< Point >	getStraightLine (const Point &isoCoordinatesStart, const Point &isoCoordinatesEnd)
	Gets all nodes in a straight line from start and end point. More...
static std::vector< Point >	getArea (const Point &isoCoordinatesStart, const Point &isoCoordinatesEnd)
	Gets all nodes in a rectangular area between start and end point. More...
static std::vector< Point >	getNeighbors (const Point &isoCoordinates, const bool includeCentralNode, int distance=1)
	Get all neighboring coordinates from provided map node isocoordinate. More...
static NeighborNodesPosition	getNeighborPositionToOrigin (const Point &neighboringPoint, const Point &originPoint)
	Get the position of the neighboring node to the originpoint (center of the neighborgroup). More...

Detailed Description

Definition at line 12 of file PointFunctions.hxx.

Member Function Documentation

getArea()

std::vector< Point > PointFunctions::getArea ( const Point &  isoCoordinatesStart, const Point &  isoCoordinatesEnd  )

static

Gets all nodes in a rectangular area between start and end point.

Parameters

isoCoordinatesStart	start coordinates
isoCoordinatesEnd	end coordinates

Returns

std::vector<Point>() containing coordinates for each tile between start and end coordinates, including start and end

Definition at line 156 of file PointFunctions.cxx.

{
  std::vector<Point> rectangle;
  SDL_Point startRect;
  SDL_Point endRect;
  std::tie(startRect.x, endRect.x) = std::minmax(isoCoordinatesStart.x, isoCoordinatesEnd.x);
  std::tie(startRect.y, endRect.y) = std::minmax(isoCoordinatesStart.y, isoCoordinatesEnd.y);
 
  for (int x = startRect.x; x <= endRect.x; x++)
  {
    for (int y = startRect.y; y <= endRect.y; y++)
    {
      rectangle.push_back(Point{x, y});
    }
  }
 
  return rectangle;
}

Here is the caller graph for this function:

getLine()

std::vector< Point > PointFunctions::getLine ( Point  isoCoordinatesStart, Point  isoCoordinatesEnd  )

static

Creates a line between two points using the Bresenham Line algorithm.

Parameters

isoCoordinatesStart	start coordinates
isoCoordinatesEnd	end coordinates

Returns

std::vector<Point>() containing coordinates for each tile between start and end coordinates, including start and end

Definition at line 10 of file PointFunctions.cxx.

{
  std::vector<Point> line;
  int x0 = isoCoordinatesStart.x;
  int x1 = isoCoordinatesEnd.x;
  int y0 = isoCoordinatesStart.y;
  int y1 = isoCoordinatesEnd.y;
 
  Point p;
  p.x = x0;
  p.y = y0;
  line.push_back(p);
 
  if (x0 != x1 || y0 != y1)
  {
    int dx = x1 - x0;
    int dy = y1 - y0;
    int stepx = 0;
    int stepy = 0;
 
    if (dx < 0)
    {
      dx = -dx;
      stepx = -1;
    }
    else
    {
      stepx = 1;
    }
 
    if (dy < 0)
    {
      dy = -dy;
      stepy = -1;
    }
    else
    {
      stepy = 1;
    }
 
    // dx is now 2*dx
    dx <<= 1;
    // dy is now 2*dy
    dy <<= 1;
 
    if (dx > dy)
    {
      int fraction = dy - (dx >> 1);
      while (x0 != x1)
      {
        x0 += stepx;
        if (fraction >= 0)
        {
          p.x = x0;
          p.y = y0;
          line.push_back(p);
 
          y0 += stepy;
          fraction -= dx;
        }
        fraction += dy;
        if (0 <= x0 && 0 <= y0)
        {
          p.x = x0;
          p.y = y0;
          line.push_back(p);
        }
      }
    }
    else
    {
      int fraction = dx - (dy >> 1);
      while (y0 != y1)
      {
        if (fraction >= 0)
        {
          x0 += stepx;
          fraction -= dy;
 
          p.x = x0;
          p.y = y0;
          line.push_back(p);
        }
        y0 += stepy;
        fraction += dx;
        if (0 <= x0 && 0 <= y0)
        {
          p.x = x0;
          p.y = y0;
          line.push_back(p);
        }
      }
    }
  }
 
  return line;
}

Here is the caller graph for this function:

getNeighborPositionToOrigin()

NeighborNodesPosition PointFunctions::getNeighborPositionToOrigin ( const Point &  neighboringPoint, const Point &  originPoint  )

static

Get the position of the neighboring node to the originpoint (center of the neighborgroup).

Parameters

neighboringPoint	the neighboring point
originPoint	the center of the neighbor group we want to get the direction to

Returns

An enum representing the Direction from the neighboring point to the origin point

Definition at line 202 of file PointFunctions.cxx.

{
  int neighborOffsetX = neighboringPoint.x - originPoint.x;
  int neighborOffsetY = neighboringPoint.y - originPoint.y;
 
  switch (neighborOffsetX)
  {
  case 0:
    switch (neighborOffsetY)
    {
    case 0:
      return NeighborNodesPosition::CENTER;
    case 1:
      return NeighborNodesPosition::TOP;
    case -1:
      return NeighborNodesPosition::BOTTOM;
    }
    break;
  case 1:
    switch (neighborOffsetY)
    {
    case 0:
      return NeighborNodesPosition::RIGHT;
    case 1:
      return NeighborNodesPosition::TOP_RIGHT;
    case -1:
      return NeighborNodesPosition::BOTTOM_RIGHT;
    }
    break;
  case -1:
    switch (neighborOffsetY)
    {
    case 0:
      return NeighborNodesPosition::LEFT;
    case 1:
      return NeighborNodesPosition::TOP_LEFT;
    case -1:
      return NeighborNodesPosition::BOTTOM_LEFT;
    }
    break;
  }
  assert(false); // this should never happen!
  return NeighborNodesPosition::CENTER;
}

Here is the caller graph for this function:

getNeighbors()

std::vector< Point > PointFunctions::getNeighbors ( const Point &  isoCoordinates, const bool  includeCentralNode, int  distance = 1  )

static

Get all neighboring coordinates from provided map node isocoordinate.

Parameters

isoCoordinates	point to get neighbors of
includeCentralNode	if set to true include the central node in the result.

Returns

std::vector<Point>() of all neighboring node coordinates.

Definition at line 175 of file PointFunctions.cxx.

{
  std::vector<Point> neighbors;
 
  for (int xOffset = -distance; xOffset <= distance; ++xOffset)
  {
    for (int yOffset = -distance; yOffset <= distance; ++yOffset)
    {
      if (!includeCentralNode && (xOffset == 0) && (yOffset == 0))
      {
        continue;
      }
 
      Point neighbor;
      neighbor.x = isoCoordinates.x + xOffset;
      neighbor.y = isoCoordinates.y + yOffset;
 
      if (neighbor.isWithinMapBoundaries())
      {
        neighbors.push_back(neighbor);
      }
    }
  }
 
  return neighbors;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getStraightLine()

std::vector< Point > PointFunctions::getStraightLine ( const Point &  isoCoordinatesStart, const Point &  isoCoordinatesEnd  )

static

Gets all nodes in a straight line from start and end point.

Parameters

isoCoordinatesStart	start coordinates
isoCoordinatesEnd	end coordinates

Returns

std::vector<Point>() containing coordinates for each tile between start and end coordinates, including start and end

Definition at line 108 of file PointFunctions.cxx.

{
  std::vector<Point> rectangle;
  int directionX = isoCoordinatesStart.x < isoCoordinatesEnd.x ? 1 : -1;
  int directionY = isoCoordinatesStart.y < isoCoordinatesEnd.y ? 1 : -1;
  int staticX, staticY;
  bool reverseDirection = false;
 
  uint32_t xDist = std::abs(isoCoordinatesStart.x - isoCoordinatesEnd.x);
  uint32_t yDist = std::abs(isoCoordinatesStart.y - isoCoordinatesEnd.y);
 
  if (xDist == 0 && yDist == 1)
  {
    reverseDirection = true;
  }
  else if (xDist == 1 && yDist == 0)
  {
    reverseDirection = false;
  }
  else if (xDist == 0 && yDist == 0)
  {
    rectangle.push_back(Point{isoCoordinatesStart.x, isoCoordinatesStart.y});
  }
 
  if (reverseDirection)
  {
    staticX = isoCoordinatesStart.x;
    staticY = isoCoordinatesEnd.y;
  }
  else
  {
    staticX = isoCoordinatesEnd.x;
    staticY = isoCoordinatesStart.y;
  }
 
  for (int x = isoCoordinatesStart.x; x != isoCoordinatesEnd.x; x += directionX)
  {
    rectangle.push_back(Point{x, staticY});
  }
 
  for (int y = isoCoordinatesStart.y; y != isoCoordinatesEnd.y; y += directionY)
  {
    rectangle.push_back(Point{staticX, y});
  }
 
  return rectangle;
}

Here is the caller graph for this function:

---

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

• src/engine/basics/PointFunctions.hxx
• src/engine/basics/PointFunctions.cxx