[ZH] Fix warnings about operators between enumerations and floating point types (TheSuperHackers#534)

Author: Bart Roossien

GeneralsMD/Code/GameEngine/Include/Common/BattleHonors.h

@@ -108,11 +108,12 @@ enum
 
 enum
 {
-	MAX_BATTLE_HONOR_COLUMNS = 4,
-	MAX_BATTLE_HONOR_IMAGE_WIDTH = 40,
-	MAX_BATTLE_HONOR_IMAGE_HEIGHT = 41,
+	MAX_BATTLE_HONOR_COLUMNS = 4
 };
 
+#define MAX_BATTLE_HONOR_IMAGE_WIDTH 40.0f
+#define MAX_BATTLE_HONOR_IMAGE_HEIGHT 41.0f
+
 //-----------------------------------------------------------------------------
 // INLINING ///////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------

GeneralsMD/Code/GameEngine/Source/Common/System/BuildAssistant.cpp

@@ -173,8 +173,8 @@ void BuildAssistant::reset( void )
 
 }  // end reset
 
-static const Real FRAMES_TO_ALLOW_SCAFFOLD = LOGICFRAMES_PER_SECOND * 1.5f;
-static const Real TOTAL_FRAMES_TO_SELL_OBJECT = LOGICFRAMES_PER_SECOND * 3.0f;
+static const Real FRAMES_TO_ALLOW_SCAFFOLD = static_cast<Real>(LOGICFRAMES_PER_SECOND) * 1.5f;
+static const Real TOTAL_FRAMES_TO_SELL_OBJECT = static_cast<Real>(LOGICFRAMES_PER_SECOND) * 3.0f;
 //-------------------------------------------------------------------------------------------------
 /** Update phase for the build assistant */
 //-------------------------------------------------------------------------------------------------

GeneralsMD/Code/GameEngine/Source/Common/System/Radar.cpp

@@ -63,7 +63,7 @@
 Radar *TheRadar = NULL;  ///< the radar global singleton
 
 // PRIVATE ////////////////////////////////////////////////////////////////////////////////////////
-#define RADAR_QUEUE_TERRAIN_REFRESH_DELAY (LOGICFRAMES_PER_SECOND * 3.0f)
+#define RADAR_QUEUE_TERRAIN_REFRESH_DELAY (static_cast<Real>(LOGICFRAMES_PER_SECOND) * 3.0f)
 
 //-------------------------------------------------------------------------------------------------
 /** Delete list resources used by the radar and return them to the memory pools */
@@ -345,8 +345,8 @@ void Radar::newMap( TerrainLogic *terrain )
 	terrain->getExtent( &m_mapExtent );
 
 	// we will sample at these intervals across the map
-	m_xSample = m_mapExtent.width() / RADAR_CELL_WIDTH;
-	m_ySample = m_mapExtent.height() / RADAR_CELL_HEIGHT;
+	m_xSample = m_mapExtent.width() / static_cast<Real>(RADAR_CELL_WIDTH);
+	m_ySample = m_mapExtent.height() / static_cast<Real>(RADAR_CELL_HEIGHT);
 
 	// find the "middle" height for the terrain (most used value) and water table
 	Int x, y;
@@ -1119,8 +1119,8 @@ void Radar::internalCreateEvent( const Coord3D *world, RadarEventType type, Real
 	m_event[ m_nextFreeRadarEvent ].type = type;
 	m_event[ m_nextFreeRadarEvent ].active = TRUE;
 	m_event[ m_nextFreeRadarEvent ].createFrame = TheGameLogic->getFrame();
-	m_event[ m_nextFreeRadarEvent ].dieFrame = TheGameLogic->getFrame() + LOGICFRAMES_PER_SECOND * secondsToLive;
-	m_event[ m_nextFreeRadarEvent ].fadeFrame = m_event[ m_nextFreeRadarEvent ].dieFrame - LOGICFRAMES_PER_SECOND * secondsBeforeDieToFade;
+	m_event[ m_nextFreeRadarEvent ].dieFrame = TheGameLogic->getFrame() + static_cast<Real>(LOGICFRAMES_PER_SECOND) * secondsToLive;
+	m_event[ m_nextFreeRadarEvent ].fadeFrame = m_event[ m_nextFreeRadarEvent ].dieFrame - static_cast<Real>(LOGICFRAMES_PER_SECOND) * secondsBeforeDieToFade;
 	m_event[ m_nextFreeRadarEvent ].color1 = *color1;
 	m_event[ m_nextFreeRadarEvent ].color2 = *color2;
 	m_event[ m_nextFreeRadarEvent ].worldLoc = *world;

GeneralsMD/Code/GameEngine/Source/Common/System/Upgrade.cpp

@@ -164,7 +164,7 @@ Int UpgradeTemplate::calcTimeToBuild( Player *player ) const
 #endif
 
 	///@todo modify this by power state of player
-	return m_buildTime * LOGICFRAMES_PER_SECOND;
+	return m_buildTime * static_cast<Real>(LOGICFRAMES_PER_SECOND);
 
 }  // end calcTimeToBuild
 

GeneralsMD/Code/GameEngine/Source/Common/Thing/ThingTemplate.cpp

@@ -1548,7 +1548,7 @@ Int ThingTemplate::calcCostToBuild( const Player* player) const
 //-------------------------------------------------------------------------------------------------
 Int ThingTemplate::calcTimeToBuild( const Player* player) const
 {
-	Int buildTime = getBuildTime() * LOGICFRAMES_PER_SECOND;
+	Int buildTime = getBuildTime() * static_cast<Real>(LOGICFRAMES_PER_SECOND);
 	buildTime *= player->getHandicap()->getHandicap(Handicap::BUILDTIME, this);
 
 	Real factionModifier = 1 + player->getProductionTimeChangePercent( getName() );

GeneralsMD/Code/GameEngine/Source/GameClient/GUI/ControlBar/ControlBarScheme.cpp

@@ -71,9 +71,7 @@
 //-----------------------------------------------------------------------------
 // DEFINES ////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
-enum{
-	COMMAND_BAR_SIZE_OFFSET = 0
-};
+#define COMMAND_BAR_SIZE_OFFSET 0.0f
 
 const FieldParse ControlBarSchemeManager::m_controlBarSchemeFieldParseTable[] = 
 {

GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GameWindowTransitionsStyles.cpp

@@ -1702,8 +1702,8 @@ void ControlBarArrowTransition::init( GameWindow *win )
 	m_isFinished = FALSE;
 	m_isForward = TRUE;
 
-	m_percent = 1.0f / CONTROLBARARROWTRANSITION_BEGIN_FADE;
-	m_fadePercent = 1.0f/ (CONTROLBARARROWTRANSITION_END - CONTROLBARARROWTRANSITION_BEGIN_FADE);
+	m_percent = 1.0f / static_cast<Real>(CONTROLBARARROWTRANSITION_BEGIN_FADE);
+	m_fadePercent = 1.0f/ (static_cast<Real>(CONTROLBARARROWTRANSITION_END) - static_cast<Real>(CONTROLBARARROWTRANSITION_BEGIN_FADE));
 
 	m_arrowImage = TheControlBar->getArrowImage();
 	GameWindow *twin = TheWindowManager->winGetWindowFromId(NULL, TheNameKeyGenerator->nameToKey("ControlBar.wnd:ButtonGeneral"));

GeneralsMD/Code/GameEngine/Source/GameClient/InGameUI.cpp

@@ -5300,7 +5300,7 @@ void InGameUI::addWorldAnimation( Anim2DTemplate *animTemplate,
 
 	// assign all data
 	wad->m_anim = anim;
-	wad->m_expireFrame = TheGameLogic->getFrame() + (durationInSeconds * LOGICFRAMES_PER_SECOND);
+	wad->m_expireFrame = TheGameLogic->getFrame() + (durationInSeconds * static_cast<Real>(LOGICFRAMES_PER_SECOND));
 	wad->m_options = options;
 	wad->m_worldPos = *pos;
 	wad->m_zRisePerSecond = zRisePerSecond;
@@ -5379,7 +5379,7 @@ void InGameUI::updateAndDrawWorldAnimations( void )
 
 			// update the Z value
 			if( wad->m_zRisePerSecond )
-				wad->m_worldPos.z += wad->m_zRisePerSecond / LOGICFRAMES_PER_SECOND;
+				wad->m_worldPos.z += wad->m_zRisePerSecond / static_cast<Real>(LOGICFRAMES_PER_SECOND);
 
 		}  // end if
 

GeneralsMD/Code/GameEngine/Source/GameLogic/AI/AIPathfind.cpp

@@ -6848,11 +6848,11 @@ Path *Pathfinder::buildHierachicalPath( const Coord3D *fromPos, PathfindCell *go
 	// This allows the unit to get around friendly units that may be near it.
 	Coord3D pos = *path->getFirstNode()->getPosition();
 	Coord3D minPos = pos;
-	minPos.x -= PathfindZoneManager::ZONE_BLOCK_SIZE*PATHFIND_CELL_SIZE_F;
-	minPos.y -= PathfindZoneManager::ZONE_BLOCK_SIZE*PATHFIND_CELL_SIZE_F;
+	minPos.x -= static_cast<Real>(PathfindZoneManager::ZONE_BLOCK_SIZE)*PATHFIND_CELL_SIZE_F;
+	minPos.y -= static_cast<Real>(PathfindZoneManager::ZONE_BLOCK_SIZE)*PATHFIND_CELL_SIZE_F;
 	Coord3D maxPos = pos;
-	maxPos.x += PathfindZoneManager::ZONE_BLOCK_SIZE*PATHFIND_CELL_SIZE_F;
-	maxPos.y += PathfindZoneManager::ZONE_BLOCK_SIZE*PATHFIND_CELL_SIZE_F;
+	maxPos.x += static_cast<Real>(PathfindZoneManager::ZONE_BLOCK_SIZE)*PATHFIND_CELL_SIZE_F;
+	maxPos.y += static_cast<Real>(PathfindZoneManager::ZONE_BLOCK_SIZE)*PATHFIND_CELL_SIZE_F;
 	ICoord2D cellNdxMin, cellNdxMax;
 	worldToCell(&minPos, &cellNdxMin);
 	worldToCell(&maxPos, &cellNdxMax);

GeneralsMD/Code/GameEngine/Source/GameLogic/AI/AIPlayer.cpp

@@ -800,7 +800,7 @@ void AIPlayer::processBaseBuilding( void )
 						info->decrementNumRebuilds();
 
 						m_readyToBuildStructure = false;
-						m_structureTimer = TheAI->getAiData()->m_structureSeconds*LOGICFRAMES_PER_SECOND;
+						m_structureTimer = TheAI->getAiData()->m_structureSeconds* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 						if (m_player->getMoney()->countMoney() < TheAI->getAiData()->m_resourcesPoor) {
 							m_structureTimer = m_structureTimer/TheAI->getAiData()->m_structuresPoorMod;
 						}	else if (m_player->getMoney()->countMoney() > TheAI->getAiData()->m_resourcesWealthy) {

GeneralsMD/Code/GameEngine/Source/GameLogic/AI/AISkirmishPlayer.cpp

@@ -262,7 +262,7 @@ void AISkirmishPlayer::processBaseBuilding( void )
 				bldgInfo->decrementNumRebuilds();
 
 				m_readyToBuildStructure = false;
-				m_structureTimer = TheAI->getAiData()->m_structureSeconds*LOGICFRAMES_PER_SECOND;
+				m_structureTimer = TheAI->getAiData()->m_structureSeconds* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 				if (m_player->getMoney()->countMoney() < TheAI->getAiData()->m_resourcesPoor) {
 					m_structureTimer = m_structureTimer/TheAI->getAiData()->m_structuresPoorMod;
 				}	else if (m_player->getMoney()->countMoney() > TheAI->getAiData()->m_resourcesWealthy) {

GeneralsMD/Code/GameEngine/Source/GameLogic/AI/AIStates.cpp

@@ -532,7 +532,7 @@ StateReturnType AIRappelState::onEnter()
 		obj->setLayer(layerAtDest);
 
 	AIUpdateInterface *ai = obj->getAI();
-	Real MAX_RAPPEL_RATE = fabs(TheGlobalData->m_gravity) * LOGICFRAMES_PER_SECOND * 2.5f;
+	Real MAX_RAPPEL_RATE = fabs(TheGlobalData->m_gravity) * static_cast<Real>(LOGICFRAMES_PER_SECOND) * 2.5f;
 	m_rappelRate = -min(ai->getDesiredSpeed(), MAX_RAPPEL_RATE);
 
 	return STATE_CONTINUE;
@@ -3669,7 +3669,7 @@ StateReturnType AIAttackMoveToState::update()
 		if (m_retryCount<1) return ret;
 		/* check for close enough. */
 		Real distSqr = sqr(owner->getPosition()->x - m_pathGoalPosition.x) + sqr(owner->getPosition()->y-m_pathGoalPosition.y);
-		if (distSqr < sqr(ATTACK_CLOSE_ENOUGH_CELLS*PATHFIND_CELL_SIZE_F)) {
+		if (distSqr < sqr(static_cast<Real>(ATTACK_CLOSE_ENOUGH_CELLS)*PATHFIND_CELL_SIZE_F)) {
 			return ret;
 		}
 		DEBUG_LOG(("AIAttackMoveToState::update Distance from goal %f, retrying.\n", sqrt(distSqr)));

GeneralsMD/Code/GameEngine/Source/GameLogic/Map/TerrainLogic.cpp

@@ -2463,7 +2463,7 @@ void TerrainLogic::changeWaterHeightOverTime( const WaterHandle *water,
 	// add the entry into the array of water to update
 	m_waterToUpdate[ m_numWaterToUpdate ].waterTable = water;
 	m_waterToUpdate[ m_numWaterToUpdate ].changePerFrame = (finalHeight - currentHeight) / 
-																												 (LOGICFRAMES_PER_SECOND * transitionTimeInSeconds);
+		(static_cast<Real>(LOGICFRAMES_PER_SECOND) * transitionTimeInSeconds);
 	m_waterToUpdate[ m_numWaterToUpdate ].targetHeight = finalHeight;
 	m_waterToUpdate[ m_numWaterToUpdate ].damageAmount = damageAmount;
 	m_waterToUpdate[ m_numWaterToUpdate ].currentHeight = currentHeight;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Behavior/MinefieldBehavior.cpp

@@ -260,7 +260,7 @@ UpdateSleepTime MinefieldBehavior::update()
 	if (m_draining)
 	{
 		DamageInfo damageInfo;
-		damageInfo.in.m_amount = (obj->getBodyModule()->getMaxHealth() * d->m_healthPercentToDrainPerSecond) / LOGICFRAMES_PER_SECOND;
+		damageInfo.in.m_amount = (obj->getBodyModule()->getMaxHealth() * d->m_healthPercentToDrainPerSecond) / static_cast<Real>(LOGICFRAMES_PER_SECOND);
 		damageInfo.in.m_sourceID = obj->getID();
 		damageInfo.in.m_damageType = DAMAGE_UNRESISTABLE;
 		damageInfo.in.m_deathType = DEATH_NORMAL;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Behavior/OverchargeBehavior.cpp

@@ -117,7 +117,7 @@ UpdateSleepTime OverchargeBehavior::update( void )
 		// do some damage
 		BodyModuleInterface *body = us->getBodyModule();
 		DamageInfo damageInfo;
-		damageInfo.in.m_amount = (body->getMaxHealth() * modData->m_healthPercentToDrainPerSecond) / LOGICFRAMES_PER_SECOND;
+		damageInfo.in.m_amount = (body->getMaxHealth() * modData->m_healthPercentToDrainPerSecond) / static_cast<Real>(LOGICFRAMES_PER_SECOND);
 		damageInfo.in.m_sourceID = us->getID();
 		damageInfo.in.m_damageType = DAMAGE_PENALTY;
 		damageInfo.in.m_deathType = DEATH_NORMAL;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Behavior/PropagandaTowerBehavior.cpp

@@ -326,7 +326,7 @@ void PropagandaTowerBehavior::effectLogic( Object *obj, Bool giving,
 			else
 				healthPercent = modData->m_autoHealPercentPerSecond;
 
-			Real amount = healthPercent / LOGICFRAMES_PER_SECOND * body->getMaxHealth();
+			Real amount = healthPercent / static_cast<Real>(LOGICFRAMES_PER_SECOND) * body->getMaxHealth();
 
 	// Dustin wants the healing effect not to stack from multiple propaganda towers...
 	// To accomplish this, I'll give every object a single healing-sender (ID)

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Behavior/RebuildHoleBehavior.cpp

@@ -310,7 +310,7 @@ UpdateSleepTime RebuildHoleBehavior::update( void )
 		DamageInfo healingInfo;
 
 		// do some healing
-		healingInfo.in.m_amount = (modData->m_holeHealthRegenPercentPerSecond / LOGICFRAMES_PER_SECOND) * 
+		healingInfo.in.m_amount = (modData->m_holeHealthRegenPercentPerSecond / static_cast<Real>(LOGICFRAMES_PER_SECOND)) *
 															body->getMaxHealth();
 		healingInfo.in.m_sourceID = hole->getID();
 		healingInfo.in.m_damageType = DAMAGE_HEALING;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Locomotor.cpp

@@ -671,7 +671,7 @@ Locomotor::Locomotor(const LocomotorTemplate* tmpl)
 	m_angleOffset = GameLogicRandomValueReal(-PI/6, PI/6);
 	m_offsetIncrement = (PI/40) * (GameLogicRandomValueReal(0.8f, 1.2f)/m_template->m_wanderLengthFactor);
 	setFlag(OFFSET_INCREASING, GameLogicRandomValue(0,1));
-	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS*LOGICFRAMES_PER_SECOND;
+	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -785,7 +785,7 @@ void Locomotor::loadPostProcess( void )
 void Locomotor::startMove(void) 
 {
 	// Reset the donut timer.
-	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS*LOGICFRAMES_PER_SECOND;
+	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -1115,7 +1115,7 @@ void Locomotor::locoUpdate_moveTowardsPosition(Object* obj, const Coord3D& goalP
 
 	if (wasBraking) 
 	{
-	#define MIN_VEL (PATHFIND_CELL_SIZE_F/(LOGICFRAMES_PER_SECOND))
+	#define MIN_VEL (PATHFIND_CELL_SIZE_F/(static_cast<Real>(LOGICFRAMES_PER_SECOND)))
 
 		Coord3D pos = *obj->getPosition();
 		if (obj->isKindOf(KINDOF_PROJECTILE)) 
@@ -1148,7 +1148,7 @@ void Locomotor::locoUpdate_moveTowardsPosition(Object* obj, const Coord3D& goalP
 			if (dist > 0.001f) 
 			{
 				Real vel = fabs(physics->getForwardSpeed2D());
-				if (vel < MIN_VEL) 
+				if (vel < MIN_VEL)
 					vel = MIN_VEL;
 				if (vel > dist)
 					vel = dist;	// do not overcompensate!
@@ -1427,7 +1427,7 @@ void Locomotor::moveTowardsPositionWheels(Object* obj, PhysicsBehavior *physics,
 	}
 
  	if (onPathDistToGoal > DONUT_DISTANCE) {
-		m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS*LOGICFRAMES_PER_SECOND;
+		m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 	} else {
 		if (m_donutTimer < TheGameLogic->getFrame()) {
 			setFlag(IS_BRAKING, true);
@@ -2441,7 +2441,7 @@ Bool Locomotor::locoUpdate_maintainCurrentPosition(Object* obj)
 		setFlag(MAINTAIN_POS_IS_VALID, true);
 	}
 
-	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS*LOGICFRAMES_PER_SECOND;
+	m_donutTimer = TheGameLogic->getFrame()+DONUT_TIME_DELAY_SECONDS* static_cast<Real>(LOGICFRAMES_PER_SECOND);
 	setFlag(IS_BRAKING, false);
 	PhysicsBehavior *physics = obj->getPhysics();
 	if (physics == NULL)

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Object.cpp

@@ -943,7 +943,7 @@ Bool Object::checkAndDetonateBoobyTrap(const Object *victim)
 	filters[1] = &filterMapStatus;
 	filters[2] = NULL;
 
-	ObjectIterator *iter = ThePartitionManager->iterateObjectsInRange( getPosition(), BOOBY_TRAP_SCAN_RANGE + getGeometryInfo().getBoundingCircleRadius(), 
+	ObjectIterator *iter = ThePartitionManager->iterateObjectsInRange( getPosition(), static_cast<Real>(BOOBY_TRAP_SCAN_RANGE) + getGeometryInfo().getBoundingCircleRadius(),
 		FROM_CENTER_2D, filters, ITER_SORTED_NEAR_TO_FAR );
 	MemoryPoolObjectHolder hold(iter);// This is the magic thing that frees the dynamically made iter in its destructor
 

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/SpecialPower/OCLSpecialPower.cpp

@@ -50,9 +50,9 @@
 //#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
 #endif
 
+#define	CREATE_ABOVE_LOCATION_HEIGHT 300.0f
 enum 
 {
-	CREATE_ABOVE_LOCATION_HEIGHT = 300,
 	MAX_ADJUST_RADIUS = 500
 };
 

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/AIUpdate.cpp

@@ -2278,8 +2278,8 @@ UpdateSleepTime AIUpdateInterface::doLocomotor( void )
 							{
 								Real dist = sqrtf(dSqr);
 								if (dist<1) dist = 1;
-								pos.x += 2*PATHFIND_CELL_SIZE_F*dx/(dist*LOGICFRAMES_PER_SECOND);
-								pos.y += 2*PATHFIND_CELL_SIZE_F*dy/(dist*LOGICFRAMES_PER_SECOND);
+								pos.x += 2*PATHFIND_CELL_SIZE_F*dx/(dist* static_cast<Real>(LOGICFRAMES_PER_SECOND));
+								pos.y += 2*PATHFIND_CELL_SIZE_F*dy/(dist* static_cast<Real>(LOGICFRAMES_PER_SECOND));
 								if (onGround)
 									pos.z = TheTerrainLogic->getGroundHeight( pos.x, pos.y );
 								getObject()->setPosition(&pos);

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/AIUpdate/ChinookAIUpdate.cpp

@@ -881,7 +881,7 @@ ChinookAIUpdateModuleData::ChinookAIUpdateModuleData()
 	m_minDropHeight = 30.0f;
 	m_ropeFinalHeight = 0.0f;
 	m_ropeDropSpeed = 1e10f;		// um, fast.
-	m_rappelSpeed = fabs(TheGlobalData->m_gravity) * LOGICFRAMES_PER_SECOND * 0.5f;
+	m_rappelSpeed = fabs(TheGlobalData->m_gravity) * static_cast<Real>(LOGICFRAMES_PER_SECOND) * 0.5f;
 	m_ropeWobbleLen = 10.0f;
 	m_ropeWobbleAmp = 1.0f;
 	m_ropeWobbleRate = 0.1f;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/AIUpdate/DozerAIUpdate.cpp

@@ -717,7 +717,7 @@ StateReturnType DozerActionDoActionState::update( void )
 
 					// figure out how much health we will restore this frame
 					Real health = body->getMaxHealth() * dozerAI->getRepairHealthPerSecond() /
-												LOGICFRAMES_PER_SECOND;
+						static_cast<Real>(LOGICFRAMES_PER_SECOND);
 
 					// try to give it a little bit-o-health
 					if ( ! goalObject->attemptHealingFromSoleBenefactor(health, dozer, 2) )//this frame and the next

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/AIUpdate/SupplyTruckAIUpdate.cpp

@@ -603,7 +603,7 @@ TheInGameUI->DEBUG_addFloatingText("entering regrouping state", getMachineOwner(
 		return STATE_FAILURE;
 	}
 
-	if( ThePartitionManager->getDistanceSquared(owner, destinationObject, FROM_BOUNDINGSPHERE_2D) < REGROUP_SUCCESS_DISTANCE_SQUARED )
+	if( ThePartitionManager->getDistanceSquared(owner, destinationObject, FROM_BOUNDINGSPHERE_2D) < static_cast<Real>(REGROUP_SUCCESS_DISTANCE_SQUARED) )
 		return STATE_CONTINUE; // Don't say Success so we don't spin the machine.  After one update we'll go back.
 
 	Coord3D destination;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/AutoDepositUpdate.cpp

@@ -161,7 +161,7 @@ UpdateSleepTime AutoDepositUpdate::update( void )
 			return UPDATE_SLEEP_NONE;
 
 		// makes sure that buildings under construction do not get a bonus CCB
-		if( getObject()->getConstructionPercent() != CONSTRUCTION_COMPLETE )
+		if( getObject()->getConstructionPercent() != static_cast<Real>(CONSTRUCTION_COMPLETE) )
 			return UPDATE_SLEEP_NONE;
 
 		int moneyAmount = modData->m_depositAmount + getUpgradedSupplyBoost();

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/BaseRenerateUpdate.cpp

@@ -138,7 +138,7 @@ UpdateSleepTime BaseRegenerateUpdate::update( void )
 
 		// do some healing
 		Real amount = HEAL_RATE * (body->getMaxHealth() * TheGlobalData->m_baseRegenHealthPercentPerSecond) / 
-														 LOGICFRAMES_PER_SECOND;
+			static_cast<Real>(LOGICFRAMES_PER_SECOND);
 		me->attemptHealing(amount, me);
 
 		return UPDATE_SLEEP(HEAL_RATE);

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/FireOCLAfterWeaponCooldownUpdate.cpp

@@ -199,7 +199,7 @@ void FireOCLAfterWeaponCooldownUpdate::fireOCL()
 	UnsignedInt now = TheGameLogic->getFrame();
 	Real seconds = (now - m_startFrame) * SECONDS_PER_LOGICFRAME_REAL;
 	seconds *= data->m_oclLifetimePerSecond * 0.001f;
-	UnsignedInt oclFrames = (UnsignedInt)(seconds * LOGICFRAMES_PER_SECOND);
+	UnsignedInt oclFrames = (UnsignedInt)(seconds * static_cast<Real>(LOGICFRAMES_PER_SECOND));
 	oclFrames = MIN( oclFrames, data->m_oclMaxFrames );
 
 	ObjectCreationList::create( data->m_ocl, obj, obj, oclFrames );

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/HelicopterSlowDeathUpdate.cpp

@@ -326,7 +326,7 @@ UpdateSleepTime HelicopterSlowDeathBehavior::update( void )
 			{
 
 				// we're going towards the max self spin, increase it		
-				m_selfSpin += modData->m_selfSpinUpdateAmount / LOGICFRAMES_PER_SECOND;
+				m_selfSpin += modData->m_selfSpinUpdateAmount / static_cast<Real>(LOGICFRAMES_PER_SECOND);
 				if( m_selfSpin > modData->m_maxSelfSpin )
 				{
 
@@ -340,7 +340,7 @@ UpdateSleepTime HelicopterSlowDeathBehavior::update( void )
 			{
 
 				// we're going towards the min self spin, decrease it
-				m_selfSpin -= modData->m_selfSpinUpdateAmount / LOGICFRAMES_PER_SECOND;
+				m_selfSpin -= modData->m_selfSpinUpdateAmount / static_cast<Real>(LOGICFRAMES_PER_SECOND);
 				if( m_selfSpin < modData->m_minSelfSpin )
 				{
 

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/ParticleUplinkCannonUpdate.cpp

@@ -562,7 +562,7 @@ UpdateSleepTime ParticleUplinkCannonUpdate::update()
 				}
 
 				//Convert speed to speed per frame.
-				speed /= LOGICFRAMES_PER_SECOND;
+				speed /= static_cast<Real>(LOGICFRAMES_PER_SECOND);
 
 				//Calculate the distance from our current position to our target dest.
 				Coord3D vector = m_overrideTargetDestination;

GeneralsMD/Code/GameEngine/Source/GameLogic/Object/Update/PhysicsUpdate.cpp

@@ -1369,7 +1369,7 @@ void PhysicsBehavior::onCollide( Object *other, const Coord3D *loc, const Coord3
 			// huh huh, he said "stiff"
 
 			Real mag = getVelocityMagnitude();
-			const Real MINBOUNCESPEED = 1.0f/(LOGICFRAMES_PER_SECOND*5.0f);
+			const Real MINBOUNCESPEED = 1.0f/(static_cast<Real>(LOGICFRAMES_PER_SECOND)*5.0f);
 			if (mag < MINBOUNCESPEED) 
 				mag = MINBOUNCESPEED;
 			factor = -mag * getMass() * stiffness;