static HSHIPFRAG
MatchSupportShip (MENU_STATE *pMS)
{
POINT *pship_pos;
HSHIPFRAG hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)),
pship_pos = (POINT*)pMS->flash_frame0;
hStarShip; hStarShip = hNextShip, ++pship_pos)
{
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
if (pship_pos->x == pMS->first_item.x
&& pship_pos->y == pMS->first_item.y)
{
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
return hStarShip;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
return 0;
}
static HSTARSHIP
MatchSupportShip (PMENU_STATE pMS)
{
PPOINT pship_pos;
HSTARSHIP hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)),
pship_pos = (PPOINT)pMS->flash_frame0;
hStarShip; hStarShip = hNextShip, ++pship_pos)
{
SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hStarShip);
if (pship_pos->x == pMS->first_item.x
&& pship_pos->y == pMS->first_item.y)
{
UnlockStarShip (&GLOBAL (built_ship_q), hStarShip);
return hStarShip;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockStarShip (&GLOBAL (built_ship_q), hStarShip);
}
return 0;
}
static bool
GenerateColony_initNpcs (SOLARSYS_STATE *solarSys)
{
HIPGROUP hGroup;
GLOBAL (BattleGroupRef) = GET_GAME_STATE_32 (COLONY_GRPOFFS0);
if (GLOBAL (BattleGroupRef) == 0)
{
CloneShipFragment (URQUAN_SHIP,
&GLOBAL (npc_built_ship_q), 0);
GLOBAL (BattleGroupRef) = PutGroupInfo (GROUPS_ADD_NEW, 1);
ReinitQueue (&GLOBAL (npc_built_ship_q));
SET_GAME_STATE_32 (COLONY_GRPOFFS0, GLOBAL (BattleGroupRef));
}
GenerateDefault_initNpcs (solarSys);
if (GLOBAL (BattleGroupRef)
&& (hGroup = GetHeadLink (&GLOBAL (ip_group_q))))
{
IP_GROUP *GroupPtr;
GroupPtr = LockIpGroup (&GLOBAL (ip_group_q), hGroup);
GroupPtr->task = IN_ORBIT;
GroupPtr->sys_loc = 0 + 1; /* orbitting colony */
GroupPtr->dest_loc = 0 + 1; /* orbitting colony */
GroupPtr->loc.x = 0;
GroupPtr->loc.y = 0;
GroupPtr->group_counter = 0;
UnlockIpGroup (&GLOBAL (ip_group_q), hGroup);
}
return true;
}
static SHIP_FRAGMENT *
LockSupportShip (ROSTER_STATE *rosterState, HSHIPFRAG *phFrag)
{
const POINT *pship_pos;
HSHIPFRAG hStarShip, hNextShip;
// Lookup the current escort's location in the unsorted points list
// to find the original escort index
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)),
pship_pos = ship_pos;
hStarShip; hStarShip = hNextShip, ++pship_pos)
{
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
if (pointsEqual (*pship_pos, rosterState->curShipPt))
{
*phFrag = hStarShip;
return StarShipPtr;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
return NULL;
}
SPECIES_ID
ShipIdStrToIndex (const char *shipIdStr)
{
HMASTERSHIP hStarShip;
HMASTERSHIP hNextShip;
SPECIES_ID result = NO_ID;
for (hStarShip = GetHeadLink (&master_q);
hStarShip != 0; hStarShip = hNextShip)
{
MASTER_SHIP_INFO *MasterPtr;
MasterPtr = LockMasterShip (&master_q, hStarShip);
hNextShip = _GetSuccLink (MasterPtr);
if (strcmp (shipIdStr, MasterPtr->ShipInfo.idStr) == 0)
{
result = MasterPtr->SpeciesID;
UnlockMasterShip (&master_q, hStarShip);
break;
}
UnlockMasterShip (&master_q, hStarShip);
}
return result;
}
/*
* Returns the number of ships of the specified race among the
* escort ships.
*/
COUNT
CountEscortShips (COUNT race)
{
HFLEETINFO hFleet;
HSHIPFRAG hStarShip, hNextShip;
COUNT result = 0;
hFleet = GetStarShipFromIndex (&GLOBAL (avail_race_q), race);
if (!hFleet)
return 0;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)); hStarShip;
hStarShip = hNextShip)
{
BYTE ship_type;
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
ship_type = StarShipPtr->race_id;
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
if (ship_type == race)
result++;
}
return result;
}
BYTE
NameCaptain (QUEUE *pQueue, SPECIES_ID SpeciesID)
{
BYTE name_index;
HLINK hStarShip;
assert (GetLinkSize (pQueue) == sizeof (STARSHIP) ||
GetLinkSize (pQueue) == sizeof (SHIP_FRAGMENT));
do
{
HLINK hNextShip;
name_index = PickCaptainName ();
for (hStarShip = GetHeadLink (pQueue); hStarShip;
hStarShip = hNextShip)
{
SHIP_BASE *ShipPtr;
BYTE test_name_index = -1;
ShipPtr = (SHIP_BASE *) LockLink (pQueue, hStarShip);
hNextShip = _GetSuccLink (ShipPtr);
if (ShipPtr->SpeciesID == SpeciesID)
test_name_index = ShipPtr->captains_name_index;
UnlockLink (pQueue, hStarShip);
if (name_index == test_name_index)
break;
}
} while (hStarShip /* name matched another ship */);
return name_index;
}
static bool
GenerateZoqFotPik_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
{
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
if (ActivateStarShip (ZOQFOTPIK_SHIP, SPHERE_TRACKING))
{
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
if (GET_GAME_STATE (ZOQFOT_DISTRESS))
{
CloneShipFragment (BLACK_URQUAN_SHIP,
&GLOBAL (npc_built_ship_q), 0);
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (BLACKURQ_CONVERSATION);
if (GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD))
return true;
if (GetHeadLink (&GLOBAL (npc_built_ship_q)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
return true;
}
}
CloneShipFragment (ZOQFOTPIK_SHIP, &GLOBAL (npc_built_ship_q),
INFINITE_FLEET);
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (ZOQFOTPIK_CONVERSATION);
if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
}
return true;
}
LoadStdLanderFont (&solarSys->SysInfo.PlanetInfo);
solarSys->PlanetSideFrame[1] =
CaptureDrawable (LoadGraphic (RUINS_MASK_PMAP_ANIM));
solarSys->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (LoadStringTable (RUINS_STRTAB));
}
GenerateDefault_generateOrbital (solarSys, world);
return true;
}
static bool
GenerateSaMatra_reinitNpcs (SOLARSYS_STATE *solarSys)
{
BOOLEAN GuardEngaged;
HIPGROUP hGroup;
HIPGROUP hNextGroup;
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
EncounterGroup = 0;
EncounterRace = -1;
// Do not want guards to chase the player
GuardEngaged = FALSE;
for (hGroup = GetHeadLink (&GLOBAL (ip_group_q));
hGroup; hGroup = hNextGroup)
{
IP_GROUP *GroupPtr;
GroupPtr = LockIpGroup (&GLOBAL (ip_group_q), hGroup);
hNextGroup = _GetSuccLink (GroupPtr);
if (GET_GAME_STATE (URQUAN_MESSED_UP))
{
GroupPtr->task &= REFORM_GROUP;
GroupPtr->task |= FLEE | IGNORE_FLAGSHIP;
GroupPtr->dest_loc = 0;
}
else if (GroupPtr->task & REFORM_GROUP)
{
// REFORM_GROUP was set in ipdisp.c:ip_group_collision
// during a collision with the flagship.
GroupPtr->task &= ~REFORM_GROUP;
GroupPtr->group_counter = 0;
GuardEngaged = TRUE;
}
UnlockIpGroup (&GLOBAL (ip_group_q), hGroup);
}
if (GuardEngaged)
{
COUNT angle;
POINT org;
org = planetOuterLocation (4);
angle = ARCTAN (GLOBAL (ip_location.x) - org.x,
GLOBAL (ip_location.y) - org.y);
GLOBAL (ip_location.x) = org.x + COSINE (angle, 3000);
GLOBAL (ip_location.y) = org.y + SINE (angle, 3000);
XFormIPLoc (&GLOBAL (ip_location),
&GLOBAL (ShipStamp.origin), TRUE);
}
(void) solarSys;
return true;
}
static void
init_probe (void)
{
BYTE b0, b1, b2, b3;
HSTARSHIP hStarShip;
b0 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS0);
b1 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS1);
b2 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS2);
b3 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS3);
GLOBAL (BattleGroupRef) = MAKE_DWORD (
MAKE_WORD (b0, b1), MAKE_WORD (b2, b3)
);
if (GLOBAL (BattleGroupRef) == 0)
{
CloneShipFragment (URQUAN_PROBE_SHIP,
&GLOBAL (npc_built_ship_q), 0);
GLOBAL (BattleGroupRef) = PutGroupInfo (~0L, 1);
b0 = LOBYTE (LOWORD (GLOBAL (BattleGroupRef)));
b1 = HIBYTE (LOWORD (GLOBAL (BattleGroupRef)));
b2 = LOBYTE (HIWORD (GLOBAL (BattleGroupRef)));
b3 = HIBYTE (HIWORD (GLOBAL (BattleGroupRef)));
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS0, b0);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS1, b1);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS2, b2);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS3, b3);
}
if (!GET_GAME_STATE (PROBE_MESSAGE_DELIVERED)
&& GetGroupInfo (GLOBAL (BattleGroupRef), (BYTE)~0)
&& (hStarShip = GetHeadLink (
&GLOBAL (npc_built_ship_q)
)))
{
SHIP_FRAGMENTPTR FragPtr;
FragPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (npc_built_ship_q), hStarShip
);
SET_GROUP_MISSION (FragPtr, IN_ORBIT);
SET_GROUP_LOC (FragPtr, 2 + 1); /* orbitting earth */
SET_GROUP_DEST (FragPtr, 2 + 1); /* orbitting earth */
FragPtr->ShipInfo.loc.x = FragPtr->ShipInfo.loc.y = 0;
FragPtr->ShipInfo.group_counter = 0;
UnlockStarShip (
&GLOBAL (npc_built_ship_q), hStarShip
);
}
}
HLINK
GetStarShipFromIndex (QUEUE *pShipQ, COUNT Index)
{
HLINK hStarShip, hNextShip;
for (hStarShip = GetHeadLink (pShipQ);
Index > 0 && hStarShip; hStarShip = hNextShip, --Index)
{
LINK *StarShipPtr;
StarShipPtr = LockLink (pShipQ, hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
UnlockLink (pShipQ, hStarShip);
}
return (hStarShip);
}
HSTARSHIP
GetStarShipFromIndex (PQUEUE pShipQ, COUNT Index)
{
HSTARSHIP hStarShip, hNextShip;
for (hStarShip = GetHeadLink (pShipQ);
Index > 0 && hStarShip; hStarShip = hNextShip, --Index)
{
STARSHIPPTR StarShipPtr;
StarShipPtr = LockStarShip (pShipQ, hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
UnlockStarShip (pShipQ, hStarShip);
}
return (hStarShip);
}
BYTE
NameCaptain (PQUEUE pQueue, STARSHIPPTR StarShipPtr)
{
BYTE name_index;
HSTARSHIP hStarShip;
do
{
HSTARSHIP hNextShip;
name_index = PickCaptainName ();
for (hStarShip = GetHeadLink (pQueue); hStarShip; hStarShip = hNextShip)
{
STARSHIPPTR TestShipPtr;
TestShipPtr = LockStarShip (pQueue, hStarShip);
hNextShip = _GetSuccLink (TestShipPtr);
if (TestShipPtr->RaceResIndex == StarShipPtr->RaceResIndex)
{
BOOLEAN SameName;
if (LOBYTE (GLOBAL (CurrentActivity)) == SUPER_MELEE)
SameName = (BOOLEAN)(
name_index == TestShipPtr->captains_name_index
);
else
SameName = (BOOLEAN)(
name_index == StarShipCaptain (TestShipPtr)
);
if (SameName)
{
UnlockStarShip (pQueue, hStarShip);
break;
}
}
UnlockStarShip (pQueue, hStarShip);
}
} while (hStarShip);
return (name_index);
}
// Returns the <index>th available ship in the queue.
static HSTARSHIP
MeleeShipByUsedIndex (const QUEUE *queue, COUNT index)
{
HSTARSHIP hShip;
HSTARSHIP hNextShip;
for (hShip = GetHeadLink (queue); hShip != 0; hShip = hNextShip)
{
STARSHIP *StarShipPtr = LockStarShip (queue, hShip);
if ((StarShipPtr->SpeciesID != NO_ID) && index-- == 0)
{
UnlockStarShip (queue, hShip);
break;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockStarShip (queue, hShip);
}
return hShip;
}
void
clearEscorts (void)
{
HSHIPFRAG hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
RemoveQueue (&GLOBAL (built_ship_q), hStarShip);
FreeShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
DeltaSISGauges (UNDEFINED_DELTA, UNDEFINED_DELTA, UNDEFINED_DELTA);
}
COUNT
GetIndexFromStarShip (QUEUE *pShipQ, HLINK hStarShip)
{
COUNT Index;
Index = 0;
while (hStarShip != GetHeadLink (pShipQ))
{
HLINK hNextShip;
LINK *StarShipPtr;
StarShipPtr = LockLink (pShipQ, hStarShip);
hNextShip = _GetPredLink (StarShipPtr);
UnlockLink (pShipQ, hStarShip);
hStarShip = hNextShip;
++Index;
}
return Index;
}
COUNT
GetIndexFromStarShip (PQUEUE pShipQ, HSTARSHIP hStarShip)
{
COUNT Index;
Index = 0;
while (hStarShip != GetHeadLink (pShipQ))
{
HSTARSHIP hNextShip;
STARSHIPPTR StarShipPtr;
StarShipPtr = LockStarShip (pShipQ, hStarShip);
hNextShip = _GetPredLink (StarShipPtr);
UnlockStarShip (pShipQ, hStarShip);
hStarShip = hNextShip;
++Index;
}
return (Index);
}
void
activateAllShips (void)
{
HFLEETINFO hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (avail_race_q));
hStarShip != NULL; hStarShip = hNextShip)
{
FLEET_INFO *FleetPtr;
FleetPtr = LockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
hNextShip = _GetSuccLink (FleetPtr);
if (FleetPtr->icons != NULL)
// Skip the Ur-Quan probe.
{
FleetPtr->allied_state = GOOD_GUY;
}
UnlockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
}
}
/*
* Returns the total value of all the ships escorting the SIS.
*/
COUNT
CalculateEscortsWorth (void)
{
COUNT ShipCost[] =
{
RACE_SHIP_COST
};
COUNT total = 0;
HSHIPFRAG hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
total += ShipCost[StarShipPtr->race_id];
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
return total;
}
static COUNT
GetRaceQueueValue (const QUEUE *queue) {
COUNT result;
HSTARSHIP hBattleShip, hNextShip;
result = 0;
for (hBattleShip = GetHeadLink (queue);
hBattleShip != 0; hBattleShip = hNextShip)
{
STARSHIP *StarShipPtr = LockStarShip (queue, hBattleShip);
hNextShip = _GetSuccLink (StarShipPtr);
if (StarShipPtr->SpeciesID == NO_ID)
continue; // Not active any more.
result += StarShipPtr->ship_cost;
UnlockStarShip (queue, hBattleShip);
}
return result;
}
// Count the ships which can be built by the player.
static COUNT
GetAvailableRaceCount (void)
{
COUNT Index;
HFLEETINFO hStarShip, hNextShip;
Index = 0;
for (hStarShip = GetHeadLink (&GLOBAL (avail_race_q));
hStarShip; hStarShip = hNextShip)
{
FLEET_INFO *FleetPtr;
FleetPtr = LockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
if (FleetPtr->allied_state == GOOD_GUY)
++Index;
hNextShip = _GetSuccLink (FleetPtr);
UnlockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
}
return Index;
}
/*
* Remove a number of escort ships of the specified race (if present).
* Returns the number of escort ships removed.
*/
COUNT
RemoveSomeEscortShips (COUNT race, COUNT count)
{
HSHIPFRAG hStarShip;
HSHIPFRAG hNextShip;
if (count == 0)
return 0;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)); hStarShip;
hStarShip = hNextShip)
{
BOOLEAN RemoveShip;
SHIP_FRAGMENT *StarShipPtr;
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
RemoveShip = (StarShipPtr->race_id == race);
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
if (RemoveShip)
{
RemoveQueue (&GLOBAL (built_ship_q), hStarShip);
FreeShipFrag (&GLOBAL (built_ship_q), hStarShip);
count--;
if (count == 0)
break;
}
}
if (count > 0)
{
// Update the display.
DeltaSISGauges (UNDEFINED_DELTA, UNDEFINED_DELTA, UNDEFINED_DELTA);
}
return count;
}
// Returns the <index>th ship in the queue, or 0 if it is not available.
static HSTARSHIP
MeleeShipByQueueIndex (const QUEUE *queue, COUNT index)
{
HSTARSHIP hShip;
HSTARSHIP hNextShip;
for (hShip = GetHeadLink (queue); hShip != 0; hShip = hNextShip)
{
STARSHIP *StarShipPtr = LockStarShip (queue, hShip);
if (StarShipPtr->index == index)
{
hNextShip = hShip;
if (StarShipPtr->SpeciesID == NO_ID)
hShip = 0;
UnlockStarShip (queue, hNextShip);
break;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockStarShip (queue, hShip);
}
return hShip;
}
void
showSpheres (void)
{
HFLEETINFO hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (avail_race_q));
hStarShip != NULL; hStarShip = hNextShip)
{
FLEET_INFO *FleetPtr;
FleetPtr = LockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
hNextShip = _GetSuccLink (FleetPtr);
if ((FleetPtr->actual_strength != INFINITE_RADIUS) &&
(FleetPtr->known_strength != FleetPtr->actual_strength))
{
FleetPtr->known_strength = FleetPtr->actual_strength;
FleetPtr->known_loc = FleetPtr->loc;
}
UnlockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
}
}
static HFLEETINFO
GetAvailableRaceFromIndex (BYTE Index)
{
HFLEETINFO hStarShip, hNextShip;
for (hStarShip = GetHeadLink (&GLOBAL (avail_race_q));
hStarShip; hStarShip = hNextShip)
{
FLEET_INFO *FleetPtr;
FleetPtr = LockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
if (FleetPtr->allied_state == GOOD_GUY && Index-- == 0)
{
UnlockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
return hStarShip;
}
hNextShip = _GetSuccLink (FleetPtr);
UnlockFleetInfo (&GLOBAL (avail_race_q), hStarShip);
}
return 0;
}
/* Set the crew and captain's name on the first fully-crewed escort
* ship of race 'which_ship' */
int
SetEscortCrewComplement (COUNT which_ship, COUNT crew_level, BYTE captain)
{
HFLEETINFO hFleet;
FLEET_INFO *TemplatePtr;
HSHIPFRAG hStarShip, hNextShip;
SHIP_FRAGMENT *StarShipPtr = 0;
int Index;
hFleet = GetStarShipFromIndex (&GLOBAL (avail_race_q), which_ship);
if (!hFleet)
return -1;
TemplatePtr = LockFleetInfo (&GLOBAL (avail_race_q), hFleet);
/* Find first ship of which_ship race */
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q)), Index = 0;
hStarShip; hStarShip = hNextShip, ++Index)
{
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
if (which_ship == StarShipPtr->race_id &&
StarShipPtr->crew_level == TemplatePtr->crew_level)
break; /* found one */
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
if (hStarShip)
{
StarShipPtr->crew_level = crew_level;
StarShipPtr->captains_name_index = captain;
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
else
Index = -1;
UnlockFleetInfo (&GLOBAL (avail_race_q), hFleet);
return Index;
}
HSHIPFRAG
GetEscortByStarShipIndex (COUNT index)
{
HSHIPFRAG hStarShip;
HSHIPFRAG hNextShip;
SHIP_FRAGMENT *StarShipPtr;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
StarShipPtr = LockShipFrag (&GLOBAL (built_ship_q), hStarShip);
if (StarShipPtr->index == index)
{
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
break;
}
hNextShip = _GetSuccLink (StarShipPtr);
UnlockShipFrag (&GLOBAL (built_ship_q), hStarShip);
}
return hStarShip;
}
// Returns TRUE if the broadcaster has been successfully activated,
// and FALSE otherwise.
static BOOLEAN
UseCaster (void)
{
if (LOBYTE (GLOBAL (CurrentActivity)) == IN_HYPERSPACE)
{
if (GET_GAME_STATE (ARILOU_SPACE_SIDE) <= 1)
{
SET_GAME_STATE (USED_BROADCASTER, 1);
return TRUE;
}
return FALSE;
}
if (LOBYTE (GLOBAL (CurrentActivity)) != IN_INTERPLANETARY
|| !playerInSolarSystem ())
return FALSE;
if (playerInPlanetOrbit ()
&& matchWorld (pSolarSysState, pSolarSysState->pOrbitalDesc,
1, MATCH_PLANET)
&& CurStarDescPtr->Index == CHMMR_DEFINED
&& !GET_GAME_STATE (CHMMR_UNLEASHED))
{
// In orbit around the Chenjesu/Mmrnmhrm home planet.
NextActivity |= CHECK_LOAD; /* fake a load game */
GLOBAL (CurrentActivity) |= START_ENCOUNTER;
EncounterGroup = 0;
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
SaveSolarSysLocation ();
return TRUE;
}
{
BOOLEAN FoundIlwrath;
HIPGROUP hGroup;
FoundIlwrath = (CurStarDescPtr->Index == ILWRATH_DEFINED)
&& ActivateStarShip (ILWRATH_SHIP, SPHERE_TRACKING);
// In the Ilwrath home system and they are alive?
if (!FoundIlwrath &&
(hGroup = GetHeadLink (&GLOBAL (ip_group_q))))
{
// Is an Ilwrath ship in the system?
IP_GROUP *GroupPtr;
GroupPtr = LockIpGroup (&GLOBAL (ip_group_q), hGroup);
FoundIlwrath = (GroupPtr->race_id == ILWRATH_SHIP);
UnlockIpGroup (&GLOBAL (ip_group_q), hGroup);
}
if (FoundIlwrath)
{
NextActivity |= CHECK_LOAD; /* fake a load game */
GLOBAL (CurrentActivity) |= START_ENCOUNTER;
EncounterGroup = 0;
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
if (CurStarDescPtr->Index == ILWRATH_DEFINED)
{
// Ilwrath home system.
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 4);
}
else
{
// Ilwrath ship.
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 5);
}
if (playerInPlanetOrbit ())
SaveSolarSysLocation ();
return TRUE;
}
}
return FALSE;
}
static DeviceStatus
InvokeDevice (BYTE which_device)
{
BYTE val;
switch (which_device)
{
case ROSY_SPHERE_DEVICE:
val = GET_GAME_STATE (ULTRON_CONDITION);
if (val)
{
SET_GAME_STATE (ULTRON_CONDITION, val + 1);
SET_GAME_STATE (ROSY_SPHERE_ON_SHIP, 0);
SET_GAME_STATE (DISCUSSED_ULTRON, 0);
SET_GAME_STATE (SUPOX_ULTRON_HELP, 0);
return DEVICE_SUCCESS;
}
break;
case ARTIFACT_2_DEVICE:
break;
case ARTIFACT_3_DEVICE:
break;
case SUN_EFFICIENCY_DEVICE:
if (LOBYTE (GLOBAL (CurrentActivity)) == IN_INTERPLANETARY
&& playerInPlanetOrbit ())
{
PlayMenuSound (MENU_SOUND_INVOKED);
SleepThreadUntil (FadeScreen (FadeAllToWhite, ONE_SECOND * 1)
+ (ONE_SECOND * 2));
if (CurStarDescPtr->Index != CHMMR_DEFINED
|| !matchWorld (pSolarSysState,
pSolarSysState->pOrbitalDesc,
1, MATCH_PLANET))
{
FadeScreen (FadeAllToColor, ONE_SECOND * 2);
}
else
{
SET_GAME_STATE (CHMMR_EMERGING, 1);
EncounterGroup = 0;
GLOBAL (CurrentActivity) |= START_ENCOUNTER;
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
CloneShipFragment (CHMMR_SHIP,
&GLOBAL (npc_built_ship_q), 0);
}
return DEVICE_SUCCESS_NO_SOUND;
}
break;
case UTWIG_BOMB_DEVICE:
SET_GAME_STATE (UTWIG_BOMB, 0);
GLOBAL (CurrentActivity) &= ~IN_BATTLE;
GLOBAL_SIS (CrewEnlisted) = (COUNT)~0;
return DEVICE_SUCCESS;
case ULTRON_0_DEVICE:
break;
case ULTRON_1_DEVICE:
break;
case ULTRON_2_DEVICE:
break;
case ULTRON_3_DEVICE:
break;
case MAIDENS_DEVICE:
break;
case TALKING_PET_DEVICE:
NextActivity |= CHECK_LOAD; /* fake a load game */
GLOBAL (CurrentActivity) |= START_ENCOUNTER;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 0);
if (LOBYTE (GLOBAL (CurrentActivity)) == IN_HYPERSPACE)
{
if (GetHeadEncounter ())
{
SET_GAME_STATE (SHIP_TO_COMPEL, 1);
}
GLOBAL (CurrentActivity) &= ~IN_BATTLE;
SaveSisHyperState ();
}
else
{
EncounterGroup = 0;
if (GetHeadLink (&GLOBAL (ip_group_q)))
{
SET_GAME_STATE (SHIP_TO_COMPEL, 1);
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (ip_group_q));
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
}
if (CurStarDescPtr->Index == SAMATRA_DEFINED)
{
SET_GAME_STATE (READY_TO_CONFUSE_URQUAN, 1);
}
if (playerInPlanetOrbit ())
SaveSolarSysLocation ();
}
return DEVICE_SUCCESS;
case AQUA_HELIX_DEVICE:
val = GET_GAME_STATE (ULTRON_CONDITION);
if (val)
{
SET_GAME_STATE (ULTRON_CONDITION, val + 1);
SET_GAME_STATE (AQUA_HELIX_ON_SHIP, 0);
SET_GAME_STATE (DISCUSSED_ULTRON, 0);
SET_GAME_STATE (SUPOX_ULTRON_HELP, 0);
return DEVICE_SUCCESS;
}
break;
case CLEAR_SPINDLE_DEVICE:
val = GET_GAME_STATE (ULTRON_CONDITION);
if (val)
{
SET_GAME_STATE (ULTRON_CONDITION, val + 1);
SET_GAME_STATE (CLEAR_SPINDLE_ON_SHIP, 0);
SET_GAME_STATE (DISCUSSED_ULTRON, 0);
SET_GAME_STATE (SUPOX_ULTRON_HELP, 0);
return DEVICE_SUCCESS;
}
break;
case UMGAH_HYPERWAVE_DEVICE:
case BURVIX_HYPERWAVE_DEVICE:
if (UseCaster ())
return DEVICE_SUCCESS;
break;
case TAALO_PROTECTOR_DEVICE:
break;
case EGG_CASING0_DEVICE:
case EGG_CASING1_DEVICE:
case EGG_CASING2_DEVICE:
break;
case SYREEN_SHUTTLE_DEVICE:
break;
case VUX_BEAST_DEVICE:
break;
case DESTRUCT_CODE_DEVICE:
break;
case PORTAL_SPAWNER_DEVICE:
#define PORTAL_FUEL_COST (10 * FUEL_TANK_SCALE)
if (LOBYTE (GLOBAL (CurrentActivity)) == IN_HYPERSPACE
&& GET_GAME_STATE (ARILOU_SPACE_SIDE) <= 1
&& GLOBAL_SIS (FuelOnBoard) >= PORTAL_FUEL_COST)
{
/* No DeltaSISGauges because the flagship picture
* is currently obscured.
*/
GLOBAL_SIS (FuelOnBoard) -= PORTAL_FUEL_COST;
SET_GAME_STATE (PORTAL_COUNTER, 1);
return DEVICE_SUCCESS;
}
break;
case URQUAN_WARP_DEVICE:
break;
case LUNAR_BASE_DEVICE:
break;
}
return DEVICE_FAILURE;
}
static void
Intro (void)
{
BYTE NumVisits;
if (LOBYTE (GLOBAL (CurrentActivity)) == WON_LAST_BATTLE)
{
NPCPhrase (OUT_TAKES);
setSegue (Segue_peace);
return;
}
if (GET_GAME_STATE (DRUUGE_MANNER))
{
if (GET_GAME_STATE (GLOBAL_FLAGS_AND_DATA) & (1 << 7))
{
NumVisits = GET_GAME_STATE (DRUUGE_HOME_VISITS);
switch (NumVisits++)
{
case 0:
NPCPhrase (HSTL_TRADE_WORLD_HELLO_1);
break;
case 1:
NPCPhrase (HSTL_TRADE_WORLD_HELLO_2);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_HOME_VISITS, NumVisits);
}
else
{
NumVisits = GET_GAME_STATE (DRUUGE_VISITS);
switch (NumVisits++)
{
case 0:
NPCPhrase (HOSTILE_SPACE_HELLO_1);
break;
case 1:
NPCPhrase (HOSTILE_SPACE_HELLO_2);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_VISITS, NumVisits);
}
setSegue (Segue_hostile);
}
else if (GET_GAME_STATE (GLOBAL_FLAGS_AND_DATA) & (1 << 7))
{
{
NumVisits = GET_GAME_STATE (DRUUGE_HOME_VISITS);
switch (NumVisits++)
{
case 0:
NPCPhrase (INITIAL_TRADE_WORLD_HELLO);
break;
case 1:
NPCPhrase (SSQ_TRADE_WORLD_HELLO_1);
break;
case 2:
NPCPhrase (SSQ_TRADE_WORLD_HELLO_2);
break;
case 3:
NPCPhrase (SSQ_TRADE_WORLD_HELLO_3);
break;
case 4:
NPCPhrase (SSQ_TRADE_WORLD_HELLO_4);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_HOME_VISITS, NumVisits);
}
if (GET_GAME_STATE (ATTACKED_DRUUGE)
&& !GET_GAME_STATE (DRUUGE_DISCLAIMER))
{
// There is no HOSTILE_TRADE voice track that we know of
// so this is currently disabled
//NPCPhrase (HOSTILE_TRADE);
SET_GAME_STATE (DRUUGE_DISCLAIMER, 1);
}
if (GET_GAME_STATE (MAIDENS_ON_SHIP)
&& !GET_GAME_STATE (SCANNED_MAIDENS))
{
NPCPhrase (SCAN_MAIDENS);
SET_GAME_STATE (SCANNED_MAIDENS, 1);
}
if ((GET_GAME_STATE (EGG_CASE0_ON_SHIP)
|| GET_GAME_STATE (EGG_CASE1_ON_SHIP)
|| GET_GAME_STATE (EGG_CASE2_ON_SHIP))
&& !GET_GAME_STATE (SCANNED_FRAGMENTS))
{
if (GET_GAME_STATE (FRAGMENTS_BOUGHT) < 2)
NPCPhrase (SCAN_FRAGMENTS);
else
NPCPhrase (ENOUGH_FRAGMENTS);
SET_GAME_STATE (SCANNED_FRAGMENTS, 1);
}
if (GET_GAME_STATE (BURV_BROADCASTERS_ON_SHIP)
&& !GET_GAME_STATE (SCANNED_CASTER))
{
NPCPhrase (SCAN_DRUUGE_CASTER);
SET_GAME_STATE (SCANNED_CASTER, 1);
}
if (GET_GAME_STATE (PORTAL_SPAWNER_ON_SHIP)
&& !GET_GAME_STATE (SCANNED_SPAWNER))
{
NPCPhrase (SCAN_ARILOU_SPAWNER);
SET_GAME_STATE (SCANNED_SPAWNER, 1);
}
TradeWorld ((RESPONSE_REF)0);
}
else if (GET_GAME_STATE (GLOBAL_FLAGS_AND_DATA) & (1 << 6))
{
if (GET_GAME_STATE (BOMB_VISITS))
NPCPhrase (SUBSEQ_BOMB_WORLD_HELLO);
else
{
NPCPhrase (INIT_BOMB_WORLD_HELLO);
SET_GAME_STATE (BOMB_VISITS, 1);
}
BombAmbush ((RESPONSE_REF)0);
}
else if (GET_GAME_STATE (ATTACKED_DRUUGE))
{
NumVisits = GET_GAME_STATE (DRUUGE_VISITS);
switch (NumVisits++)
{
case 0:
NPCPhrase (HOSTILE_SPACE_HELLO_1);
break;
case 1:
NPCPhrase (HOSTILE_SPACE_HELLO_2);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_VISITS, NumVisits);
setSegue (Segue_hostile);
}
else
{
NumVisits = 0;
if (GetHeadLink (&GLOBAL (built_ship_q)) == 0)
{
for (NumVisits = 0; NumVisits < NUM_MODULE_SLOTS; ++NumVisits)
{
BYTE which_module;
which_module = GLOBAL_SIS (ModuleSlots[NumVisits]);
if (which_module >= GUN_WEAPON
&& which_module <= CANNON_WEAPON)
{
NumVisits = 0;
break;
}
}
}
if (NumVisits)
{
NumVisits = GET_GAME_STATE (DRUUGE_SALVAGE);
switch (NumVisits++)
{
case 0:
NPCPhrase (SALVAGE_YOUR_SHIP_1);
break;
case 1:
NPCPhrase (SALVAGE_YOUR_SHIP_2);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_SALVAGE, NumVisits);
setSegue (Segue_hostile);
AttemptedSalvage = TRUE;
}
else
{
NumVisits = GET_GAME_STATE (DRUUGE_VISITS);
switch (NumVisits++)
{
case 0:
NPCPhrase (INIT_SPACE_HELLO);
break;
case 1:
NPCPhrase (SUBSEQUENT_SPACE_HELLO);
--NumVisits;
break;
}
SET_GAME_STATE (DRUUGE_VISITS, NumVisits);
Space ((RESPONSE_REF)0);
}
}
}
