diff --git a/src/power.cpp b/src/power.cpp
@@ -132,26 +132,41 @@ void delPowerRequest(STRUCTURE *psStruct)
 
 static int64_t checkPrecisePowerRequest(STRUCTURE *psStruct)
 {
-	PlayerPower *p = &asPower[psStruct->player];
+	PlayerPower const *p = &asPower[psStruct->player];
 
 	int64_t requiredPower = 0;
 	for (size_t n = 0; n < p->powerQueue.size(); ++n)
 	{
 		requiredPower += p->powerQueue[n].amount;
 		if (p->powerQueue[n].id == psStruct->id)
 		{
-			p->powerQueue.erase(p->powerQueue.begin() + n);
-			return requiredPower;
+			if (requiredPower <= p->currentPower)
+			{
+				return -1;  // Have enough power.
+			}
+			return requiredPower - p->currentPower;
 		}
 	}
 
-	ASSERT(false, "Checking power for nonexistent power request.");
-	return 1000000*FP_ONE;
+	return -1;
 }
 
 int32_t checkPowerRequest(STRUCTURE *psStruct)
 {
-	return checkPrecisePowerRequest(psStruct) / FP_ONE;
+	int64_t power = checkPrecisePowerRequest(psStruct);
+	return power != -1? power / FP_ONE : -1;
+}
+
+static int64_t getQueuedPower(unsigned player)
+{
+	PlayerPower const *p = &asPower[player];
+
+	int64_t requiredPower = 0;
+	for (size_t n = 0; n < p->powerQueue.size(); ++n)
+	{
+		requiredPower += p->powerQueue[n].amount;
+	}
+	return requiredPower;
 }
 
 static void syncDebugEconomy(unsigned player, char ch)
@@ -320,7 +335,7 @@ int32_t getPower(unsigned player)
 {
 	ASSERT(player < MAX_PLAYERS, "Bad player (%u)", player);
 
-	return asPower[player].currentPower >> 32;
+	return asPower[player].currentPower / FP_ONE;
 }
 
 int64_t getPrecisePower(unsigned player)
@@ -330,6 +345,13 @@ int64_t getPrecisePower(unsigned player)
 	return asPower[player].currentPower;
 }
 
+int32_t getPowerMinusQueued(unsigned player)
+{
+	ASSERT(player < MAX_PLAYERS, "Bad player (%u)", player);
+
+	return (asPower[player].currentPower - getQueuedPower(player)) / FP_ONE;
+}
+
 bool requestPowerFor(STRUCTURE *psStruct, int32_t amount)
 {
 	return requestPrecisePowerFor(psStruct, amount*FP_ONE);

diff --git a/src/power.h b/src/power.h
@@ -37,6 +37,7 @@ extern void clearPlayerPower(void);
 void delPowerRequest(STRUCTURE *psStruct);
 
 /// Checks how much power must be accumulated, before the power request from this structure can be satisfied.
+/// Returns -1 if there is no power request or if there is enough power already.
 int32_t checkPowerRequest(STRUCTURE *psStruct);
 
 /** Reset the power levels when a power_gen or resource_extractor is destroyed. */
@@ -62,6 +63,7 @@ void setPrecisePower(unsigned player, int64_t power);
 /** Get the amount of power current held by the given player. */
 int32_t getPower(unsigned player);
 int64_t getPrecisePower(unsigned player);
+int32_t getPowerMinusQueued(unsigned player);
 
 /** Resets the power levels for all players when power is turned back on. */
 void powerCalc(bool on);