static bool
GenerateTrap_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
int planetArray[] = { PRIMORDIAL_WORLD, WATER_WORLD, TELLURIC_WORLD };
solarSys->SunDesc[0].NumPlanets = (BYTE)~0;
solarSys->SunDesc[0].PlanetByte = 0;
if(!PrimeSeed){
solarSys->SunDesc[0].NumPlanets = (RandomContext_Random (SysGenRNG) % (9 - 1) + 1);
}
FillOrbits (solarSys, solarSys->SunDesc[0].NumPlanets, solarSys->PlanetDesc, FALSE);
GeneratePlanets (solarSys);
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].data_index = TELLURIC_WORLD;
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].alternate_colormap = NULL;
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].NumPlanets = 1;
if(!PrimeSeed){
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].data_index = planetArray[RandomContext_Random (SysGenRNG) % 2];
} else {
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].radius = EARTH_RADIUS * 203L / 100;
angle = ARCTAN (solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].location.x,
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].location.y);
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].location.x =
COSINE (angle, solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].radius);
solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].location.y =
SINE (angle, solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte].radius);
ComputeSpeed(&solarSys->PlanetDesc[solarSys->SunDesc[0].PlanetByte], FALSE, 1);
}
return true;
}
static bool
GenerateSpathi_generateMoons (SOLARSYS_STATE *solarSys, PLANET_DESC *planet)
{
COUNT angle;
GenerateDefault_generateMoons (solarSys, planet);
if (matchWorld (solarSys, planet, 0, MATCH_PLANET))
{
#ifdef NOTYET
utf8StringCopy (GLOBAL_SIS (PlanetName),
sizeof (GLOBAL_SIS (PlanetName)),
"Spathiwa");
#endif /* NOTYET */
solarSys->MoonDesc[0].data_index = PELLUCID_WORLD;
solarSys->MoonDesc[0].alternate_colormap = NULL;
solarSys->MoonDesc[0].radius = MIN_MOON_RADIUS + MOON_DELTA;
angle = NORMALIZE_ANGLE (LOWORD (RandomContext_Random (SysGenRNG)));
solarSys->MoonDesc[0].location.x =
COSINE (angle, solarSys->MoonDesc[0].radius);
solarSys->MoonDesc[0].location.y =
SINE (angle, solarSys->MoonDesc[0].radius);
ComputeSpeed(&solarSys->MoonDesc[0], TRUE, 1);
}
return true;
}
static bool
GenerateWreck_generatePlanets (SOLARSYS_STATE *solarSys)
{
solarSys->SunDesc[0].NumPlanets = (BYTE)~0;
if (!PrimeSeed)
solarSys->SunDesc[0].NumPlanets = (RandomContext_Random (SysGenRNG) % (9 - 7) + 7);
FillOrbits (solarSys, solarSys->SunDesc[0].NumPlanets, solarSys->PlanetDesc, FALSE);
GeneratePlanets (solarSys);
if(!PrimeSeed){
solarSys->PlanetDesc[6].data_index = (RandomContext_Random (SysGenRNG) % LAST_SMALL_ROCKY_WORLD);
solarSys->PlanetDesc[6].alternate_colormap = NULL;
}
return true;
}
static void
starRecurse (STAR_DESC *star, void *arg)
{
UniverseRecurseArg *universeRecurseArg = (UniverseRecurseArg *) arg;
SOLARSYS_STATE SolarSysState;
SOLARSYS_STATE *oldPSolarSysState = pSolarSysState;
STAR_DESC *oldStarDescPtr = CurStarDescPtr;
CurStarDescPtr = star;
RandomContext_SeedRandom (SysGenRNG, GetRandomSeedForStar (star));
memset (&SolarSysState, 0, sizeof (SolarSysState));
SolarSysState.SunDesc[0].pPrevDesc = 0;
SolarSysState.SunDesc[0].rand_seed = RandomContext_Random (SysGenRNG);
SolarSysState.SunDesc[0].data_index = STAR_TYPE (star->Type);
SolarSysState.SunDesc[0].location.x = 0;
SolarSysState.SunDesc[0].location.y = 0;
//SolarSysState.SunDesc[0].radius = MIN_ZOOM_RADIUS;
SolarSysState.genFuncs = getGenerateFunctions (star->Index);
pSolarSysState = &SolarSysState;
(*SolarSysState.genFuncs->generatePlanets) (&SolarSysState);
if (universeRecurseArg->systemFuncPre != NULL)
{
(*universeRecurseArg->systemFuncPre) (
star, &SolarSysState, universeRecurseArg->arg);
}
if (universeRecurseArg->planetFuncPre != NULL
|| universeRecurseArg->planetFuncPost != NULL
|| universeRecurseArg->moonFunc != NULL)
{
forAllPlanets (star, &SolarSysState, planetRecurse,
(void *) universeRecurseArg);
}
if (universeRecurseArg->systemFuncPost != NULL)
{
(*universeRecurseArg->systemFuncPost) (
star, &SolarSysState, universeRecurseArg->arg);
}
pSolarSysState = oldPSolarSysState;
CurStarDescPtr = oldStarDescPtr;
}
static bool
GenerateBurvixese_generateMoons (SOLARSYS_STATE *solarSys, PLANET_DESC *planet)
{
GenerateDefault_generateMoons (solarSys, planet);
if (matchWorld (solarSys, planet, 0, MATCH_PLANET))
{
COUNT angle;
DWORD rand_val;
solarSys->MoonDesc[0].data_index = SELENIC_WORLD;
solarSys->MoonDesc[0].radius = MIN_MOON_RADIUS
+ (MAX_MOONS - 1) * MOON_DELTA;
rand_val = RandomContext_Random (SysGenRNG);
angle = NORMALIZE_ANGLE (LOWORD (rand_val));
solarSys->MoonDesc[0].location.x =
COSINE (angle, solarSys->MoonDesc[0].radius);
solarSys->MoonDesc[0].location.y =
SINE (angle, solarSys->MoonDesc[0].radius);
ComputeSpeed(&solarSys->MoonDesc[0], TRUE, 1);
}
return true;
}
void
FillOrbits (SOLARSYS_STATE *system, BYTE NumPlanets,
PLANET_DESC *pBaseDesc, BOOLEAN TypesDefined)
{ /* Generate Planets in orbit around star */
BYTE StarColor, PlanetCount, MaxPlanet;
BOOLEAN GeneratingMoons;
COUNT StarSize;
PLANET_DESC *pPD;
struct
{
COUNT MinRockyDist, MinGasGDist;
} Suns[] =
{
{DWARF_ROCK_DIST, DWARF_GASG_DIST},
{GIANT_ROCK_DIST, GIANT_GASG_DIST},
{SUPERGIANT_ROCK_DIST, SUPERGIANT_GASG_DIST},
};
#ifdef DEBUG_ORBITS
UNICODE buf[256];
char stype[] = {'D', 'G', 'S'};
char scolor[] = {'B', 'G', 'O', 'R', 'W', 'Y'};
#endif /* DEBUG_ORBITS */
pPD = pBaseDesc;
StarSize = system->SunDesc[0].data_index;
StarColor = STAR_COLOR (CurStarDescPtr->Type);
if (NumPlanets == (BYTE)~0)
{
#define MAX_GENERATED_PLANETS 9
// XXX: This is pretty funny. Instead of calling RNG once, like so:
// 1 + Random % MAX_GENERATED_PLANETS
// we spin in a loop until the result > 0.
// Note that this behavior must be kept to preserve the universe.
do
NumPlanets = LOWORD (RandomContext_Random (SysGenRNG))
% (MAX_GENERATED_PLANETS + 1);
while (NumPlanets == 0);
system->SunDesc[0].NumPlanets = NumPlanets;
}
#ifdef DEBUG_ORBITS
GetClusterName (CurStarDescPtr, buf);
log_add (log_Debug, "cluster name = %s color = %c type = %c", buf,
scolor[STAR_COLOR (CurStarDescPtr->Type)],
stype[STAR_TYPE (CurStarDescPtr->Type)]);
#endif /* DEBUG_ORBITS */
GeneratingMoons = (BOOLEAN) (pBaseDesc == system->MoonDesc);
if (GeneratingMoons)
MaxPlanet = FIRST_LARGE_ROCKY_WORLD;
else
MaxPlanet = NUMBER_OF_PLANET_TYPES;
PlanetCount = NumPlanets;
while (NumPlanets--)
{
BYTE chance;
DWORD rand_val;
COUNT min_radius, angle;
SIZE delta_r;
PLANET_DESC *pLocPD;
do
{
rand_val = RandomContext_Random (SysGenRNG);
if (TypesDefined)
rand_val = 0;
else
pPD->data_index =
(BYTE)(HIBYTE (LOWORD (rand_val)) % MaxPlanet);
chance = PLANET_NEVER;
switch (StarColor)
{
case BLUE_BODY:
chance = BlueDistribution (pPD->data_index);
break;
case GREEN_BODY:
chance = GreenDistribution (pPD->data_index);
break;
case ORANGE_BODY:
chance = OrangeDistribution (pPD->data_index);
break;
case RED_BODY:
chance = RedDistribution (pPD->data_index);
break;
case WHITE_BODY:
chance = WhiteDistribution (pPD->data_index);
break;
case YELLOW_BODY:
chance = YellowDistribution (pPD->data_index);
break;
}
} while (LOBYTE (LOWORD (rand_val)) >= chance);
if (pPD->data_index < FIRST_GAS_GIANT)
min_radius = Suns[StarSize].MinRockyDist;
else
min_radius = Suns[StarSize].MinGasGDist;
RelocatePlanet:
rand_val = RandomContext_Random (SysGenRNG);
if (GeneratingMoons)
{
pPD->radius = MIN_MOON_RADIUS
+ ((LOWORD (rand_val) % MAX_MOONS) * MOON_DELTA);
for (pLocPD = pPD - 1; pLocPD >= pBaseDesc; --pLocPD)
{
if (pPD->radius == pLocPD->radius)
goto RelocatePlanet;
}
pPD->NumPlanets = 0;
}
else
{
pPD->radius =
(LOWORD (rand_val) % (MAX_PLANET_RADIUS - min_radius))
+ min_radius;
for (pLocPD = pPD - 1; pLocPD >= pBaseDesc; --pLocPD)
{
delta_r = UNSCALE_RADIUS (pLocPD->radius) / 5
- UNSCALE_RADIUS (pPD->radius) / 5;
if (delta_r < 0)
delta_r = -delta_r;
if (delta_r <= 1)
goto RelocatePlanet;
}
}
rand_val = RandomContext_Random (SysGenRNG);
angle = NORMALIZE_ANGLE (LOWORD (rand_val));
pPD->location.x = COSINE (angle, pPD->radius);
pPD->location.y = SINE (angle, pPD->radius);
pPD->rand_seed = MAKE_DWORD (pPD->location.x, pPD->location.y);
++pPD;
}
{
BYTE i;
for (i = 0; i < PlanetCount; ++i)
{
BYTE j;
for (j = (BYTE)(PlanetCount - 1); j > i; --j)
{
if (pBaseDesc[i].radius > pBaseDesc[j].radius)
{
PLANET_DESC temp;
temp = pBaseDesc[i];
pBaseDesc[i] = pBaseDesc[j];
pBaseDesc[j] = temp;
}
}
}
}
}
static BOOLEAN
StripShip (COUNT fuel_required)
{
BYTE i, which_module;
SBYTE crew_pods;
SET_GAME_STATE (MELNORME_RESCUE_REFUSED, 0);
crew_pods = -(SBYTE)(
(GLOBAL_SIS (CrewEnlisted) + CREW_POD_CAPACITY - 1)
/ CREW_POD_CAPACITY
);
if (fuel_required == 0)
{
GlobData.SIS_state = SIS_copy;
DeltaSISGauges (UNDEFINED_DELTA, rescue_fuel, UNDEFINED_DELTA);
}
else if (fuel_required == (COUNT)~0)
{
GLOBAL_SIS (NumLanders) = 0;
for (i = 0; i < NUM_DRIVE_SLOTS; ++i)
GLOBAL_SIS (DriveSlots[i]) = EMPTY_SLOT + 0;
for (i = 0; i < NUM_JET_SLOTS; ++i)
GLOBAL_SIS (JetSlots[i]) = EMPTY_SLOT + 1;
if (GLOBAL_SIS (FuelOnBoard) > FUEL_RESERVE)
GLOBAL_SIS (FuelOnBoard) = FUEL_RESERVE;
GLOBAL_SIS (TotalBioMass) = 0;
GLOBAL_SIS (TotalElementMass) = 0;
for (i = 0; i < NUM_ELEMENT_CATEGORIES; ++i)
GLOBAL_SIS (ElementAmounts[i]) = 0;
for (i = 0; i < NUM_MODULE_SLOTS; ++i)
{
which_module = GLOBAL_SIS (ModuleSlots[i]);
if (which_module < BOMB_MODULE_0
&& (which_module != CREW_POD
|| ++crew_pods > 0))
GLOBAL_SIS (ModuleSlots[i]) = EMPTY_SLOT + 2;
}
DeltaSISGauges (UNDEFINED_DELTA, UNDEFINED_DELTA, UNDEFINED_DELTA);
}
else if (fuel_required)
{
SBYTE bays;
BYTE num_searches, beg_mod, end_mod;
COUNT worth, total;
BYTE module_count[BOMB_MODULE_0];
BYTE slot;
DWORD capacity;
RandomContext *rc;
// Bug #567
// In order to offer the same deal each time if it is refused, we seed
// the random number generator with our location, thus making the deal
// a repeatable pseudo-random function of where we got stuck and what,
// exactly, is on our ship.
rc = RandomContext_New();
RandomContext_SeedRandom (rc, getStripRandomSeed ());
SIS_copy = GlobData.SIS_state;
for (i = PLANET_LANDER; i < BOMB_MODULE_0; ++i)
module_count[i] = 0;
capacity = FUEL_RESERVE;
slot = NUM_MODULE_SLOTS - 1;
do
{
if (SIS_copy.ModuleSlots[slot] == FUEL_TANK
|| SIS_copy.ModuleSlots[slot] == HIGHEFF_FUELSYS)
{
COUNT volume;
volume = SIS_copy.ModuleSlots[slot] == FUEL_TANK
? FUEL_TANK_CAPACITY : HEFUEL_TANK_CAPACITY;
capacity += volume;
}
} while (slot--);
if (fuel_required > capacity)
fuel_required = capacity;
bays = -(SBYTE)(
(SIS_copy.TotalElementMass + STORAGE_BAY_CAPACITY - 1)
/ STORAGE_BAY_CAPACITY
);
for (i = 0; i < NUM_MODULE_SLOTS; ++i)
{
which_module = SIS_copy.ModuleSlots[i];
if (which_module == CREW_POD)
++crew_pods;
else if (which_module == STORAGE_BAY)
++bays;
}
worth = fuel_required / FUEL_TANK_SCALE;
total = 0;
num_searches = 0;
beg_mod = end_mod = (BYTE)~0;
while (total < worth && ShipWorth () && ++num_searches)
{
DWORD rand_val;
rand_val = RandomContext_Random (rc);
switch (which_module = LOBYTE (LOWORD (rand_val)) % (CREW_POD + 1))
{
case PLANET_LANDER:
if (SIS_copy.NumLanders == 0)
continue;
--SIS_copy.NumLanders;
break;
case FUSION_THRUSTER:
for (i = 0; i < NUM_DRIVE_SLOTS; ++i)
{
if (SIS_copy.DriveSlots[i] < EMPTY_SLOT)
break;
}
if (i == NUM_DRIVE_SLOTS)
continue;
SIS_copy.DriveSlots[i] = EMPTY_SLOT + 0;
break;
case TURNING_JETS:
for (i = 0; i < NUM_JET_SLOTS; ++i)
{
if (SIS_copy.JetSlots[i] < EMPTY_SLOT)
break;
}
if (i == NUM_JET_SLOTS)
continue;
SIS_copy.JetSlots[i] = EMPTY_SLOT + 1;
break;
case CREW_POD:
i = HIBYTE (LOWORD (rand_val)) % NUM_MODULE_SLOTS;
which_module = SIS_copy.ModuleSlots[i];
if (which_module >= BOMB_MODULE_0
|| which_module == FUEL_TANK
|| which_module == HIGHEFF_FUELSYS
|| (which_module == STORAGE_BAY
&& module_count[STORAGE_BAY] >= bays)
|| (which_module == CREW_POD
&& module_count[CREW_POD] >= crew_pods))
continue;
SIS_copy.ModuleSlots[i] = EMPTY_SLOT + 2;
break;
}
if (beg_mod == (BYTE)~0)
beg_mod = end_mod = which_module;
else if (which_module > end_mod)
end_mod = which_module;
++module_count[which_module];
total += GLOBAL (ModuleCost[which_module]);
}
RandomContext_Delete (rc);
if (total == 0)
{
NPCPhrase (CHARITY);
DeltaSISGauges (0, fuel_required, 0);
return (FALSE);
}
else
{
NPCPhrase (RESCUE_OFFER);
rescue_fuel = fuel_required;
if (rescue_fuel == capacity)
NPCPhrase (RESCUE_TANKS);
else
NPCPhrase (RESCUE_HOME);
for (i = PLANET_LANDER; i < BOMB_MODULE_0; ++i)
{
if (module_count[i])
{
if (i == end_mod && i != beg_mod)
NPCPhrase (END_LIST_WITH_AND);
NPCPhrase (ENUMERATE_ONE + (module_count[i] - 1));
NPCPhrase (GetStripModuleRef (i));
}
}
}
}
return (TRUE);
}
