From 7d4dfaf48c1a4f06cdccebf7a1f6a45cc6a94fce Mon Sep 17 00:00:00 2001 From: avolkov Date: Tue, 26 Apr 2011 02:21:34 +0000 Subject: [PATCH] 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 | 25 +++- sc2/src/uqm/planets/generate/genand.c | 62 +++++----- sc2/src/uqm/planets/generate/genburv.c | 66 +++++++---- sc2/src/uqm/planets/generate/genchmmr.c | 3 + sc2/src/uqm/planets/generate/gencol.c | 3 + sc2/src/uqm/planets/generate/gendefault.c | 108 +++++++++--------- sc2/src/uqm/planets/generate/gendefault.h | 25 ++-- sc2/src/uqm/planets/generate/gendru.c | 61 +++++----- sc2/src/uqm/planets/generate/genilw.c | 35 ++++-- sc2/src/uqm/planets/generate/genmel.c | 3 + sc2/src/uqm/planets/generate/genmyc.c | 127 ++++++++++++--------- sc2/src/uqm/planets/generate/genorz.c | 68 +++++++---- sc2/src/uqm/planets/generate/genpet.c | 35 ++++-- sc2/src/uqm/planets/generate/genpku.c | 61 +++++----- sc2/src/uqm/planets/generate/genrain.c | 3 + sc2/src/uqm/planets/generate/gensam.c | 3 + sc2/src/uqm/planets/generate/genshof.c | 3 + sc2/src/uqm/planets/generate/gensly.c | 3 + sc2/src/uqm/planets/generate/gensol.c | 116 +++++++++++-------- sc2/src/uqm/planets/generate/genspa.c | 110 +++++++++++------- sc2/src/uqm/planets/generate/gensup.c | 59 ++++++---- sc2/src/uqm/planets/generate/gensyr.c | 3 + sc2/src/uqm/planets/generate/genthrad.c | 72 +++++++----- sc2/src/uqm/planets/generate/gentrap.c | 3 + sc2/src/uqm/planets/generate/genutw.c | 74 +++++++----- sc2/src/uqm/planets/generate/genvault.c | 78 +++++++------ sc2/src/uqm/planets/generate/genvux.c | 113 +++++++++++------- sc2/src/uqm/planets/generate/genwreck.c | 62 +++++----- sc2/src/uqm/planets/generate/genyeh.c | 34 ++++-- sc2/src/uqm/planets/generate/genzfpscout.c | 3 + sc2/src/uqm/planets/generate/genzoq.c | 34 ++++-- sc2/src/uqm/planets/lander.c | 18 +-- sc2/src/uqm/planets/scan.c | 50 ++++++-- sc2/src/uqm/planets/scan.h | 8 +- sc2/src/uqm/uqmdebug.c | 32 ++---- 35 files changed, 962 insertions(+), 601 deletions(-) diff --git a/sc2/src/uqm/planets/generate.h b/sc2/src/uqm/planets/generate.h index 14d212ba6..853f6c839 100644 --- a/sc2/src/uqm/planets/generate.h +++ b/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; }; diff --git a/sc2/src/uqm/planets/generate/genand.c b/sc2/src/uqm/planets/generate/genand.c index 7979cc303..755b5a172 100644 --- a/sc2/src/uqm/planets/generate/genand.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genburv.c b/sc2/src/uqm/planets/generate/genburv.c index 7473c45f5..06541e2d4 100644 --- a/sc2/src/uqm/planets/generate/genburv.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genchmmr.c b/sc2/src/uqm/planets/generate/genchmmr.c index 71f962bdb..644b2e6b4 100644 --- a/sc2/src/uqm/planets/generate/genchmmr.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/gencol.c b/sc2/src/uqm/planets/generate/gencol.c index 36f1530f8..27e4d5b20 100644 --- a/sc2/src/uqm/planets/generate/gencol.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/gendefault.c b/sc2/src/uqm/planets/generate/gendefault.c index b6044c0dd..dfa4fc54d 100644 --- a/sc2/src/uqm/planets/generate/gendefault.c +++ b/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 diff --git a/sc2/src/uqm/planets/generate/gendefault.h b/sc2/src/uqm/planets/generate/gendefault.h index 90b5a054d..f0a49e314 100644 --- a/sc2/src/uqm/planets/generate/gendefault.h +++ b/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 *); diff --git a/sc2/src/uqm/planets/generate/gendru.c b/sc2/src/uqm/planets/generate/gendru.c index 03386d434..811d36ca4 100644 --- a/sc2/src/uqm/planets/generate/gendru.c +++ b/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; } diff --git a/sc2/src/uqm/planets/generate/genilw.c b/sc2/src/uqm/planets/generate/genilw.c index 8364246e7..62a5819c8 100644 --- a/sc2/src/uqm/planets/generate/genilw.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genmel.c b/sc2/src/uqm/planets/generate/genmel.c index 540dccb13..a5a81be1d 100644 --- a/sc2/src/uqm/planets/generate/genmel.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/genmyc.c b/sc2/src/uqm/planets/generate/genmyc.c index acd34459f..f9abf2442 100644 --- a/sc2/src/uqm/planets/generate/genmyc.c +++ b/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; } diff --git a/sc2/src/uqm/planets/generate/genorz.c b/sc2/src/uqm/planets/generate/genorz.c index bd7343343..fbe847ecb 100644 --- a/sc2/src/uqm/planets/generate/genorz.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genpet.c b/sc2/src/uqm/planets/generate/genpet.c index 80f7e8a60..f2027cff7 100644 --- a/sc2/src/uqm/planets/generate/genpet.c +++ b/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 diff --git a/sc2/src/uqm/planets/generate/genpku.c b/sc2/src/uqm/planets/generate/genpku.c index 613cae2ab..4c44c50e8 100644 --- a/sc2/src/uqm/planets/generate/genpku.c +++ b/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; } diff --git a/sc2/src/uqm/planets/generate/genrain.c b/sc2/src/uqm/planets/generate/genrain.c index 7ea639db4..4e19aaa8b 100644 --- a/sc2/src/uqm/planets/generate/genrain.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/gensam.c b/sc2/src/uqm/planets/generate/gensam.c index 2da768511..4043acfd4 100644 --- a/sc2/src/uqm/planets/generate/gensam.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/genshof.c b/sc2/src/uqm/planets/generate/genshof.c index abb33e005..7025f6a35 100644 --- a/sc2/src/uqm/planets/generate/genshof.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/gensly.c b/sc2/src/uqm/planets/generate/gensly.c index 2e69b2473..48ed10000 100644 --- a/sc2/src/uqm/planets/generate/gensly.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/gensol.c b/sc2/src/uqm/planets/generate/gensol.c index 969af5290..83ee07c91 100644 --- a/sc2/src/uqm/planets/generate/gensol.c +++ b/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; } diff --git a/sc2/src/uqm/planets/generate/genspa.c b/sc2/src/uqm/planets/generate/genspa.c index f7c9a8ae0..12ddf49fd 100644 --- a/sc2/src/uqm/planets/generate/genspa.c +++ b/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); +} diff --git a/sc2/src/uqm/planets/generate/gensup.c b/sc2/src/uqm/planets/generate/gensup.c index ba6f09dc4..49d3070ce 100644 --- a/sc2/src/uqm/planets/generate/gensup.c +++ b/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; } diff --git a/sc2/src/uqm/planets/generate/gensyr.c b/sc2/src/uqm/planets/generate/gensyr.c index 4a775e5ee..ebf3be4b0 100644 --- a/sc2/src/uqm/planets/generate/gensyr.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/genthrad.c b/sc2/src/uqm/planets/generate/genthrad.c index d5eb74cd7..ad5194b35 100644 --- a/sc2/src/uqm/planets/generate/genthrad.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/gentrap.c b/sc2/src/uqm/planets/generate/gentrap.c index 25e1fdd48..e8451cdf2 100644 --- a/sc2/src/uqm/planets/generate/gentrap.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/genutw.c b/sc2/src/uqm/planets/generate/genutw.c index 0b3b74495..d1e0cfcd1 100644 --- a/sc2/src/uqm/planets/generate/genutw.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genvault.c b/sc2/src/uqm/planets/generate/genvault.c index d2da6a196..ecaa4cfae 100644 --- a/sc2/src/uqm/planets/generate/genvault.c +++ b/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; } - diff --git a/sc2/src/uqm/planets/generate/genvux.c b/sc2/src/uqm/planets/generate/genvux.c index f2c49894c..2218681fd 100644 --- a/sc2/src/uqm/planets/generate/genvux.c +++ b/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); } - diff --git a/sc2/src/uqm/planets/generate/genwreck.c b/sc2/src/uqm/planets/generate/genwreck.c index 1cf6fb071..669fe5cb0 100644 --- a/sc2/src/uqm/planets/generate/genwreck.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genyeh.c b/sc2/src/uqm/planets/generate/genyeh.c index 2e381448d..e49347673 100644 --- a/sc2/src/uqm/planets/generate/genyeh.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/generate/genzfpscout.c b/sc2/src/uqm/planets/generate/genzfpscout.c index f44a186e5..93a6d5d1a 100644 --- a/sc2/src/uqm/planets/generate/genzfpscout.c +++ b/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, }; diff --git a/sc2/src/uqm/planets/generate/genzoq.c b/sc2/src/uqm/planets/generate/genzoq.c index c31224618..2d9e0dab8 100644 --- a/sc2/src/uqm/planets/generate/genzoq.c +++ b/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; +} diff --git a/sc2/src/uqm/planets/lander.c b/sc2/src/uqm/planets/lander.c index 402018bf8..7d8041799 100644 --- a/sc2/src/uqm/planets/lander.c +++ b/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; } diff --git a/sc2/src/uqm/planets/scan.c b/sc2/src/uqm/planets/scan.c index 1c5f9f7a6..f3c4f8656 100644 --- a/sc2/src/uqm/planets/scan.c +++ b/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) { diff --git a/sc2/src/uqm/planets/scan.h b/sc2/src/uqm/planets/scan.h index 635e6ca9e..76b9b702b 100644 --- a/sc2/src/uqm/planets/scan.h +++ b/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); diff --git a/sc2/src/uqm/uqmdebug.c b/sc2/src/uqm/uqmdebug.c index 39754e4d8..c21ea50ae 100644 --- a/sc2/src/uqm/uqmdebug.c +++ b/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); }