Hexagon grid

[Eyfenna]

Hello,  I got a hexagonal grid, and it does display right and I can even put textures on each hexagon. My problem is following:

In an additional std::map I store the coordinates of the central point and the x-y coordinate of the hexagon in the grid in a std::map<sf::Vector2f, sf::Vector2i> now I try to get the sf::Vector2i as return of a map search for displaying the Hexgrid coordinates in console for the one mouse if hoovering over in the window.  I'm trying to do this with find_if algorithm on the map. The function is part of the Hexgrid class which holds the hexagonal grid:

(click to show/hide)

sf::Vector2i Hexgrid::getCoordinate(sf::Vector2f avec)
{
   auto found = find_if(coordinate.begin(), coordinate.end(), [&](const std::pair<sf::Vector2f,sf::Vector2i>& temp)->bool {return (temp.first.x = avec.x && temp.first.y == avec.y); });
   return found->second;
}

however compiler notifies me of an error on converting pairs.

I also tried with another lambda:

(click to show/hide)

[&](sf::Vector2f& temp)->bool {return (temp.x = avec.x && temp.y == avec.y)

Here the compiler can't convert pair to sf::vector2f.


So after a search I found that I might have to write something extra but can't realy bend my head around what it is and why this specific thing is lacking. Thanks for a response or a hint.

[Laurent]

It would be very helpful to see that compiler error.

[Hapax]

You are checking equality using a floating point value, which is probably not your intention as that should be avoided, pretty much.

You can explictly convert between Vector2f and Vector2i by creating one and passing the other as a parameter to its constructor.
Since you need to use a Vector2 as a key for a map, it would be better to first convert it to integer values and then use that as the key. That is, use Vector2i as the map's key.


In case I presumed too much from the start, here's an explanation of why you shouldn't be checking equality using floating point values:
https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

[Eyfenna]

The error message is (about translated) [same for std::map<sf::Vector2i, sf::Vector2i>]

Error C2664   "bool Hexgrid::GetGridPlace::<lambda_5b26f5554823591ff0c2ae8c47a36fad>::operator ()(std::pair<sf::Vector2i,sf::Vector2i> &) const" : Conversion from argument 1  "std::pair<const _Kty,_Ty>" to "std::pair<sf::Vector2i,sf::Vector2i> &" not possible. ConsoleApplication87   c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.16.27023\include\algorithm   174   

Thanks for the hint with the floating point numbers.

Solved it one possible way:

I went a different way and safe the grid position (offset coordinates according to redblob site) inside the Hexagon and do an inRange comparison with the central point:

(click to show/hide)

bool Hexagon::isinRange(sf::Vector2f avec)
{
   return (((avec.x) <= (mPosition.x + mSize * (float)(sqrt(3)/2.0f)) && (avec.x) >= (mPosition.x - mSize * ((float)sqrt(3)/2.0f))) && ((avec.y) <= (mPosition.y + mSize) && (avec.y) >= (mPosition.y - mSize)));
}

and use this in a function inside the Hexgrid class:

(click to show/hide)

void Hexgrid::GridPosition(sf::Vector2f avec, sf::Vector2i& destvec, bool& delivered)
{
   for (Hexagon d : Grid)
   {
      if (d.isinRange(avec))
      {
            delivered = true;
            destvec = d.getGridPos();
            return;
      }   
      delivered = false;
   }
}

[Elias Daler]

The error happens, because sf::Vector2i can't be implcitly converted to sf::Vector2f. This should work:

sf::Vector2i Hexgrid::getCoordinate(sf::Vector2f avec)
{
   auto found = find_if(coordinate.begin(), coordinate.end(), [&](const std::pair<const sf::Vector2i, sf::Vector2i>& temp)->bool {return static_cast<sf::Vector2f>(temp.first) == avec; });
// or just (const auto& temp) in lambda
   return found->second;
}

Also note that in std::map the key has "const" type.

Also, maybe pass "avec" as Vector2i so not casts will be needed in lambda?
Also note that "found" is an iterator, so if find_if returns "end" iterator, calling "->second" on it will result in segfault, so you need to check if the coordinate was found or not.

[Eyfenna]

Thanks for the helpfull replies

As I'm not so sure with Vertexarrays I went following way:
For the hexagonal grid I made a hexagon class(drawable) which holds the vertexarray to be more precise std::vector<vertex>. A templated GameGrid class holds a std::vector of Hexagons for example and generates the field.
I did some refractoring on it and except a pointer to a maploader - that holds the map information in an array - and three member function pointers on this class for the getters in this way I could remove the maploader header from the  GameGrid header.
I was wondering if that is still good c++ or overengineering things?

Well before describing it lengthily I post the source code for GameGrid and the hexagon class
The code for GameGrid template is all in a header now, moving things to an .inl when I played around with this format.
In so far the code for GameGrid is lengthy:

(click to show/hide)

#pragma once
#ifndef GAMEGRID_H_INCLUDED
#define GAMEGRID_H_INCLUDED

#include <SFML/Graphics.hpp>
#include <functional>
#include <vector>
#include <cassert>
#include "Hexagon.h"

template <typename Identifier, typename Fieldtype, typename Mapstorage>
class GameGrid :public sf::Drawable
{
private:

   //GameGrid Object is drawable, calls draw function of each field instance
   virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
   {
      for (Fieldtype a : mGrid)
      {
         target.draw(a);
      }
   }
protected:
   //Storage of fieldobjects, field objects have to be drawable
   std::vector<Fieldtype> mGrid;

   //Texturehandler with textures
   //Wrapper class for a std::map<Keyvalue, sf::Texture>
   ResourceHolder<Identifier, sf::Texture>* pmResources;

   //MapHolder
   //pointer to Wrapper class for two dimensional array of ints that provides three functions
   //one that returns number of lines of array
   //one that returns number of rows of array
   //one that returns value of specific array member
   Mapstorage* mMap;

   //wrapper class function that provides row ammount
   int (Mapstorage::*Rower)();

   //wrapper class function that provides line ammount
   int (Mapstorage::*Liner)();

   //wrapper class function that provides int value of specific cell
   int (Mapstorage::*Celling)(int, int);

   //function that cuts down value from wrapper class to value for texture
   std::function<int(int)> mCutter;
   
   //function that calculates X coordinate of center of field
   std::function<float(float, float, float,int, int)> mCoordinateX;

   //function that calculates Y coordinate of center of field
   std::function<float(float, float, float,int, int)> mCoordinateY;

   //top-left position of the grid
   sf::Vector2f mPosition;

   //size  of field
   float mFieldsize;
   
   //factor by which fieldsize is streched in x
   float mFactorX;

   //factor by which fieldsize is streched in y
   float mFactorY;

   //factor by which the spacing in x direction between fields is calculated
   float mSpacingX;

   //factor by which the spacing in y direction between fields is calculated
   float mSpacingY;

   //are the field textured
   bool mTextured;

   //are all fields added to the field container or are some sorted out
   bool mOnlyUnMarked;

   //Markervalue is compared with value from mapholder, in case of equal no field instance is created
   int mMarker;
   
   //exact Key value for the texture holder
   Identifier mIdentity;


public:

   //Constructor, only requires values for the TextureHandler, and exact Key rest of variables has an intial value
   GameGrid(ResourceHolder<Identifier, sf::Texture>* aResource, Identifier anIdentity, Mapstorage* aMap = nullptr, int (Mapstorage::*Rowing)() = nullptr, int (Mapstorage::*getCells)(int, int) = nullptr, int (Mapstorage::*Lining)() = nullptr, std::function<int(int)> aCut = [](int a) {return 0; }, std::function<float(float, float, float, int, int)> aXCalc = [](float a, float b, float c, int d, int e)->float {return 0.f; }, std::function<float(float, float, float, int, int)>aYCalc = [](float a, float b, float c, int d, int e)->float {return 0.f; }, sf::Vector2f aPosition = sf::Vector2f(0.f, 0.f), float aSize = 0.f, float aFactorX = 0.f, float aFactorY = 0.f, float aspaceX = 0.f, float aspaceY = 0.f, bool isTextured = false, bool onlyunmarked = false, int amarker = 0) :
      pmResources(aResource),mIdentity(anIdentity),mMap(aMap),Rower(Rowing), Liner(Lining),Celling(getCells),mCutter(aCut), mCoordinateX(aXCalc), mCoordinateY(aYCalc), mPosition(aPosition), mFactorX(aFactorX),mFactorY(aFactorY),mSpacingX(aspaceX), mSpacingY(aspaceY), mTextured(isTextured), mOnlyUnMarked(onlyunmarked),mMarker(amarker)
   {}

   //MapHolder and getter functions for MapHolder
   void setUpMap(Mapstorage* aMap, int (Mapstorage::*Rows)(), int (Mapstorage::*Lines)(), int (Mapstorage::*Cells)(int, int))
   {
      mMap = aMap;
      Rower = Rows;
      Liner = Lines;
      Celling = Cells;
   }


   //exact Identifier can be changed
   void setIdentifier(Identifier identity)
   {
      mIdentity = identity;
   }


   //setter for Calculations of center coordinates for each field object
   void setCoordinateCalcs(std::function<float(float, float, float, int, int)> CalcX, std::function<float(float, float, float, int, int)>CalcY)
   {
      mCoordinateX = CalcX;
      mCoordinateY = CalcY;
   }

   //setter for function that cuts down
   void setCutter(std::function<int(int)> Cutfunction)
   {
      mCutter = Cutfunction;
   }

   //setter for upper-left position of grid
   void setPosition(sf::Vector2f Position)
   {
      mPosition = Position;
   }

   //setter for the fieldsize
   void setFieldsize(float Size)
   {
      mFieldsize = Size;
   }

   //setter for Factors for streching and spacing of field instances
   void setFactors(float stretchX, float stretchY, float spaceX, float spaceY)
   {
      mFactorX = stretchX;
      mFactorY = stretchY;
      mSpacingX = spaceX;
      mSpacingY = spaceY;
   }

   //setter if fieldinstances are texturized
   void setTextured(bool texturized)
   {
      mTextured = texturized;
   }

   //setter if Only fields whos value from map is unequal Marker get added to container
   void setOnlyUnMarked(bool OnlyUnMarked)
   {
      mOnlyUnMarked = OnlyUnMarked;
   }

   void createGrid()
   {
      float FieldWidth = mFieldsize * mFactorX;
      float FieldHeight = mFieldsize * mFactorY;
      float InitialWidth = FieldWidth / 2;
      float InitialHeight = FieldHeight / 2;
      float SpacingWidth = mSpacingX * FieldWidth;
      float SpacingHeight = mSpacingY * FieldHeight;
      assert(mMap != nullptr);
      int ammountX = (mMap->*Rower)();
      int ammountY = (mMap->*Liner)();
      int value;
      for (int i =0; i < ammountX; ++i)
      {
         for (int j = 0; j < ammountY; ++j)
         {
            if (j % 2 == 0)
            {
               value = mCutter((mMap->*Celling)(i, j));
               if (!mOnlyUnMarked || (mOnlyUnMarked && mMarker != value))
               {
                  sf::Vector2f currpos = sf::Vector2f(mCoordinateX(mPosition.x, InitialWidth, SpacingWidth, i, 1), mCoordinateY(mPosition.y, InitialHeight, SpacingHeight, j, 1));
                  Fieldtype h(currpos, mFieldsize, value, &pmResources->get(mIdentity), sf::Vector2i(i, j), mTextured);
                  mGrid.push_back(h);
               }
            }
            if (j % 2 == 1)
            {
               value = mCutter((mMap->*Celling)(i, j));
               if (!mOnlyUnMarked || (mOnlyUnMarked && mMarker != value))
               {
                  sf::Vector2f currpos = sf::Vector2f(mCoordinateX(mPosition.x, InitialWidth, SpacingWidth, i, 2), mCoordinateY(mPosition.y, InitialHeight, SpacingHeight, j, 1));
                  Fieldtype h(currpos, mFieldsize, value, &pmResources->get(mIdentity), sf::Vector2i(i, j), mTextured);
                  mGrid.push_back(h);
               }
            }
         }
      }
   }

   //aquiering the field position for a coordinate
   void GridPosition(sf::Vector2f avec, sf::Vector2i& destvec, int& gridValue, bool& delivered)
   {
      for (Fieldtype a : mGrid)
      {
         if (a.isinRange(avec))
         {
            delivered = true;
            destvec = a.getGridPos();
            gridValue = mCutter((mMap->*Celling)(destvec.x, destvec.y)) / 10;
         }
         delivered = false;
      }
   }
};

#endif

Here the code for the Hexagon class:

the header

(click to show/hide)

#ifndef HEXAGON_H_INCLUDED
#define HEXAGON_H_INCLUDED

#include<vector>
#include <SFML/Graphics.hpp>
#include<SFML/System.hpp>
#include <math.h>

class Hexagon :public sf::Drawable//, public sf::NonCopyable
{
private:
   virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
protected:
   int mTilenumber;
   int mTileline;
   sf::Texture* m_TileSet;

        //Vertices that are textured
   std::vector<sf::Vertex> oneHex;

       //Vertices that are displayed as a line surrounding the field
   std::vector<sf::Vertex> twoHex;

   float mSize;
   sf::Vector2f mPosition;
   void claculatePoints();
   sf::Vector2i mGridPos;
   bool showField;
public:
   Hexagon(sf::Vector2f pos, float size, int tilenumber, sf::Texture* tileset, sf::Vector2i aGridPos, bool aShow);
   bool isinRange(sf::Vector2f avec);
   sf::Vector2f getLocation();
   sf::Vector2i getGridPos();
   
};

#endif

and here the .cpp with the bodies of the memberfunction for Hexagon:

I left out the dependecy for VisualStudio

(click to show/hide)

#include "Hexagon.h"
#include <math.h>


Hexagon::Hexagon(sf::Vector2f pos, float size, int tilenumber, sf::Texture* tileset, sf::Vector2i aGridPos, bool aShow) : mPosition(pos), mSize(size), m_TileSet(tileset), mGridPos(aGridPos), showField(aShow)
{   
   mTilenumber = tilenumber % 10;
   mTileline = tilenumber / 10;
   claculatePoints();
}

void Hexagon::claculatePoints()
{
   float width = mSize * (float)sqrt(3);
   float height = mSize * 2;
   if (showField)
   {
      
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y - height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f(mPosition.x, (mPosition.y - height / 2))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y - height / 4))));

      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y + height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f(mPosition.x, (mPosition.y + height / 2))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y + height / 4))));

      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y + height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y - height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y - height / 4))));

      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y - height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y + height / 4))));
      oneHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y + height / 4))));

      oneHex[0].texCoords = sf::Vector2f((float)mTilenumber*height + width * 0.25f, (float)mTileline*height + mSize - height / 4);
      oneHex[1].texCoords = sf::Vector2f((float)mTilenumber*height + mSize, (float)mTileline*height + mSize - height / 2);
      oneHex[2].texCoords = sf::Vector2f((float)mTilenumber*height + width, (float)mTileline*height + mSize - height / 4);

      oneHex[3].texCoords = sf::Vector2f((float)mTilenumber*height + width, (float)mTileline*height + mSize + height / 4);
      oneHex[4].texCoords = sf::Vector2f((float)mTilenumber*height + mSize, (float)mTileline*height + mSize + height / 2 - 1);
      oneHex[5].texCoords = sf::Vector2f((float)mTilenumber*height + width * 0.25f, (float)mTileline*height + mSize + height / 4);

      oneHex[6].texCoords = sf::Vector2f((float)mTilenumber*height + width * 0.25f, (float)mTileline*height + mSize + height / 4);
      oneHex[7].texCoords = sf::Vector2f((float)mTilenumber*height + width * 0.25f, (float)mTileline*height + mSize - height / 4);
      oneHex[8].texCoords = sf::Vector2f((float)mTilenumber*height + width, (float)mTileline*height + mSize - height / 4);

      oneHex[9].texCoords = sf::Vector2f((float)mTilenumber*height + width, (float)mTileline*height + mSize - height / 4);
      oneHex[10].texCoords = sf::Vector2f((float)mTilenumber*height + width, (float)mTileline*height + mSize + height / 4);
      oneHex[11].texCoords = sf::Vector2f((float)mTilenumber*height + width * 0.25f, (float)mTileline*height + mSize + height / 4);
   }
   else
   {
      twoHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y - height / 4))));
      twoHex.push_back(sf::Vertex(sf::Vector2f(mPosition.x, (mPosition.y - height / 2))));
      twoHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y - height / 4))));

      twoHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width / 2), (mPosition.y + height / 4))));
      twoHex.push_back(sf::Vertex(sf::Vector2f(mPosition.x, (mPosition.y + height / 2))));
      twoHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y + height / 4))));
      twoHex.push_back(sf::Vertex(sf::Vector2f((mPosition.x - width / 2), (mPosition.y - height / 4))));
   }
}

void Hexagon::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
   states.texture = &(*m_TileSet);
   if(showField)
      target.draw(&oneHex[0], oneHex.size(), sf::Triangles,states);
   else
      target.draw(&twoHex[0], twoHex.size(), sf::LineStrip);
}

sf::Vector2f Hexagon::getLocation() {
   return mPosition;
}

sf::Vector2i Hexagon::getGridPos() {
   return mGridPos;
}

bool Hexagon::isinRange(sf::Vector2f avec)
{
   return (((avec.x) <= (mPosition.x + mSize * (float)(sqrt(3)/2.0f)) && (avec.x) >= (mPosition.x - mSize * ((float)sqrt(3)/2.0f))) && ((avec.y) <= (mPosition.y + mSize) && (avec.y) >= (mPosition.y - mSize)));
}

[Elias Daler]

Some things:

1)

virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const

Should be

void draw(sf::RenderTarget& target, sf::RenderStates states) const override

2) This will do tons of copies per each frame:

for (Fieldtype a : mGrid)

Do this:

for (const auto& a : mGrid)

3) Maybe store pmResources and other stuff you can by reference, not by pointer. Seems safer (you're passing it into ctor, anyway)

4) In my opinion, it's more useful to list members in the following order: public, protected, private. I'm more interested in seeing what I can actually call first.

5) Maybe separate implementation into ".inl" files, don't have one giant header.

6) Think about providing default values to callbacks in some other way in GameGrid. Right its constructor looks scary - too many arguments.

7) I'd store all callbacks as std::function's, not as pointers to functions - it provides a lot more flexibilty.

8 ) In hexagon class you store vertices as this:

std::vector<sf::Vertex> oneHex;
std::vector<sf::Vertex> twoHex;
 

I'd store it like this:

std::array<sf::Vertex, 12> oneHex;
std::array<sf::Vertex, 12> twoHex;
 

^ no dynamic allocations!

9) The formulas for setting hexagon vertices look scary. Pretty sure it can be simplified and don't be full of copy-pasted

[Eyfenna]

The post lead to me doing thinking about the code.

9) The formulas for setting hexagon vertices look scary. Pretty sure it can be simplified and don't be full of copy-pasted

Good tip, I concluded that a

const sf::Vector2f Orientation[] = { {-.5f,-0.25f},{0.f,-0.5f}, {0.5f,-0.25f},{0.5f,0.25f},{0.f,0.5f},{-0.5,0.25f}, };

(imitating a thing from redblobgames)

allows to shorten the vertix location setting code for an empty hexagon(sf::LineStrip) to

int a;
for (int i = 0; i < 7; ++i)
{
if (i - 6 >= 0) a = i - 6;
else a = i;
mBare.push_back(sf::Vertex(sf::Vector2f((mPosition.x + width*Orientation[a].x), (mPosition.y +height*Orientation[a].y))));
}
 

similar for the textured vertices location.

7) I'd store all callbacks as std::function's, not as pointers to functions - it provides a lot more flexibilty.

Done, std::bind is sort of easiert to handle than pointers to memberfunction once one has understood it. The reason I used function pointers was that callback with them came to my mind at first and std::bind doesn't appear in tutorial pages about callbacks I found on google.

With std::function<> callback I found also that I can leave out the pointer to the class. That is nice, works with the maploader.