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);
}
void
crew_preprocess (ELEMENT *ElementPtr)
{
HELEMENT hTarget;
// Switch from dark to light or vice versa:
Color oldColor = GetPrimColor (&DisplayArray[ElementPtr->PrimIndex]);
Color newColor = sameColor (oldColor, CREW_COLOR_LOW_INTENSITY) ?
CREW_COLOR_HIGH_INTENSITY : CREW_COLOR_LOW_INTENSITY;
SetPrimColor (&DisplayArray[ElementPtr->PrimIndex], newColor);
ElementPtr->state_flags |= CHANGING;
hTarget = ElementPtr->hTarget;
if (hTarget == 0)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (StarShipPtr && StarShipPtr->RaceDescPtr->ship_info.crew_level)
ElementPtr->hTarget = StarShipPtr->hShip;
else
{
COUNT facing;
facing = 0;
TrackShip (ElementPtr, &facing);
}
}
if (hTarget)
{
#define CREW_DELTA SCALED_ONE
SIZE delta;
ELEMENT *ShipPtr;
LockElement (hTarget, &ShipPtr);
delta = ShipPtr->current.location.x
- ElementPtr->current.location.x;
delta = WRAP_DELTA_X (delta);
if (delta > 0)
ElementPtr->next.location.x += CREW_DELTA;
else if (delta < 0)
ElementPtr->next.location.x -= CREW_DELTA;
delta = ShipPtr->current.location.y -
ElementPtr->current.location.y;
delta = WRAP_DELTA_Y (delta);
if (delta > 0)
ElementPtr->next.location.y += CREW_DELTA;
else if (delta < 0)
ElementPtr->next.location.y -= CREW_DELTA;
UnlockElement (hTarget);
}
}
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;
}
}
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);
}
