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;
}
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;
}
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;
}
/*
* 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;
}
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;
}
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;
}
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);
}
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);
}
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);
}
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);
}
// 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
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;
}
// 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;
}
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;
}
/*
* 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;
}
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);
}
}
// 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;
}
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;
}
static void
BuildUrquanGuard (SOLARSYS_STATE *solarSys)
{
BYTE ship1, ship2;
BYTE b0, b1;
POINT org;
HIPGROUP hGroup, hNextGroup;
GLOBAL (BattleGroupRef) = GET_GAME_STATE_32 (SAMATRA_GRPOFFS0);
if (!GET_GAME_STATE (KOHR_AH_FRENZY))
{
ship1 = URQUAN_SHIP;
ship2 = BLACK_URQUAN_SHIP;
}
else
{
ship1 = BLACK_URQUAN_SHIP;
ship2 = URQUAN_SHIP;
}
assert (CountLinks (&GLOBAL (npc_built_ship_q)) == 0);
for (b0 = 0; b0 < MAX_SHIPS_PER_SIDE; ++b0)
CloneShipFragment (ship1, &GLOBAL (npc_built_ship_q), 0);
if (GLOBAL (BattleGroupRef) == 0)
{
GLOBAL (BattleGroupRef) = PutGroupInfo (GROUPS_ADD_NEW, 1);
SET_GAME_STATE_32 (SAMATRA_GRPOFFS0, GLOBAL (BattleGroupRef));
}
#define NUM_URQUAN_GUARDS0 12
for (b0 = 1; b0 <= NUM_URQUAN_GUARDS0; ++b0)
PutGroupInfo (GLOBAL (BattleGroupRef), b0);
ReinitQueue (&GLOBAL (npc_built_ship_q));
for (b0 = 0; b0 < MAX_SHIPS_PER_SIDE; ++b0)
CloneShipFragment (ship2, &GLOBAL (npc_built_ship_q), 0);
#define NUM_URQUAN_GUARDS1 4
for (b0 = 1; b0 <= NUM_URQUAN_GUARDS1; ++b0)
PutGroupInfo (GLOBAL (BattleGroupRef),
(BYTE)(NUM_URQUAN_GUARDS0 + b0));
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GLOBAL (BattleGroupRef), GROUP_INIT_IP);
org = planetOuterLocation (4);
hGroup = GetHeadLink (&GLOBAL (ip_group_q));
for (b0 = 0, b1 = 0;
b0 < NUM_URQUAN_GUARDS0;
++b0, b1 += FULL_CIRCLE / (NUM_URQUAN_GUARDS0 + NUM_URQUAN_GUARDS1))
{
IP_GROUP *GroupPtr;
if (b1 % (FULL_CIRCLE / NUM_URQUAN_GUARDS1) == 0)
b1 += FULL_CIRCLE / (NUM_URQUAN_GUARDS0 + NUM_URQUAN_GUARDS1);
GroupPtr = LockIpGroup (&GLOBAL (ip_group_q), hGroup);
hNextGroup = _GetSuccLink (GroupPtr);
GroupPtr->task = ON_STATION | IGNORE_FLAGSHIP;
GroupPtr->sys_loc = 0;
GroupPtr->dest_loc = 4 + 1;
GroupPtr->orbit_pos = NORMALIZE_FACING (ANGLE_TO_FACING (b1));
GroupPtr->group_counter = 0;
GroupPtr->loc.x = org.x + COSINE (b1, STATION_RADIUS);
GroupPtr->loc.y = org.y + SINE (b1, STATION_RADIUS);
UnlockIpGroup (&GLOBAL (ip_group_q), hGroup);
hGroup = hNextGroup;
}
for (b0 = 0, b1 = 0;
b0 < NUM_URQUAN_GUARDS1;
++b0, b1 += FULL_CIRCLE / NUM_URQUAN_GUARDS1)
{
IP_GROUP *GroupPtr;
GroupPtr = LockIpGroup (&GLOBAL (ip_group_q), hGroup);
hNextGroup = _GetSuccLink (GroupPtr);
GroupPtr->task = ON_STATION | IGNORE_FLAGSHIP;
GroupPtr->sys_loc = 0;
GroupPtr->dest_loc = 4 + 1;
GroupPtr->orbit_pos = NORMALIZE_FACING (ANGLE_TO_FACING (b1));
GroupPtr->group_counter = 0;
GroupPtr->loc.x = org.x + COSINE (b1, STATION_RADIUS);
GroupPtr->loc.y = org.y + SINE (b1, STATION_RADIUS);
UnlockIpGroup (&GLOBAL (ip_group_q), hGroup);
hGroup = hNextGroup;
}
(void) solarSys;
}
COUNT
ActivateStarShip (COUNT which_ship, SIZE state)
{
HSTARSHIP hStarShip, hNextShip;
hStarShip = GetStarShipFromIndex (
&GLOBAL (avail_race_q), which_ship
);
if (hStarShip)
{
switch (state)
{
case SPHERE_TRACKING:
case SPHERE_KNOWN:
{
EXTENDED_SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (EXTENDED_SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
if (state == SPHERE_KNOWN)
which_ship = StarShipPtr->ShipInfo.known_strength;
else if (StarShipPtr->ShipInfo.actual_strength == 0)
{
if (!(StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY)))
which_ship = 0;
}
else if (StarShipPtr->ShipInfo.known_strength == 0
&& StarShipPtr->ShipInfo.actual_strength != (COUNT)~0)
{
StarShipPtr->ShipInfo.known_strength = 1;
StarShipPtr->ShipInfo.known_loc =
StarShipPtr->ShipInfo.loc;
}
UnlockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
return (which_ship);
}
case ESCORT_WORTH:
which_ship = 0;
case ESCORTING_FLAGSHIP:
{
COUNT ShipCost[] =
{
RACE_SHIP_COST
};
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
BYTE ship_type;
SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hStarShip
);
hNextShip = _GetSuccLink (StarShipPtr);
if (state == ESCORT_WORTH)
which_ship += ShipCost[GET_RACE_ID (StarShipPtr)];
else
ship_type = GET_RACE_ID (StarShipPtr);
UnlockStarShip (
&GLOBAL (built_ship_q), hStarShip
);
if (state != ESCORT_WORTH
&& (COUNT)ship_type == which_ship)
return (1);
}
return (state == ESCORTING_FLAGSHIP ? 0 : which_ship);
}
case FEASIBILITY_STUDY:
return (MAX_BUILT_SHIPS
- CountLinks (&GLOBAL (built_ship_q)));
default:
{
SHIP_FRAGMENTPTR StarShipPtr;
if (state <= 0)
{
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
if (state == CHECK_ALLIANCE)
{
state = StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY);
UnlockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
return ((COUNT)state);
}
else if (StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY))
{
StarShipPtr->ShipInfo.ship_flags &= ~(GOOD_GUY | BAD_GUY);
if (state == 0)
StarShipPtr->ShipInfo.ship_flags |= GOOD_GUY;
else
{
StarShipPtr->ShipInfo.ship_flags |= BAD_GUY;
if (which_ship == ORZ_SHIP)
{
BOOLEAN ShipRemoved;
ShipRemoved = FALSE;
for (hStarShip = GetHeadLink (
&GLOBAL (built_ship_q
)); hStarShip; hStarShip = hNextShip)
{
BOOLEAN RemoveShip;
SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q),
hStarShip
);
hNextShip = _GetSuccLink (StarShipPtr);
RemoveShip = (BOOLEAN)(
GET_RACE_ID (StarShipPtr) == ORZ_SHIP
);
UnlockStarShip (
&GLOBAL (built_ship_q),
hStarShip
);
if (RemoveShip)
{
ShipRemoved = TRUE;
RemoveQueue (
&GLOBAL (built_ship_q),
hStarShip
);
FreeStarShip (
&GLOBAL (built_ship_q),
hStarShip
);
}
}
if (ShipRemoved)
{
SetSemaphore (GraphicsSem);
DeltaSISGauges (UNDEFINED_DELTA,
UNDEFINED_DELTA, UNDEFINED_DELTA);
ClearSemaphore (GraphicsSem);
}
}
}
}
UnlockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
}
else
{
BYTE which_window;
COUNT i;
which_window = 0;
for
(
i = 0;
i < (COUNT)state
&&
(
hStarShip = CloneShipFragment
(
(COUNT)which_ship,
(PQUEUE)(&GLOBAL (built_ship_q)),
(BYTE)
(
(
which_ship == SPATHI_SHIP &&
GET_GAME_STATE (FOUND_PLUTO_SPATHI)
) == 1 ? 1 : 0
)
)
);
i++
)
{
HSTARSHIP hOldShip;
RemoveQueue (
&GLOBAL (built_ship_q),
hStarShip
);
while ((hOldShip = GetStarShipFromIndex (
&GLOBAL (built_ship_q),
which_window++
)))
{
BYTE win_loc;
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hOldShip
);
win_loc = GET_GROUP_LOC (StarShipPtr);
UnlockStarShip (
&GLOBAL (built_ship_q), hOldShip
);
if (which_window <= win_loc)
break;
}
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hStarShip
);
SET_GROUP_LOC (StarShipPtr, which_window - 1);
if (which_ship == SPATHI_SHIP
&& GET_GAME_STATE (FOUND_PLUTO_SPATHI) == 1)
{
OwnStarShip (StarShipPtr,
GOOD_GUY,
NAME_OFFSET + NUM_CAPTAINS_NAMES);
}
UnlockStarShip (
&GLOBAL (built_ship_q), hStarShip
);
InsertQueue (
&GLOBAL (built_ship_q),
hStarShip, hOldShip
);
}
SetSemaphore (GraphicsSem);
DeltaSISGauges (UNDEFINED_DELTA,
UNDEFINED_DELTA, UNDEFINED_DELTA);
ClearSemaphore (GraphicsSem);
return (i);
}
break;
}
}
return (1);
}
return (0);
}
static void
ProcessInput (void)
{
BOOLEAN CanRunAway;
size_t sideI;
#ifdef NETPLAY
netInput ();
#endif
CanRunAway = RunAwayAllowed ();
for (sideI = 0; sideI < NUM_SIDES; sideI++)
{
HSTARSHIP hBattleShip, hNextShip;
size_t cur_player = battleInputOrder[sideI];
for (hBattleShip = GetHeadLink (&race_q[cur_player]);
hBattleShip != 0; hBattleShip = hNextShip)
{
BATTLE_INPUT_STATE InputState;
STARSHIP *StarShipPtr;
StarShipPtr = LockStarShip (&race_q[cur_player], hBattleShip);
hNextShip = _GetSuccLink (StarShipPtr);
if (StarShipPtr->hShip)
{
// TODO: review and see if we have to do this every frame, or
// if we can do this once somewhere
StarShipPtr->control = PlayerControl[cur_player];
InputState = PlayerInput[cur_player]->handlers->frameInput (
PlayerInput[cur_player], StarShipPtr);
#if CREATE_JOURNAL
JournalInput (InputState);
#endif /* CREATE_JOURNAL */
#ifdef NETPLAY
if (!(PlayerControl[cur_player] & NETWORK_CONTROL))
{
BattleInputBuffer *bib = getBattleInputBuffer(cur_player);
Netplay_NotifyAll_battleInput (InputState);
flushPacketQueues ();
BattleInputBuffer_push (bib, InputState);
// Add this input to the end of the buffer.
BattleInputBuffer_pop (bib, &InputState);
// Get the input from the front of the buffer.
}
#endif
StarShipPtr->ship_input_state = 0;
if (StarShipPtr->RaceDescPtr->ship_info.crew_level)
{
if (InputState & BATTLE_LEFT)
StarShipPtr->ship_input_state |= LEFT;
else if (InputState & BATTLE_RIGHT)
StarShipPtr->ship_input_state |= RIGHT;
if (InputState & BATTLE_THRUST)
StarShipPtr->ship_input_state |= THRUST;
if (InputState & BATTLE_WEAPON)
StarShipPtr->ship_input_state |= WEAPON;
if (InputState & BATTLE_SPECIAL)
StarShipPtr->ship_input_state |= SPECIAL;
if (InputState & BATTLE_DOWN)
StarShipPtr->ship_input_state |= DOWN; // JMS_KEYS: Down key is now in use!
if (CanRunAway && cur_player == 0 &&
(InputState & BATTLE_ESCAPE))
DoRunAway (StarShipPtr);
}
}
UnlockStarShip (&race_q[cur_player], hBattleShip);
}
}
#ifdef NETPLAY
flushPacketQueues ();
#endif
if (GLOBAL (CurrentActivity) & (CHECK_LOAD | CHECK_ABORT))
GLOBAL (CurrentActivity) &= ~IN_BATTLE;
}
/*
* What this function does depends on the value of the 'state' argument:
* SPHERE_TRACKING:
* The sphere of influence for the race for 'which_ship' will be shown
* on the starmap in the future.
* The value returned is 'which_ship', unless the type of ship is only
* available in SuperMelee, in which case 0 is returned.
* SPHERE_KNOWN:
* The size of the fleet of the race of 'which_ship' when the starmap was
* last checked is returned.
* ESCORT_WORTH:
* The total value of all the ships escorting the SIS is returned.
* 'which_ship' is ignored.
* ESCORTING_FLAGSHIP:
* Test if a ship of type 'which_ship' is among the escorts of the SIS
* 0 is returned if false, 1 if true.
* FEASIBILITY_STUDY:
* Test if the SIS can have an escort of type 'which_ship'.
* 0 is returned if 'which_ship' is not available.
* Otherwise, the number of ships that can be added is returned.
* CHECK_ALLIANCE:
* Test the alliance status of the race of 'which_ship'.
* Either GOOD_GUY (allied) or BAD_GUY (not allied) is returned.
* 0:
* Ally with the race of 'which_ship'. This makes their ship available
* for building in the shipyard.
* -1:
* End an alliance with the race of 'which_ship'. This ends the possibility
* of building their ships in the shipyard. For the Orz also the ships the
* player has with him will disappear.
* any other positive number:
* Give the player this much ships of type 'which_ship'. If it's
*/
COUNT
ActivateStarShip (COUNT which_ship, SIZE state)
{
HSTARSHIP hStarShip, hNextShip;
hStarShip = GetStarShipFromIndex (
&GLOBAL (avail_race_q), which_ship
);
if (hStarShip)
{
switch (state)
{
case SPHERE_TRACKING:
case SPHERE_KNOWN:
{
EXTENDED_SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (EXTENDED_SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (avail_race_q), hStarShip);
if (state == SPHERE_KNOWN)
which_ship = StarShipPtr->ShipInfo.known_strength;
else if (StarShipPtr->ShipInfo.actual_strength == 0)
{
if (!(StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY)))
which_ship = 0;
}
else if (StarShipPtr->ShipInfo.known_strength == 0
&& StarShipPtr->ShipInfo.actual_strength != (COUNT)~0)
{
StarShipPtr->ShipInfo.known_strength = 1;
StarShipPtr->ShipInfo.known_loc =
StarShipPtr->ShipInfo.loc;
}
UnlockStarShip (&GLOBAL (avail_race_q), hStarShip);
return (which_ship);
}
case ESCORT_WORTH:
{
COUNT ShipCost[] =
{
RACE_SHIP_COST
};
COUNT total = 0;
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (SHIP_FRAGMENTPTR) LockStarShip (
&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
total += ShipCost[GET_RACE_ID (StarShipPtr)];
UnlockStarShip (&GLOBAL (built_ship_q), hStarShip);
}
return total;
}
case ESCORTING_FLAGSHIP:
{
for (hStarShip = GetHeadLink (&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
BYTE ship_type;
SHIP_FRAGMENTPTR StarShipPtr;
StarShipPtr = (SHIP_FRAGMENTPTR) LockStarShip (
&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr);
ship_type = GET_RACE_ID (StarShipPtr);
UnlockStarShip (&GLOBAL (built_ship_q), hStarShip);
if ((COUNT) ship_type == which_ship)
return 1;
}
return 0;
}
case FEASIBILITY_STUDY:
return (MAX_BUILT_SHIPS
- CountLinks (&GLOBAL (built_ship_q)));
default:
{
SHIP_FRAGMENTPTR StarShipPtr;
if (state <= 0)
{
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (avail_race_q), hStarShip
);
if (state == CHECK_ALLIANCE)
{
state = StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY);
UnlockStarShip (&GLOBAL (avail_race_q), hStarShip);
return ((COUNT)state);
}
else if (StarShipPtr->ShipInfo.ship_flags
& (GOOD_GUY | BAD_GUY))
{
StarShipPtr->ShipInfo.ship_flags &= ~(GOOD_GUY | BAD_GUY);
if (state == 0)
StarShipPtr->ShipInfo.ship_flags |= GOOD_GUY;
else
{
StarShipPtr->ShipInfo.ship_flags |= BAD_GUY;
if (which_ship == ORZ_SHIP)
{
BOOLEAN ShipRemoved;
ShipRemoved = FALSE;
for (hStarShip = GetHeadLink (
&GLOBAL (built_ship_q));
hStarShip; hStarShip = hNextShip)
{
BOOLEAN RemoveShip;
SHIP_FRAGMENTPTR StarShipPtr2;
StarShipPtr2 =
(SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hStarShip);
hNextShip = _GetSuccLink (StarShipPtr2);
RemoveShip = (BOOLEAN) (
GET_RACE_ID (StarShipPtr2) ==
ORZ_SHIP);
UnlockStarShip (&GLOBAL (built_ship_q),
hStarShip);
if (RemoveShip)
{
ShipRemoved = TRUE;
RemoveQueue (&GLOBAL (built_ship_q),
hStarShip);
FreeStarShip (&GLOBAL (built_ship_q),
hStarShip);
}
}
if (ShipRemoved)
{
LockMutex (GraphicsLock);
DeltaSISGauges (UNDEFINED_DELTA,
UNDEFINED_DELTA, UNDEFINED_DELTA);
UnlockMutex (GraphicsLock);
}
}
}
}
UnlockStarShip (&GLOBAL (avail_race_q), hStarShip);
}
else
{
/* 'state > 0', add ships to the escorts */
BYTE which_window;
COUNT i;
which_window = 0;
for (i = 0; i < (COUNT)state; i++)
{
HSTARSHIP hOldShip;
BYTE crewLevel;
if (which_ship == SPATHI_SHIP &&
GET_GAME_STATE (FOUND_PLUTO_SPATHI) == 1)
crewLevel = 1; // Only Fwiffo is on board.
else
crewLevel = 0; // Crewed to the max
hStarShip = CloneShipFragment((COUNT) which_ship,
&GLOBAL (built_ship_q), crewLevel);
if (!hStarShip)
break;
RemoveQueue (&GLOBAL (built_ship_q), hStarShip);
while ((hOldShip = GetStarShipFromIndex (
&GLOBAL (built_ship_q), which_window++)))
{
BYTE win_loc;
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hOldShip);
win_loc = GET_GROUP_LOC (StarShipPtr);
UnlockStarShip (&GLOBAL (built_ship_q),
hOldShip);
if (which_window <= win_loc)
break;
}
StarShipPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (built_ship_q), hStarShip);
SET_GROUP_LOC (StarShipPtr, which_window - 1);
if (which_ship == SPATHI_SHIP
&& GET_GAME_STATE (FOUND_PLUTO_SPATHI) == 1)
{
OwnStarShip (StarShipPtr, GOOD_GUY,
NAME_OFFSET + NUM_CAPTAINS_NAMES);
}
UnlockStarShip (&GLOBAL (built_ship_q), hStarShip);
InsertQueue (&GLOBAL (built_ship_q), hStarShip,
hOldShip);
}
LockMutex (GraphicsLock);
DeltaSISGauges (UNDEFINED_DELTA,
UNDEFINED_DELTA, UNDEFINED_DELTA);
UnlockMutex (GraphicsLock);
return (i);
}
break;
}
}
return 1;
}
return 0;
}