You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
521 lines
15 KiB
521 lines
15 KiB
/*
|
|
This file is part of the KDE games library
|
|
Copyright (C) 2001-02 Nicolas Hadacek (hadacek@kde.org)
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License version 2 as published by the Free Software Foundation.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifndef __KGRID2D_H_
|
|
#define __KGRID2D_H_
|
|
|
|
#include <math.h>
|
|
|
|
#include <tqpair.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqvaluevector.h>
|
|
|
|
#include <kglobal.h>
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
namespace KGrid2D
|
|
{
|
|
/**
|
|
* This type represents coordinates on a bidimensionnal grid.
|
|
* @since 3.2
|
|
*/
|
|
typedef TQPair<int, int> Coord;
|
|
|
|
/**
|
|
* This type represents a list of @ref Coord.
|
|
* @since 3.2
|
|
*/
|
|
typedef TQValueList<Coord> CoordList;
|
|
}
|
|
|
|
inline KGrid2D::Coord
|
|
operator +(const KGrid2D::Coord &c1, const KGrid2D::Coord &c2) {
|
|
return KGrid2D::Coord(c1.first + c2.first, c1.second + c2.second);
|
|
}
|
|
|
|
inline KGrid2D::Coord
|
|
operator -(const KGrid2D::Coord &c1, const KGrid2D::Coord &c2) {
|
|
return KGrid2D::Coord(c1.first - c2.first, c1.second - c2.second);
|
|
}
|
|
|
|
/**
|
|
* @return the maximum of both coordinates.
|
|
* @since 3.2
|
|
*/
|
|
inline KGrid2D::Coord
|
|
maximum(const KGrid2D::Coord &c1, const KGrid2D::Coord &c2) {
|
|
return KGrid2D::Coord(kMax(c1.first, c2.first), kMax(c1.second, c2.second));
|
|
}
|
|
/**
|
|
* @return the minimum of both coordinates.
|
|
* @since 3.2
|
|
*/
|
|
inline KGrid2D::Coord
|
|
minimum(const KGrid2D::Coord &c1, const KGrid2D::Coord &c2) {
|
|
return KGrid2D::Coord(kMin(c1.first, c2.first), kMin(c1.second, c2.second));
|
|
}
|
|
|
|
inline TQTextStream &operator <<(TQTextStream &s, const KGrid2D::Coord &c) {
|
|
return s << '(' << c.second << ", " << c.first << ')';
|
|
}
|
|
|
|
inline TQTextStream &operator <<(TQTextStream &s, const KGrid2D::CoordList &list)
|
|
{
|
|
for(KGrid2D::CoordList::const_iterator i=list.begin(); i!=list.end(); ++i)
|
|
s << *i;
|
|
return s;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
namespace KGrid2D
|
|
{
|
|
/**
|
|
* This template class represents a generic bidimensionnal grid. Each node
|
|
* contains an element of the template type.
|
|
*
|
|
* @since 3.2
|
|
*/
|
|
template <class Type>
|
|
class Generic
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
Generic(uint width = 0, uint height = 0) {
|
|
resize(width, height);
|
|
}
|
|
|
|
virtual ~Generic() {}
|
|
|
|
/**
|
|
* Resize the grid.
|
|
*/
|
|
void resize(uint width, uint height) {
|
|
_width = width;
|
|
_height = height;
|
|
_vector.resize(width*height);
|
|
}
|
|
|
|
/**
|
|
* Fill the nodes with the given value.
|
|
*/
|
|
void fill(const Type &value) {
|
|
for (uint i=0; i<_vector.count(); i++) _vector[i] = value;
|
|
}
|
|
|
|
/**
|
|
* @return the width.
|
|
*/
|
|
uint width() const { return _width; }
|
|
/**
|
|
* @return the height.
|
|
*/
|
|
uint height() const { return _height; }
|
|
/**
|
|
* @return the number of nodes (ie width*height).
|
|
*/
|
|
uint size() const { return _width*_height; }
|
|
|
|
/**
|
|
* @return the linear index for the given coordinate.
|
|
*/
|
|
uint index(const Coord &c) const {
|
|
return c.first + c.second*_width;
|
|
}
|
|
|
|
/**
|
|
* @return the coordinate corresponding to the linear index.
|
|
*/
|
|
Coord coord(uint index) const {
|
|
return Coord(index % _width, index / _width);
|
|
}
|
|
|
|
/**
|
|
* @return the value at the given coordinate.
|
|
*/
|
|
const Type &at(const Coord &c) const { return _vector[index(c)]; }
|
|
/**
|
|
* @return the value at the given coordinate.
|
|
*/
|
|
Type &at(const Coord &c) { return _vector[index(c)]; }
|
|
/**
|
|
* @return the value at the given coordinate.
|
|
*/
|
|
const Type &operator [](const Coord &c) const { return _vector[index(c)]; }
|
|
/**
|
|
* @return the value at the given coordinate.
|
|
*/
|
|
Type &operator [](const Coord &c) { return _vector[index(c)]; }
|
|
|
|
/**
|
|
* @return the value at the given linear index.
|
|
*/
|
|
const Type &at(uint index) const { return _vector[index]; }
|
|
/**
|
|
* @return the value at the given linear index.
|
|
*/
|
|
Type &at(uint index) { return _vector[index]; }
|
|
/**
|
|
* @return the value at the given linear index.
|
|
*/
|
|
const Type &operator [](uint index) const { return _vector[index]; }
|
|
/**
|
|
* @return the value at the given linear index.
|
|
*/
|
|
Type &operator [](uint index) { return _vector[index]; }
|
|
|
|
/**
|
|
* @return if the given coordinate is inside the grid.
|
|
*/
|
|
bool inside(const Coord &c) const {
|
|
return ( c.first>=0 && c.first<(int)_width
|
|
&& c.second>=0 && c.second<(int)_height );
|
|
}
|
|
|
|
/**
|
|
* Bound the given coordinate with the grid dimensions.
|
|
*/
|
|
void bound(Coord &c) const {
|
|
c.first = kMax(kMin(c.first, (int)_width-1), 0);
|
|
c.second = kMax(kMin(c.second, (int)_height-1), 0);
|
|
}
|
|
|
|
protected:
|
|
uint _width, _height;
|
|
TQValueVector<Type> _vector;
|
|
};
|
|
}
|
|
|
|
template <class Type>
|
|
TQDataStream &operator <<(TQDataStream &s, const KGrid2D::Generic<Type> &m) {
|
|
s << (TQ_UINT32)m.width() << (TQ_UINT32)m.height();
|
|
for (uint i=0; i<m.size(); i++) s << m[i];
|
|
return s;
|
|
}
|
|
|
|
template <class Type>
|
|
TQDataStream &operator >>(TQDataStream &s, KGrid2D::Generic<Type> &m) {
|
|
TQ_UINT32 w, h;
|
|
s >> w >> h;
|
|
m.resize(w, h);
|
|
for (uint i=0; i<m.size(); i++) s >> m[i];
|
|
return s;
|
|
}
|
|
|
|
|
|
namespace KGrid2D
|
|
{
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* This class contains static methods to manipulate coordinates for a
|
|
* square bidimensionnal grid.
|
|
*
|
|
* @since 3.2
|
|
*/
|
|
class SquareBase
|
|
{
|
|
public:
|
|
/**
|
|
* Identify the eight neighbours.
|
|
*/
|
|
enum Neighbour { Left=0, Right, Up, Down, LeftUp, LeftDown,
|
|
RightUp, RightDown, Nb_Neighbour };
|
|
|
|
/**
|
|
* @return the trigonometric angle in radians for the given neighbour.
|
|
*/
|
|
static double angle(Neighbour n) {
|
|
switch (n) {
|
|
case Left: return M_PI;
|
|
case Right: return 0;
|
|
case Up: return M_PI_2;
|
|
case Down: return -M_PI_2;
|
|
case LeftUp: return 3.0*M_PI_4;
|
|
case LeftDown: return -3.0*M_PI_4;
|
|
case RightUp: return M_PI_4;
|
|
case RightDown: return -M_PI_4;
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @return the opposed neighbour.
|
|
*/
|
|
static Neighbour opposed(Neighbour n) {
|
|
switch (n) {
|
|
case Left: return Right;
|
|
case Right: return Left;
|
|
case Up: return Down;
|
|
case Down: return Up;
|
|
case LeftUp: return RightDown;
|
|
case LeftDown: return RightUp;
|
|
case RightUp: return LeftDown;
|
|
case RightDown: return LeftUp;
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return Nb_Neighbour;
|
|
}
|
|
|
|
/**
|
|
* @return true if the neighbour is a direct one (ie is one of the four
|
|
* nearest).
|
|
*/
|
|
static bool isDirect(Neighbour n) { return n<LeftUp; }
|
|
|
|
/**
|
|
* @return the neighbour for the given coordinate.
|
|
*/
|
|
static Coord neighbour(const Coord &c, Neighbour n) {
|
|
switch (n) {
|
|
case Left: return c + Coord(-1, 0);
|
|
case Right: return c + Coord( 1, 0);
|
|
case Up: return c + Coord( 0, -1);
|
|
case Down: return c + Coord( 0, 1);
|
|
case LeftUp: return c + Coord(-1, -1);
|
|
case LeftDown: return c + Coord(-1, 1);
|
|
case RightUp: return c + Coord( 1, -1);
|
|
case RightDown: return c + Coord( 1, 1);
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return c;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This template is a @ref Generic implementation for a square bidimensionnal
|
|
* grid (@ref SquareBase).
|
|
*
|
|
* @since 3.2
|
|
*/
|
|
template <class T>
|
|
class Square : public Generic<T>, public SquareBase
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
Square(uint width = 0, uint height = 0)
|
|
: Generic<T>(width, height) {}
|
|
|
|
/**
|
|
* @return the neighbours of coordinate @param c
|
|
* to the given set of coordinates
|
|
* @param c the coordinate to use as the reference point
|
|
* @param insideOnly only add coordinates that are inside the grid.
|
|
* @param directOnly only add the four nearest neighbours.
|
|
*/
|
|
CoordList neighbours(const Coord &c, bool insideOnly = true,
|
|
bool directOnly = false) const {
|
|
CoordList neighbours;
|
|
for (uint i=0; i<(directOnly ? LeftUp : Nb_Neighbour); i++) {
|
|
Coord n = neighbour(c, (Neighbour)i);
|
|
if ( insideOnly && !Generic<T>::inside(n) ) continue;
|
|
neighbours.append(n);
|
|
}
|
|
return neighbours;
|
|
}
|
|
|
|
/**
|
|
* @return the "projection" of the given coordinate on the grid edges.
|
|
*
|
|
* @param c the coordinate to use as the reference point
|
|
* @param n the direction of projection.
|
|
*/
|
|
Coord toEdge(const Coord &c, Neighbour n) const {
|
|
switch (n) {
|
|
case Left: return Coord(0, c.second);
|
|
case Right: return Coord(Generic<T>::width()-1, c.second);
|
|
case Up: return Coord(c.first, 0);
|
|
case Down: return Coord(c.first, Generic<T>::height()-1);
|
|
case LeftUp: return Coord(0, 0);
|
|
case LeftDown: return Coord(0, Generic<T>::height()-1);
|
|
case RightUp: return Coord(Generic<T>::width()-1, 0);
|
|
case RightDown: return Coord(Generic<T>::width()-1, Generic<T>::height()-1);
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return c;
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* This class contains static methods to manipulate coordinates on an
|
|
* hexagonal grid where hexagons form horizontal lines:
|
|
* <pre>
|
|
* (0,0) (0,1) (0,2)
|
|
* (1,0) (1,1) (1,2)
|
|
* (2,0) (2,1) (2,2)
|
|
* </pre>
|
|
*
|
|
* @since 3.2
|
|
*/
|
|
class HexagonalBase
|
|
{
|
|
public:
|
|
/**
|
|
* Identify the six neighbours.
|
|
*/
|
|
enum Neighbour { Left = 0, Right, LeftUp, LeftDown,
|
|
RightUp, RightDown, Nb_Neighbour };
|
|
|
|
/**
|
|
* @return the trigonometric angle in radians for the given neighbour.
|
|
*/
|
|
static double angle(Neighbour n) {
|
|
switch (n) {
|
|
case Left: return M_PI;
|
|
case Right: return 0;
|
|
case LeftUp: return 2.0*M_PI/3;
|
|
case LeftDown: return -2.0*M_PI/3;
|
|
case RightUp: return M_PI/3;
|
|
case RightDown: return -M_PI/3;
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @return the opposed neighbour.
|
|
*/
|
|
static Neighbour opposed(Neighbour n) {
|
|
switch (n) {
|
|
case Left: return Right;
|
|
case Right: return Left;
|
|
case LeftUp: return RightDown;
|
|
case LeftDown: return RightUp;
|
|
case RightUp: return LeftDown;
|
|
case RightDown: return LeftUp;
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return Nb_Neighbour;
|
|
}
|
|
|
|
/**
|
|
* @return the neighbour of the given coordinate.
|
|
*/
|
|
static Coord neighbour(const Coord &c, Neighbour n) {
|
|
bool oddRow = c.second%2;
|
|
switch (n) {
|
|
case Left: return c + Coord(-1, 0);
|
|
case Right: return c + Coord( 1, 0);
|
|
case LeftUp: return c + (oddRow ? Coord( 0, -1) : Coord(-1, -1));
|
|
case LeftDown: return c + (oddRow ? Coord( 0, 1) : Coord(-1, 1));
|
|
case RightUp: return c + (oddRow ? Coord( 1, -1) : Coord( 0, -1));
|
|
case RightDown: return c + (oddRow ? Coord( 1, 1) : Coord( 0, 1));
|
|
case Nb_Neighbour: Q_ASSERT(false);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* @return the distance between the two coordinates in term of hexagons.
|
|
*/
|
|
static uint distance(const Coord &c1, const Coord &c2) {
|
|
return kAbs(c1.first - c2.first) + kAbs(c1.second - c2.second)
|
|
+ (c1.first==c2.first || c1.second==c2.second ? 0 : -1);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This template implements a hexagonal grid
|
|
* where hexagons form horizontal lines:
|
|
* <pre>
|
|
* (0,0) (0,1) (0,2)
|
|
* (1,0) (1,1) (1,2)
|
|
* (2,0) (2,1) (2,2)
|
|
* </pre>
|
|
*
|
|
* @ since 3.2
|
|
*/
|
|
template <class Type>
|
|
class Hexagonal : public Generic<Type>, public HexagonalBase
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
Hexagonal(uint width = 0, uint height = 0)
|
|
: Generic<Type>(width, height) {}
|
|
|
|
/**
|
|
* @return the neighbours of coordinate @param c
|
|
* to the given set of coordinates
|
|
* @param c the coordiante to use as the reference point
|
|
* @param insideOnly only add coordinates that are inside the grid.
|
|
*/
|
|
CoordList neighbours(const Coord &c, bool insideOnly = true) const {
|
|
CoordList neighbours;
|
|
for (uint i=0; i<Nb_Neighbour; i++) {
|
|
Coord n = neighbour(c, (Neighbour)i);
|
|
if ( insideOnly && !Generic<Type>::inside(n) ) continue;
|
|
neighbours.append(n);
|
|
}
|
|
return neighbours;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return the neighbours at distance @param distance of coordinate
|
|
* @param c the coordinate to use as the reference point
|
|
* @param distance distance to the neighbour (1 means at contact).
|
|
* @param insideOnly only add coordinates that are inside the grid.
|
|
* @param all returns all neighbours at distance equal and less than
|
|
* @param distance (the original coordinate is not included).
|
|
*/
|
|
CoordList neighbours(const Coord &c, uint distance, bool all,
|
|
bool insideOnly = true) const {
|
|
// brute force algorithm -- you're welcome to make it more efficient :)
|
|
CoordList ring;
|
|
if ( distance==0 ) return ring;
|
|
ring = neighbours(c, insideOnly);
|
|
if ( distance==1 ) return ring;
|
|
CoordList center;
|
|
center.append(c);
|
|
for (uint i=1; i<distance; i++) {
|
|
CoordList newRing;
|
|
CoordList::const_iterator it;
|
|
for (it=ring.begin(); it!=ring.end(); ++it) {
|
|
CoordList n = neighbours(*it, insideOnly);
|
|
CoordList::const_iterator it2;
|
|
for (it2=n.begin(); it2!=n.end(); ++it2)
|
|
if ( center.find(*it2)==center.end()
|
|
&& ring.find(*it2)==ring.end()
|
|
&& newRing.find(*it2)==newRing.end() )
|
|
newRing.append(*it2);
|
|
center.append(*it);
|
|
}
|
|
ring = newRing;
|
|
}
|
|
if ( !all ) return ring;
|
|
CoordList::const_iterator it;
|
|
for (it=ring.begin(); it!=ring.end(); ++it)
|
|
center.append(*it);
|
|
center.remove(c);
|
|
return center;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif
|