Merge branch 'develop' of https://github.com/vcmi/vcmi into RMG

client/CSpellWindow.cpp

@@ -744,23 +744,26 @@ void CSpellWindow::SpellArea::clickLeft(tribool down, bool previousState)
 
 					if (h->getSpellSchoolLevel(CGI->spellh->objects[spell]) < 2) //not advanced or expert - teleport to nearest available city
 					{
-						int nearest = -1; //nearest town's ID
+						auto nearest = Towns.cbegin(); //nearest town's iterator
-						double dist = -1;
+						si32 dist = LOCPLINT->cb->getTown((*nearest)->id)->pos.dist2dSQ(h->pos);
-						for (int g=0; g<Towns.size(); ++g)
+
+						for (auto i = nearest + 1; i != Towns.cend(); ++i)
 						{
-							const CGTownInstance * dest = LOCPLINT->cb->getTown(Towns[g]->id);
+							const CGTownInstance * dest = LOCPLINT->cb->getTown((*i)->id);
-							double curDist = dest->pos.dist2d(h->pos);
+							si32 curDist = dest->pos.dist2dSQ(h->pos);
-							if (nearest == -1 || curDist < dist)
+
+							if (curDist < dist)
 							{
-								nearest = g;
+								nearest = i;
 								dist = curDist;
 							}
 						}
-						if ( Towns[nearest]->visitingHero )
+
+						if ((*nearest)->visitingHero)
 							LOCPLINT->showInfoDialog(CGI->generaltexth->allTexts[123]);
 						else
 						{
-							const CGTownInstance * town = LOCPLINT->cb->getTown(Towns[nearest]->id);
+							const CGTownInstance * town = LOCPLINT->cb->getTown((*nearest)->id);
 							LOCPLINT->cb->castSpell(h, spell, town->visitablePos());// - town->getVisitableOffset());
 						}
 					}

lib/CGameState.cpp

@@ -1032,7 +1032,7 @@ void CGameState::initGrailPosition()
 						&& !t.visitable
 						&& t.terType != ETerrainType::WATER
 						&& t.terType != ETerrainType::ROCK
-						&& map->grailPos.dist2d(int3(i,j,k)) <= map->grailRadious)
+						&& map->grailPos.dist2dSQ(int3(i, j, k)) <= (map->grailRadious * map->grailRadious))
 						allowedPos.push_back(int3(i,j,k));
 				}
 			}

lib/CObjectHandler.cpp

@@ -4173,13 +4173,13 @@ void CGTeleport::postInit() //matches subterranean gates into pairs
 		const CGObjectInstance *cur = gatesSplit[0][i];
 
 		//find nearest underground exit
-		std::pair<int,double> best(-1,150000); //pair<pos_in_vector, distance>
+		std::pair<int, si32> best(-1, std::numeric_limits<si32>::max()); //pair<pos_in_vector, distance^2>
 		for(int j = 0; j < gatesSplit[1].size(); j++)
 		{
 			const CGObjectInstance *checked = gatesSplit[1][j];
 			if(!checked)
 				continue;
-			double hlp = checked->pos.dist2d(cur->pos);
+			si32 hlp = checked->pos.dist2dSQ(cur->pos);
 			if(hlp < best.second)
 			{
 				best.first = j;
@@ -4193,9 +4193,7 @@ void CGTeleport::postInit() //matches subterranean gates into pairs
 			gatesSplit[1][best.first] = nullptr;
 		}
 		else
-		{
 			gates.push_back(std::make_pair(cur->id, ObjectInstanceID()));
-		}
 	}
 	objs.erase(Obj::SUBTERRANEAN_GATE);
 }

lib/int3.h

@@ -14,96 +14,135 @@
 class int3
 {
 public:
-	si32 x,y,z;
+	si32 x, y, z;
-	inline int3():x(0),y(0),z(0){}; //c-tor, x/y/z initialized to 0
+
-	inline int3(const si32 X, const si32 Y, const si32 Z):x(X),y(Y),z(Z){}; //c-tor
+	//c-tor: x, y, z initialized to 0
-	inline int3(const int3 & val) : x(val.x), y(val.y), z(val.z){} //copy c-tor
+	int3() : x(0), y(0), z(0) {} // I think that x, y, z should be left uninitialized.
-	inline int3 & operator=(const int3 & val) {x = val.x; y = val.y; z = val.z; return *this;} //assignemt operator
+	//c-tor: x, y, z initialized to i
-	~int3() {} // d-tor - does nothing
+	explicit int3(const si32 i) : x(i), y(i), z(i) {}
-	inline int3 operator+(const int3 & i) const //returns int3 with coordinates increased by corresponding coordinate of given int3
+	//c-tor: x, y, z initialized to X, Y, Z
-		{return int3(x+i.x,y+i.y,z+i.z);}
+	int3(const si32 X, const si32 Y, const si32 Z) : x(X), y(Y), z(Z) {}
-	inline int3 operator+(const si32 i) const //returns int3 with coordinates increased by given numer
+	int3(const int3 & c) : x(c.x), y(c.y), z(c.z) {} // Should be set to default (C++11)?
-		{return int3(x+i,y+i,z+i);}
+
-	inline int3 operator-(const int3 & i) const //returns int3 with coordinates decreased by corresponding coordinate of given int3
+	int3 & operator=(const int3 & c) // Should be set to default (C++11)?
-		{return int3(x-i.x,y-i.y,z-i.z);}
-	inline int3 operator-(const si32 i) const //returns int3 with coordinates decreased by given numer
-		{return int3(x-i,y-i,z-i);}
-	inline int3 operator-() const //returns opposite position
-		{return int3(-x,-y,-z);}
-	inline double dist2d(const int3 &other) const //distance (z coord is not used)
-		{return std::sqrt((double)(x-other.x)*(x-other.x) + (y-other.y)*(y-other.y));}
-	inline bool areNeighbours(const int3 &other) const
-		{return dist2d(other) < 2. && z == other.z;}
-	inline void operator+=(const int3 & i)
 	{
-		x+=i.x;
+		x = c.x;
-		y+=i.y;
+		y = c.y;
-		z+=i.z;
+		z = c.z;
+
+		return *this;
 	}
-	inline void operator+=(const si32 & i)
+	int3 operator-() const { return int3(-x, -y, -z); }
+
+	int3 operator+(const int3 & i) const { return int3(x + i.x, y + i.y, z + i.z); }
+	int3 operator-(const int3 & i) const { return int3(x - i.x, y - i.y, z - i.z); }
+	//returns int3 with coordinates increased by given number
+	int3 operator+(const si32 i) const { return int3(x + i, y + i, z + i); }
+	//returns int3 with coordinates decreased by given number
+	int3 operator-(const si32 i) const { return int3(x - i, y - i, z - i); }
+
+	int3 & operator+=(const int3 & i)
 	{
-		x+=i;
+		x += i.x;
-		y+=i;
+		y += i.y;
-		z+=i;
+		z += i.z;
+		return *this;
 	}
-	inline void operator-=(const int3 & i)
+	int3 & operator-=(const int3 & i)
 	{
-		x-=i.x;
+		x -= i.x;
-		y-=i.y;
+		y -= i.y;
-		z-=i.z;
+		z -= i.z;
+		return *this;
 	}
-	inline void operator-=(const si32 & i)
+	
+	//increases all coordinates by given number
+	int3 & operator+=(const si32 i)
 	{
-		x+=i;
+		x += i;
-		y+=i;
+		y += i;
-		z+=i;
+		z += i;
+		return *this;
 	}
-	inline bool operator==(const int3 & i) const
+	//decreases all coordinates by given number
-		{return (x==i.x) && (y==i.y) && (z==i.z);}
+	int3 & operator-=(const si32 i)
-	inline bool operator!=(const int3 & i) const
-		{return !(*this==i);}
-	inline bool operator<(const int3 & i) const
 	{
-		if (z<i.z)
+		x -= i;
+		y -= i;
+		z -= i;
+		return *this;
+	}
+
+	bool operator==(const int3 & i) const { return (x == i.x && y == i.y && z == i.z); }
+	bool operator!=(const int3 & i) const { return (x != i.x || y != i.y || z != i.z); }
+
+	bool operator<(const int3 & i) const
+	{
+		if (z < i.z)
 			return true;
-		if (z>i.z)
+		if (z > i.z)
 			return false;
-		if (y<i.y)
+		if (y < i.y)
 			return true;
-		if (y>i.y)
+		if (y > i.y)
 			return false;
-		if (x<i.x)
+		if (x < i.x)
 			return true;
-		if (x>i.x)
+		if (x > i.x)
 			return false;
 		return false;
 	}
-	inline std::string operator ()() const
+
+	//returns squared distance on Oxy plane (z coord is not used)
+	si32 dist2dSQ(const int3 & o) const
 	{
-		return	"(" + boost::lexical_cast<std::string>(x) +
+		const si32 dx = (x - o.x);
-				" " + boost::lexical_cast<std::string>(y) +
+		const si32 dy = (y - o.y);
-				" " + boost::lexical_cast<std::string>(z) + ")";
+		return dx*dx + dy*dy;
 	}
-	inline bool valid() const
+	//returns distance on Oxy plane (z coord is not used)
+	double dist2d(const int3 & o) const
+	{
+		return std::sqrt((double)dist2dSQ(o));
+	}
+
+	bool areNeighbours(const int3 & o) const
+	{
+		return (dist2dSQ(o) < 4) && (z == o.z);
+	}
+
+	//returns "(x y z)" string
+	std::string operator ()() const //Change to int3::toString()?
+	{
+		std::string result("(");
+		result += boost::lexical_cast<std::string>(x); result += ' ';
+		result += boost::lexical_cast<std::string>(y); result += ' ';
+		result += boost::lexical_cast<std::string>(z); result += ')';
+		return result;
+	}
+
+	bool valid() const //Should be named "isValid"?
 	{
 		return z >= 0; //minimal condition that needs to be fulfilled for tiles in the map
 	}
-	template <typename Handler> void serialize(Handler &h, const int version)
+
+	template <typename Handler>
+	void serialize(Handler &h, const int version)
 	{
 		h & x & y & z;
 	}
-	
 };
-inline std::istream & operator>>(std::istream & str, int3 & dest)
+
-{
-	str>>dest.x>>dest.y>>dest.z;
-	return str;
-}
 inline std::ostream & operator<<(std::ostream & str, const int3 & sth)
 {
-	return str<<sth.x<<' '<<sth.y<<' '<<sth.z;
+	return str << sth.x << ' ' << sth.y << ' ' << sth.z;
+}
+inline std::istream & operator>>(std::istream & str, int3 & dest)
+{
+	return str >> dest.x >> dest.y >> dest.z;
 }
 
+//Why not normal function?
 struct ShashInt3
 {
 	size_t operator()(int3 const& pos) const
@@ -113,4 +152,4 @@ struct ShashInt3
 		vstd::hash_combine(ret, pos.z);
 		return ret;
 	}
-};
+};

lib/mapping/CMap.cpp

@@ -424,7 +424,7 @@ const CGObjectInstance * CMap::getObjectiveObjectFrom(int3 pos, Obj::EObj type)
 				bestMatch = object;
 			else
 			{
-				if (object->pos.dist2d(pos) < bestMatch->pos.dist2d(pos))
+				if (object->pos.dist2dSQ(pos) < bestMatch->pos.dist2dSQ(pos))
 					bestMatch = object;// closer than one we already found
 			}
 		}

lib/rmg/CRmgTemplateZone.cpp

@@ -306,12 +306,12 @@ int3 CRmgTemplateZone::getPos()
 {
 	return pos;
 }
-void CRmgTemplateZone::setPos(int3 &Pos)
+void CRmgTemplateZone::setPos(const int3 &Pos)
 {
 	pos = Pos;
 }
 
-void CRmgTemplateZone::addTile (int3 &pos)
+void CRmgTemplateZone::addTile (const int3 &pos)
 {
 	tileinfo[pos] = CTileInfo();
 }

lib/rmg/CRmgTemplateZone.h

@@ -103,9 +103,9 @@ public:
 	float3 getCenter() const;
 	void setCenter(float3 f);
 	int3 getPos();
-	void setPos(int3 &pos);
+	void setPos(const int3 &pos);
 
-	void addTile (int3 &pos);
+	void addTile (const int3 &pos);
 	void setShape(std::vector<int3> shape);
 	bool fill(CMapGenerator* gen);
 

lib/rmg/CZonePlacer.cpp

@@ -33,7 +33,7 @@ CZonePlacer::~CZonePlacer()
 
 }
 
-int3 CZonePlacer::cords (float3 f) const
+int3 CZonePlacer::cords (const float3 f) const
 {
 	return int3(std::max(0.f, (f.x * gen->map->width)-1), std::max(0.f, (f.y * gen->map->height-1)), f.z);
 }
@@ -160,7 +160,7 @@ void CZonePlacer::placeZones(shared_ptr<CMapGenOptions> mapGenOptions, CRandomGe
 	}
 }
 
-float CZonePlacer::metric (int3 &A, int3 &B) const
+float CZonePlacer::metric (const int3 &A, const int3 &B) const
 {
 /*
 

lib/rmg/CZonePlacer.h

@@ -39,8 +39,8 @@ class CZonePlacer
 {
 public:
 	explicit CZonePlacer(CMapGenerator * gen);
-	int3 cords (float3 f) const;
+	int3 cords (const float3 f) const;
-	float metric (int3 &a, int3 &b) const;
+	float metric (const int3 &a, const int3 &b) const;
 	~CZonePlacer();
 
 	void placeZones(shared_ptr<CMapGenOptions> mapGenOptions, CRandomGenerator * rand);

server/CGameHandler.cpp

@@ -5592,15 +5592,15 @@ bool CGameHandler::castSpell(const CGHeroInstance *h, SpellID spellID, const int
 
 			if (h->getSpellSchoolLevel(s) < 2)
 			{
-				double dist = town->pos.dist2d(h->pos);
+				si32 dist = town->pos.dist2dSQ(h->pos);
 				ObjectInstanceID nearest = town->id; //nearest town's ID
 				for(const CGTownInstance * currTown : gs->getPlayer(h->tempOwner)->towns)
 				{
-					double curDist = currTown->pos.dist2d(h->pos);
+					si32 currDist = currTown->pos.dist2dSQ(h->pos);
-					if (nearest == ObjectInstanceID() || curDist < dist)
+					if (currDist < dist)
 					{
-						nearest = town->id;
+						nearest = currTown->id;
-						dist = curDist;
+						dist = currDist;
 					}
 				}
 				if (town->id != nearest)