static void
druuge_postprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
/* if just fired cannon */
if ((StarShipPtr->cur_status_flags & WEAPON)
&& StarShipPtr->weapon_counter ==
StarShipPtr->RaceDescPtr->characteristics.weapon_wait)
{
COUNT angle;
SIZE cur_delta_x, cur_delta_y;
StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE;
DeltaVelocityComponents (&ElementPtr->velocity,
COSINE (angle, RECOIL_VELOCITY),
SINE (angle, RECOIL_VELOCITY));
GetCurrentVelocityComponents (&ElementPtr->velocity,
&cur_delta_x, &cur_delta_y);
if ((long)cur_delta_x * (long)cur_delta_x
+ (long)cur_delta_y * (long)cur_delta_y
> (long)MAX_RECOIL_VELOCITY * (long)MAX_RECOIL_VELOCITY)
{
angle = ARCTAN (cur_delta_x, cur_delta_y);
SetVelocityComponents (&ElementPtr->velocity,
COSINE (angle, MAX_RECOIL_VELOCITY),
SINE (angle, MAX_RECOIL_VELOCITY));
}
}
}
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
GenerateVux_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
if (CurStarDescPtr->Index == MAIDENS_DEFINED)
{
GenerateDefault_generatePlanets (solarSys);
// XXX: this is the second time that this function is
// called. Is it safe to remove one, or does this change
// the RNG so that the outcome is different?
solarSys->PlanetDesc[0].data_index = REDUX_WORLD;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 212L / 100;
angle = ARCTAN (solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
ComputeSpeed(&solarSys->PlanetDesc[0], FALSE, 1);
}
else
{
if (CurStarDescPtr->Index == VUX_DEFINED)
{
solarSys->PlanetDesc[0].data_index = REDUX_WORLD;
solarSys->PlanetDesc[0].NumPlanets = 1;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 42L / 100;
angle = HALF_CIRCLE + OCTANT;
ComputeSpeed(&solarSys->PlanetDesc[0], FALSE, 1);
}
else /* if (CurStarDescPtr->Index == VUX_BEAST_DEFINED) */
{
memmove (&solarSys->PlanetDesc[1], &solarSys->PlanetDesc[0],
sizeof (solarSys->PlanetDesc[0])
* solarSys->SunDesc[0].NumPlanets);
++solarSys->SunDesc[0].NumPlanets;
angle = HALF_CIRCLE - OCTANT;
solarSys->PlanetDesc[0].data_index = WATER_WORLD;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 110L / 100;
solarSys->PlanetDesc[0].NumPlanets = 0;
ComputeSpeed(&solarSys->PlanetDesc[0], FALSE, 1);
}
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].rand_seed = MAKE_DWORD (
solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
}
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
buzztrack_preprocess (PELEMENT ElementPtr)
{
if (ElementPtr->thrust_wait)
--ElementPtr->thrust_wait;
else
{
COUNT facing = 0;
if (ElementPtr->hTarget == 0
&& TrackShip (ElementPtr, &facing) < 0)
{
ZeroVelocityComponents (&ElementPtr->velocity);
}
else
{
#define ACTIVATE_RANGE 224 /* Originally SPACE_WIDTH */
SIZE delta_x, delta_y;
ELEMENTPTR eptr;
LockElement (ElementPtr->hTarget, &eptr);
delta_x = eptr->current.location.x
- ElementPtr->current.location.x;
delta_y = eptr->current.location.y
- ElementPtr->current.location.y;
UnlockElement (ElementPtr->hTarget);
delta_x = WRAP_DELTA_X (delta_x);
delta_y = WRAP_DELTA_Y (delta_y);
facing = NORMALIZE_FACING (
ANGLE_TO_FACING (ARCTAN (delta_x, delta_y))
);
if (delta_x < 0)
delta_x = -delta_x;
if (delta_y < 0)
delta_y = -delta_y;
delta_x = WORLD_TO_DISPLAY (delta_x);
delta_y = WORLD_TO_DISPLAY (delta_y);
if (delta_x >= ACTIVATE_RANGE
|| delta_y >= ACTIVATE_RANGE
|| (DWORD)((UWORD)delta_x * delta_x)
+ (DWORD)((UWORD)delta_y * delta_y) >=
(DWORD)ACTIVATE_RANGE * ACTIVATE_RANGE)
{
ZeroVelocityComponents (&ElementPtr->velocity);
}
else
{
ElementPtr->thrust_wait = TRACK_WAIT;
SetVelocityVector (&ElementPtr->velocity,
DISPLAY_TO_WORLD (2), facing);
}
}
}
spin_preprocess (ElementPtr);
}
/*----------------------------------------------------------------------
ComputePropandAngle : interpolate proportion of each point over
total list of point
float length; total length
ThotPath *Path; The Path
float *Proportion; per segment % of total length
----------------------------------------------------------------------*/
static void ComputePropandAngle (AnimPath *pop_path)
{
int i, npoints = 0;
float x, y, totallength, length;
ThotPoint *points;
float *proportion, *angle;
points = pop_path->Path;
npoints = pop_path->npoints;
proportion = (float *) TtaGetMemory (npoints * sizeof(float));
angle = (float *) TtaGetMemory (npoints * sizeof(float));
totallength = 0;
proportion[0] = 0;
for (i = 1; i < npoints; i++)
{
x = (float)(points[i].x - points[i-1].x);
y = (float)(points[i].y - points[i-1].y);
length = (float)sqrt(x*x + y*y);
/*
/|
/ |
/ |
/ |
/ |
/ |
/ |
/ _|
/ angle| |
+-------+-+
<--- x -->
cos j = a1 / square root(a1*a1 + a2*a2)
if (length > 0)
angle[i] = acos (x / length)
else
angle[i] = 90;
*/
if (fabs (y) < 0.0001)
angle[i] = (float)ARCTAN (x/y);
else
angle[i] = 90.;
totallength += length;
proportion[i] = totallength;
}
if (totallength == 0)
totallength = 1;
for (i = 1; i < npoints; i++)
{
proportion[i] = proportion[i] / totallength;
}
pop_path->Proportion = proportion;
pop_path->length = totallength;
pop_path->Tangent_angle = angle;
}
int main()
{
double a, r;
a = __VERIFIER_nondet_double();
__VERIFIER_assume(a >= -1.79e308 && a <= 1.79e308);
r = ARCTAN(a);
__VERIFIER_assert(r >= -1.571 && r <= 1.571);
return 0;
}
static void
doggy_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
++StarShipPtr->special_counter;
if (ElementPtr->thrust_wait > 0) /* could be non-zero after a collision */
--ElementPtr->thrust_wait;
else
{
COUNT facing, orig_facing;
SIZE delta_facing;
facing = orig_facing =
NORMALIZE_FACING (ANGLE_TO_FACING (
GetVelocityTravelAngle (&ElementPtr->velocity)
));
if ((delta_facing = TrackShip (ElementPtr, &facing)) < 0)
facing = NORMALIZE_FACING (TFB_Random ());
else
{
ELEMENT *ShipPtr;
LockElement (ElementPtr->hTarget, &ShipPtr);
facing = NORMALIZE_FACING (ANGLE_TO_FACING (
ARCTAN (ShipPtr->current.location.x -
ElementPtr->current.location.x,
ShipPtr->current.location.y -
ElementPtr->current.location.y)
));
delta_facing = NORMALIZE_FACING (facing -
GetFrameIndex (ShipPtr->current.image.frame));
UnlockElement (ElementPtr->hTarget);
if (delta_facing > ANGLE_TO_FACING (HALF_CIRCLE - OCTANT) &&
delta_facing < ANGLE_TO_FACING (HALF_CIRCLE + OCTANT))
{
if (delta_facing >= ANGLE_TO_FACING (HALF_CIRCLE))
facing -= ANGLE_TO_FACING (QUADRANT);
else
facing += ANGLE_TO_FACING (QUADRANT);
}
facing = NORMALIZE_FACING (facing);
}
if (facing != orig_facing)
SetVelocityVector (&ElementPtr->velocity,
DOGGY_SPEED, facing);
}
}
static void
spathi_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,
COUNT ConcernCounter)
{
STARSHIP *StarShipPtr;
EVALUATE_DESC *lpEvalDesc;
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
GetElementStarShip (ShipPtr, &StarShipPtr);
StarShipPtr->ship_input_state &= ~SPECIAL;
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
if (StarShipPtr->special_counter == 0
&& lpEvalDesc->ObjectPtr
&& lpEvalDesc->which_turn <= 24)
{
COUNT travel_facing, direction_facing;
SIZE delta_x, delta_y;
travel_facing = NORMALIZE_FACING (
ANGLE_TO_FACING (GetVelocityTravelAngle (&ShipPtr->velocity)
+ HALF_CIRCLE)
);
delta_x = lpEvalDesc->ObjectPtr->current.location.x
- ShipPtr->current.location.x;
delta_y = lpEvalDesc->ObjectPtr->current.location.y
- ShipPtr->current.location.y;
direction_facing = NORMALIZE_FACING (
ANGLE_TO_FACING (ARCTAN (delta_x, delta_y))
);
if (NORMALIZE_FACING (direction_facing
- (StarShipPtr->ShipFacing + ANGLE_TO_FACING (HALF_CIRCLE))
+ ANGLE_TO_FACING (QUADRANT))
<= ANGLE_TO_FACING (HALF_CIRCLE)
&& (lpEvalDesc->which_turn <= 8
|| NORMALIZE_FACING (direction_facing
+ ANGLE_TO_FACING (HALF_CIRCLE)
- ANGLE_TO_FACING (GetVelocityTravelAngle (
&lpEvalDesc->ObjectPtr->velocity
))
+ ANGLE_TO_FACING (QUADRANT))
<= ANGLE_TO_FACING (HALF_CIRCLE))
&& (!(StarShipPtr->cur_status_flags &
(SHIP_BEYOND_MAX_SPEED | SHIP_IN_GRAVITY_WELL))
|| NORMALIZE_FACING (direction_facing
- travel_facing + ANGLE_TO_FACING (QUADRANT))
<= ANGLE_TO_FACING (HALF_CIRCLE)))
StarShipPtr->ship_input_state |= SPECIAL;
}
}
static bool
GenerateColony_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
PLANET_DESC *pMinPlanet;
pMinPlanet = &solarSys->PlanetDesc[0];
FillOrbits (solarSys, (BYTE)~0, pMinPlanet, FALSE);
pMinPlanet->radius = EARTH_RADIUS * 115L / 100;
angle = ARCTAN (pMinPlanet->location.x, pMinPlanet->location.y);
pMinPlanet->location.x = COSINE (angle, pMinPlanet->radius);
pMinPlanet->location.y = SINE (angle, pMinPlanet->radius);
pMinPlanet->data_index = WATER_WORLD | PLANET_SHIELDED;
return true;
}
static bool
GenerateBurvixese_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
solarSys->PlanetDesc[0].data_index = REDUX_WORLD;
solarSys->PlanetDesc[0].NumPlanets = 1;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 39L / 100;
angle = ARCTAN (solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
return true;
}
static bool
GenerateAndrosynth_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
solarSys->PlanetDesc[1].data_index = TELLURIC_WORLD;
solarSys->PlanetDesc[1].radius = EARTH_RADIUS * 204L / 100;
angle = ARCTAN (solarSys->PlanetDesc[1].location.x,
solarSys->PlanetDesc[1].location.y);
solarSys->PlanetDesc[1].location.x =
COSINE (angle, solarSys->PlanetDesc[1].radius);
solarSys->PlanetDesc[1].location.y =
SINE (angle, solarSys->PlanetDesc[1].radius);
ComputeSpeed(&solarSys->PlanetDesc[1], FALSE, 1);
return true;
}
static bool
GenerateSupox_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
solarSys->PlanetDesc[0].data_index = WATER_WORLD;
solarSys->PlanetDesc[0].NumPlanets = 2;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 152L / 100;
angle = ARCTAN (solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
ComputeSpeed(&solarSys->PlanetDesc[0], FALSE, 1);
return true;
}
static bool
GenerateUtwig_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
if (CurStarDescPtr->Index == UTWIG_DEFINED)
{
solarSys->PlanetDesc[0].data_index = WATER_WORLD;
solarSys->PlanetDesc[0].NumPlanets = 1;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 174L / 100;
angle = ARCTAN (solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
ComputeSpeed(&solarSys->PlanetDesc[0], FALSE, 1);
}
return true;
}
static bool
GenerateRainbowWorld_generatePlanets (SOLARSYS_STATE *solarSys)
{
COUNT angle;
GenerateDefault_generatePlanets (solarSys);
solarSys->PlanetDesc[0].data_index = RAINBOW_WORLD;
solarSys->PlanetDesc[0].NumPlanets = 0;
solarSys->PlanetDesc[0].radius = EARTH_RADIUS * 50L / 100;
angle = ARCTAN (solarSys->PlanetDesc[0].location.x,
solarSys->PlanetDesc[0].location.y);
if (angle <= QUADRANT)
angle += QUADRANT;
else if (angle >= FULL_CIRCLE - QUADRANT)
angle -= QUADRANT;
solarSys->PlanetDesc[0].location.x =
COSINE (angle, solarSys->PlanetDesc[0].radius);
solarSys->PlanetDesc[0].location.y =
SINE (angle, solarSys->PlanetDesc[0].radius);
return true;
}
static bool
GenerateSpathi_generatePlanets (SOLARSYS_STATE *solarSys)
{
PLANET_DESC *pMinPlanet;
COUNT angle;
pMinPlanet = &solarSys->PlanetDesc[0];
solarSys->SunDesc[0].NumPlanets = 1;
FillOrbits (solarSys,
solarSys->SunDesc[0].NumPlanets, pMinPlanet, FALSE);
pMinPlanet->radius = EARTH_RADIUS * 1150L / 100;
angle = ARCTAN (pMinPlanet->location.x, pMinPlanet->location.y);
pMinPlanet->location.x = COSINE (angle, pMinPlanet->radius);
pMinPlanet->location.y = SINE (angle, pMinPlanet->radius);
pMinPlanet->data_index = WATER_WORLD;
pMinPlanet->alternate_colormap = NULL;
if (GET_GAME_STATE (SPATHI_SHIELDED_SELVES))
pMinPlanet->data_index |= PLANET_SHIELDED;
pMinPlanet->NumPlanets = 1;
ComputeSpeed(pMinPlanet, FALSE, 1);
return true;
}
static void
cannon_collision (ELEMENT *ElementPtr0, POINT *pPt0,
ELEMENT *ElementPtr1, POINT *pPt1)
{
weapon_collision (ElementPtr0, pPt0, ElementPtr1, pPt1);
if ((ElementPtr1->state_flags & PLAYER_SHIP)
&& ElementPtr1->crew_level
&& !GRAVITY_MASS (ElementPtr1->mass_points + 1))
{
COUNT angle;
SIZE cur_delta_x, cur_delta_y;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr1, &StarShipPtr);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
angle = FACING_TO_ANGLE (
GetFrameIndex (ElementPtr0->next.image.frame)
);
DeltaVelocityComponents (&ElementPtr1->velocity,
COSINE (angle, RECOIL_VELOCITY),
SINE (angle, RECOIL_VELOCITY));
GetCurrentVelocityComponents (&ElementPtr1->velocity,
&cur_delta_x, &cur_delta_y);
if ((long)cur_delta_x * (long)cur_delta_x
+ (long)cur_delta_y * (long)cur_delta_y
> (long)MAX_RECOIL_VELOCITY * (long)MAX_RECOIL_VELOCITY)
{
angle = ARCTAN (cur_delta_x, cur_delta_y);
SetVelocityComponents (&ElementPtr1->velocity,
COSINE (angle, MAX_RECOIL_VELOCITY),
SINE (angle, MAX_RECOIL_VELOCITY));
}
}
}
void
GeneratePkunk (BYTE control)
{
switch (control)
{
case GENERATE_ENERGY:
if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0])
{
COUNT i, which_node;
DWORD rand_val, old_rand;
old_rand = TFB_SeedRandom (
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN]
);
which_node = i = 0;
do
{
rand_val = TFB_Random ();
pSolarSysState->SysInfo.PlanetInfo.CurPt.x =
(LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8;
pSolarSysState->SysInfo.PlanetInfo.CurPt.y =
(HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8;
if (!GET_GAME_STATE (CLEAR_SPINDLE))
pSolarSysState->SysInfo.PlanetInfo.CurType = 0;
else
pSolarSysState->SysInfo.PlanetInfo.CurType = 1;
pSolarSysState->SysInfo.PlanetInfo.CurDensity = 0;
if (pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
& (1L << i))
{
pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
&= ~(1L << i);
if (!GET_GAME_STATE (CLEAR_SPINDLE))
{
((PPLANETSIDE_DESC)pMenuState->ModuleFrame)->InTransit = TRUE;
SET_GAME_STATE (CLEAR_SPINDLE, 1);
SET_GAME_STATE (CLEAR_SPINDLE_ON_SHIP, 1);
}
}
if (which_node >= pSolarSysState->CurNode
&& !(pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
& (1L << i)))
break;
++which_node;
} while (++i < 16);
pSolarSysState->CurNode = which_node;
TFB_SeedRandom (old_rand);
break;
}
pSolarSysState->CurNode = 0;
break;
case GENERATE_PLANETS:
{
COUNT angle;
GenerateRandomIP (GENERATE_PLANETS);
pSolarSysState->PlanetDesc[0].data_index = WATER_WORLD;
pSolarSysState->PlanetDesc[0].NumPlanets = 1;
pSolarSysState->PlanetDesc[0].radius = EARTH_RADIUS * 104L / 100;
angle = ARCTAN (
pSolarSysState->PlanetDesc[0].location.x,
pSolarSysState->PlanetDesc[0].location.y
);
pSolarSysState->PlanetDesc[0].location.x =
COSINE (angle, pSolarSysState->PlanetDesc[0].radius);
pSolarSysState->PlanetDesc[0].location.y =
SINE (angle, pSolarSysState->PlanetDesc[0].radius);
break;
}
case GENERATE_ORBITAL:
if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0])
{
if (ActivateStarShip (PKUNK_SHIP, SPHERE_TRACKING))
{
NotifyOthers (PKUNK_SHIP, (BYTE)~0);
PutGroupInfo (GROUPS_RANDOM, GROUP_SAVE_IP);
ReinitQueue (&GLOBAL (npc_built_ship_q));
CloneShipFragment (PKUNK_SHIP,
&GLOBAL (npc_built_ship_q), INFINITE_FLEET);
pSolarSysState->MenuState.Initialized += 2;
GLOBAL (CurrentActivity) |= START_INTERPLANETARY;
SET_GAME_STATE (GLOBAL_FLAGS_AND_DATA, 1 << 7);
InitCommunication (PKUNK_CONVERSATION);
pSolarSysState->MenuState.Initialized -= 2;
if (!(GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_LOAD)))
{
GLOBAL (CurrentActivity) &= ~START_INTERPLANETARY;
ReinitQueue (&GLOBAL (npc_built_ship_q));
GetGroupInfo (GROUPS_RANDOM, GROUP_LOAD_IP);
}
break;
}
else
{
LoadStdLanderFont (&pSolarSysState->SysInfo.PlanetInfo);
pSolarSysState->PlanetSideFrame[1] =
CaptureDrawable (
LoadGraphic (RUINS_MASK_PMAP_ANIM)
);
pSolarSysState->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (
LoadStringTable (PKUNK_RUINS_STRTAB)
);
if (GET_GAME_STATE (CLEAR_SPINDLE))
pSolarSysState->SysInfo.PlanetInfo.DiscoveryString =
SetAbsStringTableIndex (
pSolarSysState->SysInfo.PlanetInfo.DiscoveryString,
1
);
}
}
default:
GenerateRandomIP (control);
break;
}
}
BOOLEAN
CalculateGravity (ELEMENT *ElementPtr)
{
BOOLEAN retval, HasGravity;
HELEMENT hTestElement, hSuccElement;
retval = FALSE;
HasGravity = (BOOLEAN)(CollidingElement (ElementPtr)
&& GRAVITY_MASS (ElementPtr->mass_points + 1));
for (hTestElement = GetHeadElement ();
hTestElement != 0; hTestElement = hSuccElement)
{
BOOLEAN TestHasGravity;
ELEMENT *TestElementPtr;
LockElement (hTestElement, &TestElementPtr);
if (TestElementPtr != ElementPtr
&& CollidingElement (TestElementPtr)
&& (TestHasGravity =
GRAVITY_MASS (TestElementPtr->mass_points + 1)) != HasGravity)
{
COUNT abs_dx, abs_dy;
SIZE dx, dy;
if (!(ElementPtr->state_flags & PRE_PROCESS))
{
dx = ElementPtr->current.location.x
- TestElementPtr->current.location.x;
dy = ElementPtr->current.location.y
- TestElementPtr->current.location.y;
}
else
{
dx = ElementPtr->next.location.x
- TestElementPtr->next.location.x;
dy = ElementPtr->next.location.y
- TestElementPtr->next.location.y;
}
#ifdef DEBUG_GRAVITY
if (TestElementPtr->state_flags & PLAYER_SHIP)
{
log_add (log_Debug, "CalculateGravity:");
log_add (log_Debug, "\tdx = %d, dy = %d", dx, dy);
}
#endif /* DEBUG_GRAVITY */
dx = WRAP_DELTA_X (dx);
dy = WRAP_DELTA_Y (dy);
#ifdef DEBUG_GRAVITY
if (TestElementPtr->state_flags & PLAYER_SHIP)
log_add (log_Debug, "\twrap_dx = %d, wrap_dy = %d", dx, dy);
#endif /* DEBUG_GRAVITY */
abs_dx = dx >= 0 ? dx : -dx;
abs_dy = dy >= 0 ? dy : -dy;
abs_dx = WORLD_TO_DISPLAY (abs_dx);
abs_dy = WORLD_TO_DISPLAY (abs_dy);
#ifdef DEBUG_GRAVITY
if (TestElementPtr->state_flags & PLAYER_SHIP)
log_add (log_Debug, "\tdisplay_dx = %d, display_dy = %d",
abs_dx, abs_dy);
#endif /* DEBUG_GRAVITY */
if (abs_dx <= GRAVITY_THRESHOLD
&& abs_dy <= GRAVITY_THRESHOLD)
{
DWORD dist_squared;
dist_squared = (DWORD)(abs_dx * abs_dx)
+ (DWORD)(abs_dy * abs_dy);
if (dist_squared <= (DWORD)(GRAVITY_THRESHOLD
* GRAVITY_THRESHOLD))
{
#ifdef NEVER
COUNT magnitude;
#define DIFUSE_GRAVITY RES_SCALE(175) // JMS_GFX: Because of the ifdef NEVER this is actually never run. Well, changed it for consistency
dist_squared += (DWORD)abs_dx * (DIFUSE_GRAVITY << 1)
+ (DWORD)abs_dy * (DIFUSE_GRAVITY << 1)
+ ((DWORD)(DIFUSE_GRAVITY * DIFUSE_GRAVITY) << 1);
if ((magnitude = (COUNT)((DWORD)(GRAVITY_THRESHOLD
* GRAVITY_THRESHOLD) / dist_squared)) == 0)
magnitude = 1;
#define MAX_MAGNITUDE RES_SCALE(6) // JMS_GFX: Because of the ifdef NEVER this is actually never run. Well, changed it for consistency
else if (magnitude > MAX_MAGNITUDE)
magnitude = MAX_MAGNITUDE;
log_add (log_Debug, "magnitude = %u", magnitude);
#endif /* NEVER */
#ifdef DEBUG_GRAVITY
if (TestElementPtr->state_flags & PLAYER_SHIP)
log_add (log_Debug, "dist_squared = %lu", dist_squared);
#endif /* DEBUG_GRAVITY */
if (TestHasGravity)
{
retval = TRUE;
UnlockElement (hTestElement);
break;
}
else
{
COUNT angle;
angle = ARCTAN (dx, dy);
DeltaVelocityComponents (&TestElementPtr->velocity,
COSINE (angle, WORLD_TO_VELOCITY (RES_SCALE(1))),
SINE (angle, WORLD_TO_VELOCITY (RES_SCALE(1)))); // JMS_GFX
if (TestElementPtr->state_flags & PLAYER_SHIP)
{
STARSHIP *StarShipPtr;
GetElementStarShip (TestElementPtr, &StarShipPtr);
StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;
StarShipPtr->cur_status_flags |= SHIP_IN_GRAVITY_WELL;
}
}
}
}
}
hSuccElement = GetSuccElement (TestElementPtr);
UnlockElement (hTestElement);
}
return (retval);
}
static void
supox_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,
COUNT ConcernCounter)
{
STARSHIP *StarShipPtr;
EVALUATE_DESC *lpEvalDesc;
GetElementStarShip (ShipPtr, &StarShipPtr);
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
if (StarShipPtr->special_counter || lpEvalDesc->ObjectPtr == 0)
StarShipPtr->ship_input_state &= ~SPECIAL;
else
{
BOOLEAN LinedUp;
COUNT direction_angle;
SIZE delta_x, delta_y;
delta_x = lpEvalDesc->ObjectPtr->next.location.x
- ShipPtr->next.location.x;
delta_y = lpEvalDesc->ObjectPtr->next.location.y
- ShipPtr->next.location.y;
direction_angle = ARCTAN (delta_x, delta_y);
LinedUp = (BOOLEAN)(NORMALIZE_ANGLE (NORMALIZE_ANGLE (direction_angle
- FACING_TO_ANGLE (StarShipPtr->ShipFacing))
+ QUADRANT) <= HALF_CIRCLE);
if (!LinedUp
|| lpEvalDesc->which_turn > 20
|| NORMALIZE_ANGLE (
lpEvalDesc->facing
- (FACING_TO_ANGLE (StarShipPtr->ShipFacing)
+ HALF_CIRCLE) + OCTANT
) > QUADRANT)
StarShipPtr->ship_input_state &= ~SPECIAL;
else if (LinedUp && lpEvalDesc->which_turn <= 12)
StarShipPtr->ship_input_state |= SPECIAL;
if (StarShipPtr->ship_input_state & SPECIAL)
lpEvalDesc->MoveState = PURSUE;
}
ship_intelligence (ShipPtr,
ObjectsOfConcern, ConcernCounter);
if (StarShipPtr->ship_input_state & SPECIAL)
StarShipPtr->ship_input_state |= THRUST | WEAPON;
lpEvalDesc = &ObjectsOfConcern[ENEMY_WEAPON_INDEX];
if (StarShipPtr->special_counter == 0
&& lpEvalDesc->ObjectPtr
&& lpEvalDesc->MoveState == AVOID
&& ShipPtr->turn_wait == 0)
{
StarShipPtr->ship_input_state &= ~THRUST;
StarShipPtr->ship_input_state |= SPECIAL;
if (!(StarShipPtr->cur_status_flags & (LEFT | RIGHT)))
StarShipPtr->ship_input_state |= 1 << ((BYTE)TFB_Random () & 1);
else
StarShipPtr->ship_input_state |=
StarShipPtr->cur_status_flags & (LEFT | RIGHT);
}
}
static void
butt_missile_preprocess (ELEMENT *ElementPtr)
{
if (ElementPtr->turn_wait > 0)
--ElementPtr->turn_wait;
else
{
COUNT facing;
// COUNT num_frames;
SIZE delta_x, delta_y, delta_facing;
ELEMENT *EnemyPtr;
facing = GetFrameIndex (ElementPtr->next.image.frame);
if (ElementPtr->hTarget)
{
LockElement (ElementPtr->hTarget, &EnemyPtr);
delta_x = EnemyPtr->current.location.x
- ElementPtr->current.location.x;
delta_x = WRAP_DELTA_X (delta_x);
delta_y = EnemyPtr->current.location.y
- ElementPtr->current.location.y;
delta_y = WRAP_DELTA_Y (delta_y);
/* num_frames = (square_root ((long)delta_x * delta_x
+ (long)delta_y * delta_y)) / DISCRIMINATOR_SPEED;
if (num_frames == 0)
num_frames = 1;
GetNextVelocityComponents (&EnemyPtr->velocity,
&delta_x, &delta_y, num_frames);
// Lead the target by its apparent trajectory.
delta_x = (EnemyPtr->current.location.x + (delta_x / 2))
- ElementPtr->current.location.x;
delta_y = (EnemyPtr->current.location.y + (delta_y / 2))
- ElementPtr->current.location.y; */
delta_facing = NORMALIZE_FACING (
ANGLE_TO_FACING (ARCTAN (delta_x, delta_y)) - facing);
if (delta_facing > 0 && !OBJECT_CLOAKED(EnemyPtr))
{
if (delta_facing == ANGLE_TO_FACING (HALF_CIRCLE))
facing += (((BYTE)TFB_Random () & 1) << 1) - 1;
else if (delta_facing < ANGLE_TO_FACING (HALF_CIRCLE))
++facing;
else
--facing;
}
ElementPtr->next.image.frame =
SetAbsFrameIndex (ElementPtr->next.image.frame, facing);
ElementPtr->state_flags |= CHANGING;
SetVelocityVector (&ElementPtr->velocity, DISCRIMINATOR_SPEED, facing);
UnlockElement (ElementPtr->hTarget);
}
else if (TrackShip (ElementPtr, &facing) > 0)
{
ElementPtr->next.image.frame =
SetAbsFrameIndex (ElementPtr->next.image.frame,
facing);
ElementPtr->state_flags |= CHANGING;
SetVelocityVector (&ElementPtr->velocity,
DISCRIMINATOR_SPEED, facing);
}
ElementPtr->turn_wait = TRACK_WAIT;
}
}
static void
androsynth_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,
COUNT ConcernCounter)
{
EVALUATE_DESC *lpEvalDesc;
STARSHIP *StarShipPtr;
GetElementStarShip (ShipPtr, &StarShipPtr);
lpEvalDesc = &ObjectsOfConcern[ENEMY_WEAPON_INDEX];
/* in blazer form */
if (ShipPtr->next.image.farray == StarShipPtr->RaceDescPtr->ship_data.special)
{
ObjectsOfConcern[CREW_OBJECT_INDEX].ObjectPtr = 0;
if (lpEvalDesc->ObjectPtr && lpEvalDesc->MoveState == ENTICE)
{
if ((lpEvalDesc->ObjectPtr->state_flags & FINITE_LIFE)
&& !(lpEvalDesc->ObjectPtr->state_flags & CREW_OBJECT))
lpEvalDesc->MoveState = AVOID;
else
lpEvalDesc->ObjectPtr = 0;
}
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
}
else
{
STARSHIP *pEnemyStarShip = NULL;
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
if (lpEvalDesc->ObjectPtr)
{
GetElementStarShip (lpEvalDesc->ObjectPtr, &pEnemyStarShip);
// JMS_GFX
if (lpEvalDesc->which_turn <= 16
&& (StarShipPtr->special_counter > 0
|| StarShipPtr->RaceDescPtr->ship_info.energy_level < MAX_ENERGY / 3
|| ((WEAPON_RANGE (&pEnemyStarShip->RaceDescPtr->cyborg_control) <= (CLOSE_RANGE_WEAPON << RESOLUTION_FACTOR)
&& lpEvalDesc->ObjectPtr->crew_level > BLAZER_DAMAGE)
|| (lpEvalDesc->ObjectPtr->crew_level > (BLAZER_DAMAGE * 3)
&& MANEUVERABILITY (&pEnemyStarShip->RaceDescPtr->cyborg_control) > SLOW_SHIP))))
lpEvalDesc->MoveState = ENTICE;
}
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
if (StarShipPtr->special_counter == 0)
{
StarShipPtr->ship_input_state &= ~SPECIAL;
// JMS_GFX
if ((ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr
&& ObjectsOfConcern[ENEMY_WEAPON_INDEX].which_turn <= 4)
|| (lpEvalDesc->ObjectPtr
&& StarShipPtr->RaceDescPtr->ship_info.energy_level >= MAX_ENERGY / 3
&& (WEAPON_RANGE (&pEnemyStarShip->RaceDescPtr->cyborg_control) >=
WEAPON_RANGE (&StarShipPtr->RaceDescPtr->cyborg_control) << 1
|| (lpEvalDesc->which_turn < 16
&& (WEAPON_RANGE (&pEnemyStarShip->RaceDescPtr->cyborg_control) > (CLOSE_RANGE_WEAPON << RESOLUTION_FACTOR)
|| lpEvalDesc->ObjectPtr->crew_level <= BLAZER_DAMAGE)
&& (lpEvalDesc->ObjectPtr->crew_level <= (BLAZER_DAMAGE * 3)
|| MANEUVERABILITY (&pEnemyStarShip->RaceDescPtr->cyborg_control) <=
SLOW_SHIP)))))
StarShipPtr->ship_input_state |= SPECIAL;
}
if (!(StarShipPtr->ship_input_state & SPECIAL)
&& StarShipPtr->weapon_counter == 0
&& lpEvalDesc->ObjectPtr)
{
if (lpEvalDesc->which_turn <= 4)
StarShipPtr->ship_input_state |= WEAPON;
else if (lpEvalDesc->MoveState != PURSUE
&& lpEvalDesc->which_turn <= 12)
{
COUNT travel_facing, direction_facing;
SIZE delta_x, delta_y,
ship_delta_x, ship_delta_y,
other_delta_x, other_delta_y;
GetCurrentVelocityComponents (&ShipPtr->velocity,
&ship_delta_x, &ship_delta_y);
GetCurrentVelocityComponents (&lpEvalDesc->ObjectPtr->velocity,
&other_delta_x, &other_delta_y);
delta_x = ship_delta_x - other_delta_x;
delta_y = ship_delta_y - other_delta_y;
travel_facing = ARCTAN (delta_x, delta_y);
delta_x =
lpEvalDesc->ObjectPtr->next.location.x -
ShipPtr->next.location.x;
delta_y =
lpEvalDesc->ObjectPtr->next.location.y -
ShipPtr->next.location.y;
direction_facing = ARCTAN (delta_x, delta_y);
if (NORMALIZE_ANGLE (travel_facing
- direction_facing + OCTANT) <= QUADRANT)
StarShipPtr->ship_input_state |= WEAPON;
}
}
}
}
static void
mmrnmhrm_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern,
COUNT ConcernCounter)
{
BOOLEAN CanTransform;
EVALUATE_DESC *lpEvalDesc;
STARSHIP *StarShipPtr;
STARSHIP *EnemyStarShipPtr;
GetElementStarShip (ShipPtr, &StarShipPtr);
CanTransform = (BOOLEAN)(StarShipPtr->special_counter == 0
&& StarShipPtr->RaceDescPtr->ship_info.energy_level >=
StarShipPtr->RaceDescPtr->characteristics.special_energy_cost);
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
if (lpEvalDesc->ObjectPtr)
{
GetElementStarShip (lpEvalDesc->ObjectPtr, &EnemyStarShipPtr);
}
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
StarShipPtr->ship_input_state &= ~SPECIAL;
if (CanTransform
&& lpEvalDesc->ObjectPtr
&& !(StarShipPtr->ship_input_state & WEAPON))
{
SIZE delta_x, delta_y;
COUNT travel_angle, direction_angle;
GetCurrentVelocityComponents (&lpEvalDesc->ObjectPtr->velocity,
&delta_x, &delta_y);
if (delta_x == 0 && delta_y == 0)
direction_angle = travel_angle = 0;
else
{
delta_x = lpEvalDesc->ObjectPtr->current.location.x
- ShipPtr->current.location.x;
delta_y = lpEvalDesc->ObjectPtr->current.location.y
- ShipPtr->current.location.y;
direction_angle = ARCTAN (-delta_x, -delta_y);
travel_angle = GetVelocityTravelAngle (
&lpEvalDesc->ObjectPtr->velocity
);
}
if (ShipPtr->next.image.farray == StarShipPtr->RaceDescPtr->ship_data.ship)
{
if (lpEvalDesc->which_turn > 8)
{
if (MANEUVERABILITY (&EnemyStarShipPtr->RaceDescPtr->cyborg_control) <= SLOW_SHIP
|| NORMALIZE_ANGLE (
direction_angle - travel_angle + QUADRANT
) > HALF_CIRCLE)
StarShipPtr->ship_input_state |= SPECIAL;
}
}
else
{
SIZE ship_delta_x, ship_delta_y;
GetCurrentVelocityComponents (&ShipPtr->velocity,
&ship_delta_x, &ship_delta_y);
delta_x -= ship_delta_x;
delta_y -= ship_delta_y;
travel_angle = ARCTAN (delta_x, delta_y);
if (lpEvalDesc->which_turn < 16)
{
if (lpEvalDesc->which_turn <= 8
|| NORMALIZE_ANGLE (
direction_angle - travel_angle + OCTANT
) <= QUADRANT)
StarShipPtr->ship_input_state |= SPECIAL;
}
else if (lpEvalDesc->which_turn > 32
&& NORMALIZE_ANGLE (
direction_angle - travel_angle + QUADRANT
) > HALF_CIRCLE)
StarShipPtr->ship_input_state |= SPECIAL;
}
}
if (ShipPtr->current.image.farray == StarShipPtr->RaceDescPtr->ship_data.special)
{
if (!(StarShipPtr->ship_input_state & SPECIAL)
&& lpEvalDesc->ObjectPtr)
StarShipPtr->ship_input_state |= WEAPON;
else
StarShipPtr->ship_input_state &= ~WEAPON;
}
}
void
GenerateBurvixes (BYTE control)
{
COUNT i;
DWORD rand_val;
switch (control)
{
case GENERATE_ENERGY:
{
DWORD rand_val, old_rand;
if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0])
{
COUNT which_node;
old_rand = TFB_SeedRandom (
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN]
);
which_node = i = 0;
do
{
rand_val = TFB_Random ();
pSolarSysState->SysInfo.PlanetInfo.CurPt.x =
(LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8;
pSolarSysState->SysInfo.PlanetInfo.CurPt.y =
(HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8;
pSolarSysState->SysInfo.PlanetInfo.CurType = 1;
pSolarSysState->SysInfo.PlanetInfo.CurDensity = 0;
if (which_node >= pSolarSysState->CurNode
&& !(pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
& (1L << i)))
break;
++which_node;
} while (++i < 16);
pSolarSysState->CurNode = which_node;
TFB_SeedRandom (old_rand);
break;
}
else if (pSolarSysState->pOrbitalDesc->pPrevDesc == &pSolarSysState->PlanetDesc[0]
&& pSolarSysState->pOrbitalDesc == &pSolarSysState->MoonDesc[0]
&& !GET_GAME_STATE (BURVIXESE_BROADCASTERS))
{
old_rand = TFB_SeedRandom (
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN]
);
rand_val = TFB_Random ();
pSolarSysState->SysInfo.PlanetInfo.CurPt.x =
(LOBYTE (LOWORD (rand_val)) % (MAP_WIDTH - (8 << 1))) + 8;
pSolarSysState->SysInfo.PlanetInfo.CurPt.y =
(HIBYTE (LOWORD (rand_val)) % (MAP_HEIGHT - (8 << 1))) + 8;
pSolarSysState->SysInfo.PlanetInfo.CurDensity = 0;
pSolarSysState->SysInfo.PlanetInfo.CurType = 0;
if (!(pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
& (1L << 0))
&& pSolarSysState->CurNode == (COUNT)~0)
pSolarSysState->CurNode = 1;
else
{
pSolarSysState->CurNode = 0;
if (pSolarSysState->SysInfo.PlanetInfo.ScanRetrieveMask[ENERGY_SCAN]
& (1L << 0))
{
SET_GAME_STATE (BURVIXESE_BROADCASTERS, 1);
SET_GAME_STATE (BURV_BROADCASTERS_ON_SHIP, 1);
}
}
TFB_SeedRandom (old_rand);
break;
}
pSolarSysState->CurNode = 0;
break;
}
case GENERATE_MOONS:
GenerateRandomIP (GENERATE_MOONS);
if (pSolarSysState->pBaseDesc == &pSolarSysState->PlanetDesc[0])
{
COUNT angle;
pSolarSysState->MoonDesc[0].data_index = SELENIC_WORLD;
pSolarSysState->MoonDesc[0].radius = MIN_MOON_RADIUS
+ (MAX_MOONS - 1) * MOON_DELTA;
rand_val = TFB_Random ();
angle = NORMALIZE_ANGLE (LOWORD (rand_val));
pSolarSysState->MoonDesc[0].location.x =
COSINE (angle, pSolarSysState->MoonDesc[0].radius);
pSolarSysState->MoonDesc[0].location.y =
SINE (angle, pSolarSysState->MoonDesc[0].radius);
}
break;
case GENERATE_PLANETS:
{
COUNT angle;
GenerateRandomIP (GENERATE_PLANETS);
pSolarSysState->PlanetDesc[0].data_index = REDUX_WORLD;
pSolarSysState->PlanetDesc[0].NumPlanets = 1;
pSolarSysState->PlanetDesc[0].radius = EARTH_RADIUS * 39L / 100;
angle = ARCTAN (
pSolarSysState->PlanetDesc[0].location.x,
pSolarSysState->PlanetDesc[0].location.y
);
pSolarSysState->PlanetDesc[0].location.x =
COSINE (angle, pSolarSysState->PlanetDesc[0].radius);
pSolarSysState->PlanetDesc[0].location.y =
SINE (angle, pSolarSysState->PlanetDesc[0].radius);
break;
}
case GENERATE_ORBITAL:
{
rand_val = DoPlanetaryAnalysis (
&pSolarSysState->SysInfo, pSolarSysState->pOrbitalDesc
);
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[BIOLOGICAL_SCAN] = rand_val;
i = (COUNT)~0;
rand_val = GenerateLifeForms (&pSolarSysState->SysInfo, &i);
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[MINERAL_SCAN] = rand_val;
i = (COUNT)~0;
GenerateMineralDeposits (&pSolarSysState->SysInfo, &i);
pSolarSysState->SysInfo.PlanetInfo.ScanSeed[ENERGY_SCAN] = rand_val;
if (pSolarSysState->pOrbitalDesc == &pSolarSysState->PlanetDesc[0])
{
LoadStdLanderFont (&pSolarSysState->SysInfo.PlanetInfo);
pSolarSysState->PlanetSideFrame[1] =
CaptureDrawable (
LoadGraphic (RUINS_MASK_PMAP_ANIM));
pSolarSysState->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (
LoadStringTable (BURV_RUINS_STRTAB));
pSolarSysState->SysInfo.PlanetInfo.Weather = 0;
pSolarSysState->SysInfo.PlanetInfo.Tectonics = 0;
}
else if (pSolarSysState->pOrbitalDesc->pPrevDesc == &pSolarSysState->PlanetDesc[0]
&& pSolarSysState->pOrbitalDesc == &pSolarSysState->MoonDesc[0]
&& !GET_GAME_STATE (BURVIXESE_BROADCASTERS))
{
LoadStdLanderFont (&pSolarSysState->SysInfo.PlanetInfo);
pSolarSysState->PlanetSideFrame[1] =
CaptureDrawable (
LoadGraphic (BURV_BCS_MASK_PMAP_ANIM));
pSolarSysState->SysInfo.PlanetInfo.DiscoveryString =
CaptureStringTable (
LoadStringTable (BURV_BCS_STRTAB));
}
LoadPlanet (NULL);
break;
}
default:
GenerateRandomIP (control);
break;
}
}
static void
sis_hyper_preprocess (ELEMENT *ElementPtr)
{
SIZE udx, udy, dx, dy;
SIZE AccelerateDirection;
STARSHIP *StarShipPtr;
if (ElementPtr->state_flags & APPEARING)
ElementPtr->velocity = GLOBAL (velocity);
AccelerateDirection = 0;
GetElementStarShip (ElementPtr, &StarShipPtr);
++StarShipPtr->weapon_counter; /* no shooting in hyperspace! */
if ((GLOBAL (autopilot)).x == ~0
|| (GLOBAL (autopilot)).y == ~0
|| (StarShipPtr->cur_status_flags & (LEFT | RIGHT | THRUST)))
{
LeaveAutoPilot:
(GLOBAL (autopilot)).x =
(GLOBAL (autopilot)).y = ~0;
if (!(StarShipPtr->cur_status_flags & THRUST)
|| (GLOBAL_SIS (FuelOnBoard) == 0
&& GET_GAME_STATE (ARILOU_SPACE_SIDE) <= 1))
{
AccelerateDirection = -1;
GetCurrentVelocityComponents (&ElementPtr->velocity,
&dx, &dy);
udx = dx << 4;
udy = dy << 4;
StarShipPtr->cur_status_flags &= ~THRUST;
}
}
else
{
SIZE facing;
POINT universe;
universe.x = LOGX_TO_UNIVERSE (GLOBAL_SIS (log_x));
universe.y = LOGY_TO_UNIVERSE (GLOBAL_SIS (log_y));
udx = (GLOBAL (autopilot)).x - universe.x;
udy = -((GLOBAL (autopilot)).y - universe.y);
if ((dx = udx) < 0)
dx = -dx;
if ((dy = udy) < 0)
dy = -dy;
if (dx <= 1 && dy <= 1)
goto LeaveAutoPilot;
facing = NORMALIZE_FACING (ANGLE_TO_FACING (ARCTAN (udx, udy)));
/* This prevents ship from flying backwards on auto-pilot.
* It could also theoretically abort autopilot in a bad savegame */
if ((StarShipPtr->cur_status_flags & SHIP_AT_MAX_SPEED)
/*|| (ElementPtr->state_flags & APPEARING)*/ )
{
if (NORMALIZE_FACING (StarShipPtr->ShipFacing
+ ANGLE_TO_FACING (QUADRANT)
- facing) > ANGLE_TO_FACING (HALF_CIRCLE))
goto LeaveAutoPilot;
facing = StarShipPtr->ShipFacing;
}
else if ((int)facing != (int)StarShipPtr->ShipFacing
&& ElementPtr->turn_wait == 0)
{
if (NORMALIZE_FACING (
StarShipPtr->ShipFacing - facing
) >= ANGLE_TO_FACING (HALF_CIRCLE))
{
facing = NORMALIZE_FACING (facing - 1);
StarShipPtr->cur_status_flags |= RIGHT;
}
else if ((int)StarShipPtr->ShipFacing != (int)facing)
{
facing = NORMALIZE_FACING (facing + 1);
StarShipPtr->cur_status_flags |= LEFT;
}
if ((int)facing == (int)StarShipPtr->ShipFacing)
{
ZeroVelocityComponents (&ElementPtr->velocity);
}
}
GetCurrentVelocityComponents (&ElementPtr->velocity, &dx, &dy);
if ((GLOBAL_SIS (FuelOnBoard)
|| GET_GAME_STATE (ARILOU_SPACE_SIDE) > 1)
&& (int)facing == (int)StarShipPtr->ShipFacing)
{
StarShipPtr->cur_status_flags |= SHIP_AT_MAX_SPEED;
AccelerateDirection = 1;
}
else
{
AccelerateDirection = -1;
udx = dx << 4;
udy = dy << 4;
}
}
if (ElementPtr->thrust_wait == 0 && AccelerateDirection)
{
COUNT dist;
SIZE speed, velocity_increment;
velocity_increment = WORLD_TO_VELOCITY (
StarShipPtr->RaceDescPtr->characteristics.thrust_increment);
if ((dist = square_root ((long)udx * udx + (long)udy * udy)) == 0)
dist = 1; /* prevent divide by zero */
speed = square_root ((long)dx * dx + (long)dy * dy);
if (AccelerateDirection < 0)
{
dy = (speed / velocity_increment - 1) * velocity_increment;
if (dy < speed - velocity_increment)
dy = speed - velocity_increment;
if ((speed = dy) < 0)
speed = 0;
StarShipPtr->cur_status_flags &= ~SHIP_AT_MAX_SPEED;
}
else
{
SIZE max_velocity;
AccelerateDirection = 0;
max_velocity = WORLD_TO_VELOCITY (
StarShipPtr->RaceDescPtr->characteristics.max_thrust);
dy = (speed / velocity_increment + 1)
* velocity_increment;
if (dy < speed + velocity_increment)
dy = speed + velocity_increment;
if ((speed = dy) > max_velocity)
{
speed = max_velocity;
StarShipPtr->cur_status_flags |= SHIP_AT_MAX_SPEED;
}
}
dx = (SIZE)((long)udx * speed / (long)dist);
dy = (SIZE)((long)udy * speed / (long)dist);
SetVelocityComponents (&ElementPtr->velocity, dx, dy);
ElementPtr->thrust_wait =
StarShipPtr->RaceDescPtr->characteristics.thrust_wait;
}
}
static void
ilwrath_preprocess (PELEMENT ElementPtr)
{
ELEMENT_FLAGS status_flags;
STARSHIPPTR StarShipPtr;
PPRIMITIVE lpPrim;
GetElementStarShip (ElementPtr, &StarShipPtr);
status_flags = StarShipPtr->cur_status_flags;
lpPrim = &(GLOBAL (DisplayArray))[ElementPtr->PrimIndex];
if (GetPrimType (lpPrim) == STAMPFILL_PRIM)
{
COLOR Color;
BOOLEAN weapon_discharge;
Color = GetPrimColor (lpPrim);
weapon_discharge = ((status_flags & WEAPON)
&& StarShipPtr->RaceDescPtr->ship_info.energy_level >= WEAPON_ENERGY_COST);
if (weapon_discharge
|| (StarShipPtr->special_counter == 0
&& ((status_flags & SPECIAL) || Color != BLACK_COLOR)))
{
if (Color == BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F))
SetPrimType (lpPrim, STAMP_PRIM);
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B));
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03));
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09));
else
{
ProcessSound (SetAbsSoundIndex (
/* CLOAKING_OFF */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 2), ElementPtr);
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01));
if (weapon_discharge)
{
COUNT facing;
facing = StarShipPtr->ShipFacing;
if (TrackShip (ElementPtr, &facing) >= 0)
{
#define LOOK_AHEAD 4
ELEMENTPTR eptr;
SIZE dx0, dy0, dx1, dy1;
VELOCITY_DESC v;
LockElement (ElementPtr->hTarget, &eptr);
v = eptr->velocity;
GetNextVelocityComponents (&v, &dx0, &dy0, LOOK_AHEAD);
v = ElementPtr->velocity;
GetNextVelocityComponents (&v, &dx1, &dy1, LOOK_AHEAD);
dx0 = (eptr->current.location.x + dx0)
- (ElementPtr->current.location.x + dx1);
dy0 = (eptr->current.location.y + dy0)
- (ElementPtr->current.location.y + dy1);
UnlockElement (ElementPtr->hTarget);
StarShipPtr->ShipFacing =
NORMALIZE_FACING (
ANGLE_TO_FACING (ARCTAN (dx0, dy0))
);
#ifdef NOTYET
if (ElementPtr->thrust_wait == 0
&& (StarShipPtr->cur_status_flags & THRUST))
{
COUNT last_facing;
do
{
VELOCITY_DESC temp_v;
last_facing = StarShipPtr->ShipFacing;
inertial_thrust (ElementPtr);
temp_v = ElementPtr->velocity;
ElementPtr->velocity = v;
dx0 += dx1;
dy0 += dy1;
GetNextVelocityComponents (&temp_v,
&dx1, &dy1, LOOK_AHEAD);
dx0 -= dx1;
dy0 -= dy1;
StarShipPtr->ShipFacing =
NORMALIZE_FACING (
ANGLE_TO_FACING (ARCTAN (dx0, dy0))
);
} while (StarShipPtr->ShipFacing != last_facing);
}
#endif /* NOTYET */
if (ElementPtr->turn_wait == 0)
++ElementPtr->turn_wait;
ElementPtr->next.image.frame =
SetAbsFrameIndex (ElementPtr->next.image.frame,
StarShipPtr->ShipFacing);
}
ElementPtr->hTarget = 0;
}
}
ElementPtr->state_flags |= CHANGING;
status_flags &= ~SPECIAL;
StarShipPtr->special_counter = 0;
}
else if (Color != BLACK_COLOR)
{
if (Color == BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01))
{
SetPrimColor (lpPrim, BLACK_COLOR);
Untarget (ElementPtr);
}
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01));
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09));
else if (Color == BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03));
else
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B));
ElementPtr->state_flags |= CHANGING;
}
}
if ((status_flags & SPECIAL)
&& StarShipPtr->special_counter == 0
&& DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST))
{
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
SetPrimType (lpPrim, STAMPFILL_PRIM);
ProcessSound (SetAbsSoundIndex (
/* CLOAKING_ON */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
StarShipPtr->special_counter =
StarShipPtr->RaceDescPtr->characteristics.special_wait;
ElementPtr->state_flags |= CHANGING;
}
}
static void
thraddash_intelligence (ELEMENT *ShipPtr, EVALUATE_DESC *ObjectsOfConcern, COUNT ConcernCounter)
{
STARSHIP *StarShipPtr;
EVALUATE_DESC *lpEvalDesc;
lpEvalDesc = &ObjectsOfConcern[ENEMY_SHIP_INDEX];
if (lpEvalDesc->ObjectPtr)
{
#define STATIONARY_SPEED WORLD_TO_VELOCITY (DISPLAY_TO_WORLD (4))
SIZE dx, dy;
GetCurrentVelocityComponents (
&lpEvalDesc->ObjectPtr->velocity, &dx, &dy
);
if (lpEvalDesc->which_turn > 8
|| (long)dx * dx + (long)dy * dy <=
(long)STATIONARY_SPEED * STATIONARY_SPEED)
lpEvalDesc->MoveState = PURSUE;
else
lpEvalDesc->MoveState = ENTICE;
}
ship_intelligence (ShipPtr, ObjectsOfConcern, ConcernCounter);
GetElementStarShip (ShipPtr, &StarShipPtr);
if (StarShipPtr->special_counter == 0)
{
StarShipPtr->ship_input_state &= ~SPECIAL;
if (ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr
&& ObjectsOfConcern[ENEMY_WEAPON_INDEX].MoveState == ENTICE)
{
if ((StarShipPtr->ship_input_state & THRUST)
|| (ShipPtr->turn_wait == 0
&& !(StarShipPtr->ship_input_state & (LEFT | RIGHT)))
|| NORMALIZE_FACING (ANGLE_TO_FACING (
GetVelocityTravelAngle (
&ObjectsOfConcern[ENEMY_WEAPON_INDEX].ObjectPtr->velocity
) + HALF_CIRCLE + OCTANT)
- StarShipPtr->ShipFacing) > ANGLE_TO_FACING (QUADRANT))
StarShipPtr->ship_input_state |= SPECIAL;
}
else if (lpEvalDesc->ObjectPtr)
{
if (lpEvalDesc->MoveState == PURSUE)
{
if (StarShipPtr->RaceDescPtr->ship_info.energy_level >= WEAPON_ENERGY_COST
+ SPECIAL_ENERGY_COST
&& ShipPtr->turn_wait == 0
&& !(StarShipPtr->ship_input_state & (LEFT | RIGHT))
&& (!(StarShipPtr->cur_status_flags & SPECIAL)
|| !(StarShipPtr->cur_status_flags
& (SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED))))
StarShipPtr->ship_input_state |= SPECIAL;
}
else if (lpEvalDesc->MoveState == ENTICE)
{
COUNT direction_angle;
SIZE delta_x, delta_y;
delta_x = lpEvalDesc->ObjectPtr->next.location.x
- ShipPtr->next.location.x;
delta_y = lpEvalDesc->ObjectPtr->next.location.y
- ShipPtr->next.location.y;
direction_angle = ARCTAN (delta_x, delta_y);
if ((lpEvalDesc->which_turn > 24
&& !(StarShipPtr->ship_input_state & (LEFT | RIGHT)))
|| (lpEvalDesc->which_turn <= 16
&& NORMALIZE_ANGLE (direction_angle
- (FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE)
+ QUADRANT) <= HALF_CIRCLE
&& (lpEvalDesc->which_turn < 12
|| NORMALIZE_ANGLE (direction_angle
- (GetVelocityTravelAngle (
&lpEvalDesc->ObjectPtr->velocity
) + HALF_CIRCLE)
+ (OCTANT + 2)) <= ((OCTANT + 2) << 1))))
StarShipPtr->ship_input_state |= SPECIAL;
}
}
if ((StarShipPtr->ship_input_state & SPECIAL)
&& StarShipPtr->RaceDescPtr->ship_info.energy_level >=
SPECIAL_ENERGY_COST)
StarShipPtr->ship_input_state &= ~THRUST;
}
}
