Generation code refactoring: split off pickupXxx() from generateXxx(), make generateXxx() return the count and take non-pointer

git-svn-id: svn://svn.code.sf.net/p/sc2/code/trunk@3587 8092fc87-c524-0410-9efc-e669fe64eaf9

sc2/src/uqm/planets/generate.h

@@ -57,12 +57,22 @@ typedef bool (*GenerateOrbitalFunction)(SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
 typedef bool (*GenerateNameFunction)(SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-typedef bool (*GenerateMineralsFunction)(SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-typedef bool (*GenerateEnergyFunction)(SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-typedef bool (*GenerateLifeFunction)(SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+// The following functions return the number of objects being generated
+// (or the index of the current object in some cases)
+typedef COUNT (*GenerateMineralsFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+typedef COUNT (*GenerateEnergyFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+typedef COUNT (*GenerateLifeFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+// The following functions return true if the node should be removed
+// from the surface, i.e. picked up.
+typedef bool (*PickupMineralsFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+typedef bool (*PickupEnergyFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+typedef bool (*PickupLifeFunction)(SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 struct GenerateFunctions {
@@ -86,6 +96,9 @@ struct GenerateFunctions {
 			// Energy sources on the planet surface.
 	GenerateLifeFunction generateLife;
 			// Bio on the planet surface.
+	PickupMineralsFunction pickupMinerals;
+	PickupEnergyFunction pickupEnergy;
+	PickupLifeFunction pickupLife;
 };
 
 

sc2/src/uqm/planets/generate/genand.c

@@ -30,8 +30,10 @@
 static bool GenerateAndrosynth_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateAndrosynth_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateAndrosynth_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateAndrosynth_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateAndrosynth_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateAndrosynthFunctions = {
@@ -45,6 +47,9 @@ const GenerateFunctions generateAndrosynthFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateAndrosynth_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateAndrosynth_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -121,34 +126,39 @@ GenerateAndrosynth_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world
 }
 
 static bool
-onRuinPickedUp (SOLARSYS_STATE *solarSys, COUNT whichNode)
-{
-	PLANET_INFO *planetInfo = &solarSys->SysInfo.PlanetInfo;
-
-	// Ruins previously visited are marked in the upper 16 bits
-	if (isNodeRetrieved (planetInfo, ENERGY_SCAN, whichNode + 16))
-		return false; // already visited this ruin before, no report
-
-	setNodeRetrieved (planetInfo, ENERGY_SCAN, whichNode + 16);
-	// We set the retrieved bit manually here and need to indicate
-	// the change to the solar system state functions
-	SET_GAME_STATE (PLANETARY_CHANGE, 1);
-
-	return true; // give whatever report is next
-}
-
-static bool
-GenerateAndrosynth_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GenerateAndrosynth_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 1, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, onRuinPickedUp);
-		return true;
+		PLANET_INFO *planetInfo = &solarSys->SysInfo.PlanetInfo;
+
+		// Ruins previously visited are marked in the upper 16 bits
+		if (isNodeRetrieved (planetInfo, ENERGY_SCAN, whichNode + 16))
+			return false; // already visited this ruin, do not remove
+
+		setNodeRetrieved (planetInfo, ENERGY_SCAN, whichNode + 16);
+		// We set the retrieved bit manually here and need to indicate
+		// the change to the solar system state functions
+		SET_GAME_STATE (PLANETARY_CHANGE, 1);
+
+		// Androsynth ruins have several lander reports which form a story
+		GenerateDefault_landerReportCycle (solarSys);
+
+		return false; // do not remove the node from the surface
 	}
 
-	*whichNode = 0;
-	return true;
+	return false;
 }
 
+static COUNT
+GenerateAndrosynth_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 1, MATCH_PLANET))
+	{
+		return GenerateDefault_generateRuins (solarSys, whichNode);
+	}
+
+	return 0;
+}

sc2/src/uqm/planets/generate/genburv.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../globdata.h"
 #include "../../nameref.h"
 #include "../../resinst.h"
@@ -31,8 +30,10 @@ static bool GenerateBurvixese_generateMoons (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *planet);
 static bool GenerateBurvixese_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateBurvixese_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateBurvixese_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateBurvixese_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateBurvixeseFunctions = {
@@ -46,6 +47,9 @@ const GenerateFunctions generateBurvixeseFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateBurvixese_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateBurvixese_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -136,40 +140,54 @@ GenerateBurvixese_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateBurvixese_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
 	if (matchWorld (solarSys, world, 0, 0))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (BURVIXESE_BROADCASTERS))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 		
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (BURVIXESE_BROADCASTERS, 1);
-			SET_GAME_STATE (BURV_BROADCASTERS_ON_SHIP, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateBurvixese_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	if (matchWorld (solarSys, world, 0, 0))
+	{
+		assert (!GET_GAME_STATE (BURVIXESE_BROADCASTERS) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (BURVIXESE_BROADCASTERS, 1);
+		SET_GAME_STATE (BURV_BROADCASTERS_ON_SHIP, 1);
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genchmmr.c

@@ -46,6 +46,9 @@ const GenerateFunctions generateChmmrFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/gencol.c

@@ -42,6 +42,9 @@ const GenerateFunctions generateColonyFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/gendefault.c

@@ -16,7 +16,6 @@
 
 #include "genall.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../lander.h"
 #include "../../encount.h"
 #include "../../gamestr.h"
@@ -38,12 +37,6 @@ bool GenerateDefault_generateName (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
 bool GenerateDefault_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-bool GenerateDefault_generateMinerals (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-bool GenerateDefault_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-bool GenerateDefault_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
 
 static void GeneratePlanets (SOLARSYS_STATE *system);
 static void check_yehat_rebellion (void);
@@ -60,6 +53,9 @@ const GenerateFunctions generateDefaultFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -166,74 +162,84 @@ GenerateDefault_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-bool
+COUNT
 GenerateDefault_generateMinerals (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode)
+		PLANET_DESC *world, COUNT whichNode)
 {
-	GenerateMineralDeposits (&solarSys->SysInfo, whichNode);
+	GenerateMineralDeposits (&solarSys->SysInfo, &whichNode);
 	(void) world;
-	return true;
+	return whichNode;
 }
 
 bool
-GenerateDefault_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GenerateDefault_pickupMinerals (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
-	*whichNode = 0;
+	// Minerals do not need any extra handling as of now
 	(void) solarSys;
 	(void) world;
+	(void) whichNode;
 	return true;
 }
 
-bool
-GenerateDefault_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+COUNT
+GenerateDefault_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
-	GenerateLifeForms (&solarSys->SysInfo, whichNode);
+	(void) whichNode;
+	(void) solarSys;
 	(void) world;
-	return true;
+	return 0;
 }
 
 bool
-GenerateDefault_generateArtifact (SOLARSYS_STATE *solarSys, COUNT *whichNode)
+GenerateDefault_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	// This should never be called since every energy node needs
+	// special handling and the function should be overridden
+	assert (false);
+	(void) solarSys;
+	(void) world;
+	(void) whichNode;
+	return false;
+}
+
+COUNT
+GenerateDefault_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	GenerateLifeForms (&solarSys->SysInfo, &whichNode);
+	(void) world;
+	return whichNode;
+}
+
+bool
+GenerateDefault_pickupLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	// Bio does not need any extra handling as of now
+	(void) solarSys;
+	(void) world;
+	(void) whichNode;
+	return true;
+}
+
+COUNT
+GenerateDefault_generateArtifact (SOLARSYS_STATE *solarSys, COUNT whichNode)
 {
 	// Generate an energy node at a random location
-	GenerateRandomNodes (&solarSys->SysInfo, ENERGY_SCAN, 1, 0, whichNode);
-	return true;
+	GenerateRandomNodes (&solarSys->SysInfo, ENERGY_SCAN, 1, 0, &whichNode);
+	return whichNode;
 }
 
-bool
-GenerateDefault_generateRuins (SOLARSYS_STATE *solarSys, COUNT *whichNode)
+COUNT
+GenerateDefault_generateRuins (SOLARSYS_STATE *solarSys, COUNT whichNode)
 {
 	// Generate a standard spread of city ruins of a destroyed civilization
 	GenerateRandomNodes (&solarSys->SysInfo, ENERGY_SCAN, NUM_RACE_RUINS,
-			0, whichNode);
-	return true;
-}
-
-bool
-GenerateDefault_pickupRuins (SOLARSYS_STATE *solarSys,
-		PickupRuinCallback callback)
-{
-	PLANET_INFO *planetInfo = &solarSys->SysInfo.PlanetInfo;
-	COUNT i;
-
-	for (i = 0; i < NUM_RACE_RUINS; ++i)
-	{
-		if (!isNodeRetrieved (planetInfo, ENERGY_SCAN, i))
-			continue;
-
-		// Retrieval status is cleared to keep the node on the map
-		setNodeNotRetrieved (planetInfo, ENERGY_SCAN, i);
-
-		if (callback && !callback (solarSys, i))
-			continue; // no lander report wanted
-
-		// Some ruins have more than one lander report, like when
-		// you fish artifacts out of the ruins.
-		GenerateDefault_landerReportCycle (solarSys);
-	}
-	return true;
+			0, &whichNode);
+	return whichNode;
 }
 
 static inline void

sc2/src/uqm/planets/generate/gendefault.h

@@ -31,20 +31,21 @@ bool GenerateDefault_generateName (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
 bool GenerateDefault_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-bool GenerateDefault_generateMinerals (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-bool GenerateDefault_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-bool GenerateDefault_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-
-// Ruin callback returns 'true' if a lander report should be given
-typedef bool (*PickupRuinCallback)(SOLARSYS_STATE *solarSys,
+COUNT GenerateDefault_generateMinerals (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+COUNT GenerateDefault_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+COUNT GenerateDefault_generateLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+bool GenerateDefault_pickupMinerals (SOLARSYS_STATE *, PLANET_DESC *world,
+		COUNT whichNode);
+bool GenerateDefault_pickupEnergy (SOLARSYS_STATE *, PLANET_DESC *world,
+		COUNT whichNode);
+bool GenerateDefault_pickupLife (SOLARSYS_STATE *, PLANET_DESC *world,
 		COUNT whichNode);
 
-bool GenerateDefault_generateArtifact (SOLARSYS_STATE *, COUNT *whichNode);
-bool GenerateDefault_generateRuins (SOLARSYS_STATE *, COUNT *whichNode);
-bool GenerateDefault_pickupRuins (SOLARSYS_STATE *, PickupRuinCallback);
+COUNT GenerateDefault_generateArtifact (SOLARSYS_STATE *, COUNT whichNode);
+COUNT GenerateDefault_generateRuins (SOLARSYS_STATE *, COUNT whichNode);
 bool GenerateDefault_landerReport (SOLARSYS_STATE *);
 bool GenerateDefault_landerReportCycle (SOLARSYS_STATE *);
 

sc2/src/uqm/planets/generate/gendru.c

@@ -33,8 +33,10 @@
 static bool GenerateDruuge_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateDruuge_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateDruuge_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateDruuge_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateDruuge_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateDruugeFunctions = {
@@ -48,6 +50,9 @@ const GenerateFunctions generateDruugeFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDruuge_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDruuge_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -127,34 +132,38 @@ GenerateDruuge_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 }
 
 static bool
-onRuinPickedUp (SOLARSYS_STATE *solarSys, COUNT whichNode)
-{
-	if (!GET_GAME_STATE (ROSY_SPHERE))
-	{	// Just picked up the Rosy Sphere from a ruin
-		SetLanderTakeoff ();
-
-		SET_GAME_STATE (ROSY_SPHERE, 1);
-		SET_GAME_STATE (ROSY_SPHERE_ON_SHIP, 1);
-	}
-
-	(void) solarSys;
-	(void) whichNode;
-
-	return true; // give whatever report is next
-}
-
-static bool
-GenerateDruuge_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GenerateDruuge_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, onRuinPickedUp);
-		return true;
+		GenerateDefault_landerReportCycle (solarSys);
+
+		// The artifact can be picked up from any ruin
+		if (!GET_GAME_STATE (ROSY_SPHERE))
+		{	// Just picked up the Rosy Sphere from a ruin
+			SetLanderTakeoff ();
+
+			SET_GAME_STATE (ROSY_SPHERE, 1);
+			SET_GAME_STATE (ROSY_SPHERE_ON_SHIP, 1);
+		}
+
+		return false; // do not remove the node
 	}
 
-	*whichNode = 0;
-	return true;
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
+GenerateDruuge_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		return GenerateDefault_generateRuins (solarSys, whichNode);
+	}
+
+	return 0;
 }
 

sc2/src/uqm/planets/generate/genilw.c

@@ -30,8 +30,10 @@
 static bool GenerateIlwrath_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateIlwrath_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateIlwrath_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateIlwrath_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateIlwrath_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateIlwrathFunctions = {
@@ -45,6 +47,9 @@ const GenerateFunctions generateIlwrathFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateIlwrath_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateIlwrath_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -117,19 +122,29 @@ GenerateIlwrath_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateIlwrath_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-
-	return true;
+	return 0;
 }
 
+static bool
+GenerateIlwrath_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genmel.c

@@ -42,6 +42,9 @@ const GenerateFunctions generateMelnormeFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/genmyc.c

@@ -34,10 +34,12 @@
 static bool GenerateMycon_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateMycon_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateMycon_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-static bool GenerateMycon_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateMycon_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static COUNT GenerateMycon_generateLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateMycon_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateMyconFunctions = {
@@ -51,6 +53,9 @@ const GenerateFunctions generateMyconFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateMycon_generateEnergy,
 	/* .generateLife     = */ GenerateMycon_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateMycon_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -182,32 +187,21 @@ GenerateMycon_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateMycon_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == SUN_DEVICE_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (SUN_DEVICE))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (SUN_DEVICE, 1);
-			SET_GAME_STATE (SUN_DEVICE_ON_SHIP, 1);
-			SET_GAME_STATE (MYCON_VISITS, 0);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
 	if ((CurStarDescPtr->Index == EGG_CASE0_DEFINED
@@ -215,50 +209,77 @@ GenerateMycon_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 			|| CurStarDescPtr->Index == EGG_CASE2_DEFINED)
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		// XXX: DiscoveryString is set by generateOrbital() only when the
 		//   node has not been picked up yet
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0)
-				&& !solarSys->SysInfo.PlanetInfo.DiscoveryString)
+		if (!solarSys->SysInfo.PlanetInfo.DiscoveryString)
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-		
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			switch (CurStarDescPtr->Index)
-			{
-				case EGG_CASE0_DEFINED:
-					SET_GAME_STATE (EGG_CASE0_ON_SHIP, 1);
-					break;
-				case EGG_CASE1_DEFINED:
-					SET_GAME_STATE (EGG_CASE1_ON_SHIP, 1);
-					break;
-				case EGG_CASE2_DEFINED:
-					SET_GAME_STATE (EGG_CASE2_ON_SHIP, 1);
-					break;
-			}
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
 static bool
-GenerateMycon_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GenerateMycon_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
-	*whichNode = 0;
+	if (CurStarDescPtr->Index == SUN_DEVICE_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		assert (!GET_GAME_STATE (SUN_DEVICE) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (SUN_DEVICE, 1);
+		SET_GAME_STATE (SUN_DEVICE_ON_SHIP, 1);
+		SET_GAME_STATE (MYCON_VISITS, 0);
+
+		return true; // picked up
+	}
+
+	if ((CurStarDescPtr->Index == EGG_CASE0_DEFINED
+			|| CurStarDescPtr->Index == EGG_CASE1_DEFINED
+			|| CurStarDescPtr->Index == EGG_CASE2_DEFINED)
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		assert (whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		switch (CurStarDescPtr->Index)
+		{
+			case EGG_CASE0_DEFINED:
+				SET_GAME_STATE (EGG_CASE0_ON_SHIP, 1);
+				break;
+			case EGG_CASE1_DEFINED:
+				SET_GAME_STATE (EGG_CASE1_ON_SHIP, 1);
+				break;
+			case EGG_CASE2_DEFINED:
+				SET_GAME_STATE (EGG_CASE2_ON_SHIP, 1);
+				break;
+		}
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
+GenerateMycon_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	(void) whichNode;
 	(void) solarSys;
 	(void) world;
-	return true;
+	return 0;
 }
 

sc2/src/uqm/planets/generate/genorz.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../build.h"
 #include "../../comm.h"
 #include "../../encount.h"
@@ -34,8 +33,10 @@
 static bool GenerateOrz_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateOrz_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateOrz_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateOrz_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateOrz_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateOrzFunctions = {
@@ -49,6 +50,9 @@ const GenerateFunctions generateOrzFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateOrz_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateOrz_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -162,42 +166,58 @@ GenerateOrz_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateOrz_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == TAALO_PROTECTOR_DEFINED
 			&& matchWorld (solarSys, world, 1, 2))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (TAALO_PROTECTOR))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (TAALO_PROTECTOR, 1);
-			SET_GAME_STATE (TAALO_PROTECTOR_ON_SHIP, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
 	if (CurStarDescPtr->Index == ORZ_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateOrz_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (CurStarDescPtr->Index == TAALO_PROTECTOR_DEFINED
+			&& matchWorld (solarSys, world, 1, 2))
+	{
+		assert (!GET_GAME_STATE (TAALO_PROTECTOR) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (TAALO_PROTECTOR, 1);
+		SET_GAME_STATE (TAALO_PROTECTOR_ON_SHIP, 1);
+
+		return true; // picked up
+	}
+
+	if (CurStarDescPtr->Index == ORZ_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genpet.c

@@ -32,8 +32,10 @@
 static bool GenerateTalkingPet_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateTalkingPet_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateTalkingPet_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateTalkingPet_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateTalkingPet_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 static void ZapToUrquanEncounter (void);
 
@@ -49,6 +51,9 @@ const GenerateFunctions generateTalkingPetFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateTalkingPet_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateTalkingPet_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -154,19 +159,31 @@ GenerateTalkingPet_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world
 	return true;
 }
 
-static bool
+static COUNT
 GenerateTalkingPet_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
+}
+
+static bool
+GenerateTalkingPet_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
 }
 
 static void

sc2/src/uqm/planets/generate/genpku.c

@@ -31,8 +31,10 @@
 static bool GeneratePkunk_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GeneratePkunk_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GeneratePkunk_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GeneratePkunk_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GeneratePkunk_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generatePkunkFunctions = {
@@ -46,6 +48,9 @@ const GenerateFunctions generatePkunkFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GeneratePkunk_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GeneratePkunk_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -117,34 +122,38 @@ GeneratePkunk_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 }
 
 static bool
-onRuinPickedUp (SOLARSYS_STATE *solarSys, COUNT whichNode)
-{
-	if (!GET_GAME_STATE (CLEAR_SPINDLE))
-	{	// Just picked up the Clear Spindle from a ruin
-		SetLanderTakeoff ();
-
-		SET_GAME_STATE (CLEAR_SPINDLE, 1);
-		SET_GAME_STATE (CLEAR_SPINDLE_ON_SHIP, 1);
-	}
-
-	(void) solarSys;
-	(void) whichNode;
-
-	return true; // give whatever report is next
-}
-
-static bool
-GeneratePkunk_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GeneratePkunk_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, onRuinPickedUp);
-		return true;
+		GenerateDefault_landerReportCycle (solarSys);
+
+		// The artifact can be picked up from any ruin
+		if (!GET_GAME_STATE (CLEAR_SPINDLE))
+		{	// Just picked up the Clear Spindle from a ruin
+			SetLanderTakeoff ();
+
+			SET_GAME_STATE (CLEAR_SPINDLE, 1);
+			SET_GAME_STATE (CLEAR_SPINDLE_ON_SHIP, 1);
+		}
+
+		return false; // do not remove the node
 	}
 
-	*whichNode = 0;
-	return true;
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
+GeneratePkunk_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		return GenerateDefault_generateRuins (solarSys, whichNode);
+	}
+
+	return 0;
 }
 

sc2/src/uqm/planets/generate/genrain.c

@@ -39,6 +39,9 @@ const GenerateFunctions generateRainbowWorldFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/gensam.c

@@ -49,6 +49,9 @@ const GenerateFunctions generateSaMatraFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/genshof.c

@@ -43,6 +43,9 @@ const GenerateFunctions generateShofixtiFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/gensly.c

@@ -37,6 +37,9 @@ const GenerateFunctions generateSlylandroFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/gensol.c

@@ -20,7 +20,6 @@
 #include "../lander.h"
 #include "../lifeform.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../build.h"
 #include "../../encount.h"
 #include "../../globdata.h"
@@ -40,10 +39,12 @@ static bool GenerateSol_generateName (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
 static bool GenerateSol_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateSol_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-static bool GenerateSol_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateSol_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static COUNT GenerateSol_generateLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateSol_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 static int init_probe (void);
 static void check_probe (void);
@@ -60,6 +61,9 @@ const GenerateFunctions generateSolFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateSol_generateEnergy,
 	/* .generateLife     = */ GenerateSol_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateSol_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -509,88 +513,100 @@ GenerateSol_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateSol_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 8, MATCH_PLANET))
 	{
 		/* Pluto */
+		// This check is needed because the retrieval bit is not set for
+		// this node to keep it on the surface while the lander is taking off
 		if (GET_GAME_STATE (FOUND_PLUTO_SPATHI))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
 		solarSys->SysInfo.PlanetInfo.CurPt.x = 20;
 		solarSys->SysInfo.PlanetInfo.CurPt.y = MAP_HEIGHT - 8;
 
-		*whichNode = 1; // only matters when count is requested
-		
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{	// Ran into Fwiffo on Pluto
-			// Retrieval status is cleared to keep the node on the map
-			// while the lander is taking off. FOUND_PLUTO_SPATHI bit
-			// will keep the node from showing up on subsequent visits.
-			setNodeNotRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0);
-
-			#define FWIFFO_FRAGS  8
-			if (!KillLanderCrewSeq (FWIFFO_FRAGS, ONE_SECOND / 20))
-				return true; // lander probably died
-
-			SET_GAME_STATE (FOUND_PLUTO_SPATHI, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return 1; // only matters when count is requested
 	}
 	
 	if (matchWorld (solarSys, world, 2, 1))
 	{
 		/* Earth Moon */
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (MOONBASE_DESTROYED))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
 		solarSys->SysInfo.PlanetInfo.CurPt.x = MAP_WIDTH * 3 / 4;
 		solarSys->SysInfo.PlanetInfo.CurPt.y = MAP_HEIGHT * 1 / 4;
 
-		*whichNode = 1; // only matters when count is requested
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (MOONBASE_DESTROYED, 1);
-			SET_GAME_STATE (MOONBASE_ON_SHIP, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return 1; // only matters when count is requested
 	}
 
-	*whichNode = 0;
-	return true;
+	(void) whichNode;
+	return 0;
 }
 
 static bool
+GenerateSol_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 8, MATCH_PLANET))
+	{	// Pluto
+		assert (!GET_GAME_STATE (FOUND_PLUTO_SPATHI) && whichNode == 0);
+	
+		// Ran into Fwiffo on Pluto
+		#define FWIFFO_FRAGS  8
+		if (!KillLanderCrewSeq (FWIFFO_FRAGS, ONE_SECOND / 20))
+			return false; // lander probably died
+
+		SET_GAME_STATE (FOUND_PLUTO_SPATHI, 1);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		// Do not remove the node from the surface while the lander is
+		// taking off. FOUND_PLUTO_SPATHI bit will keep the node from
+		// showing up on subsequent visits.
+		return false;
+	}
+	
+	if (matchWorld (solarSys, world, 2, 1))
+	{	// Earth Moon
+		assert (!GET_GAME_STATE (MOONBASE_DESTROYED) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (MOONBASE_DESTROYED, 1);
+		SET_GAME_STATE (MOONBASE_ON_SHIP, 1);
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
 GenerateSol_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 2, 1))
 	{
 		/* Earth Moon */
 		GenerateRandomNodes (&solarSys->SysInfo, BIOLOGICAL_SCAN, 10,
-				NUM_CREATURE_TYPES + 1, whichNode);
-		return true;
+				NUM_CREATURE_TYPES + 1, &whichNode);
+		return whichNode;
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
 

sc2/src/uqm/planets/generate/genspa.c

@@ -35,10 +35,14 @@ static bool GenerateSpathi_generateMoons (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *planet);
 static bool GenerateSpathi_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateSpathi_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-static bool GenerateSpathi_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateSpathi_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static COUNT GenerateSpathi_generateLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateSpathi_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateSpathi_pickupLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateSpathiFunctions = {
@@ -52,6 +56,9 @@ const GenerateFunctions generateSpathiFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateSpathi_generateEnergy,
 	/* .generateLife     = */ GenerateSpathi_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateSpathi_pickupEnergy,
+	/* .pickupLife       = */ GenerateSpathi_pickupLife,
 };
 
 
@@ -191,64 +198,79 @@ GenerateSpathi_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateSpathi_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, 0))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (UMGAH_BROADCASTERS))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (UMGAH_BROADCASTERS, 1);
-			SET_GAME_STATE (UMGAH_BROADCASTERS_ON_SHIP, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
 static bool
+GenerateSpathi_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, 0))
+	{
+		assert (!GET_GAME_STATE (UMGAH_BROADCASTERS) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (UMGAH_BROADCASTERS, 1);
+		SET_GAME_STATE (UMGAH_BROADCASTERS_ON_SHIP, 1);
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
 GenerateSpathi_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		if (GET_GAME_STATE (SPATHI_CREATURES_ELIMINATED)
-				|| GET_GAME_STATE (SPATHI_SHIELDED_SELVES))
-		{	// no creatures left
-			*whichNode = 0;
-			return true;
-		}
-
-		GenerateRandomNodes (&solarSys->SysInfo, BIOLOGICAL_SCAN, 32,
-				NUM_CREATURE_TYPES, whichNode);
-
-		if (solarSys->SysInfo.PlanetInfo.ScanRetrieveMask[BIOLOGICAL_SCAN])
-		{
-			SET_GAME_STATE (SPATHI_CREATURES_EXAMINED, 1);
-			if (solarSys->SysInfo.
-					PlanetInfo.ScanRetrieveMask[BIOLOGICAL_SCAN] == 0xFFFFFFFF)
-				SET_GAME_STATE (SPATHI_CREATURES_ELIMINATED, 1);
-		}
-
-		return true;
+		#define NUM_EVIL_ONES  32
+		GenerateRandomNodes (&solarSys->SysInfo, BIOLOGICAL_SCAN, NUM_EVIL_ONES,
+				NUM_CREATURE_TYPES, &whichNode);
+		return whichNode;
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateSpathi_pickupLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		assert (!GET_GAME_STATE (SPATHI_CREATURES_ELIMINATED) &&
+				!GET_GAME_STATE (SPATHI_SHIELDED_SELVES));
+
+		SET_GAME_STATE (SPATHI_CREATURES_EXAMINED, 1);
+		if (countNodesRetrieved (&solarSys->SysInfo.PlanetInfo, BIOLOGICAL_SCAN)
+				+ 1 == NUM_EVIL_ONES)
+		{	// last creature picked up
+			SET_GAME_STATE (SPATHI_CREATURES_ELIMINATED, 1);
+		}
+
+		return true; // picked up
+	}
+
+	return GenerateDefault_pickupLife (solarSys, world, whichNode);
+}

sc2/src/uqm/planets/generate/gensup.c

@@ -31,8 +31,10 @@
 static bool GenerateSupox_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateSupox_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateSupox_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateSupox_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateSupox_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateSupoxFunctions = {
@@ -46,6 +48,9 @@ const GenerateFunctions generateSupoxFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateSupox_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateSupox_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -118,33 +123,37 @@ GenerateSupox_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 }
 
 static bool
-onRuinPickedUp (SOLARSYS_STATE *solarSys, COUNT whichNode)
-{
-	if (!GET_GAME_STATE (ULTRON_CONDITION))
-	{	// Just picked up the Ultron from a ruin
-		SetLanderTakeoff ();
-
-		SET_GAME_STATE (ULTRON_CONDITION, 1);
-	}
-
-	(void) solarSys;
-	(void) whichNode;
-
-	return true; // give whatever report is next
-}
-
-static bool
-GenerateSupox_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+GenerateSupox_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, onRuinPickedUp);
-		return true;
+		GenerateDefault_landerReportCycle (solarSys);
+
+		// The artifact can be picked up from any ruin
+		if (!GET_GAME_STATE (ULTRON_CONDITION))
+		{	// Just picked up the Ultron from a ruin
+			SetLanderTakeoff ();
+
+			SET_GAME_STATE (ULTRON_CONDITION, 1);
+		}
+
+		return false; // do not remove the node
 	}
 
-	*whichNode = 0;
-	return true;
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
+GenerateSupox_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		return GenerateDefault_generateRuins (solarSys, whichNode);
+	}
+
+	return 0;
 }
 

sc2/src/uqm/planets/generate/gensyr.c

@@ -38,6 +38,9 @@ const GenerateFunctions generateSyreenFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/genthrad.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../build.h"
 #include "../../comm.h"
 #include "../../encount.h"
@@ -34,8 +33,10 @@
 static bool GenerateThraddash_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateThraddash_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateThraddash_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateThraddash_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateThraddash_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateThraddashFunctions = {
@@ -49,6 +50,9 @@ const GenerateFunctions generateThraddashFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateThraddash_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateThraddash_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -155,44 +159,60 @@ GenerateThraddash_generateOrbital (SOLARSYS_STATE *solarSys,
 	return true;
 }
 
-static bool
+static COUNT
 GenerateThraddash_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode)
+		PLANET_DESC *world, COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == THRADD_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
 	if (CurStarDescPtr->Index == AQUA_HELIX_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (AQUA_HELIX))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (HELIX_VISITS, 0);
-			SET_GAME_STATE (AQUA_HELIX, 1);
-			SET_GAME_STATE (AQUA_HELIX_ON_SHIP, 1);
-			SET_GAME_STATE (HELIX_UNPROTECTED, 1);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateThraddash_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (CurStarDescPtr->Index == THRADD_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	if (CurStarDescPtr->Index == AQUA_HELIX_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		assert (!GET_GAME_STATE (AQUA_HELIX) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (HELIX_VISITS, 0);
+		SET_GAME_STATE (AQUA_HELIX, 1);
+		SET_GAME_STATE (AQUA_HELIX_ON_SHIP, 1);
+		SET_GAME_STATE (HELIX_UNPROTECTED, 1);
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/gentrap.c

@@ -36,6 +36,9 @@ const GenerateFunctions generateTrapFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/genutw.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../build.h"
 #include "../../comm.h"
 #include "../../encount.h"
@@ -35,8 +34,10 @@ static bool GenerateUtwig_initNpcs (SOLARSYS_STATE *solarSys);
 static bool GenerateUtwig_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateUtwig_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateUtwig_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateUtwig_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateUtwig_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateUtwigFunctions = {
@@ -50,6 +51,9 @@ const GenerateFunctions generateUtwigFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateUtwig_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateUtwig_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -206,45 +210,61 @@ GenerateUtwig_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateUtwig_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == UTWIG_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
 	if (CurStarDescPtr->Index == BOMB_DEFINED
 			&& matchWorld (solarSys, world, 5, 1))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (UTWIG_BOMB))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			SET_GAME_STATE (UTWIG_BOMB, 1);
-			SET_GAME_STATE (UTWIG_BOMB_ON_SHIP, 1);
-			SET_GAME_STATE (DRUUGE_MANNER, 1);
-			SET_GAME_STATE (DRUUGE_VISITS, 0);
-			SET_GAME_STATE (DRUUGE_HOME_VISITS, 0);
-
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateUtwig_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (CurStarDescPtr->Index == UTWIG_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	if (CurStarDescPtr->Index == BOMB_DEFINED
+			&& matchWorld (solarSys, world, 5, 1))
+	{
+		assert (!GET_GAME_STATE (UTWIG_BOMB) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (UTWIG_BOMB, 1);
+		SET_GAME_STATE (UTWIG_BOMB_ON_SHIP, 1);
+		SET_GAME_STATE (DRUUGE_MANNER, 1);
+		SET_GAME_STATE (DRUUGE_VISITS, 0);
+		SET_GAME_STATE (DRUUGE_HOME_VISITS, 0);
+
+		return true; // picked up
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genvault.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../globdata.h"
 #include "../../nameref.h"
 #include "../../resinst.h"
@@ -28,8 +27,10 @@
 
 static bool GenerateVault_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateVault_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateVault_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateVault_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateVaultFunctions = {
@@ -43,6 +44,9 @@ const GenerateFunctions generateVaultFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateVault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateVault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -74,50 +78,54 @@ GenerateVault_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateVault_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, 0))
 	{
-		PLANET_INFO *planetInfo = &solarSys->SysInfo.PlanetInfo;
-		
-		GenerateDefault_generateArtifact (solarSys, whichNode);
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
+	}
 
-		if (isNodeRetrieved (planetInfo, ENERGY_SCAN, 0))
+	return 0;
+}
+
+static bool
+GenerateVault_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, 0))
+	{
+		assert (whichNode == 0);
+
+		if (GET_GAME_STATE (SHIP_VAULT_UNLOCKED))
+		{	// Give the final report, "omg empty" and whatnot
+			GenerateDefault_landerReportCycle (solarSys);
+		}
+		else if (GET_GAME_STATE (SYREEN_SHUTTLE_ON_SHIP))
 		{
-			// Retrieval status is cleared to keep the node on the map
-			setNodeNotRetrieved (planetInfo, ENERGY_SCAN, 0);
+			GenerateDefault_landerReportCycle (solarSys);
+			SetLanderTakeoff ();
 
-			if (GET_GAME_STATE (SHIP_VAULT_UNLOCKED))
-			{	// Give the final report, "omg empty" and whatnot
-				GenerateDefault_landerReportCycle (solarSys);
-			}
-			else if (GET_GAME_STATE (SYREEN_SHUTTLE_ON_SHIP))
+			SET_GAME_STATE (SHIP_VAULT_UNLOCKED, 1);
+			SET_GAME_STATE (SYREEN_SHUTTLE_ON_SHIP, 0);
+			SET_GAME_STATE (SYREEN_HOME_VISITS, 0);
+		}
+		else
+		{
+			GenerateDefault_landerReport (solarSys);
+
+			if (!GET_GAME_STATE (KNOW_SYREEN_VAULT))
 			{
-				GenerateDefault_landerReportCycle (solarSys);
-				SetLanderTakeoff ();
-
-				SET_GAME_STATE (SHIP_VAULT_UNLOCKED, 1);
-				SET_GAME_STATE (SYREEN_SHUTTLE_ON_SHIP, 0);
+				SET_GAME_STATE (KNOW_SYREEN_VAULT, 1);
 				SET_GAME_STATE (SYREEN_HOME_VISITS, 0);
 			}
-			else
-			{
-				GenerateDefault_landerReport (solarSys);
-
-				if (!GET_GAME_STATE (KNOW_SYREEN_VAULT))
-				{
-					SET_GAME_STATE (KNOW_SYREEN_VAULT, 1);
-					SET_GAME_STATE (SYREEN_HOME_VISITS, 0);
-				}
-			}
 		}
 
-		return true;
+		// The Vault cannot be "picked up". It is always on the surface.
+		return false;
 	}
 
-	*whichNode = 0;
-	return true;
+	(void) whichNode;
+	return false;
 }
-

sc2/src/uqm/planets/generate/genvux.c

@@ -20,7 +20,6 @@
 #include "../lander.h"
 #include "../lifeform.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../build.h"
 #include "../../comm.h"
 #include "../../encount.h"
@@ -36,10 +35,14 @@
 static bool GenerateVux_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateVux_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateVux_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
-static bool GenerateVux_generateLife (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateVux_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static COUNT GenerateVux_generateLife (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateVux_pickupEnergy (SOLARSYS_STATE *, PLANET_DESC *world,
+		COUNT whichNode);
+static bool GenerateVux_pickupLife (SOLARSYS_STATE *, PLANET_DESC *world,
+		COUNT whichNode);
 
 
 const GenerateFunctions generateVuxFunctions = {
@@ -53,6 +56,9 @@ const GenerateFunctions generateVuxFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateVux_generateEnergy,
 	/* .generateLife     = */ GenerateVux_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateVux_pickupEnergy,
+	/* .pickupLife       = */ GenerateVux_pickupLife,
 };
 
 
@@ -203,51 +209,68 @@ GenerateVux_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateVux_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == MAIDENS_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
+		// This check is redundant since the retrieval bit will keep the
+		// node from showing up again
 		if (GET_GAME_STATE (SHOFIXTI_MAIDENS))
 		{	// already picked up
-			*whichNode = 0;
-			return true;
+			return 0;
 		}
 
 		solarSys->SysInfo.PlanetInfo.CurPt.x = MAP_WIDTH / 3;
 		solarSys->SysInfo.PlanetInfo.CurPt.y = MAP_HEIGHT * 5 / 8;
 		
-		*whichNode = 1; // only matters when count is requested
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			GenerateDefault_landerReport (solarSys);
-			SetLanderTakeoff ();
-
-			SET_GAME_STATE (SHOFIXTI_MAIDENS, 1);
-			SET_GAME_STATE (MAIDENS_ON_SHIP, 1);
-		}
-		
-		return true;
+		return 1; // only matters when count is requested
 	}
 
 	if (CurStarDescPtr->Index == VUX_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
 static bool
+GenerateVux_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (CurStarDescPtr->Index == MAIDENS_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		assert (!GET_GAME_STATE (SHOFIXTI_MAIDENS) && whichNode == 0);
+
+		GenerateDefault_landerReport (solarSys);
+		SetLanderTakeoff ();
+
+		SET_GAME_STATE (SHOFIXTI_MAIDENS, 1);
+		SET_GAME_STATE (MAIDENS_ON_SHIP, 1);
+		
+		return true; // picked up
+	}
+
+	if (CurStarDescPtr->Index == VUX_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}
+
+static COUNT
 GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (CurStarDescPtr->Index == MAIDENS_DEFINED
 			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
@@ -258,7 +281,7 @@ GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 		old_rand = TFB_SeedRandom (
 				solarSys->SysInfo.PlanetInfo.ScanSeed[BIOLOGICAL_SCAN]);
 
-		for (i = 0; i <= *whichNode && i < 12; ++i)
+		for (i = 0; i <= whichNode && i < 12; ++i)
 		{
 			GenerateRandomLocation (&solarSys->SysInfo);
 			if (i < 4)
@@ -269,10 +292,9 @@ GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 				solarSys->SysInfo.PlanetInfo.CurType = 18;
 		}
 		
-		*whichNode = 12; // only matters when count is requested
-
 		TFB_SeedRandom (old_rand);
-		return true;
+
+		return 12; // only matters when count is requested
 	}
 
 	if (CurStarDescPtr->Index == VUX_BEAST_DEFINED
@@ -284,7 +306,7 @@ GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 		old_rand = TFB_SeedRandom (
 				solarSys->SysInfo.PlanetInfo.ScanSeed[BIOLOGICAL_SCAN]);
 
-		for (i = 0; i <= *whichNode && i < 11; ++i)
+		for (i = 0; i <= whichNode && i < 11; ++i)
 		{
 			GenerateRandomLocation (&solarSys->SysInfo);
 			if (i == 0) /* VUX Beast */
@@ -297,11 +319,25 @@ GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 				solarSys->SysInfo.PlanetInfo.CurType = 8;
 		}
 		
-		*whichNode = 11; // only matters when count is requested
+		TFB_SeedRandom (old_rand);
 
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, BIOLOGICAL_SCAN, 0)
-				&& !GET_GAME_STATE (VUX_BEAST))
+		return  11; // only matters when count is requested
+	}
+
+	return GenerateDefault_generateLife (solarSys, world, whichNode);
+}
+
+static bool
+GenerateVux_pickupLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (CurStarDescPtr->Index == VUX_BEAST_DEFINED
+			&& matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		if (whichNode == 0)
 		{	// Picked up Zex' Beauty
+			assert (!GET_GAME_STATE (VUX_BEAST));
+
 			GenerateDefault_landerReport (solarSys);
 			SetLanderTakeoff ();
 
@@ -309,11 +345,8 @@ GenerateVux_generateLife (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 			SET_GAME_STATE (VUX_BEAST_ON_SHIP, 1);
 		}
 
-		TFB_SeedRandom (old_rand);
-		return true;
+		return true; // picked up
 	}
 
-	GenerateDefault_generateLife (solarSys, world, whichNode);
-	return true;
+	return GenerateDefault_pickupLife (solarSys, world, whichNode);
 }
-

sc2/src/uqm/planets/generate/genwreck.c

@@ -19,7 +19,6 @@
 #include "genall.h"
 #include "../lander.h"
 #include "../planets.h"
-#include "../scan.h"
 #include "../../globdata.h"
 #include "../../nameref.h"
 #include "../../resinst.h"
@@ -28,8 +27,10 @@
 
 static bool GenerateWreck_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateWreck_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateWreck_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateWreck_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateWreckFunctions = {
@@ -43,6 +44,9 @@ const GenerateFunctions generateWreckFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateWreck_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateWreck_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -68,34 +72,40 @@ GenerateWreck_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateWreck_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 6, MATCH_PLANET))
 	{
-		GenerateDefault_generateArtifact (solarSys, whichNode);
-
-		if (isNodeRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0))
-		{
-			// Retrieval status is cleared to keep the node on the map
-			setNodeNotRetrieved (&solarSys->SysInfo.PlanetInfo, ENERGY_SCAN, 0);
-
-			GenerateDefault_landerReportCycle (solarSys);
-
-			if (!GET_GAME_STATE (PORTAL_KEY))
-			{
-				SetLanderTakeoff ();
-
-				SET_GAME_STATE (PORTAL_KEY, 1);
-				SET_GAME_STATE (PORTAL_KEY_ON_SHIP, 1);
-			}
-		}
-
-		return true;
+		return GenerateDefault_generateArtifact (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateWreck_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 6, MATCH_PLANET))
+	{
+		assert (whichNode == 0);
+
+		GenerateDefault_landerReportCycle (solarSys);
+
+		if (!GET_GAME_STATE (PORTAL_KEY))
+		{
+			SetLanderTakeoff ();
+
+			SET_GAME_STATE (PORTAL_KEY, 1);
+			SET_GAME_STATE (PORTAL_KEY_ON_SHIP, 1);
+		}
+
+		// The Wreck cannot be "picked up". It is always on the surface.
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genyeh.c

@@ -30,8 +30,10 @@
 static bool GenerateYehat_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateYehat_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateYehat_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateYehat_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateYehat_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateYehatFunctions = {
@@ -45,6 +47,9 @@ const GenerateFunctions generateYehatFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateYehat_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateYehat_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -107,18 +112,29 @@ GenerateYehat_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateYehat_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateYehat_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/generate/genzfpscout.c

@@ -38,6 +38,9 @@ const GenerateFunctions generateZoqFotPikScoutFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateDefault_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateDefault_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 

sc2/src/uqm/planets/generate/genzoq.c

@@ -30,8 +30,10 @@ static bool GenerateZoqFotPik_initNpcs (SOLARSYS_STATE *solarSys);
 static bool GenerateZoqFotPik_generatePlanets (SOLARSYS_STATE *solarSys);
 static bool GenerateZoqFotPik_generateOrbital (SOLARSYS_STATE *solarSys,
 		PLANET_DESC *world);
-static bool GenerateZoqFotPik_generateEnergy (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *whichNode);
+static COUNT GenerateZoqFotPik_generateEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
+static bool GenerateZoqFotPik_pickupEnergy (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT whichNode);
 
 
 const GenerateFunctions generateZoqFotPikFunctions = {
@@ -45,6 +47,9 @@ const GenerateFunctions generateZoqFotPikFunctions = {
 	/* .generateMinerals = */ GenerateDefault_generateMinerals,
 	/* .generateEnergy   = */ GenerateZoqFotPik_generateEnergy,
 	/* .generateLife     = */ GenerateDefault_generateLife,
+	/* .pickupMinerals   = */ GenerateDefault_pickupMinerals,
+	/* .pickupEnergy     = */ GenerateZoqFotPik_pickupEnergy,
+	/* .pickupLife       = */ GenerateDefault_pickupLife,
 };
 
 
@@ -137,18 +142,29 @@ GenerateZoqFotPik_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
 	return true;
 }
 
-static bool
+static COUNT
 GenerateZoqFotPik_generateEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *whichNode)
+		COUNT whichNode)
 {
 	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
 	{
-		GenerateDefault_generateRuins (solarSys, whichNode);
-		GenerateDefault_pickupRuins (solarSys, NULL);
-		return true;
+		return GenerateDefault_generateRuins (solarSys, whichNode);
 	}
 
-	*whichNode = 0;
-	return true;
+	return 0;
 }
 
+static bool
+GenerateZoqFotPik_pickupEnergy (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT whichNode)
+{
+	if (matchWorld (solarSys, world, 0, MATCH_PLANET))
+	{
+		// Standard ruins report
+		GenerateDefault_landerReportCycle (solarSys);
+		return false;
+	}
+
+	(void) whichNode;
+	return false;
+}

sc2/src/uqm/planets/lander.c

@@ -718,7 +718,6 @@ CheckObjectCollision (COUNT index)
 			{
 				COUNT scan, NumRetrieved;
 				SIZE which_node;
-				COUNT allNodes;
 
 				scan = LOBYTE (ElementPtr->scan_node);
 				if (pLanderPrim == 0)
@@ -826,18 +825,11 @@ CheckObjectCollision (COUNT index)
 				}
 
 				which_node = HIBYTE (ElementPtr->scan_node) - 1;
-				setNodeRetrieved (&pSolarSysState->SysInfo.PlanetInfo, scan,
-						which_node);
-				allNodes = (COUNT)~0;
-				callGenerateForScanType (pSolarSysState,
-						pSolarSysState->pOrbitalDesc,
-						&allNodes, scan);
-
-				// Generation func above may reset the retrieved status bit
-				// to keep the node on the map
-				if (isNodeRetrieved (&pSolarSysState->SysInfo.PlanetInfo, scan,
-						which_node))
-				{
+				if (callPickupForScanType (pSolarSysState,
+						pSolarSysState->pOrbitalDesc, which_node, scan))
+				{	// Node retrieved, remove from the surface
+					setNodeRetrieved (&pSolarSysState->SysInfo.PlanetInfo,
+							scan, which_node);
 					SET_GAME_STATE (PLANETARY_CHANGE, 1);
 					ElementPtr->state_flags |= DISAPPEARING;
 				}

sc2/src/uqm/planets/scan.c

@@ -934,9 +934,9 @@ DrawScannedStuff (COUNT y, COUNT scan)
 	SetContextForeGroundColor (OldColor);
 }
 
-bool
+COUNT
 callGenerateForScanType (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
-		COUNT *node, BYTE scanType)
+		COUNT node, BYTE scanType)
 {
 	switch (scanType)
 	{
@@ -951,6 +951,27 @@ callGenerateForScanType (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
 					solarSys, world, node);
 	}
 
+	assert (false);
+	return 0;
+}
+
+bool
+callPickupForScanType (SOLARSYS_STATE *solarSys, PLANET_DESC *world,
+		COUNT node, BYTE scanType)
+{
+	switch (scanType)
+	{
+		case MINERAL_SCAN:
+			return (*solarSys->genFuncs->pickupMinerals) (
+					solarSys, world, node);
+		case ENERGY_SCAN:
+			return (*solarSys->genFuncs->pickupEnergy) (
+					solarSys, world, node);
+		case BIOLOGICAL_SCAN:
+			return (*solarSys->genFuncs->pickupLife) (
+					solarSys, world, node);
+	}
+
 	assert (false);
 	return false;
 }
@@ -1337,15 +1358,13 @@ GeneratePlanetSide (void)
 		f = SetAbsFrameIndex (MiscDataFrame,
 				NUM_SCANDOT_TRANSITIONS * (scan - ENERGY_SCAN));
 
-		num_nodes = (COUNT)~0;
-		callGenerateForScanType (pSolarSysState,
-				pSolarSysState->pOrbitalDesc, &num_nodes, scan);
+		num_nodes = callGenerateForScanType (pSolarSysState,
+				pSolarSysState->pOrbitalDesc, ~0, scan);
 
 		while (num_nodes--)
 		{
 			HELEMENT hNodeElement;
 			ELEMENT *NodeElementPtr;
-			COUNT whichNode;
 
 			if (isNodeRetrieved (&pSolarSysState->SysInfo.PlanetInfo,
 					scan, num_nodes))
@@ -1357,9 +1376,8 @@ GeneratePlanetSide (void)
 
 			LockElement (hNodeElement, &NodeElementPtr);
 
-			whichNode = num_nodes;
 			callGenerateForScanType (pSolarSysState,
-					pSolarSysState->pOrbitalDesc, &whichNode,
+					pSolarSysState->pOrbitalDesc, num_nodes,
 					scan);
 
 			NodeElementPtr->scan_node = MAKE_WORD (scan, num_nodes + 1);
@@ -1425,6 +1443,22 @@ isNodeRetrieved (PLANET_INFO *planetInfo, BYTE scanType, BYTE nodeNr)
 			!= 0;
 }
 
+COUNT
+countNodesRetrieved (PLANET_INFO *planetInfo, BYTE scanType)
+{
+	COUNT count;
+	DWORD mask = planetInfo->ScanRetrieveMask[scanType];
+
+	// count the number of bits set
+	// Caution: 'mask' must be unsigned
+	for (count = 0; mask != 0; mask >>= 1)
+	{
+		if (mask & 1)
+			++count;
+	}
+	return count;
+}
+
 void
 setNodeRetrieved (PLANET_INFO *planetInfo, BYTE scanType, BYTE nodeNr)
 {

sc2/src/uqm/planets/scan.h

@@ -47,14 +47,18 @@ extern void ScanSystem (void);
 
 extern void RepairBackRect (RECT *pRect);
 extern void GeneratePlanetSide (void);
-extern bool callGenerateForScanType (SOLARSYS_STATE *solarSys,
-		PLANET_DESC *world, COUNT *node, BYTE scanType);
+extern COUNT callGenerateForScanType (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT node, BYTE scanType);
+// Returns true if the node should be removed from the surface
+extern bool callPickupForScanType (SOLARSYS_STATE *solarSys,
+		PLANET_DESC *world, COUNT node, BYTE scanType);
 
 extern void RedrawSurfaceScan (const POINT *newLoc);
 extern CONTEXT GetScanContext (BOOLEAN *owner);
 extern void DestroyScanContext (void);
 
 bool isNodeRetrieved (PLANET_INFO *planetInfo, BYTE scanType, BYTE nodeNr);
+COUNT countNodesRetrieved (PLANET_INFO *planetInfo, BYTE scanType);
 void setNodeRetrieved (PLANET_INFO *planetInfo, BYTE scanType, BYTE nodeNr);
 void setNodeNotRetrieved (PLANET_INFO *planetInfo, BYTE scanType, BYTE nodeNr);
 

sc2/src/uqm/uqmdebug.c

@@ -1059,16 +1059,14 @@ calculateBioValue (const SOLARSYS_STATE *system, const PLANET_DESC *world)
 
 	assert (system->pOrbitalDesc == world);
 	
-	numBio = (COUNT)~0;
-	callGenerateForScanType ((SOLARSYS_STATE *) system, (PLANET_DESC *) world,
-			&numBio, BIOLOGICAL_SCAN);
+	numBio = callGenerateForScanType ((SOLARSYS_STATE *) system,
+			(PLANET_DESC *) world, ~0, BIOLOGICAL_SCAN);
 
 	result = 0;
 	for (i = 0; i < numBio; i++)
 	{
-		COUNT whichNode = i;
 		callGenerateForScanType ((SOLARSYS_STATE *) system,
-				(PLANET_DESC *) world, &whichNode, BIOLOGICAL_SCAN);
+				(PLANET_DESC *) world, i, BIOLOGICAL_SCAN);
 		result += BIO_CREDIT_VALUE * LONIBBLE (CreatureData[
 				system->SysInfo.PlanetInfo.CurType].ValueAndHitPoints);
 	}
@@ -1084,18 +1082,16 @@ generateBioIndex(const SOLARSYS_STATE *system, const PLANET_DESC *world,
 
 	assert (system->pOrbitalDesc == world);
 	
-	numBio = (COUNT)~0;
-	callGenerateForScanType ((SOLARSYS_STATE *) system, (PLANET_DESC *) world,
-			&numBio, BIOLOGICAL_SCAN);
+	numBio = callGenerateForScanType ((SOLARSYS_STATE *) system,
+			(PLANET_DESC *) world, ~0, BIOLOGICAL_SCAN);
 
 	for (i = 0; i < NUM_CREATURE_TYPES + NUM_SPECIAL_CREATURE_TYPES; i++)
 		bio[i] = 0;
 	
 	for (i = 0; i < numBio; i++)
 	{
-		COUNT whichNode = i;
 		callGenerateForScanType ((SOLARSYS_STATE *) system,
-				(PLANET_DESC *) world, &whichNode, BIOLOGICAL_SCAN);
+				(PLANET_DESC *) world, i, BIOLOGICAL_SCAN);
 		bio[system->SysInfo.PlanetInfo.CurType]++;
 	}
 }
@@ -1109,16 +1105,14 @@ calculateMineralValue (const SOLARSYS_STATE *system, const PLANET_DESC *world)
 
 	assert (system->pOrbitalDesc == world);
 	
-	numDeposits = (COUNT)~0;
-	callGenerateForScanType ((SOLARSYS_STATE *) system, (PLANET_DESC *) world,
-			&numDeposits, MINERAL_SCAN);
+	numDeposits = callGenerateForScanType ((SOLARSYS_STATE *) system,
+			(PLANET_DESC *) world, ~0, MINERAL_SCAN);
 
 	result = 0;
 	for (i = 0; i < numDeposits; i++)
 	{
-		COUNT whichNode = i;
 		callGenerateForScanType ((SOLARSYS_STATE *) system,
-				(PLANET_DESC *) world, &whichNode, MINERAL_SCAN);
+				(PLANET_DESC *) world, i, MINERAL_SCAN);
 		result += HIBYTE (system->SysInfo.PlanetInfo.CurDensity) *
 				GLOBAL (ElementWorth[ElementCategory (
 				system->SysInfo.PlanetInfo.CurType)]);
@@ -1135,18 +1129,16 @@ generateMineralIndex(const SOLARSYS_STATE *system, const PLANET_DESC *world,
 
 	assert (system->pOrbitalDesc == world);
 	
-	numDeposits = (COUNT)~0;
-	callGenerateForScanType ((SOLARSYS_STATE *) system, (PLANET_DESC *) world,
-			&numDeposits, MINERAL_SCAN);
+	numDeposits = callGenerateForScanType ((SOLARSYS_STATE *) system,
+			(PLANET_DESC *) world, ~0, MINERAL_SCAN);
 
 	for (i = 0; i < NUM_ELEMENT_CATEGORIES; i++)
 		minerals[i] = 0;
 	
 	for (i = 0; i < numDeposits; i++)
 	{
-		COUNT whichNode = i;
 		callGenerateForScanType ((SOLARSYS_STATE *) system,
-				(PLANET_DESC *) world, &whichNode, MINERAL_SCAN);
+				(PLANET_DESC *) world, i, MINERAL_SCAN);
 		minerals[ElementCategory(system->SysInfo.PlanetInfo.CurType)] +=
 				HIBYTE (system->SysInfo.PlanetInfo.CurDensity);
 	}