diff --git a/source/glest_game/ai/path_finder.cpp b/source/glest_game/ai/path_finder.cpp
index 1f52bd72..9e84e534 100644
--- a/source/glest_game/ai/path_finder.cpp
+++ b/source/glest_game/ai/path_finder.cpp
@@ -995,7 +995,7 @@ TravelState PathFinder::aStar(Unit *unit, const Vec2i &targetPos, bool inBailout
 	const Vec2i unitPos = unit->getPos();
 	const Vec2i finalPos= computeNearestFreePos(unit, targetPos);
 
-	double dist= unitPos.dist(finalPos);
+	float dist= unitPos.dist(finalPos);
 	factions[unitFactionIndex].useMaxNodeCount = PathFinder::pathFindNodesMax;
 
 	if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled == true && chrono.getMillis() > 4) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
@@ -1352,7 +1352,7 @@ TravelState PathFinder::aStar(Unit *unit, const Vec2i &targetPos, bool inBailout
 	//if consumed all nodes find best node (to avoid strange behaviour)
 	if(nodeLimitReached == true) {
 		if(factions[unitFactionIndex].closedNodesList.size() > 0) {
-			double bestHeuristic = factions[unitFactionIndex].closedNodesList.begin()->first;
+			float bestHeuristic = factions[unitFactionIndex].closedNodesList.begin()->first;
 			if(bestHeuristic < lastNode->heuristic) {
 				lastNode= factions[unitFactionIndex].closedNodesList.begin()->second[0];
 			}
@@ -1520,10 +1520,10 @@ TravelState PathFinder::aStar(Unit *unit, const Vec2i &targetPos, bool inBailout
 	return ts;
 }
 
-void PathFinder::processNearestFreePos(const Vec2i &finalPos, int i, int j, int size, Field field, int teamIndex,Vec2i unitPos, Vec2i &nearestPos, double &nearestDist) {
+void PathFinder::processNearestFreePos(const Vec2i &finalPos, int i, int j, int size, Field field, int teamIndex,Vec2i unitPos, Vec2i &nearestPos, float &nearestDist) {
 	Vec2i currPos= finalPos + Vec2i(i, j);
 	if(map->isAproxFreeCells(currPos, size, field, teamIndex)) {
-		double dist= currPos.dist(finalPos);
+		float dist= currPos.dist(finalPos);
 
 		//if nearer from finalPos
 		if(dist < nearestDist){
@@ -1557,7 +1557,7 @@ Vec2i PathFinder::computeNearestFreePos(const Unit *unit, const Vec2i &finalPos)
 	//find nearest pos
 	Vec2i unitPos= unit->getPosNotThreadSafe();
 	Vec2i nearestPos= unitPos;
-	double nearestDist= unitPos.dist(finalPos);
+	float nearestDist= unitPos.dist(finalPos);
 
 	for(int i= -maxFreeSearchRadius; i <= maxFreeSearchRadius; ++i) {
 		for(int j= -maxFreeSearchRadius; j <= maxFreeSearchRadius; ++j) {
@@ -1639,7 +1639,7 @@ void PathFinder::saveGame(XmlNode *rootNode) {
 			nodePoolNode->addAttribute("next",intToStr(nextIdx), mapTagReplacements);
 			int prevIdx = findNodeIndex(curNode->prev, factionState.nodePool);
 			nodePoolNode->addAttribute("prev",intToStr(prevIdx), mapTagReplacements);
-			nodePoolNode->addAttribute("heuristic",doubleToStr(curNode->heuristic,6), mapTagReplacements);
+			nodePoolNode->addAttribute("heuristic",floatToStr(curNode->heuristic,6), mapTagReplacements);
 			nodePoolNode->addAttribute("exploredCell",intToStr(curNode->exploredCell), mapTagReplacements);
 		}
 
diff --git a/source/glest_game/ai/path_finder.h b/source/glest_game/ai/path_finder.h
index c04e492c..7f060434 100644
--- a/source/glest_game/ai/path_finder.h
+++ b/source/glest_game/ai/path_finder.h
@@ -95,7 +95,7 @@ public:
 		Vec2i pos;
 		Node *next;
 		Node *prev;
-		double heuristic;
+		float heuristic;
 		bool exploredCell;
 	};
 	typedef vector<Node*> Nodes;
@@ -119,8 +119,8 @@ public:
 			//fa = NULL;
 		}
 		std::map<Vec2i, bool> openPosList;
-		std::map<double, Nodes> openNodesList;
-		std::map<double, Nodes> closedNodesList;
+		std::map<float, Nodes> openNodesList;
+		std::map<float, Nodes> closedNodesList;
 		std::vector<Node> nodePool;
 		int nodePoolCount;
 		RandomGen random;
@@ -201,7 +201,7 @@ private:
 
 	Vec2i computeNearestFreePos(const Unit *unit, const Vec2i &targetPos);
 	//float heuristic(const Vec2i &pos, const Vec2i &finalPos);
-	inline static double heuristic(const Vec2i &pos, const Vec2i &finalPos) {
+	inline static float heuristic(const Vec2i &pos, const Vec2i &finalPos) {
 		return pos.dist(finalPos);
 	}
 
@@ -277,7 +277,7 @@ private:
 		return result;
 	}
 
-	void processNearestFreePos(const Vec2i &finalPos, int i, int j, int size, Field field, int teamIndex,Vec2i unitPos, Vec2i &nearestPos, double &nearestDist);
+	void processNearestFreePos(const Vec2i &finalPos, int i, int j, int size, Field field, int teamIndex,Vec2i unitPos, Vec2i &nearestPos, float &nearestDist);
 	int getPathFindExtendRefreshNodeCount(int factionIndex);
 
 
diff --git a/source/glest_game/game/game.cpp b/source/glest_game/game/game.cpp
index 70405966..b3dcfde1 100644
--- a/source/glest_game/game/game.cpp
+++ b/source/glest_game/game/game.cpp
@@ -2145,14 +2145,14 @@ void Game::update() {
 					if(currentCameraFollowUnit!=NULL){
 						Vec3f c=currentCameraFollowUnit->getCurrVector();
 						int rotation=currentCameraFollowUnit->getRotation();
-						double angle=rotation+180;
+						float angle=rotation+180;
 
 						c.z=c.z+4*std::cos(degToRad(angle));
 						c.x=c.x+4*std::sin(degToRad(angle));
 
 						c.y=c.y+currentCameraFollowUnit->getType()->getHeight()/2.f+2.0f;
 
-						getGameCameraPtr()->setPos(Vec3f(c));
+						getGameCameraPtr()->setPos(c);
 
 						rotation=(540-rotation)%360;
 						getGameCameraPtr()->rotateToVH(18.0f,rotation);
@@ -4426,7 +4426,7 @@ void Game::startCameraFollowUnit() {
 		if(currentUnit != NULL) {
 			currentCameraFollowUnit = currentUnit;
 			getGameCameraPtr()->setState(GameCamera::sUnit);
-			getGameCameraPtr()->setPos(Vec3f(currentCameraFollowUnit->getCurrVector()));
+			getGameCameraPtr()->setPos(currentCameraFollowUnit->getCurrVector());
 
 			int rotation=currentCameraFollowUnit->getRotation();
 			getGameCameraPtr()->stop();
@@ -5159,7 +5159,7 @@ string Game::getDebugStats(std::map<int,string> &factionDebugInfo) {
 	}
 
 	//intToStr(stats.getFramesToCalculatePlaytime()/GameConstants::updateFps/60
-	str+= "Time: "           + doubleToStr(world.getTimeFlow()->getTime(),2) + " [" + doubleToStr((double)world.getStats()->getFramesToCalculatePlaytime() / (double)GameConstants::updateFps / 60.0,2) + "]\n";
+	str+= "Time: "           + floatToStr(world.getTimeFlow()->getTime(),2) + " [" + floatToStr((double)world.getStats()->getFramesToCalculatePlaytime() / (float)GameConstants::updateFps / 60.0,2) + "]\n";
 
 	if(SystemFlags::getThreadedLoggerRunning() == true) {
 		str+= "Log buffer count: " + intToStr(SystemFlags::getLogEntryBufferCount())+"\n";
@@ -5203,7 +5203,7 @@ string Game::getDebugStats(std::map<int,string> &factionDebugInfo) {
 	//		}
 		str+= "\n";
 
-		str+= "Visible quad area:        " + doubleToStr(visibleQuad.area()) +"\n";
+		str+= "Visible quad area:        " + floatToStr(visibleQuad.area()) +"\n";
 	//		str+= "Visible quad camera area: " + floatToStr(visibleQuadCamera.area()) +"\n";
 
 	//		Rect2i boundingRect= visibleQuad.computeBoundingRect();
diff --git a/source/glest_game/graphics/renderer.cpp b/source/glest_game/graphics/renderer.cpp
index ba133f89..715f2692 100644
--- a/source/glest_game/graphics/renderer.cpp
+++ b/source/glest_game/graphics/renderer.cpp
@@ -1058,7 +1058,7 @@ void Renderer::setupLighting() {
 					unit->getType()->getLight() && unit->isOperative()) {
 					//printf("$$$ Show light for faction: %s # %d / %d for Unit [%d - %s]\n",world->getFaction(i)->getType()->getName().c_str(),lightCount,maxLights,unit->getId(),unit->getFullName().c_str());
 
-					Vec4f pos= Vec4f(Vec3f(unit->getCurrVector()));
+					Vec4f pos= Vec4f(unit->getCurrVector());
 					pos.y+=4.f;
 
 					GLenum lightEnum= GL_LIGHT0 + lightCount;
@@ -4584,7 +4584,7 @@ void Renderer::renderObjects(const int renderFps) {
 
 		Model *objModel= o->getModelPtr();
 		//objModel->updateInterpolationData(o->getAnimProgress(), true);
-		const Vec3f v= Vec3f(o->getConstPos());
+		const Vec3f v= o->getConstPos();
 
 		if(modelRenderStarted == false) {
 			modelRenderStarted = true;
@@ -4826,7 +4826,7 @@ void Renderer::renderTeamColorCircle(){
 		for(int visibleUnitIndex = 0;
 							visibleUnitIndex < qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
 				Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
-				Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+				Vec3f currVec= unit->getCurrVectorFlat();
 				Vec3f color=unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
 				glColor4f(color.x, color.y, color.z, 0.7f);
 				renderSelectionCircle(currVec, unit->getType()->getSize(), 0.8f, 0.05f);
@@ -4881,7 +4881,7 @@ void Renderer::renderSpecialHighlightUnits(std::map<int,HighlightSpecialUnitInfo
 
 					glColor4f(color.x, color.y, color.z, alpha);
 
-					Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+					Vec3f currVec= unit->getCurrVectorFlat();
 					renderSelectionCircle(currVec, unit->getType()->getSize(), radius, thickness);
 				}
 		}
@@ -4905,7 +4905,7 @@ void Renderer::renderTeamColorPlane(){
 		for(int visibleUnitIndex = 0;
 				visibleUnitIndex < qCache.visibleQuadUnitList.size(); ++visibleUnitIndex){
 			Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			renderTeamColorEffect(currVec,visibleUnitIndex,unit->getType()->getSize(),
 					unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0),texture);
 		}
@@ -5022,7 +5022,7 @@ void Renderer::renderUnits(const int renderFps) {
 			glPushMatrix();
 
 			//translate
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			glTranslatef(currVec.x, currVec.y, currVec.z);
 
 			//rotate
@@ -5193,7 +5193,7 @@ void Renderer::renderMorphEffects(){
 							initialized=true;
 						}
 
-						Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+						Vec3f currVec= unit->getCurrVectorFlat();
 						currVec=Vec3f(currVec.x,currVec.y+0.3f,currVec.z);
 						if(mType->getField() == fAir && unit->getType()->getField()== fLand) {
 							currVec=Vec3f(currVec.x,currVec.y+game->getWorld()->getTileset()->getAirHeight(),currVec.z);
@@ -5247,7 +5247,7 @@ void Renderer::renderSelectionEffects() {
 		const Unit *unit= selection->getUnit(i);
 		if(unit != NULL) {
 			//translate
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			currVec.y+= 0.3f;
 
 			//selection circle
@@ -5283,7 +5283,7 @@ void Renderer::renderSelectionEffects() {
 						if(i == 0) {
 							lastPosValue = curPosValue;
 						}
-						Vec3f currVec2 = Vec3f(unit->getVectorFlat(lastPosValue,curPosValue));
+						Vec3f currVec2 = unit->getVectorFlat(lastPosValue,curPosValue);
 						currVec2.y+= 0.3f;
 						renderSelectionCircle(currVec2, 1, selectionCircleRadius);
 						//renderSelectionCircle(currVec2, unit->getType()->getSize(), selectionCircleRadius);
@@ -5315,7 +5315,7 @@ void Renderer::renderSelectionEffects() {
 						int findUnitId = effect.currentAttackBoostUnits[i];
 						Unit *affectedUnit = game->getWorld()->findUnitById(findUnitId);
 						if(affectedUnit != NULL) {
-							Vec3f currVecBoost = Vec3f(affectedUnit->getCurrVectorFlat());
+							Vec3f currVecBoost = affectedUnit->getCurrVectorFlat();
 							currVecBoost.y += 0.3f;
 
 							renderSelectionCircle(currVecBoost, affectedUnit->getType()->getSize(), 1.f);
@@ -5331,7 +5331,7 @@ void Renderer::renderSelectionEffects() {
 		int defaultValue= r->getType()->getDefResPerPatch();
 		float colorValue=static_cast<float>(r->getAmount())/static_cast<float>(defaultValue);
 		glColor4f(0.1f, 0.1f , colorValue, 0.4f);
-		renderSelectionCircle(Vec3f(selectedResourceObject->getPos()),2, selectionCircleRadius);
+		renderSelectionCircle(selectedResourceObject->getPos(),2, selectionCircleRadius);
 	}
 	//target arrow
 	if(selection->getCount() == 1) {
@@ -5361,7 +5361,7 @@ void Renderer::renderSelectionEffects() {
 					Vec3f arrowTarget;
 					Command *c= unit->getCurrCommand();
 					if(c->getUnit() != NULL) {
-						arrowTarget= Vec3f(c->getUnit()->getCurrVectorFlat());
+						arrowTarget= c->getUnit()->getCurrVectorFlat();
 					}
 					else {
 						Vec2i pos= c->getPos();
@@ -5370,7 +5370,7 @@ void Renderer::renderSelectionEffects() {
 						arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
 					}
 
-					renderArrow(Vec3f(unit->getCurrVectorFlat()), arrowTarget, arrowColor, 0.3f);
+					renderArrow(unit->getCurrVectorFlat(), arrowTarget, arrowColor, 0.3f);
 				}
 			}
 
@@ -5380,7 +5380,7 @@ void Renderer::renderSelectionEffects() {
 				map->clampPos(pos);
 
 				Vec3f arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
-				renderArrow(Vec3f(unit->getCurrVectorFlat()), arrowTarget, Vec3f(0.f, 0.f, 1.f), 0.3f);
+				renderArrow(unit->getCurrVectorFlat(), arrowTarget, Vec3f(0.f, 0.f, 1.f), 0.3f);
 			}
 		}
 	}
@@ -5398,7 +5398,7 @@ void Renderer::renderSelectionEffects() {
 				glColor4f(1.f, 0.f, 0.f, highlight);
 			}
 
-			Vec3f v= Vec3f(unit->getCurrVectorFlat());
+			Vec3f v= unit->getCurrVectorFlat();
 			v.y+= 0.3f;
 			renderSelectionCircle(v, unit->getType()->getSize(), 0.5f+0.4f*highlight );
 		}
@@ -5429,7 +5429,7 @@ void Renderer::renderSelectionEffects() {
 		if(object->isHighlighted()) {
 			float highlight= object->getHightlight();
 			glColor4f(0.1f, 0.1f , 1.0f, highlight);
-			Vec3f v= Vec3f(object->getPos());
+			Vec3f v= object->getPos();
 			v.y+= 0.3f;
 			renderSelectionCircle(v, 2, 0.4f+0.4f*highlight );
 		}
@@ -7434,7 +7434,7 @@ vector<Unit *> Renderer::renderUnitsFast(bool renderingShadows, bool colorPickin
 				glPushMatrix();
 
 				//translate
-				Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+				Vec3f currVec= unit->getCurrVectorFlat();
 				glTranslatef(currVec.x, currVec.y, currVec.z);
 
 				//rotate
@@ -7537,7 +7537,7 @@ vector<Object *>  Renderer::renderObjectsFast(bool renderingShadows, bool resour
 					//objModel->updateInterpolationData(o->getAnimProgress(), true);
 
 				//}
-				const Vec3f v= Vec3f(o->getConstPos());
+				const Vec3f v= o->getConstPos();
 
 				if(colorPickingSelection == false) {
 					glPushName(OBJECT_SELECT_OFFSET+visibleIndex);
diff --git a/source/glest_game/gui/gui.cpp b/source/glest_game/gui/gui.cpp
index 68928ccf..c124c156 100644
--- a/source/glest_game/gui/gui.cpp
+++ b/source/glest_game/gui/gui.cpp
@@ -305,7 +305,7 @@ void Gui::mouseUpLeftGraphics(int x, int y) {
 			if(selection.isCommandable() && random.randRange(0, 1)==0){
 				SoundRenderer::getInstance().playFx(
 					selection.getFrontUnit()->getType()->getSelectionSound(),
-					Vec3f(selection.getFrontUnit()->getCurrVector()),
+					selection.getFrontUnit()->getCurrVector(),
 					gameCamera->getPos());
 			}
 			selectionQuad.disable();
@@ -477,7 +477,7 @@ void Gui::giveDefaultOrders(int x, int y,const Unit *targetUnit, bool paintMouse
 		if(random.randRange(0, 1)==0){
 			SoundRenderer::getInstance().playFx(
 				selection.getFrontUnit()->getType()->getCommandSound(),
-				Vec3f(selection.getFrontUnit()->getCurrVector()),
+				selection.getFrontUnit()->getCurrVector(),
 				gameCamera->getPos());
 		}
 	}
@@ -532,7 +532,7 @@ void Gui::giveTwoClickOrders(int x, int y , bool prepared) {
 		if(random.randRange(0, 1) == 0) {
 			SoundRenderer::getInstance().playFx(
 				selection.getFrontUnit()->getType()->getCommandSound(),
-				Vec3f(selection.getFrontUnit()->getCurrVector()),
+				selection.getFrontUnit()->getCurrVector(),
 				gameCamera->getPos());
 		}
 	}
diff --git a/source/glest_game/type_instances/faction.cpp b/source/glest_game/type_instances/faction.cpp
index e2aca5f8..e85a2d89 100644
--- a/source/glest_game/type_instances/faction.cpp
+++ b/source/glest_game/type_instances/faction.cpp
@@ -125,8 +125,8 @@ bool CommandGroupUnitSorter::compare(const Unit *l, const Unit *r) {
 			result = curCommandGroupId < commandPeer->getUnitCommandGroupId();
 		}
 		else {
-			double unitDist = l->getCenteredPos().dist(command->getPos());
-			double unitDistPeer = r->getCenteredPos().dist(commandPeer->getPos());
+			float unitDist = l->getCenteredPos().dist(command->getPos());
+			float unitDistPeer = r->getCenteredPos().dist(commandPeer->getPos());
 
 			// Closest unit in commandgroup
 			result = (unitDist < unitDistPeer);
diff --git a/source/glest_game/type_instances/unit.cpp b/source/glest_game/type_instances/unit.cpp
index 125aeb75..5e020098 100644
--- a/source/glest_game/type_instances/unit.cpp
+++ b/source/glest_game/type_instances/unit.cpp
@@ -388,7 +388,7 @@ void UnitAttackBoostEffectOriginator::saveGame(XmlNode *rootNode) {
 // 	class Unit
 // =====================================================
 
-const double Unit::ANIMATION_SPEED_MULTIPLIER = 100000.f;
+const float Unit::ANIMATION_SPEED_MULTIPLIER = 100000.f;
 //const float Unit::PROGRESS_SPEED_MULTIPLIER  = 100000.f;
 const int64 Unit::PROGRESS_SPEED_MULTIPLIER  = 100000;
 
@@ -726,14 +726,14 @@ Vec2i Unit::getCellPos() const {
 
 			//find nearest pos to center that is free
 			Vec2i centeredPos= getCenteredPos();
-			double nearestDist= -1.f;
+			float nearestDist= -1.f;
 			Vec2i nearestPos= pos;
 
 			for(int i=0; i<type->getSize(); ++i){
 				for(int j=0; j<type->getSize(); ++j){
 					if(type->getCellMapCell(i, j, modelFacing)){
 						Vec2i currPos= pos + Vec2i(i, j);
-						double dist= currPos.dist(centeredPos);
+						float dist= currPos.dist(centeredPos);
 						if(nearestDist == -1.f || dist < nearestDist) {
 							nearestDist= dist;
 							nearestPos= currPos;
@@ -836,7 +836,7 @@ int Unit::getProductionPercent() const{
 	return -1;
 }
 
-double Unit::getProgressRatio() const{
+float Unit::getProgressRatio() const{
 	if(anyCommand()){
 		const ProducibleType *produced= commands.front()->getCommandType()->getProduced();
 		if(produced != NULL){
@@ -844,28 +844,28 @@ double Unit::getProgressRatio() const{
 				return 0.f;
 			}
 
-			double help = progress2;
+			float help = progress2;
 			return clamp(help / produced->getProductionTime(), 0.f, 1.f);
 		}
 	}
 	return -1;
 }
 
-double Unit::getHpRatio() const {
+float Unit::getHpRatio() const {
 	if(type == NULL) {
 		char szBuf[8096]="";
 		snprintf(szBuf,8096,"In [%s::%s Line: %d] ERROR: type == NULL, Unit = [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,this->toString().c_str());
 		throw megaglest_runtime_error(szBuf);
 	}
 
-	double maxHpAllowed = type->getTotalMaxHp(&totalUpgrade);
+	float maxHpAllowed = type->getTotalMaxHp(&totalUpgrade);
 	if(maxHpAllowed == 0.f) {
 		return 0.f;
 	}
-	return clamp(static_cast<double>(hp) / maxHpAllowed, 0.f, 1.f);
+	return clamp(static_cast<float>(hp) / maxHpAllowed, 0.f, 1.f);
 }
 
-double Unit::getEpRatio() const {
+float Unit::getEpRatio() const {
 	if(type == NULL) {
 		char szBuf[8096]="";
 		snprintf(szBuf,8096,"In [%s::%s Line: %d] ERROR: type == NULL, Unit = [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,this->toString().c_str());
@@ -876,11 +876,11 @@ double Unit::getEpRatio() const {
 		return 0.f;
 	}
 	else {
-		double maxEpAllowed = type->getTotalMaxEp(&totalUpgrade);
+		float maxEpAllowed = type->getTotalMaxEp(&totalUpgrade);
 		if(maxEpAllowed == 0.f) {
 			return 0.f;
 		}
-		return clamp(static_cast<double>(ep) / maxEpAllowed, 0.f, 1.f);
+		return clamp(static_cast<float>(ep) / maxEpAllowed, 0.f, 1.f);
 	}
 }
 
@@ -1225,7 +1225,7 @@ FowAlphaCellsLookupItem Unit::getFogOfWarRadius(bool useCache) const {
 		Vec2i surfPos= Map::toSurfCoords(sightpos);
 
 		//compute max alpha
-		double maxAlpha= 0.0f;
+		float maxAlpha= 0.0f;
 		if(surfPos.x > 1 && surfPos.y > 1 && surfPos.x < map->getSurfaceW() -2 && surfPos.y < map->getSurfaceH() -2) {
 			maxAlpha= 1.f;
 		}
@@ -1234,8 +1234,8 @@ FowAlphaCellsLookupItem Unit::getFogOfWarRadius(bool useCache) const {
 		}
 
 		//compute alpha
-		double alpha = maxAlpha;
-		double dist = this->getPosNotThreadSafe().dist(sightpos);
+		float alpha = maxAlpha;
+		float dist = this->getPosNotThreadSafe().dist(sightpos);
 		if(dist > sightRange) {
 			alpha= clamp(1.f-(dist - sightRange) / (World::indirectSightRange), 0.f, maxAlpha);
 		}
@@ -1424,9 +1424,9 @@ Vec3f Unit::getCurrVectorFlat() const{
 	return getVectorFlat(lastPos, pos);
 }
 
-double Unit::getProgressAsFloat() const {
-	double result = (static_cast<double>(progress) / static_cast<double>(PROGRESS_SPEED_MULTIPLIER));
-	result = truncateDecimal<double>(result,6);
+float Unit::getProgressAsFloat() const {
+	float result = (static_cast<float>(progress) / static_cast<float>(PROGRESS_SPEED_MULTIPLIER));
+	result = truncateDecimal<float>(result,6);
 	return result;
 }
 
@@ -2023,8 +2023,8 @@ int64 Unit::getHeightFactor(int64 speedMultiplier) {
 			throw megaglest_runtime_error("targetCell == NULL");
 		}
 
-		int64 heightDiff= ((truncateDecimal<double>(unitCell->getHeight(),2) * speedMultiplier) -
-				         (truncateDecimal<double>(targetCell->getHeight(),2) * speedMultiplier));
+		int64 heightDiff= ((truncateDecimal<float>(unitCell->getHeight(),2) * speedMultiplier) -
+				         (truncateDecimal<float>(targetCell->getHeight(),2) * speedMultiplier));
 		//heightFactor= clamp(speedMultiplier + heightDiff / (5.f * speedMultiplier), 0.2f * speedMultiplier, 5.f * speedMultiplier);
 		heightFactor= clamp(speedMultiplier + heightDiff / (5 * speedMultiplier), (2 * (speedMultiplier / 10)), 5 * speedMultiplier);
 	}
@@ -2328,7 +2328,7 @@ bool Unit::update() {
 	//printf("Test progress = %d for unit [%d - %s]\n",progress,id,getType()->getName().c_str());
 
 	if(isAnimProgressBound() == true) {
-		double targetProgress=0;
+		float targetProgress=0;
 		if(currSkill->getClass() == scBeBuilt) {
 			targetProgress = this->getHpRatio();
 		}
@@ -2342,10 +2342,10 @@ bool Unit::update() {
 			targetProgress = this->getProgressRatio();
 		}
 
-		double targetProgressIntValue = targetProgress * ANIMATION_SPEED_MULTIPLIER;
+		float targetProgressIntValue = targetProgress * ANIMATION_SPEED_MULTIPLIER;
 		if(this->animProgress < targetProgressIntValue) {
-			double diff = targetProgressIntValue - this->animProgress;
-			double progressIncrease = static_cast<double>(this->animProgress) + diff / static_cast<double>(GameConstants::updateFps);
+			float diff = targetProgressIntValue - this->animProgress;
+			float progressIncrease = static_cast<float>(this->animProgress) + diff / static_cast<float>(GameConstants::updateFps);
 			// Ensure we increment at least a value of 1 of the action will be stuck infinitely
 			if(diff > 0.f && GameConstants::updateFps > 0 && progressIncrease == 0.f) {
 				progressIncrease = 1.f;
diff --git a/source/glest_game/type_instances/unit.h b/source/glest_game/type_instances/unit.h
index d0a57914..4345cfb6 100644
--- a/source/glest_game/type_instances/unit.h
+++ b/source/glest_game/type_instances/unit.h
@@ -330,7 +330,7 @@ private:
 	static std::map<Unit *,bool> mapMemoryList;
 #endif
 
-	static const double ANIMATION_SPEED_MULTIPLIER;
+	static const float ANIMATION_SPEED_MULTIPLIER;
 	static const int64 PROGRESS_SPEED_MULTIPLIER;
 
 public:
@@ -517,8 +517,8 @@ public:
 
     //inline int getLastAnimProgress() const			{return lastAnimProgress;}
     //inline int getAnimProgress() const				{return animProgress;}
-    inline double getLastAnimProgressAsFloat() const	{return static_cast<double>(lastAnimProgress) / ANIMATION_SPEED_MULTIPLIER;}
-    inline double getAnimProgressAsFloat() const		{return static_cast<double>(animProgress) / ANIMATION_SPEED_MULTIPLIER;}
+    inline float getLastAnimProgressAsFloat() const	{return static_cast<float>(lastAnimProgress) / ANIMATION_SPEED_MULTIPLIER;}
+    inline float getAnimProgressAsFloat() const		{return static_cast<float>(animProgress) / ANIMATION_SPEED_MULTIPLIER;}
 
     inline float getHightlight() const					{return highlight;}
     inline int getProgress2() const					{return progress2;}
@@ -531,9 +531,9 @@ public:
 	inline int getHp() const							{return hp;}
 	inline int getEp() const							{return ep;}
 	int getProductionPercent() const;
-	double getProgressRatio() const;
-	double getHpRatio() const;
-	double getEpRatio() const;
+	float getProgressRatio() const;
+	float getHpRatio() const;
+	float getEpRatio() const;
 	inline bool getToBeUndertaken() const				{return toBeUndertaken;}
 	inline Vec2i getTargetPos() const					{return targetPos;}
 	inline Vec3f getTargetVec() const					{return targetVec;}
@@ -742,7 +742,7 @@ public:
 
 	std::string toString(bool crcMode=false) const;
 	bool needToUpdate();
-	double getProgressAsFloat() const;
+	float getProgressAsFloat() const;
 	int64 getUpdateProgress();
 	int64 getDiagonalFactor();
 	int64 getHeightFactor(int64 speedMultiplier=PROGRESS_SPEED_MULTIPLIER);
diff --git a/source/glest_game/types/skill_type.cpp b/source/glest_game/types/skill_type.cpp
index 040697e6..8b98fb16 100644
--- a/source/glest_game/types/skill_type.cpp
+++ b/source/glest_game/types/skill_type.cpp
@@ -140,7 +140,7 @@ bool AttackBoost::isAffected(const Unit *source, const Unit *dest) const {
 		}
 
 		if(destUnitMightApply == true) {
-			double distance = source->getCenteredPos().dist(dest->getCenteredPos());
+			float distance = source->getCenteredPos().dist(dest->getCenteredPos());
 			if(distance <= radius) {
 				result = true;
 			}
@@ -516,7 +516,7 @@ const AnimationAttributes SkillType::getAnimationAttribute(int index) const {
 	return animationAttributes[index];
 }
 
-Model *SkillType::getAnimation(double animProgress, const Unit *unit,
+Model *SkillType::getAnimation(float animProgress, const Unit *unit,
 		int *lastAnimationIndex, int *animationRandomCycleCount) const {
 	int modelIndex = 0;
 	//printf("Count [%d] animProgress = [%f] for skill [%s] animationRandomCycleCount = %d\n",animations.size(),animProgress,name.c_str(),*animationRandomCycleCount);
diff --git a/source/glest_game/types/skill_type.h b/source/glest_game/types/skill_type.h
index 510864f1..e9e71ea5 100644
--- a/source/glest_game/types/skill_type.h
+++ b/source/glest_game/types/skill_type.h
@@ -175,7 +175,7 @@ public:
 	int getHpCost() const				{return hpCost;}
 	int getSpeed() const				{return speed;}
 	int getAnimSpeed() const			{return animSpeed;}
-	Model *getAnimation(double animProgress=0, const Unit *unit=NULL, int *lastAnimationIndex=NULL, int *animationRandomCycleCount=NULL) const;
+	Model *getAnimation(float animProgress=0, const Unit *unit=NULL, int *lastAnimationIndex=NULL, int *animationRandomCycleCount=NULL) const;
 	StaticSound *getSound() const		{return sounds.getRandSound();}
 	float getSoundStartTime() const		{return soundStartTime;}
 	
diff --git a/source/glest_game/world/map.cpp b/source/glest_game/world/map.cpp
index a3e0b8d3..664073df 100644
--- a/source/glest_game/world/map.cpp
+++ b/source/glest_game/world/map.cpp
@@ -529,8 +529,8 @@ void Map::init(Tileset *tileset) {
 
 class FindBestPos  {
 public:
-	double distanceFromUnitNoAdjustment;
-	double distanceFromClickNoAdjustment;
+	float distanceFromUnitNoAdjustment;
+	float distanceFromClickNoAdjustment;
 	Vec2i resourcePosNoAdjustment;
 };
 
@@ -540,8 +540,8 @@ bool Map::isResourceNear(int frameIndex,const Vec2i &pos, const ResourceType *rt
 		Vec2i *resourceClickPos) const {
 
 	bool resourceNear = false;
-	double distanceFromUnit=-1;
-	double distanceFromClick=-1;
+	float distanceFromUnit=-1;
+	float distanceFromClick=-1;
 
 	if(resourceClickPos) {
 		//printf("+++++++++ unit [%s - %d] pos = [%s] resourceClickPos [%s]\n",unit->getFullName().c_str(),unit->getId(),pos.getString().c_str(),resourceClickPos->getString().c_str());
@@ -694,7 +694,7 @@ bool Map::isResourceNear(int frameIndex,const Vec2i &pos, const ResourceType *rt
 			}
 		}
 
-		double bestUnitDist = distanceFromUnit;
+		float bestUnitDist = distanceFromUnit;
 		for(unsigned int i = 0; i < bestPosList.size(); ++i) {
 			FindBestPos &bestPosItem = bestPosList[i];
 
@@ -1115,12 +1115,12 @@ Vec2i Map::computeDestPos(	const Vec2i &refUnitPos, const Vec2i &unitPos,
     return pos;
 }
 
-std::pair<double,Vec2i> Map::getUnitDistanceToPos(const Unit *unit,Vec2i pos,const UnitType *ut) {
+std::pair<float,Vec2i> Map::getUnitDistanceToPos(const Unit *unit,Vec2i pos,const UnitType *ut) {
 	if(unit == NULL) {
 		throw megaglest_runtime_error("unit == NULL");
 	}
 
-	std::pair<double,Vec2i> result(-1,Vec2i(0));
+	std::pair<float,Vec2i> result(-1,Vec2i(0));
 	//int unitId= unit->getId();
 	Vec2i unitPos= computeDestPos(unit->getPosNotThreadSafe(), unit->getPosNotThreadSafe(), pos);
 
@@ -1136,7 +1136,7 @@ std::pair<double,Vec2i> Map::getUnitDistanceToPos(const Unit *unit,Vec2i pos,con
 			Vec2i testPos(i,j);
 
 			if(ut == NULL || isInUnitTypeCells(ut, pos,testPos) == false) {
-				double distance = unitPos.dist(testPos);
+				float distance = unitPos.dist(testPos);
 				if(result.first < 0 || result.first > distance) {
 					result.first = distance;
 					result.second = testPos;
@@ -1155,7 +1155,7 @@ const Unit * Map::findClosestUnitToPos(const Selection *selection, Vec2i origina
 
 	Vec2i pos = originalBuildPos;
 
-	double bestRange = -1;
+	float bestRange = -1;
 
 	Vec2i start = pos - Vec2i(1);
 	int unitTypeSize = 0;
@@ -1173,7 +1173,7 @@ const Unit * Map::findClosestUnitToPos(const Selection *selection, Vec2i origina
 			for(int j = start.y; j <= end.y; ++j){
 				Vec2i testPos(i,j);
 				if(isInUnitTypeCells(ut, originalBuildPos,testPos) == false) {
-					double distance = unitBuilderPos.dist(testPos);
+					float distance = unitBuilderPos.dist(testPos);
 					if(bestRange < 0 || bestRange > distance) {
 						bestRange = distance;
 						pos = testPos;
@@ -1198,7 +1198,7 @@ Vec2i Map::findBestBuildApproach(const Unit *unit, Vec2i originalBuildPos,const
     Vec2i unitBuilderPos    = unit->getPosNotThreadSafe();
 	Vec2i pos               = originalBuildPos;
 
-	double bestRange = -1;
+	float bestRange = -1;
 
 	Vec2i start = pos - Vec2i(unit->getType()->getSize());
 	Vec2i end 	= pos + Vec2i(ut->getSize());
@@ -1207,7 +1207,7 @@ Vec2i Map::findBestBuildApproach(const Unit *unit, Vec2i originalBuildPos,const
 		for(int j = start.y; j <= end.y; ++j) {
 			Vec2i testPos(i,j);
 			if(isInUnitTypeCells(ut, originalBuildPos,testPos) == false) {
-				double distance = unitBuilderPos.dist(testPos);
+				float distance = unitBuilderPos.dist(testPos);
 				if(bestRange < 0 || bestRange > distance) {
 				    // Check if the cell is occupied by another unit
 				    if(isFreeCellOrHasUnit(testPos, unit->getType()->getField(), unit) == true) {
diff --git a/source/glest_game/world/map.h b/source/glest_game/world/map.h
index d473460c..4046263e 100644
--- a/source/glest_game/world/map.h
+++ b/source/glest_game/world/map.h
@@ -346,7 +346,7 @@ public:
 	bool isInUnitTypeCells(const UnitType *ut, const Vec2i &pos,const Vec2i &testPos) const;
 	bool isNextToUnitTypeCells(const UnitType *ut, const Vec2i &pos,const Vec2i &testPos) const;
 	Vec2i findBestBuildApproach(const Unit *unit, Vec2i originalBuildPos,const UnitType *ut) const;
-	std::pair<double,Vec2i> getUnitDistanceToPos(const Unit *unit,Vec2i pos,const UnitType *ut);
+	std::pair<float,Vec2i> getUnitDistanceToPos(const Unit *unit,Vec2i pos,const UnitType *ut);
 
 	//misc
 	bool isNextTo(const Vec2i &pos, const Unit *unit) const;
diff --git a/source/glest_game/world/unit_updater.cpp b/source/glest_game/world/unit_updater.cpp
index 419a9dcc..b5745185 100644
--- a/source/glest_game/world/unit_updater.cpp
+++ b/source/glest_game/world/unit_updater.cpp
@@ -123,7 +123,7 @@ bool UnitUpdater::updateUnit(Unit *unit) {
 		if(soundStartTime >= unit->getLastAnimProgressAsFloat() && soundStartTime < unit->getAnimProgressAsFloat()) {
 			if(map->getSurfaceCell(Map::toSurfCoords(unit->getPos()))->isVisible(world->getThisTeamIndex()) ||
 				(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
-				soundRenderer.playFx(currSkill->getSound(), Vec3f(unit->getCurrVector()), gameCamera->getPos());
+				soundRenderer.playFx(currSkill->getSound(), unit->getCurrVector(), gameCamera->getPos());
 			}
 		}
 	}
@@ -276,7 +276,7 @@ bool UnitUpdater::updateUnit(Unit *unit) {
 				if(Config::getInstance().getBool("DisableWaterSounds","false") == false) {
 					soundRenderer.playFx(
 						CoreData::getInstance().getWaterSound(),
-						Vec3f(unit->getCurrVector()),
+						unit->getCurrVector(),
 						gameCamera->getPos()
 					);
 
@@ -713,7 +713,7 @@ void UnitUpdater::updateAttackStopped(Unit *unit, int frameIndex) {
     	return;
     }
 
-    double distToUnit=-1;
+    float distToUnit=-1;
     std::pair<bool,Unit *> result = make_pair(false,(Unit *)NULL);
     unitBeingAttacked(result, unit, asct->getAttackSkillType(), &distToUnit);
 	if(result.first == true) {
@@ -749,10 +749,10 @@ void UnitUpdater::updateAttackStopped(Unit *unit, int frameIndex) {
     if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s] Line: %d took msecs: %lld --------------------------- [END OF METHOD] ---------------------------\n",__FILE__,__FUNCTION__,__LINE__,chrono.getMillis());
 }
 
-void UnitUpdater::unitBeingAttacked(std::pair<bool,Unit *> &result, const Unit *unit, const AttackSkillType *ast, double *currentDistToUnit) {
+void UnitUpdater::unitBeingAttacked(std::pair<bool,Unit *> &result, const Unit *unit, const AttackSkillType *ast, float *currentDistToUnit) {
 	//std::pair<bool,Unit *> result = make_pair(false,(Unit *)NULL);
 
-	double distToUnit = -1;
+	float distToUnit = -1;
 	if(currentDistToUnit != NULL) {
 		distToUnit = *currentDistToUnit;
 	}
@@ -787,7 +787,7 @@ void UnitUpdater::unitBeingAttacked(std::pair<bool,Unit *> &result, const Unit *
 std::pair<bool,Unit *> UnitUpdater::unitBeingAttacked(const Unit *unit) {
 	std::pair<bool,Unit *> result = make_pair(false,(Unit *)NULL);
 
-	double distToUnit = -1;
+	float distToUnit = -1;
 	for(unsigned int i = 0; i < unit->getType()->getSkillTypeCount(); ++i) {
 		const SkillType *st = unit->getType()->getSkillType(i);
 		const AttackSkillType *ast = dynamic_cast<const AttackSkillType *>(st);
@@ -931,7 +931,7 @@ void UnitUpdater::updateBuild(Unit *unit, int frameIndex) {
 						(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
 						SoundRenderer::getInstance().playFx(
 							bct->getStartSound(),
-							Vec3f(unit->getCurrVector()),
+							unit->getCurrVector(),
 							gameCamera->getPos());
 					}
 
@@ -1023,7 +1023,7 @@ void UnitUpdater::updateBuild(Unit *unit, int frameIndex) {
 					(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
 					SoundRenderer::getInstance().playFx(
 						bct->getBuiltSound(),
-						Vec3f(unit->getCurrVector()),
+						unit->getCurrVector(),
 						gameCamera->getPos());
 				}
 			}
@@ -2210,8 +2210,8 @@ void UnitUpdater::hit(Unit *attacker, const AttackSkillType* ast, const Vec2i &t
 					attacker->setLastAttackedUnitId(attacked->getId());
 					scriptManager->onUnitAttacking(attacker);
 
-					double distance = pci.getPos().dist(targetPos);
-					distance = truncateDecimal<double>(distance,6);
+					float distance = pci.getPos().dist(targetPos);
+					distance = truncateDecimal<float>(distance,6);
 					damage(attacker, ast, attacked, distance);
 			  	}
 			}
@@ -2225,7 +2225,7 @@ void UnitUpdater::hit(Unit *attacker, const AttackSkillType* ast, const Vec2i &t
 	}
 }
 
-void UnitUpdater::damage(Unit *attacker, const AttackSkillType* ast, Unit *attacked, double distance) {
+void UnitUpdater::damage(Unit *attacker, const AttackSkillType* ast, Unit *attacked, float distance) {
 	if(attacker == NULL) {
 		throw megaglest_runtime_error("attacker == NULL");
 	}
@@ -2237,11 +2237,11 @@ void UnitUpdater::damage(Unit *attacker, const AttackSkillType* ast, Unit *attac
 	}
 
 	//get vars
-	double damage			= ast->getTotalAttackStrength(attacker->getTotalUpgrade());
+	float damage			= ast->getTotalAttackStrength(attacker->getTotalUpgrade());
 	int var					= ast->getAttackVar();
 	int armor				= attacked->getType()->getTotalArmor(attacked->getTotalUpgrade());
-	double damageMultiplier	= world->getTechTree()->getDamageMultiplier(ast->getAttackType(), attacked->getType()->getArmorType());
-	damageMultiplier = truncateDecimal<double>(damageMultiplier,6);
+	float damageMultiplier	= world->getTechTree()->getDamageMultiplier(ast->getAttackType(), attacked->getType()->getArmorType());
+	damageMultiplier = truncateDecimal<float>(damageMultiplier,6);
 
 	//compute damage
 	//damage += random.randRange(-var, var);
@@ -2249,7 +2249,7 @@ void UnitUpdater::damage(Unit *attacker, const AttackSkillType* ast, Unit *attac
 	damage /= distance+1;
 	damage -= armor;
 	damage *= damageMultiplier;
-	damage = truncateDecimal<double>(damage,6);
+	damage = truncateDecimal<float>(damage,6);
 
 	if(damage < 1) {
 		damage= 1;
@@ -2524,10 +2524,10 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 	}
 
 	//attack enemies that can attack first
-	double distToUnit= -1;
+	float distToUnit= -1;
 	Unit* enemySeen= NULL;
 
-	double distToStandingUnit= -1;
+	float distToStandingUnit= -1;
 	Unit* attackingEnemySeen= NULL;
 	ControlType controlType= unit->getFaction()->getControlType();
 	bool isUltra= controlType == ctCpuUltra || controlType == ctNetworkCpuUltra;
@@ -2547,7 +2547,7 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 
     		// Attackers get first priority
     		if(enemy->getType()->hasSkillClass(scAttack) == true) {
-    			double currentDist = unit->getCenteredPos().dist(enemy->getCenteredPos());
+    			float currentDist = unit->getCenteredPos().dist(enemy->getCenteredPos());
 
     			// Select closest attacking unit
     			if(distToUnit < 0 ||  currentDist< distToUnit) {
@@ -2598,8 +2598,8 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 			Vec2f enemyFloatCenter	= enemyUnit->getFloatCenteredPos();
 			// find nearest Attack and cleanup old dates
 			AttackWarningData *nearest	= NULL;
-			double currentDistance		= 0.f;
-			double nearestDistance		= 0.f;
+			float currentDistance		= 0.f;
+			float nearestDistance		= 0.f;
 
 			MutexSafeWrapper safeMutex(&mutexAttackWarnings,string(__FILE__) + "_" + intToStr(__LINE__));
 			for(int i = attackWarnings.size() - 1; i >= 0; --i) {
@@ -2866,7 +2866,7 @@ void ParticleDamager::update(ParticleSystem *particleSystem) {
 		//play sound
 		StaticSound *projSound= ast->getProjSound();
 		if(particleSystem->getVisible() && projSound != NULL) {
-			SoundRenderer::getInstance().playFx(projSound, Vec3f(attacker->getCurrVector()), gameCamera->getPos());
+			SoundRenderer::getInstance().playFx(projSound, attacker->getCurrVector(), gameCamera->getPos());
 		}
 	}
 	particleSystem->setObserver(NULL);
diff --git a/source/glest_game/world/unit_updater.h b/source/glest_game/world/unit_updater.h
index 02a15004..784d2ce7 100644
--- a/source/glest_game/world/unit_updater.h
+++ b/source/glest_game/world/unit_updater.h
@@ -124,7 +124,7 @@ public:
 
 	inline unsigned int getAttackWarningCount() const { return attackWarnings.size(); }
 	std::pair<bool,Unit *> unitBeingAttacked(const Unit *unit);
-	void unitBeingAttacked(std::pair<bool,Unit *> &result, const Unit *unit, const AttackSkillType *ast,double *currentDistToUnit=NULL);
+	void unitBeingAttacked(std::pair<bool,Unit *> &result, const Unit *unit, const AttackSkillType *ast,float *currentDistToUnit=NULL);
 	vector<Unit*> enemyUnitsOnRange(const Unit *unit,const AttackSkillType *ast);
 	void findEnemiesForCell(const Vec2i pos, int size, int sightRange, const Faction *faction, vector<Unit*> &enemies, bool attackersOnly) const;
 
@@ -142,7 +142,7 @@ private:
     //attack
     void hit(Unit *attacker);
 	void hit(Unit *attacker, const AttackSkillType* ast, const Vec2i &targetPos, Field targetField);
-	void damage(Unit *attacker, const AttackSkillType* ast, Unit *attacked, double distance);
+	void damage(Unit *attacker, const AttackSkillType* ast, Unit *attacked, float distance);
 	void startAttackParticleSystem(Unit *unit);
 
 	//misc
diff --git a/source/glest_game/world/world.cpp b/source/glest_game/world/world.cpp
index 2194e0ce..7b6305d9 100644
--- a/source/glest_game/world/world.cpp
+++ b/source/glest_game/world/world.cpp
@@ -1164,7 +1164,7 @@ void World::addAttackEffects(const Unit *unit) {
 
 //returns the nearest unit that can store a type of resource given a position and a faction
 Unit *World::nearestStore(const Vec2i &pos, int factionIndex, const ResourceType *rt) {
-    double currDist = infinity;
+	float currDist = infinity;
     Unit *currUnit= NULL;
 
     if(factionIndex >= getFactionCount()) {
@@ -1174,7 +1174,7 @@ Unit *World::nearestStore(const Vec2i &pos, int factionIndex, const ResourceType
     for(int i=0; i < getFaction(factionIndex)->getUnitCount(); ++i) {
 		Unit *u= getFaction(factionIndex)->getUnit(i);
 		if(u != NULL) {
-			double tmpDist= u->getPos().dist(pos);
+			float tmpDist= u->getPos().dist(pos);
 			if(tmpDist < currDist &&  u->getType() != NULL && u->getType()->getStore(rt) > 0 && u->isOperative()) {
 				currDist= tmpDist;
 				currUnit= u;
@@ -2348,7 +2348,7 @@ void World::exploreCells(const Vec2i &newPos, int sightRange, int teamIndex) {
 				}
 
 				//explore
-				double posLength = currRelPos.length();
+				float posLength = currRelPos.length();
 				//if(Vec2i(0).dist(currRelPos) < surfSightRange + indirectSightRange + 1) {
 				if(posLength < surfSightRange + indirectSightRange + 1) {
                     sc->setExplored(teamIndex, true);
diff --git a/source/shared_lib/include/graphics/math_util.h b/source/shared_lib/include/graphics/math_util.h
index f1683656..18ab3dba 100644
--- a/source/shared_lib/include/graphics/math_util.h
+++ b/source/shared_lib/include/graphics/math_util.h
@@ -233,7 +233,7 @@ public:
 		}
 	}
 
-	double area() {
+	float area() {
 		Vec2i v0= p[3]-p[0];
 		Vec2i v1= p[1]-p[2];
 
@@ -312,54 +312,6 @@ inline T radToDeg(T rad){
 //#endif
 //}
 
-template<typename T>
-inline T truncateDecimal(const T &value, int precision=6) {
-
-/*
-	int iSigned = value >= 0 ? 1: -1;
-
-#ifdef USE_STREFLOP
-	unsigned int uiTemp = (unsigned int)(value * streflop::pow((streflop::Simple)10, (streflop::Simple)precision)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
-	T result = (((T)uiTemp) / streflop::pow((streflop::Simple)10,(streflop::Simple)precision) * iSigned);
-#else
-	unsigned int uiTemp = (value * pow((T)10, precision)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
-	T result = (((double)uiTemp) / pow((T)10,precision) * iSigned);
-#endif
-	return result;
-*/
-
-	T precNum = 0;
-	if(precision == 0) {
-		precNum = 1;
-	}
-	else if(precision == 1) {
-		precNum = 10;
-	}
-	else if(precision == 2) {
-		precNum = 100;
-	}
-	else if(precision == 3) {
-		precNum = 1000;
-	}
-	else if(precision == 4) {
-		precNum = 10000;
-	}
-	else if(precision == 5) {
-		precNum = 100000;
-	}
-	else if(precision == 6) {
-		precNum = 1000000;
-	}
-	else  {
-		precNum = std::pow((T)10,(T)precision);
-	}
-
-	int64 resultInt = (T)value * (T)precNum;
-
-	T result = (long double)resultInt / precNum;
-	return result;
-}
-
 
 }}//end namespace
 
diff --git a/source/shared_lib/include/graphics/vec.h b/source/shared_lib/include/graphics/vec.h
index 98c4557a..ce816397 100644
--- a/source/shared_lib/include/graphics/vec.h
+++ b/source/shared_lib/include/graphics/vec.h
@@ -24,10 +24,61 @@
 //#include <tr1/unordered_map>
 //using namespace std::tr1;
 
+#include "data_types.h"
 #include "leak_dumper.h"
 
+using namespace Shared::Platform;
+
 namespace Shared{ namespace Graphics{
 
+template<typename T>
+inline T truncateDecimal(const T &value, int precision=6) {
+
+/*
+	int iSigned = value >= 0 ? 1: -1;
+
+#ifdef USE_STREFLOP
+	unsigned int uiTemp = (unsigned int)(value * streflop::pow((streflop::Simple)10, (streflop::Simple)precision)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
+	T result = (((T)uiTemp) / streflop::pow((streflop::Simple)10,(streflop::Simple)precision) * iSigned);
+#else
+	unsigned int uiTemp = (value * pow((T)10, precision)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
+	T result = (((double)uiTemp) / pow((T)10,precision) * iSigned);
+#endif
+	return result;
+*/
+
+	T precNum = 0;
+	if(precision == 0) {
+		precNum = 1;
+	}
+	else if(precision == 1) {
+		precNum = 10;
+	}
+	else if(precision == 2) {
+		precNum = 100;
+	}
+	else if(precision == 3) {
+		precNum = 1000;
+	}
+	else if(precision == 4) {
+		precNum = 10000;
+	}
+	else if(precision == 5) {
+		precNum = 100000;
+	}
+	else if(precision == 6) {
+		precNum = 1000000;
+	}
+	else  {
+		precNum = std::pow((T)10,(T)precision);
+	}
+
+	int64 resultInt = (T)value * (T)precNum;
+
+	T result = (long double)resultInt / precNum;
+	return result;
+}
+
 inline std::vector<std::string> TokenizeString(const std::string str,const std::string delimiters) {
 	std::vector<std::string> tokens;
 	// Assume textLine contains the line of text to parse.
@@ -206,8 +257,10 @@ public:
 		return x*v.x+y*v.y;
 	}
 
-	inline double dist(const Vec2<T> &v) const{
-		return Vec2<T>(v-*this).length();
+	inline float dist(const Vec2<T> &v) const{
+		float distance = Vec2<T>(v-*this).length();
+		distance = truncateDecimal<float>(distance,6);
+		return distance;
 	}
 
 	// strict week ordering, so Vec2<T> can be used as key for set<> or map<>
@@ -215,7 +268,7 @@ public:
 		return x < v.x || (x == v.x && y < v.y);
 	}
 
-	inline double length() const {
+	inline float length() const {
 //#ifdef USE_STREFLOP
 //		if(requireAccuracy == true) {
 //			return static_cast<float>(streflop::sqrt(static_cast<streflop::Simple>(x*x + y*y)));
@@ -224,7 +277,9 @@ public:
 //#else
 //		return static_cast<float>(sqrt(static_cast<float>(x*x + y*y)));
 //#endif
-		return static_cast<double>(std::sqrt(static_cast<double>(x*x + y*y)));
+		float len = static_cast<float>(std::sqrt(static_cast<float>(x*x + y*y)));
+		len = truncateDecimal<float>(len,6);
+		return len;
 	}
 
 	inline void normalize(){
@@ -233,7 +288,7 @@ public:
 		y/= m;
 	}
 	
-	inline Vec2<T> rotate(double rad) {
+	inline Vec2<T> rotate(float rad) {
 //		const float
 //#ifdef USE_STREFLOP
 //			c = streflop::cosf(rad),
@@ -242,13 +297,13 @@ public:
 //			c = cosf(rad),
 //			s = sinf(rad);
 //#endif
-		double c = std::cos(rad),
+		float  c = std::cos(rad),
 			   s = std::sin(rad);
 
 		return Vec2<T>(x*c-y*s,x*s+y*c);
 	}
 
-	inline Vec2<T> rotateAround(double rad,const Vec2<T>& pt){
+	inline Vec2<T> rotateAround(float rad,const Vec2<T>& pt) {
 		return pt+(*this-pt).rotate(rad);
 	}
 
@@ -452,11 +507,13 @@ public:
 		return x*v.x + y*v.y + z*v.z;
 	}
 
-	inline double dist(const Vec3<T> &v) const{
-		return Vec3<T>(v-*this).length();
+	inline float dist(const Vec3<T> &v) const {
+		float distance = Vec3<T>(v-*this).length();
+		distance = truncateDecimal<float>(distance,6);
+		return distance;
 	}
 
-	inline double length() const {
+	inline float length() const {
 //#ifdef USE_STREFLOP
 //		if(requireAccuracy == true) {
 //			return static_cast<float>(streflop::sqrt(static_cast<streflop::Simple>(x*x + y*y + z*z)));
@@ -465,7 +522,9 @@ public:
 //#else
 //		return static_cast<float>(sqrt(x*x + y*y + z*z));
 //#endif
-		return static_cast<double>(std::sqrt(x*x + y*y + z*z));
+		float len = static_cast<float>(std::sqrt(x*x + y*y + z*z));
+		len = truncateDecimal<float>(len,6);
+		return len;
 	}
 
 	inline void normalize() {
diff --git a/source/shared_lib/include/util/randomgen.h b/source/shared_lib/include/util/randomgen.h
index ff57606e..92720be5 100644
--- a/source/shared_lib/include/util/randomgen.h
+++ b/source/shared_lib/include/util/randomgen.h
@@ -43,7 +43,7 @@ public:
 	void init(int seed);
 
 	int randRange(int min, int max,std::string lastCaller="");
-	double randRange(double min, double max,std::string lastCaller="");
+	float randRange(float min, float max,std::string lastCaller="");
 
 	int getLastNumber() const { return lastNumber; }
 	void setLastNumber(int value) { lastNumber = value; }
diff --git a/source/shared_lib/include/util/util.h b/source/shared_lib/include/util/util.h
index 164cf792..e707e04e 100644
--- a/source/shared_lib/include/util/util.h
+++ b/source/shared_lib/include/util/util.h
@@ -231,10 +231,10 @@ void copyStringToBuffer(char *buffer, int bufferSize, const string& s);
 
 //numeric fcs
 int clamp(int value, int min, int max);
-double clamp(double value, double min, double max);
+float clamp(float value, float min, float max);
 int64 clamp(int64 value, int64 min, int64 max);
-double saturate(double value);
-int round(double f);
+float saturate(float value);
+int round(float f);
 
 //misc
 bool checkVersionComptability(string clientVersionString, string serverVersionString);
diff --git a/source/shared_lib/sources/graphics/gl/particle_renderer_gl.cpp b/source/shared_lib/sources/graphics/gl/particle_renderer_gl.cpp
index f5f68e88..ff49f7ff 100644
--- a/source/shared_lib/sources/graphics/gl/particle_renderer_gl.cpp
+++ b/source/shared_lib/sources/graphics/gl/particle_renderer_gl.cpp
@@ -109,7 +109,7 @@ void ParticleRendererGl::renderSystem(ParticleSystem *ps){
 	for(int i=0; i<ps->getAliveParticleCount(); ++i){
 		const Particle *particle= ps->getParticle(i);
 		float size= particle->getSize()/2.0f;
-		Vec3f pos= Vec3f(particle->getPos());
+		Vec3f pos= particle->getPos();
 		Vec4f color= particle->getColor();
 
 		vertexBuffer[bufferIndex] = pos - (rightVector - upVector) * size;
@@ -159,8 +159,8 @@ void ParticleRendererGl::renderSystemLine(ParticleSystem *ps){
 			particle= ps->getParticle(i);
 			Vec4f color= particle->getColor();
 
-			vertexBuffer[bufferIndex] = Vec3f(particle->getPos());
-			vertexBuffer[bufferIndex+1] = Vec3f(particle->getLastPos());
+			vertexBuffer[bufferIndex] = particle->getPos();
+			vertexBuffer[bufferIndex+1] = particle->getLastPos();
 
 			colorBuffer[bufferIndex]= color;
 			colorBuffer[bufferIndex+1]= color;
@@ -203,8 +203,8 @@ void ParticleRendererGl::renderSystemLineAlpha(ParticleSystem *ps){
 			particle= ps->getParticle(i);
 			Vec4f color= particle->getColor();
 
-			vertexBuffer[bufferIndex] = Vec3f(particle->getPos());
-			vertexBuffer[bufferIndex+1] = Vec3f(particle->getLastPos());
+			vertexBuffer[bufferIndex] = particle->getPos();
+			vertexBuffer[bufferIndex+1] = particle->getLastPos();
 
 			colorBuffer[bufferIndex]= color;
 			colorBuffer[bufferIndex+1]= color;
@@ -236,11 +236,11 @@ void ParticleRendererGl::renderModel(GameParticleSystem *ps, ModelRenderer *mr){
 		glPushMatrix();
 
 		//translate
-		Vec3f pos= Vec3f(ps->getPos());
+		Vec3f pos= ps->getPos();
 		glTranslatef(pos.x, pos.y, pos.z);
 
 		//rotate
-		Vec3f direction= Vec3f(ps->getDirection());
+		Vec3f direction= ps->getDirection();
 		Vec3f flatDirection= Vec3f(direction.x, 0.f, direction.z);
 		Vec3f rotVector= Vec3f(0.f, 1.f, 0.f).cross(flatDirection);
 
diff --git a/source/shared_lib/sources/util/randomgen.cpp b/source/shared_lib/sources/util/randomgen.cpp
index 715b36b7..c2e28f2b 100644
--- a/source/shared_lib/sources/util/randomgen.cpp
+++ b/source/shared_lib/sources/util/randomgen.cpp
@@ -80,8 +80,8 @@ int RandomGen::randRange(int min, int max,string lastCaller) {
 	}
 
 	int diff= max-min;
-	double numerator = static_cast<double>(diff + 1) * static_cast<double>(RandomGen::rand(lastCaller));
-	int res= min + static_cast<int>(truncateDecimal<double>(numerator / static_cast<double>(m),6));
+	float numerator = static_cast<float>(diff + 1) * static_cast<float>(RandomGen::rand(lastCaller));
+	int res= min + static_cast<int>(truncateDecimal<float>(numerator / static_cast<float>(m),6));
 	if(res < min || res > max) {
 		char szBuf[8096]="";
 		snprintf(szBuf,8096,"In [%s::%s Line: %d] res < min || res > max, min = %d, max = %d, res = %d",__FILE__,__FUNCTION__,__LINE__,min,max,res);
@@ -93,16 +93,16 @@ int RandomGen::randRange(int min, int max,string lastCaller) {
 	return res;
 }
 
-double RandomGen::randRange(double min, double max,string lastCaller) {
+float RandomGen::randRange(float min, float max,string lastCaller) {
 	if(min > max) {
 		char szBuf[8096]="";
 		snprintf(szBuf,8096,"In [%s::%s Line: %d] min > max, min = %f, max = %f",__FILE__,__FUNCTION__,__LINE__,min,max);
 		throw megaglest_runtime_error(szBuf);
 	}
 
-	double rand01 = static_cast<double>(RandomGen::rand(lastCaller)) / (m-1);
-	double res= min + (max - min) * rand01;
-	res = truncateDecimal<double>(res,6);
+	float rand01 = static_cast<float>(RandomGen::rand(lastCaller)) / (m-1);
+	float res= min + (max - min) * rand01;
+	res = truncateDecimal<float>(res,6);
 
 	if(res < min || res > max) {
 		char szBuf[8096]="";
diff --git a/source/shared_lib/sources/util/util.cpp b/source/shared_lib/sources/util/util.cpp
index 7afa38ae..fca0c457 100644
--- a/source/shared_lib/sources/util/util.cpp
+++ b/source/shared_lib/sources/util/util.cpp
@@ -710,7 +710,7 @@ void copyStringToBuffer(char *buffer, int bufferSize, const string& s){
 
 // ==================== numeric fcs ====================
 
-double saturate(double value) {
+float saturate(float value) {
 	if (value < 0.f){
         return 0.f;
 	}
@@ -740,7 +740,7 @@ int64 clamp(int64 value, int64 min, int64 max){
     return value;
 }
 
-double clamp(double value, double min, double max) {
+float clamp(float value, float min, float max) {
 	if (value < min) {
         return min;
 	}
@@ -750,7 +750,7 @@ double clamp(double value, double min, double max) {
     return value;
 }
 
-int round(double f){
+int round(float f){
      return (int) f;
 }