static void
DoRunAway (STARSHIP *StarShipPtr)
{
ELEMENT *ElementPtr;
LockElement (StarShipPtr->hShip, &ElementPtr);
if (GetPrimType (&DisplayArray[ElementPtr->PrimIndex]) == STAMP_PRIM
&& ElementPtr->life_span == NORMAL_LIFE
&& !(ElementPtr->state_flags & FINITE_LIFE)
&& ElementPtr->mass_points != MAX_SHIP_MASS * 10
&& !(ElementPtr->state_flags & APPEARING))
{
battle_counter[0]--;
ElementPtr->turn_wait = 3;
ElementPtr->thrust_wait = 4;
ElementPtr->colorCycleIndex = 0;
ElementPtr->preprocess_func = flee_preprocess;
ElementPtr->mass_points = MAX_SHIP_MASS * 10;
ZeroVelocityComponents (&ElementPtr->velocity);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
SetPrimColor (&DisplayArray[ElementPtr->PrimIndex],
BUILD_COLOR (MAKE_RGB15 (0x0B, 0x00, 0x00), 0x2E));
// XXX: I think this is supposed to be the same as the
// first entry of the color cycle table in flee_preeprocess,
// but it is slightly different (0x0A as red value). - SvdB.
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], STAMPFILL_PRIM);
StarShipPtr->ship_input_state = 0;
}
UnlockElement (StarShipPtr->hShip);
}
static void
spawn_rubble (ELEMENT *AsteroidElementPtr)
{
HELEMENT hRubbleElement;
hRubbleElement = AllocElement ();
if (hRubbleElement)
{
ELEMENT *RubbleElementPtr;
PutElement (hRubbleElement);
LockElement (hRubbleElement, &RubbleElementPtr);
RubbleElementPtr->playerNr = AsteroidElementPtr->playerNr;
RubbleElementPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
RubbleElementPtr->life_span = 5;
RubbleElementPtr->turn_wait = RubbleElementPtr->next_turn = 0;
SetPrimType (&DisplayArray[RubbleElementPtr->PrimIndex], STAMP_PRIM);
RubbleElementPtr->current.image.farray = asteroid;
RubbleElementPtr->current.image.frame =
SetAbsFrameIndex (asteroid[0], ANGLE_TO_FACING (FULL_CIRCLE));
RubbleElementPtr->current.location = AsteroidElementPtr->current.location;
RubbleElementPtr->preprocess_func = animation_preprocess;
RubbleElementPtr->death_func = spawn_asteroid;
UnlockElement (hRubbleElement);
}
}
static void
spawn_doggy (ELEMENT *ElementPtr)
{
HELEMENT hDoggyElement;
if ((hDoggyElement = AllocElement ()) != 0)
{
COUNT angle;
ELEMENT *DoggyElementPtr;
STARSHIP *StarShipPtr;
ElementPtr->state_flags |= DEFY_PHYSICS;
PutElement (hDoggyElement);
LockElement (hDoggyElement, &DoggyElementPtr);
DoggyElementPtr->hit_points = DOGGY_HITS;
DoggyElementPtr->mass_points = DOGGY_MASS;
DoggyElementPtr->thrust_wait = 0;
DoggyElementPtr->playerNr = ElementPtr->playerNr;
DoggyElementPtr->state_flags = APPEARING;
DoggyElementPtr->life_span = NORMAL_LIFE;
SetPrimType (&(GLOBAL (DisplayArray))[DoggyElementPtr->PrimIndex],
STAMP_PRIM);
{
DoggyElementPtr->preprocess_func = doggy_preprocess;
DoggyElementPtr->postprocess_func = NULL;
DoggyElementPtr->collision_func = doggy_collision;
DoggyElementPtr->death_func = doggy_death;
}
GetElementStarShip (ElementPtr, &StarShipPtr);
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE;
DoggyElementPtr->current.location.x = ElementPtr->next.location.x
+ COSINE (angle, DISPLAY_TO_WORLD (CHENJESU_OFFSET + DOGGY_OFFSET));
DoggyElementPtr->current.location.y = ElementPtr->next.location.y
+ SINE (angle, DISPLAY_TO_WORLD (CHENJESU_OFFSET + DOGGY_OFFSET));
DoggyElementPtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.special;
DoggyElementPtr->current.image.frame = StarShipPtr->RaceDescPtr->ship_data.special[0];
SetVelocityVector (&DoggyElementPtr->velocity,
DOGGY_SPEED, NORMALIZE_FACING (ANGLE_TO_FACING (angle)));
SetElementStarShip (DoggyElementPtr, StarShipPtr);
ProcessSound (SetAbsSoundIndex (
/* RELEASE_DOGGY */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 4), DoggyElementPtr);
UnlockElement (hDoggyElement);
}
}
void
spawn_planet (void)
{
HELEMENT hPlanetElement;
hPlanetElement = AllocElement ();
if (hPlanetElement)
{
ELEMENT *PlanetElementPtr;
extern FRAME planet[];
LockElement (hPlanetElement, &PlanetElementPtr);
PlanetElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
PlanetElementPtr->hit_points = 200;
PlanetElementPtr->state_flags = APPEARING;
PlanetElementPtr->life_span = NORMAL_LIFE + 1;
SetPrimType (&DisplayArray[PlanetElementPtr->PrimIndex], STAMP_PRIM);
PlanetElementPtr->current.image.farray = planet;
PlanetElementPtr->current.image.frame =
PlanetElementPtr->current.image.farray[0];
PlanetElementPtr->collision_func = collision;
PlanetElementPtr->postprocess_func =
(void (*) (struct element *ElementPtr))CalculateGravity;
ZeroVelocityComponents (&PlanetElementPtr->velocity);
do
{
PlanetElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
PlanetElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
} while (CalculateGravity (PlanetElementPtr)
|| Overlap (PlanetElementPtr));
PlanetElementPtr->mass_points = PlanetElementPtr->hit_points;
PlanetElementPtr->triggers_teleport_safety = TRUE;
UnlockElement (hPlanetElement);
PutElement (hPlanetElement);
}
}
static void
flame_napalm_preprocess (ELEMENT *ElementPtr)
{
ZeroVelocityComponents (&ElementPtr->velocity);
if (ElementPtr->state_flags & NONSOLID)
{
ElementPtr->state_flags &= ~NONSOLID;
ElementPtr->state_flags |= APPEARING;
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
}
/* turn_wait is abused here to store the speed of the decay animation */
else if (ElementPtr->turn_wait > 0)
--ElementPtr->turn_wait;
else
{
if (ElementPtr->life_span <= NUM_NAPALM_FADES * (NAPALM_DECAY_RATE + 1)
|| GetFrameIndex (
ElementPtr->current.image.frame
) != NUM_NAPALM_FADES)
ElementPtr->next.image.frame =
DecFrameIndex (ElementPtr->current.image.frame);
else if (ElementPtr->life_span > NUM_NAPALM_FADES * (NAPALM_DECAY_RATE + 1))
ElementPtr->next.image.frame = SetAbsFrameIndex (
ElementPtr->current.image.frame,
GetFrameCount (ElementPtr->current.image.frame) - 1
);
/* turn_wait is abused here to store the speed of the decay
* animation. */
ElementPtr->turn_wait = NAPALM_DECAY_RATE;
ElementPtr->state_flags |= CHANGING;
}
}
// When gas expires, display animation of the gas dissolving.
static void
gas_death (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (StarShipPtr->hShip)
{
HELEMENT hDissolve;
ELEMENT *ShipPtr;
LockElement (StarShipPtr->hShip, &ShipPtr);
if ((hDissolve = AllocElement ()))
{
ELEMENT *DissolvePtr;
LockElement (hDissolve, &DissolvePtr);
DissolvePtr->playerNr = ElementPtr->playerNr;
DissolvePtr->state_flags = FINITE_LIFE | NONSOLID | IGNORE_SIMILAR | APPEARING;
DissolvePtr->turn_wait = 0;
DissolvePtr->life_span = NUM_DISSOLVE_FRAMES;
DissolvePtr->current.location.x = ElementPtr->current.location.x;
DissolvePtr->current.location.y = ElementPtr->current.location.y;
DissolvePtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.special;
DissolvePtr->current.image.frame = SetAbsFrameIndex (ElementPtr->current.image.frame, LAST_SHOCKWAVE_INDEX);
DissolvePtr->preprocess_func = gas_death_animation;
SetElementStarShip (DissolvePtr, StarShipPtr);
SetPrimType (&(GLOBAL (DisplayArray))[DissolvePtr->PrimIndex], STAMP_PRIM);
UnlockElement (hDissolve);
PutElement (hDissolve);
}
UnlockElement (StarShipPtr->hShip);
}
}
static void
flame_napalm_preprocess (ELEMENT *ElementPtr)
{
ZeroVelocityComponents (&ElementPtr->velocity);
if (ElementPtr->state_flags & NONSOLID)
{
ElementPtr->state_flags &= ~NONSOLID;
ElementPtr->state_flags |= APPEARING;
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
}
else if (ElementPtr->turn_wait > 0)
--ElementPtr->turn_wait;
else
{
#define NUM_NAPALM_FADES 6
if (ElementPtr->life_span <= NUM_NAPALM_FADES * (NAPALM_WAIT + 1)
|| GetFrameIndex (
ElementPtr->current.image.frame
) != NUM_NAPALM_FADES)
ElementPtr->next.image.frame =
DecFrameIndex (ElementPtr->current.image.frame);
else if (ElementPtr->life_span > NUM_NAPALM_FADES * (NAPALM_WAIT + 1))
ElementPtr->next.image.frame = SetAbsFrameIndex (
ElementPtr->current.image.frame,
GetFrameCount (ElementPtr->current.image.frame) - 1
);
ElementPtr->turn_wait = NAPALM_WAIT;
ElementPtr->state_flags |= CHANGING;
}
}
void
AbandonShip (ELEMENT *ShipPtr, ELEMENT *TargetPtr,
COUNT crew_loss)
{
SIZE dx, dy;
COUNT direction;
RECT r;
STARSHIP *StarShipPtr;
HELEMENT hCrew;
INTERSECT_CONTROL ShipIntersect;
GetElementStarShip (ShipPtr, &StarShipPtr);
if (StarShipPtr->RaceDescPtr->ship_info.ship_flags & CREW_IMMUNE)
return;
ShipIntersect = ShipPtr->IntersectControl;
GetFrameRect (ShipIntersect.IntersectStamp.frame, &r);
if ((direction = GetVelocityTravelAngle (
&ShipPtr->velocity)) == FULL_CIRCLE)
dx = dy = 0;
else
{
#define MORE_THAN_ENOUGH 100
direction += HALF_CIRCLE;
dx = COSINE (direction, MORE_THAN_ENOUGH);
dy = SINE (direction, MORE_THAN_ENOUGH);
}
while (crew_loss-- && (hCrew = AllocElement ()))
{
#define CREW_LIFE 300
ELEMENT *CrewPtr;
DeltaCrew (ShipPtr, -1);
PutElement (hCrew);
LockElement (hCrew, &CrewPtr);
CrewPtr->playerNr = NEUTRAL_PLAYER_NUM;
CrewPtr->hit_points = 1;
CrewPtr->state_flags = APPEARING | FINITE_LIFE | CREW_OBJECT;
CrewPtr->life_span = CREW_LIFE;
SetPrimType (&DisplayArray[CrewPtr->PrimIndex], POINT_PRIM);
SetPrimColor (&DisplayArray[CrewPtr->PrimIndex],
BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x00), 0x02));
CrewPtr->current.image.frame = DecFrameIndex (stars_in_space);
CrewPtr->current.image.farray = &stars_in_space;
CrewPtr->preprocess_func = crew_preprocess;
CrewPtr->collision_func = crew_collision;
SetElementStarShip (CrewPtr, StarShipPtr);
GetElementStarShip (TargetPtr, &StarShipPtr);
CrewPtr->hTarget = StarShipPtr->hShip;
{
SIZE w, h;
INTERSECT_CONTROL CrewIntersect;
ShipIntersect.IntersectStamp.origin =
ShipPtr->IntersectControl.EndPoint;
w = (SIZE)((COUNT)TFB_Random () % r.extent.width);
h = (SIZE)((COUNT)TFB_Random () % r.extent.height);
CrewIntersect.EndPoint = ShipIntersect.EndPoint;
CrewIntersect.IntersectStamp.frame = DecFrameIndex (stars_in_space);
if (dx == 0 && dy == 0)
{
CrewIntersect.EndPoint.x += w - (r.extent.width >> 1);
CrewIntersect.EndPoint.y += h - (r.extent.height >> 1);
CrewIntersect.IntersectStamp.origin =
TargetPtr->IntersectControl.EndPoint;
}
else
{
if (dx == 0)
CrewIntersect.EndPoint.x += w - (r.extent.width >> 1);
else if (dx > 0)
CrewIntersect.EndPoint.x += w;
else
CrewIntersect.EndPoint.x -= w;
if (dy == 0)
CrewIntersect.EndPoint.y += h - (r.extent.height >> 1);
else if (dy > 0)
// When hit by Baul spray, gas clouds explodes transforming into a lethal shockwave.
static void
generate_shockwave (ELEMENT *ElementPtr, BYTE which_player)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
// Gas is still 'solid' when it's hit by the spray. Let's make a shockwave and kill the gas cloud.
if (!(ElementPtr->state_flags & NONSOLID))
{
HELEMENT hShockwave;
hShockwave = AllocElement ();
if (hShockwave)
{
ELEMENT *ShockwavePtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
PutElement (hShockwave);
LockElement (hShockwave, &ShockwavePtr);
SetElementStarShip (ShockwavePtr, StarShipPtr);
ShockwavePtr->hit_points = ShockwavePtr->mass_points = 0;
ShockwavePtr->playerNr = which_player;
ShockwavePtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID | IGNORE_SIMILAR;
ShockwavePtr->life_span = SHOCKWAVE_FRAMES;
SetPrimType (&(GLOBAL (DisplayArray))[ShockwavePtr->PrimIndex], STAMP_PRIM);
ShockwavePtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.special;
ShockwavePtr->current.image.frame = SetAbsFrameIndex(StarShipPtr->RaceDescPtr->ship_data.special[0], LAST_GAS_INDEX);
ShockwavePtr->next.image.frame = SetAbsFrameIndex(ElementPtr->current.image.frame, LAST_GAS_INDEX);
ShockwavePtr->current.location = ElementPtr->current.location;
ShockwavePtr->preprocess_func = shockwave_preprocess;
ShockwavePtr->postprocess_func = NULL;
ShockwavePtr->death_func = NULL;
ZeroVelocityComponents (&ShockwavePtr->velocity);
UnlockElement (hShockwave);
}
// Gas dies on the next turn.
ElementPtr->state_flags |= NONSOLID;
// Explosion sounds.
ProcessSound (SetAbsSoundIndex (StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 2), ElementPtr);
ProcessSound (SetAbsSoundIndex (GameSounds, TARGET_DAMAGED_FOR_6_PLUS_PT), ElementPtr);
}
{
// This is called during PostProcessQueue(), close to or at the end,
// for the temporary shockwave element to apply the damage.
// The effects are not seen until the next frame.
HELEMENT hElement, hNextElement;
for (hElement = GetHeadElement (); hElement != 0; hElement = hNextElement)
{
ELEMENT *ObjPtr;
LockElement (hElement, &ObjPtr);
hNextElement = GetSuccElement (ObjPtr);
if (IS_GAS (ObjPtr))
{
SIZE delta_x, delta_y;
DWORD dist;
if ((delta_x = ObjPtr->next.location.x - ElementPtr->next.location.x) < 0) delta_x = -delta_x;
if ((delta_y = ObjPtr->next.location.y - ElementPtr->next.location.y) < 0) delta_y = -delta_y;
delta_x = WORLD_TO_DISPLAY (delta_x);
delta_y = WORLD_TO_DISPLAY (delta_y);
if (delta_x <= SHOCKWAVE_RANGE && delta_y <= SHOCKWAVE_RANGE
&& (dist = (DWORD)(delta_x * delta_x) + (DWORD)(delta_y * delta_y)) <= (DWORD)(SHOCKWAVE_RANGE * SHOCKWAVE_RANGE))
{
SIZE destruction;
destruction = ((MAX_DESTRUCTION * (SHOCKWAVE_RANGE - square_root (dist))) / SHOCKWAVE_RANGE) + 1;
// The shockwave is delayed according to how far it is from the shockwave that set it off.
ObjPtr->life_span = (10 / destruction);
ObjPtr->death_func = generate_shockwave_2;
ObjPtr->playerNr = which_player;
}
}
else if (CollidingElement (ObjPtr) || ORZ_MARINE (ObjPtr))
{
SIZE delta_x, delta_y;
DWORD dist;
if ((delta_x = ObjPtr->next.location.x - ElementPtr->next.location.x) < 0) delta_x = -delta_x;
if ((delta_y = ObjPtr->next.location.y - ElementPtr->next.location.y) < 0) delta_y = -delta_y;
delta_x = WORLD_TO_DISPLAY (delta_x);
delta_y = WORLD_TO_DISPLAY (delta_y);
if (delta_x <= SHOCKWAVE_RANGE && delta_y <= SHOCKWAVE_RANGE
&& (dist = (DWORD)(delta_x * delta_x) + (DWORD)(delta_y * delta_y)) <= (DWORD)(SHOCKWAVE_RANGE * SHOCKWAVE_RANGE))
{
SIZE destruction;
destruction = ((MAX_DESTRUCTION * (SHOCKWAVE_RANGE - square_root (dist))) / SHOCKWAVE_RANGE) + 1;
if (ObjPtr->state_flags & PLAYER_SHIP && ObjPtr->playerNr != which_player)
{
STARSHIP *EnemyShipPtr;
GetElementStarShip (ObjPtr, &EnemyShipPtr);
// Deal damage to ships except shield-using Yehat & Utwig.
if (!((EnemyShipPtr->SpeciesID == YEHAT_ID || EnemyShipPtr->SpeciesID == UTWIG_ID)
&& ObjPtr->life_span > NORMAL_LIFE))
{
if (!DeltaCrew (ObjPtr, -destruction))
ObjPtr->life_span = 0;
}
// Charge Utwig shield.
else if (EnemyShipPtr->SpeciesID == UTWIG_ID && ObjPtr->life_span > NORMAL_LIFE)
ObjPtr->life_span += destruction;
}
else if (!GRAVITY_MASS (ObjPtr->mass_points) && ObjPtr->playerNr != which_player)
{
if ((BYTE)destruction < ObjPtr->hit_points)
ObjPtr->hit_points -= (BYTE)destruction;
else
{
ObjPtr->hit_points = 0;
ObjPtr->life_span = 0;
}
}
}
}
UnlockElement (hElement);
}
}
}
void
spawn_asteroid (ELEMENT *ElementPtr)
{
HELEMENT hAsteroidElement;
if ((hAsteroidElement = AllocElement ()) == 0)
{
if (ElementPtr != 0)
{
ElementPtr->state_flags &= ~DISAPPEARING;
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], NO_PRIM);
ElementPtr->life_span = 1;
}
}
else
{
ELEMENT *AsteroidElementPtr;
COUNT val;
LockElement (hAsteroidElement, &AsteroidElementPtr);
AsteroidElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
AsteroidElementPtr->hit_points = 1;
AsteroidElementPtr->mass_points = 3;
AsteroidElementPtr->state_flags = APPEARING;
AsteroidElementPtr->life_span = NORMAL_LIFE;
SetPrimType (&DisplayArray[AsteroidElementPtr->PrimIndex], STAMP_PRIM);
if ((val = (COUNT)TFB_Random ()) & (1 << 0))
{
if (!(val & (1 << 1)))
AsteroidElementPtr->current.location.x = 0;
else
AsteroidElementPtr->current.location.x = LOG_SPACE_WIDTH;
AsteroidElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
}
else
{
AsteroidElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
if (!(val & (1 << 1)))
AsteroidElementPtr->current.location.y = 0;
else
AsteroidElementPtr->current.location.y = LOG_SPACE_HEIGHT;
}
{
// Using these temporary variables because the execution order
// of function arguments may vary per system, which may break
// synchronisation on network games.
SIZE magnitude =
DISPLAY_TO_WORLD (((SIZE)TFB_Random () & 7) + 4);
COUNT facing = (COUNT)TFB_Random ();
SetVelocityVector (&AsteroidElementPtr->velocity, magnitude,
facing);
}
AsteroidElementPtr->current.image.farray = asteroid;
AsteroidElementPtr->current.image.frame =
SetAbsFrameIndex (asteroid[0],
NORMALIZE_FACING (TFB_Random ()));
AsteroidElementPtr->turn_wait =
AsteroidElementPtr->thrust_wait =
(BYTE)TFB_Random () & (BYTE)((1 << 2) - 1);
AsteroidElementPtr->thrust_wait |=
(BYTE)TFB_Random () & (BYTE)(1 << 7);
AsteroidElementPtr->preprocess_func = asteroid_preprocess;
AsteroidElementPtr->death_func = spawn_rubble;
AsteroidElementPtr->collision_func = collision;
AsteroidElementPtr->triggers_teleport_safety = TRUE;
UnlockElement (hAsteroidElement);
PutElement (hAsteroidElement);
}
}
static void
new_pkunk (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
ELEMENT *ShipPtr;
LockElement (StarShipPtr->hShip, &ShipPtr);
ShipPtr->death_func = new_pkunk;
UnlockElement (StarShipPtr->hShip);
}
else
{
ElementPtr->state_flags = APPEARING | PLAYER_SHIP | IGNORE_SIMILAR;
ElementPtr->mass_points = SHIP_MASS;
ElementPtr->preprocess_func = StarShipPtr->RaceDescPtr->preprocess_func;
ElementPtr->postprocess_func = StarShipPtr->RaceDescPtr->postprocess_func;
ElementPtr->death_func =
(void (*) (ELEMENT *ElementPtr))
StarShipPtr->RaceDescPtr->init_weapon_func;
StarShipPtr->RaceDescPtr->preprocess_func = pkunk_preprocess;
StarShipPtr->RaceDescPtr->postprocess_func = pkunk_postprocess;
StarShipPtr->RaceDescPtr->init_weapon_func = initialize_bug_missile;
StarShipPtr->RaceDescPtr->ship_info.crew_level = MAX_CREW;
StarShipPtr->RaceDescPtr->ship_info.energy_level = MAX_ENERGY;
/* fix vux impairment */
StarShipPtr->RaceDescPtr->characteristics.max_thrust = MAX_THRUST;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.turn_wait = TURN_WAIT;
StarShipPtr->RaceDescPtr->characteristics.thrust_wait = THRUST_WAIT;
StarShipPtr->RaceDescPtr->characteristics.special_wait = 0;
StarShipPtr->ship_input_state = 0;
StarShipPtr->cur_status_flags = 0;
StarShipPtr->old_status_flags = 0;
StarShipPtr->energy_counter = 0;
StarShipPtr->weapon_counter = 0;
StarShipPtr->special_counter = 0;
ElementPtr->crew_level = 0;
ElementPtr->turn_wait = 0;
ElementPtr->thrust_wait = 0;
ElementPtr->life_span = NORMAL_LIFE;
StarShipPtr->ShipFacing = NORMALIZE_FACING (TFB_Random ());
ElementPtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.ship;
ElementPtr->current.image.frame =
SetAbsFrameIndex (StarShipPtr->RaceDescPtr->ship_data.ship[0],
StarShipPtr->ShipFacing);
SetPrimType (&(GLOBAL (DisplayArray))[
ElementPtr->PrimIndex
], STAMP_PRIM);
do
{
ElementPtr->current.location.x =
WRAP_X (DISPLAY_ALIGN_X (TFB_Random ()));
ElementPtr->current.location.y =
WRAP_Y (DISPLAY_ALIGN_Y (TFB_Random ()));
} while (CalculateGravity (ElementPtr)
|| TimeSpaceMatterConflict (ElementPtr));
ElementPtr->hTarget = StarShipPtr->hShip;
}
}
static void
pump_up_postprocess (ELEMENT *ElementPtr)
{
if (ElementPtr->state_flags & APPEARING)
{
ZeroVelocityComponents (&ElementPtr->velocity);
}
else
{
HELEMENT hPumpUp;
ELEMENT *EPtr;
ELEMENT *ShipPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
LockElement (StarShipPtr->hShip, &ShipPtr);
initialize_pump_up (ShipPtr, &hPumpUp);
DeltaEnergy (ShipPtr, 0);
UnlockElement (StarShipPtr->hShip);
LockElement (hPumpUp, &EPtr);
EPtr->current.image.frame = ElementPtr->current.image.frame;
EPtr->turn_wait = ElementPtr->turn_wait;
EPtr->thrust_wait = ElementPtr->thrust_wait;
if (--EPtr->thrust_wait == 0)
{
if ((EPtr->turn_wait & ~REVERSE_DIR) < MAX_PUMP - 1)
{
++EPtr->turn_wait;
EPtr->current.image.frame = SetRelFrameIndex (
EPtr->current.image.frame, NUM_PUMP_ANIMS);
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 2),
EPtr);
}
EPtr->thrust_wait = LEVEL_COUNTER;
}
EPtr->mass_points = EPtr->hit_points =
(PUMPUP_DAMAGE << (ElementPtr->turn_wait & ~REVERSE_DIR));
SetElementStarShip (EPtr, StarShipPtr);
if (EPtr->thrust_wait & 1)
{
COUNT frame_index;
frame_index = GetFrameIndex (EPtr->current.image.frame);
if (((EPtr->turn_wait & REVERSE_DIR)
&& (frame_index % NUM_PUMP_ANIMS) != 0)
|| (!(EPtr->turn_wait & REVERSE_DIR)
&& ((frame_index + 1) % NUM_PUMP_ANIMS) == 0))
{
--frame_index;
EPtr->turn_wait |= REVERSE_DIR;
}
else
{
++frame_index;
EPtr->turn_wait &= ~REVERSE_DIR;
}
EPtr->current.image.frame = SetAbsFrameIndex (
EPtr->current.image.frame, frame_index);
}
if (StarShipPtr->cur_status_flags & StarShipPtr->old_status_flags
& WEAPON)
{
StarShipPtr->weapon_counter = WEAPON_WAIT;
}
else
{
SIZE dx, dy;
COUNT angle;
EPtr->life_span = PUMPUP_LIFE;
EPtr->preprocess_func = pump_up_preprocess;
EPtr->postprocess_func = 0;
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing);
SetVelocityComponents (&EPtr->velocity,
COSINE (angle, WORLD_TO_VELOCITY (PUMPUP_SPEED)),
SINE (angle, WORLD_TO_VELOCITY (PUMPUP_SPEED)));
GetCurrentVelocityComponents (&ShipPtr->velocity, &dx, &dy);
dx = dx * 1/2;
dy = dy * 1/2;
// Add some of the Trader's velocity to its projectiles.
DeltaVelocityComponents (&EPtr->velocity, dx, dy);
EPtr->current.location.x -= VELOCITY_TO_WORLD (dx);
EPtr->current.location.y -= VELOCITY_TO_WORLD (dy);
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 3), EPtr);
}
UnlockElement (hPumpUp);
PutElement (hPumpUp);
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
NO_PRIM);
ElementPtr->state_flags |= NONSOLID;
}
}
static void
confusion_collision (ELEMENT *ElementPtr0, POINT *pPt0,
ELEMENT *ElementPtr1, POINT *pPt1)
{
if (ElementPtr1->state_flags & PLAYER_SHIP)
{
HELEMENT hConfusionElement, hNextElement;
ELEMENT *ConfusionPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr0, &StarShipPtr);
for (hConfusionElement = GetHeadElement ();
hConfusionElement; hConfusionElement = hNextElement)
{
LockElement (hConfusionElement, &ConfusionPtr);
if (elementsOfSamePlayer (ConfusionPtr, ElementPtr0)
&& ConfusionPtr->current.image.farray ==
StarShipPtr->RaceDescPtr->ship_data.special
&& (ConfusionPtr->state_flags & NONSOLID))
{
UnlockElement (hConfusionElement);
break;
}
hNextElement = GetSuccElement (ConfusionPtr);
UnlockElement (hConfusionElement);
}
if (hConfusionElement || (hConfusionElement = AllocElement ()))
{
LockElement (hConfusionElement, &ConfusionPtr);
if (ConfusionPtr->state_flags == 0) /* not allocated before */
{
InsertElement (hConfusionElement, GetHeadElement ());
ConfusionPtr->current = ElementPtr0->next;
ConfusionPtr->current.image.frame = SetAbsFrameIndex (
ConfusionPtr->current.image.frame, 8
);
ConfusionPtr->next = ConfusionPtr->current;
ConfusionPtr->playerNr = ElementPtr0->playerNr;
ConfusionPtr->state_flags = FINITE_LIFE | NONSOLID | CHANGING;
ConfusionPtr->preprocess_func = confuse_preprocess;
SetPrimType (
&(GLOBAL (DisplayArray))[ConfusionPtr->PrimIndex],
NO_PRIM
);
SetElementStarShip (ConfusionPtr, StarShipPtr);
GetElementStarShip (ElementPtr1, &StarShipPtr);
ConfusionPtr->hTarget = StarShipPtr->hShip;
}
ConfusionPtr->life_span = 400;
ConfusionPtr->turn_wait =
(BYTE)(1 << ((BYTE)TFB_Random () & 1)); /* LEFT or RIGHT */
UnlockElement (hConfusionElement);
}
ElementPtr0->hit_points = 0;
ElementPtr0->life_span = 0;
ElementPtr0->state_flags |= DISAPPEARING | COLLISION | NONSOLID;
}
(void) pPt0; /* Satisfying compiler (unused parameter) */
(void) pPt1; /* Satisfying compiler (unused parameter) */
}
static void
ilwrath_preprocess (ELEMENT *ElementPtr)
{
STATUS_FLAGS status_flags;
STARSHIP *StarShipPtr;
PRIMITIVE *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
&& (
((!sameColor(color, BLACK_COLOR)) && (!sameColor(color, INVIS_COLOR)))
|| status_flags & SPECIAL
)
)
)
{
if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F)))
SetPrimType (lpPrim, STAMP_PRIM);
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x0A, 0x1F, 0x1F), 0x0B));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03));
else if (sameColor (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));
}
ElementPtr->state_flags |= CHANGING;
status_flags &= ~SPECIAL;
StarShipPtr->special_counter = 0;
}
else if ( (!sameColor (color, BLACK_COLOR))
&& (!sameColor (color, INVIS_COLOR)))
{
if (sameColor (color, BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01)))
{
if(PlayerControl[ElementPtr->playerNr] & HUMAN_CONTROL)
SetPrimColor (lpPrim, INVIS_COLOR);
else
SetPrimColor (lpPrim, BLACK_COLOR);
Untarget (ElementPtr);
}
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x00, 0x00, 0x14), 0x01));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x00, 0x14, 0x14), 0x03)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x0A, 0x0A, 0x1F), 0x09));
else if (sameColor (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
gas_collision (ELEMENT *ElementPtr0, POINT *pPt0, ELEMENT *ElementPtr1, POINT *pPt1)
{
STARSHIP *StarShipPtr;
STARSHIP *EnemyStarShipPtr;
BYTE enemyShipIsBaul = 0;
BYTE enemyShipIsChmmr = 0;
// This is the ship this gas cloud belongs to.
GetElementStarShip (ElementPtr0, &StarShipPtr);
// Check if the colliding element is a ship. If it is not, check if it's a projectile from Baul or Chmmr ship.
if (!elementsOfSamePlayer(ElementPtr0, ElementPtr1) && !(ElementPtr1->state_flags & PLAYER_SHIP)
&& ElementPtr1->playerNr > -1)
{
GetElementStarShip (ElementPtr1, &EnemyStarShipPtr);
if (EnemyStarShipPtr->SpeciesID == BAUL_ID)
enemyShipIsBaul = 1;
else if (EnemyStarShipPtr->SpeciesID == CHMMR_ID)
enemyShipIsChmmr = 1; // This is important because the gas can stick to zapsats.
}
// If colliding with Baul's spray weapon or shockwave, EXPLODE!!!
if (ElementPtr1->current.image.farray == StarShipPtr->RaceDescPtr->ship_data.weapon
|| (enemyShipIsBaul && ElementPtr1->current.image.farray == EnemyStarShipPtr->RaceDescPtr->ship_data.weapon))
{
// Move to shockwave graphics.
ElementPtr0->current.image.frame = SetAbsFrameIndex (ElementPtr0->current.image.frame, LAST_GAS_INDEX);
ElementPtr0->next.image.frame = SetAbsFrameIndex (ElementPtr0->current.image.frame, LAST_GAS_INDEX);
// Remove the lock on enemy ship and make the gas die on next turn.
ElementPtr0->hTarget = 0;
ElementPtr0->life_span = 1;
// Don't do the gas dissolve anim now that the shockwave appears.
ElementPtr0->death_func = NULL;
// Generate the actual shockwave.
generate_shockwave (ElementPtr0, -1); // XXX ElementPtr1->playerNr);
}
// If colliding with enemy ship, stick to the ship.
// Also stick to Chmmr's zapsats.
else if (ElementPtr0->state_flags & IGNORE_VELOCITY
&& ElementPtr1->playerNr != ElementPtr0->playerNr
&& (ElementPtr1->state_flags & PLAYER_SHIP
|| (enemyShipIsChmmr && ElementPtr1->mass_points == 10) ))
{
HELEMENT hGasElement;
HELEMENT hTargetElement;
ELEMENT *GasPtr;
// Create a new gas element which is sticking to the enemy ship.
if ((hGasElement = AllocElement ()))
{
LockElement (hGasElement, &GasPtr);
if (GasPtr->state_flags == 0) /* not allocated before */
{
InsertElement (hGasElement, GetHeadElement ());
GasPtr->current = ElementPtr0->next;
GasPtr->next = GasPtr->current;
GasPtr->playerNr = ElementPtr0->playerNr;
GasPtr->state_flags = FINITE_LIFE | GASSY_SUBSTANCE | CHANGING;
GasPtr->preprocess_func = gas_preprocess;
GasPtr->collision_func = gas_collision;
SetPrimType (&(GLOBAL (DisplayArray))[GasPtr->PrimIndex], NO_PRIM);
SetElementStarShip (GasPtr, StarShipPtr);
GetElementStarShip (ElementPtr1, &StarShipPtr);
// Ships and Chmmr Zapsats require different ways of making them the target of the gas cloud.
if (ElementPtr1->state_flags & PLAYER_SHIP)
GasPtr->hTarget = StarShipPtr->hShip;
else
{
GasPtr->life_span = 0;
LockElement (ElementPtr1, &hTargetElement);
GasPtr->hTarget = hTargetElement;
}
}
GasPtr->hit_points = ElementPtr0->hit_points;
GasPtr->life_span = ElementPtr0->life_span;
GasPtr->thrust_wait = 1;
GasPtr->weapon_element_index = ElementPtr0->weapon_element_index;
GasPtr->turn_wait = (BYTE)(1 << ((BYTE)TFB_Random () & 1)); /* LEFT or RIGHT */
GasPtr->death_func = gas_death;
UnlockElement (hGasElement);
}
// Erase the original gas element.
ElementPtr0->hit_points = 0;
ElementPtr0->life_span = 0;
ElementPtr0->state_flags |= DISAPPEARING | COLLISION | NONSOLID;
}
(void) pPt0; /* Satisfying compiler (unused parameter) */
(void) pPt1; /* Satisfying compiler (unused parameter) */
}
static void
phoenix_transition (ELEMENT *ElementPtr)
{
HELEMENT hShipImage;
ELEMENT *ShipImagePtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
LockElement (StarShipPtr->hShip, &ShipImagePtr);
if (!(ShipImagePtr->state_flags & NONSOLID))
{
ElementPtr->preprocess_func = NULL;
}
else if ((hShipImage = AllocElement ()))
{
#define TRANSITION_SPEED DISPLAY_TO_WORLD (20)
COUNT angle;
PutElement (hShipImage);
LockElement (hShipImage, &ShipImagePtr);
ShipImagePtr->playerNr = NEUTRAL_PLAYER_NUM;
ShipImagePtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
ShipImagePtr->life_span = TRANSITION_LIFE;
SetPrimType (&(GLOBAL (DisplayArray))[ShipImagePtr->PrimIndex],
STAMPFILL_PRIM);
SetPrimColor (
&(GLOBAL (DisplayArray))[ShipImagePtr->PrimIndex],
START_PHOENIX_COLOR);
ShipImagePtr->colorCycleIndex = 0;
ShipImagePtr->current.image = ElementPtr->current.image;
ShipImagePtr->current.location = ElementPtr->current.location;
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
angle = ElementPtr->mass_points;
ShipImagePtr->current.location.x +=
COSINE (angle, TRANSITION_SPEED);
ShipImagePtr->current.location.y +=
SINE (angle, TRANSITION_SPEED);
ElementPtr->preprocess_func = NULL;
}
else
{
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing);
ShipImagePtr->current.location.x -=
COSINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.y -=
SINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.x =
WRAP_X (ShipImagePtr->current.location.x);
ShipImagePtr->current.location.y =
WRAP_Y (ShipImagePtr->current.location.y);
}
ShipImagePtr->mass_points = (BYTE)angle;
ShipImagePtr->preprocess_func = phoenix_transition;
ShipImagePtr->death_func = spawn_phoenix_trail;
SetElementStarShip (ShipImagePtr, StarShipPtr);
UnlockElement (hShipImage);
}
UnlockElement (StarShipPtr->hShip);
}
static void
destruct_preprocess (ELEMENT *ElementPtr)
{
#define DESTRUCT_SWITCH ((NUM_EXPLOSION_FRAMES * 3) - 3)
PRIMITIVE *lpPrim;
// ship_death() set the ship element's life_span to
// (NUM_EXPLOSION_FRAMES * 3)
lpPrim = &(GLOBAL (DisplayArray))[ElementPtr->PrimIndex];
ElementPtr->state_flags |= CHANGING;
if (ElementPtr->life_span > DESTRUCT_SWITCH)
{
// First, stamp-fill the ship's own element with changing colors
// for 3 frames. No explosion element yet.
SetPrimType (lpPrim, STAMPFILL_PRIM);
if (ElementPtr->life_span == DESTRUCT_SWITCH + 2)
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E));
else
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
}
else if (ElementPtr->life_span < DESTRUCT_SWITCH)
{
// Stamp-fill the explosion element with cycling colors for the
// remainder of the glory explosion frames.
Color color = GetPrimColor (lpPrim);
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame);
if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x0A, 0x0A), 0x0C));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x0A, 0x0A), 0x0C)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x14, 0x0A, 0x00), 0x06));
else if (sameColor (color,
BUILD_COLOR (MAKE_RGB15 (0x14, 0x0A, 0x00), 0x06)))
SetPrimColor (lpPrim,
BUILD_COLOR (MAKE_RGB15 (0x14, 0x00, 0x00), 0x04));
}
else
{
HELEMENT hDestruct;
SetPrimType (lpPrim, NO_PRIM);
// The ship's own element will not be drawn anymore but will remain
// alive all through the glory explosion.
ElementPtr->preprocess_func = NULL;
// Spawn a separate glory explosion element.
// XXX: Why? Why not keep using the ship's element?
// Is it because of conflicting state_flags, hit_points or
// mass_points?
hDestruct = AllocElement ();
if (hDestruct)
{
ELEMENT *DestructPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
PutElement (hDestruct);
LockElement (hDestruct, &DestructPtr);
SetElementStarShip (DestructPtr, StarShipPtr);
DestructPtr->hit_points = DestructPtr->mass_points = 0;
DestructPtr->playerNr = NEUTRAL_PLAYER_NUM;
DestructPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
DestructPtr->life_span = (NUM_EXPLOSION_FRAMES - 3) - 1;
SetPrimType (&(GLOBAL (DisplayArray))[DestructPtr->PrimIndex],
STAMPFILL_PRIM);
SetPrimColor (&(GLOBAL (DisplayArray))[DestructPtr->PrimIndex],
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
DestructPtr->current.image.farray =
StarShipPtr->RaceDescPtr->ship_data.special;
DestructPtr->current.image.frame =
StarShipPtr->RaceDescPtr->ship_data.special[0];
DestructPtr->current.location = ElementPtr->current.location;
DestructPtr->preprocess_func = destruct_preprocess;
DestructPtr->postprocess_func = NULL;
DestructPtr->death_func = NULL;
ZeroVelocityComponents (&DestructPtr->velocity);
UnlockElement (hDestruct);
}
}
}
static void
pkunk_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (ElementPtr->state_flags & APPEARING)
{
HELEMENT hPhoenix = 0;
if ((BYTE)TFB_Random () & 1)
hPhoenix = AllocElement ();
if (hPhoenix)
{
ELEMENT *PhoenixPtr;
LockElement (hPhoenix, &PhoenixPtr);
PhoenixPtr->playerNr = ElementPtr->playerNr;
PhoenixPtr->state_flags = FINITE_LIFE | NONSOLID | IGNORE_SIMILAR;
PhoenixPtr->life_span = 1;
PhoenixPtr->death_func = intercept_pkunk_death;
SetElementStarShip (PhoenixPtr, StarShipPtr);
UnlockElement (hPhoenix);
InsertElement (hPhoenix, GetHeadElement ());
}
StarShipPtr->RaceDescPtr->data = (intptr_t) hPhoenix;
if (ElementPtr->hTarget == 0)
StarShipPtr->RaceDescPtr->preprocess_func = 0;
else
{
COUNT angle, facing;
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1
), ElementPtr);
ElementPtr->life_span = PHOENIX_LIFE;
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
NO_PRIM);
ElementPtr->state_flags |= NONSOLID | FINITE_LIFE | CHANGING;
facing = StarShipPtr->ShipFacing;
for (angle = OCTANT; angle < FULL_CIRCLE; angle += QUADRANT)
{
StarShipPtr->ShipFacing = NORMALIZE_FACING (
facing + ANGLE_TO_FACING (angle)
);
phoenix_transition (ElementPtr);
}
StarShipPtr->ShipFacing = facing;
}
}
if (StarShipPtr->RaceDescPtr->preprocess_func)
{
StarShipPtr->cur_status_flags &=
~(LEFT | RIGHT | THRUST | WEAPON | SPECIAL);
if (ElementPtr->life_span == NORMAL_LIFE)
{
ElementPtr->current.image.frame =
ElementPtr->next.image.frame =
SetEquFrameIndex (
ElementPtr->current.image.farray[0],
ElementPtr->current.image.frame);
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
ZeroVelocityComponents (&ElementPtr->velocity);
ElementPtr->state_flags &= ~(NONSOLID | FINITE_LIFE);
ElementPtr->state_flags |= CHANGING;
StarShipPtr->RaceDescPtr->preprocess_func = 0;
}
}
}
static void
gas_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
SDWORD dx, dy;
// Baul's gas now flies forward. Slow down the gas smoothly.
GetCurrentVelocityComponentsSdword (&ElementPtr->velocity, &dx, &dy);
if (dx != 0 || dy != 0)
{
dx = (SDWORD)(dx * 9 / 10);
dy = (SDWORD)(dy * 9 / 10);
SetVelocityComponents (&ElementPtr->velocity, dx, dy);
}
GetElementStarShip (ElementPtr, &StarShipPtr);
// Move to next image frame. (Abusing thrust_wait to slow down the anim.)
if (ElementPtr->thrust_wait > 0)
--ElementPtr->thrust_wait;
else
{
// Abusing thrust_wait to slow down the anim. (Should help performance a bit.)
ElementPtr->thrust_wait = 1;
// This makes the gas animate even if the ships are not moving and the screen is stationary.
ElementPtr->state_flags |= CHANGING;
if (GetFrameIndex (ElementPtr->current.image.frame) >= LAST_DISSOLVE_INDEX
&& GetFrameIndex (ElementPtr->current.image.frame) < LAST_DISSOLVE_INDEX + NUM_EMERGE_FRAMES)
ElementPtr->next.image.frame = IncFrameIndex (ElementPtr->current.image.frame);
else if (GetFrameIndex (ElementPtr->current.image.frame) < LAST_GAS_INDEX - 1)
ElementPtr->next.image.frame = IncFrameIndex (ElementPtr->current.image.frame);
else
ElementPtr->next.image.frame = SetAbsFrameIndex (ElementPtr->current.image.frame, 0);
}
// If enemy ship dies, remove the gas (this prevents game crashing upon enemy ship dying with gas on it).
if ((!(ElementPtr->state_flags & IGNORE_VELOCITY) && ElementPtr->hTarget == 0)
|| StarShipPtr->RaceDescPtr->ship_info.crew_level == 0)
{
ElementPtr->life_span = 0;
ElementPtr->state_flags |= DISAPPEARING;
}
// When the gas has collided with enemy ship, it sticks to the ship until expires.
// (When the gas is sticking to enemy ship, the gas's IGNORE_VELOCITY flag is disabled.)
else if (!(ElementPtr->state_flags & IGNORE_VELOCITY) && !(ElementPtr->state_flags & DISAPPEARING))
{
ELEMENT *eptr;
SIZE offs_x, offs_y;
SBYTE leftOrRight, upOrDown;
COUNT angle, angleCorrect;
static BYTE alignment[NUM_SIDES]={0,0};
// eptr points to enemy ship now.
LockElement (ElementPtr->hTarget, &eptr);
// Make gas's location the same as the enemy ship's.
ElementPtr->next.location = eptr->next.location;
// Randomize the gas's location so every gas cloud doesn't stick to the same place on the enemy ship.
GetElementStarShip (eptr, &StarShipPtr);
angle = (ElementPtr->weapon_element_index) % 16;
alignment[ElementPtr->playerNr] = ElementPtr->weapon_element_index % 4;
if (alignment[ElementPtr->playerNr] == 0)
{
leftOrRight = -1;
upOrDown = 1;
angleCorrect = 0;
}
else if (alignment[ElementPtr->playerNr] == 1)
{
leftOrRight = 1;
upOrDown = -1;
angleCorrect = 0;
}
else if (alignment[ElementPtr->playerNr] == 2)
{
leftOrRight = -1;
upOrDown = 1;
angleCorrect = HALF_CIRCLE / 2;
}
else
{
leftOrRight = 1;
upOrDown = -1;
angleCorrect = HALF_CIRCLE / 2;
}
offs_x = SINE (angle - angleCorrect, (ElementPtr->weapon_element_index % 16) * (5 << RESOLUTION_FACTOR));
offs_y = COSINE (angle - angleCorrect, (ElementPtr->weapon_element_index % 16) * (5 << RESOLUTION_FACTOR));
ElementPtr->next.location.x = ElementPtr->next.location.x + leftOrRight * offs_x;
ElementPtr->next.location.y = ElementPtr->next.location.y + upOrDown * offs_y;
if (ElementPtr->turn_wait)
{
HELEMENT hEffect;
hEffect = AllocElement ();
if (hEffect)
{
// eptr points to the new gas element now.
LockElement (hEffect, &eptr);
eptr->playerNr = ElementPtr->playerNr;
eptr->state_flags = FINITE_LIFE | GASSY_SUBSTANCE | CHANGING;
eptr->life_span = 1;
eptr->thrust_wait = 1;
eptr->weapon_element_index = ElementPtr->weapon_element_index;
eptr->current = eptr->next = ElementPtr->next;
eptr->preprocess_func = gas_preprocess;
eptr->collision_func = gas_collision;
// No need to have death_func here: It carries on from the declaration in gas_collision.
// In fact, if gas_death is put here as death_func, it just messes up the graphics.
SetPrimType (&(GLOBAL (DisplayArray))[eptr->PrimIndex], STAMP_PRIM);
GetElementStarShip (ElementPtr, &StarShipPtr);
SetElementStarShip (eptr, StarShipPtr);
eptr->hTarget = ElementPtr->hTarget;
UnlockElement (hEffect);
PutElement (hEffect);
}
}
UnlockElement (ElementPtr->hTarget);
}
}
static void
thraddash_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (!(StarShipPtr->cur_status_flags & SPECIAL))
{
if ((StarShipPtr->old_status_flags & SPECIAL)
&& (StarShipPtr->cur_status_flags & SHIP_AT_MAX_SPEED))
StarShipPtr->cur_status_flags |= SHIP_BEYOND_MAX_SPEED;
}
else if (DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST))
{
COUNT max_thrust, thrust_increment;
STATUS_FLAGS thrust_status;
HELEMENT hTrailElement;
if (!(StarShipPtr->old_status_flags & SPECIAL))
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
if (ElementPtr->thrust_wait == 0)
++ElementPtr->thrust_wait;
thrust_increment =
StarShipPtr->RaceDescPtr->characteristics.thrust_increment;
max_thrust = StarShipPtr->RaceDescPtr->characteristics.max_thrust;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment =
SPECIAL_THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.max_thrust =
SPECIAL_MAX_THRUST;
thrust_status = inertial_thrust (ElementPtr);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED
| SHIP_BEYOND_MAX_SPEED
| SHIP_IN_GRAVITY_WELL);
StarShipPtr->cur_status_flags |= thrust_status;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment =
thrust_increment;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = max_thrust;
{
MISSILE_BLOCK MissileBlock;
MissileBlock.cx = ElementPtr->next.location.x;
MissileBlock.cy = ElementPtr->next.location.y;
MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;
MissileBlock.face = 0;
MissileBlock.index = GetFrameCount (
StarShipPtr->RaceDescPtr->ship_data.special[0]
) - 1;
MissileBlock.sender = ElementPtr->playerNr;
MissileBlock.flags = IGNORE_SIMILAR;
MissileBlock.pixoffs = 0;
MissileBlock.speed = 0;
MissileBlock.hit_points = NAPALM_HITS;
MissileBlock.damage = NAPALM_DAMAGE;
MissileBlock.life = NAPALM_LIFE;
MissileBlock.preprocess_func = flame_napalm_preprocess;
MissileBlock.blast_offs = NAPALM_OFFSET;
hTrailElement = initialize_missile (&MissileBlock);
if (hTrailElement)
{
ELEMENT *TrailElementPtr;
LockElement (hTrailElement, &TrailElementPtr);
SetElementStarShip (TrailElementPtr, StarShipPtr);
TrailElementPtr->hTarget = 0;
/* turn_wait is abused here to store the speed of the decay
* animation */
TrailElementPtr->turn_wait = NAPALM_DECAY_RATE;
TrailElementPtr->state_flags |= NONSOLID;
SetPrimType (
&(GLOBAL (DisplayArray))[TrailElementPtr->PrimIndex],
NO_PRIM
);
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
TrailElementPtr->next = TrailElementPtr->current;
TrailElementPtr->state_flags |= PRE_PROCESS;
UnlockElement (hTrailElement);
InsertElement (hTrailElement, GetHeadElement ());
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
}
}
}
}
static void
thraddash_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
// Switch side guns after every shot.
if (StarShipPtr->weapon_counter == 1)
{
if (StarShipPtr->static_counter == 0)
++StarShipPtr->static_counter;
else
StarShipPtr->static_counter = 0;
}
if (!(StarShipPtr->cur_status_flags & SPECIAL))
{
if (StarShipPtr->old_status_flags & SPECIAL
&& StarShipPtr->cur_status_flags & SHIP_AT_MAX_SPEED)
StarShipPtr->cur_status_flags |= SHIP_BEYOND_MAX_SPEED;
}
else if (StarShipPtr->RaceDescPtr->ship_info.energy_level >= SPECIAL_ENERGY_COST)
{
COUNT max_thrust, thrust_increment;
STATUS_FLAGS thrust_status;
HELEMENT hTrailElement;
if (!(StarShipPtr->old_status_flags & SPECIAL))
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
if (ElementPtr->thrust_wait == 0)
++ElementPtr->thrust_wait;
thrust_increment = StarShipPtr->RaceDescPtr->characteristics.thrust_increment;
max_thrust = StarShipPtr->RaceDescPtr->characteristics.max_thrust;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = SPECIAL_THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = SPECIAL_MAX_THRUST;
thrust_status = inertial_thrust (ElementPtr);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED
| SHIP_BEYOND_MAX_SPEED
| SHIP_IN_GRAVITY_WELL);
StarShipPtr->cur_status_flags |= thrust_status;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = thrust_increment;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = max_thrust;
// Reduce afterburner energy consumption to 2/3.
if (StarShipPtr->special_counter == 0)
{
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST);
StarShipPtr->special_counter = 3;
}
else if (StarShipPtr->special_counter == 2)
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST);
{
MISSILE_BLOCK MissileBlock;
MissileBlock.cx = ElementPtr->next.location.x;
MissileBlock.cy = ElementPtr->next.location.y;
MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;
MissileBlock.face = 0;
MissileBlock.index = GetFrameCount (StarShipPtr->RaceDescPtr->ship_data.special[0]) - 1;
MissileBlock.sender = ElementPtr->playerNr;
MissileBlock.flags = IGNORE_SIMILAR;
MissileBlock.pixoffs = 0;
MissileBlock.speed = 0;
MissileBlock.hit_points = NAPALM_HITS;
MissileBlock.damage = NAPALM_DAMAGE;
MissileBlock.life = NAPALM_LIFE;
MissileBlock.preprocess_func = flame_napalm_preprocess;
MissileBlock.blast_offs = NAPALM_OFFSET;
hTrailElement = initialize_missile (&MissileBlock);
if (hTrailElement)
{
ELEMENT *TrailElementPtr;
LockElement (hTrailElement, &TrailElementPtr);
SetElementStarShip (TrailElementPtr, StarShipPtr);
TrailElementPtr->hTarget = 0;
TrailElementPtr->turn_wait = NAPALM_FADE_WAIT;
TrailElementPtr->state_flags |= NONSOLID;
SetPrimType (
&(GLOBAL (DisplayArray))[TrailElementPtr->PrimIndex],
NO_PRIM
);
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
TrailElementPtr->next = TrailElementPtr->current;
TrailElementPtr->state_flags |= PRE_PROCESS;
UnlockElement (hTrailElement);
InsertElement (hTrailElement, GetHeadElement ());
ProcessSound (SetAbsSoundIndex (
/* BURNT_TOAST */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
}
}
}
else if (StarShipPtr->RaceDescPtr->ship_info.energy_level < SPECIAL_ENERGY_COST)
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST); /* so text will flash */
}
void
cleanup_dead_ship (ELEMENT *DeadShipPtr)
{
STARSHIP *DeadStarShipPtr;
ProcessSound ((SOUND)~0, NULL);
GetElementStarShip (DeadShipPtr, &DeadStarShipPtr);
{
// Ship explosion has finished, or ship has just warped out
// if DeadStarShipPtr->crew_level != 0
BOOLEAN MusicStarted;
HELEMENT hElement, hSuccElement;
/* Record crew left after the battle */
DeadStarShipPtr->crew_level =
DeadStarShipPtr->RaceDescPtr->ship_info.crew_level;
MusicStarted = FALSE;
for (hElement = GetHeadElement (); hElement; hElement = hSuccElement)
{
ELEMENT *ElementPtr;
STARSHIP *StarShipPtr;
LockElement (hElement, &ElementPtr);
hSuccElement = GetSuccElement (ElementPtr);
GetElementStarShip (ElementPtr, &StarShipPtr);
// Get the STARSHIP that this ELEMENT belongs to.
if (StarShipPtr == DeadStarShipPtr)
{
// This element belongs to the dead ship; it may be the
// ship's own element.
SetElementStarShip (ElementPtr, 0);
if (!(ElementPtr->state_flags & CREW_OBJECT)
|| ElementPtr->preprocess_func != crew_preprocess)
{
// Set the element up for deletion.
SetPrimType (&DisplayArray[ElementPtr->PrimIndex],
NO_PRIM);
ElementPtr->life_span = 0;
ElementPtr->state_flags =
NONSOLID | DISAPPEARING | FINITE_LIFE;
ElementPtr->preprocess_func = 0;
ElementPtr->postprocess_func = 0;
ElementPtr->death_func = 0;
ElementPtr->collision_func = 0;
}
}
if (StarShipPtr
&& (StarShipPtr->cur_status_flags & PLAY_VICTORY_DITTY))
{
// StarShipPtr points to the remaining ship.
MusicStarted = TRUE;
PlayDitty (StarShipPtr);
StarShipPtr->cur_status_flags &= ~PLAY_VICTORY_DITTY;
}
UnlockElement (hElement);
}
DeadShipPtr->state_flags |= DeadShipPtr->turn_wait;
#define MIN_DITTY_FRAME_COUNT ((ONE_SECOND * 3) / BATTLE_FRAME_RATE)
// The ship will be "alive" for at least 2 more frames to make sure
// the elements it owns (set up for deletion above) expire first.
// Ditty does NOT play in the following circumstances:
// * The winning ship dies before the loser finishes exploding
// * At the moment the losing ship dies, the winner has started
// the warp out sequence
DeadShipPtr->life_span = MusicStarted ? MIN_DITTY_FRAME_COUNT : 1;
if (DeadStarShipPtr == winnerStarShip)
{ // This ship died but won the battle. We need to keep it alive
// longer than the dead opponent ship so that the winning player
// picks last.
DeadShipPtr->life_span = MIN_DITTY_FRAME_COUNT + 1;
}
DeadShipPtr->death_func = new_ship;
DeadShipPtr->preprocess_func = preprocess_dead_ship;
DeadShipPtr->state_flags &= ~DISAPPEARING;
// XXX: this increment was originally done by another piece of code
// just below this one. I am almost sure it is not needed, but it
// keeps the original framecount.
++DeadShipPtr->life_span;
SetElementStarShip (DeadShipPtr, DeadStarShipPtr);
}
}
static void
destruct_preprocess (PELEMENT ElementPtr)
{
#define DESTRUCT_SWITCH ((NUM_EXPLOSION_FRAMES * 3) - 3)
PPRIMITIVE lpPrim;
lpPrim = &(GLOBAL (DisplayArray))[ElementPtr->PrimIndex];
ElementPtr->state_flags |= CHANGING;
if (ElementPtr->life_span > DESTRUCT_SWITCH)
{
SetPrimType (lpPrim, STAMPFILL_PRIM);
if (ElementPtr->life_span == DESTRUCT_SWITCH + 2)
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E));
else
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
}
else if (ElementPtr->life_span < DESTRUCT_SWITCH)
{
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame);
if (GetPrimColor (lpPrim) == BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E));
else if (GetPrimColor (lpPrim) == BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x0A), 0x0E))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x1F, 0x0A, 0x0A), 0x0C));
else if (GetPrimColor (lpPrim) == BUILD_COLOR (MAKE_RGB15 (0x1F, 0x0A, 0x0A), 0x0C))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x14, 0x0A, 0x00), 0x06));
else if (GetPrimColor (lpPrim) == BUILD_COLOR (MAKE_RGB15 (0x14, 0x0A, 0x00), 0x06))
SetPrimColor (lpPrim, BUILD_COLOR (MAKE_RGB15 (0x14, 0x00, 0x00), 0x04));
}
else
{
HELEMENT hDestruct;
SetPrimType (lpPrim, NO_PRIM);
ElementPtr->preprocess_func = NULL_PTR;
hDestruct = AllocElement ();
if (hDestruct)
{
ELEMENTPTR DestructPtr;
STARSHIPPTR StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
PutElement (hDestruct);
LockElement (hDestruct, &DestructPtr);
SetElementStarShip (DestructPtr, StarShipPtr);
DestructPtr->hit_points = DestructPtr->mass_points = 0;
DestructPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
DestructPtr->life_span = (NUM_EXPLOSION_FRAMES - 3) - 1;
SetPrimType (
&(GLOBAL (DisplayArray))[DestructPtr->PrimIndex],
STAMPFILL_PRIM
);
SetPrimColor (
&(GLOBAL (DisplayArray))[DestructPtr->PrimIndex],
BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F)
);
DestructPtr->current.image.farray = StarShipPtr->RaceDescPtr->ship_data.special;
DestructPtr->current.image.frame = StarShipPtr->RaceDescPtr->ship_data.special[0];
DestructPtr->current.location = ElementPtr->current.location;
{
DestructPtr->preprocess_func = destruct_preprocess;
}
DestructPtr->postprocess_func =
DestructPtr->death_func = NULL_PTR;
ZeroVelocityComponents (&DestructPtr->velocity);
UnlockElement (hDestruct);
}
}
}
static void
explosion_preprocess (ELEMENT *ShipPtr)
{
BYTE i;
i = (NUM_EXPLOSION_FRAMES * 3) - ShipPtr->life_span;
switch (i)
{
case 25:
ShipPtr->preprocess_func = NULL;
case 0:
case 1:
case 2:
case 20:
case 21:
case 22:
case 23:
case 24:
i = 1;
break;
case 3:
case 4:
case 5:
case 18:
case 19:
i = 2;
break;
case 15:
SetPrimType (&DisplayArray[ShipPtr->PrimIndex], NO_PRIM);
ShipPtr->state_flags |= CHANGING;
default:
i = 3;
break;
}
do
{
HELEMENT hElement;
hElement = AllocElement ();
if (hElement)
{
COUNT angle, dist;
DWORD rand_val;
ELEMENT *ElementPtr;
extern FRAME explosion[];
PutElement (hElement);
LockElement (hElement, &ElementPtr);
ElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
ElementPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
ElementPtr->life_span = 9;
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], STAMP_PRIM);
ElementPtr->current.image.farray = explosion;
ElementPtr->current.image.frame = explosion[0];
rand_val = TFB_Random ();
angle = LOBYTE (HIWORD (rand_val));
dist = DISPLAY_TO_WORLD (LOBYTE (LOWORD (rand_val)) % 8);
if (HIBYTE (LOWORD (rand_val)) < 256 * 1 / 3)
dist += DISPLAY_TO_WORLD (8);
ElementPtr->current.location.x =
ShipPtr->current.location.x + COSINE (angle, dist);
ElementPtr->current.location.y =
ShipPtr->current.location.y + SINE (angle, dist);
ElementPtr->preprocess_func = animation_preprocess;
rand_val = TFB_Random ();
angle = LOBYTE (LOWORD (rand_val));
dist = WORLD_TO_VELOCITY (
DISPLAY_TO_WORLD (HIBYTE (LOWORD (rand_val)) % 5));
SetVelocityComponents (&ElementPtr->velocity,
COSINE (angle, dist), SINE (angle, dist));
UnlockElement (hElement);
}
} while (--i);
}
static void
confuse_preprocess (ELEMENT *ElementPtr)
{
if (!(ElementPtr->state_flags & NONSOLID))
{
ElementPtr->next.image.frame = SetAbsFrameIndex (
ElementPtr->current.image.frame,
(GetFrameIndex (ElementPtr->current.image.frame) + 1) & 7);
ElementPtr->state_flags |= CHANGING;
}
else if (ElementPtr->hTarget == 0)
{
ElementPtr->life_span = 0;
ElementPtr->state_flags |= DISAPPEARING;
}
else
{
ELEMENT *eptr;
LockElement (ElementPtr->hTarget, &eptr);
ElementPtr->next.location = eptr->next.location;
if (ElementPtr->turn_wait)
{
HELEMENT hEffect;
STARSHIP *StarShipPtr;
if (GetFrameIndex (ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame)) == 0)
ElementPtr->next.image.frame =
SetRelFrameIndex (ElementPtr->next.image.frame, -8);
GetElementStarShip (eptr, &StarShipPtr);
StarShipPtr->ship_input_state =
(StarShipPtr->ship_input_state
& ~(LEFT | RIGHT | SPECIAL))
| ElementPtr->turn_wait;
// Disable Ur-Quan autoturret.
if (StarShipPtr && StarShipPtr->SpeciesID == UR_QUAN_ID)
++StarShipPtr->auxiliary_counter;
hEffect = AllocElement ();
if (hEffect)
{
LockElement (hEffect, &eptr);
eptr->playerNr = ElementPtr->playerNr;
eptr->state_flags = FINITE_LIFE | NONSOLID | CHANGING;
eptr->life_span = 1;
eptr->current = eptr->next = ElementPtr->next;
eptr->preprocess_func = confuse_preprocess;
SetPrimType (&(GLOBAL (DisplayArray))[eptr->PrimIndex],
STAMP_PRIM);
GetElementStarShip (ElementPtr, &StarShipPtr);
SetElementStarShip (eptr, StarShipPtr);
eptr->hTarget = ElementPtr->hTarget;
UnlockElement (hEffect);
PutElement (hEffect);
}
}
UnlockElement (ElementPtr->hTarget);
}
}
void
spawn_ion_trail (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
SHIP_INFO *ShipInfoPtr;
HELEMENT hIonElement;
assert (ElementPtr->state_flags & PLAYER_SHIP);
// JMS: Get the pointers to element's owner ship.
// They are needed to see if the ship's thrust is damaged
GetElementStarShip (ElementPtr, &StarShipPtr);
ShipInfoPtr = &StarShipPtr->RaceDescPtr->ship_info;
hIonElement = AllocElement ();
if (hIonElement)
{
#define ION_LIFE 1
COUNT angle;
RECT r;
ELEMENT *IonElementPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE;
GetFrameRect (StarShipPtr->RaceDescPtr->ship_data.ship[0], &r);
r.extent.height = DISPLAY_TO_WORLD (r.extent.height + r.corner.y);
InsertElement (hIonElement, GetHeadElement ());
LockElement (hIonElement, &IonElementPtr);
IonElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
IonElementPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
IonElementPtr->thrust_wait = ION_LIFE;
IonElementPtr->life_span = IonElementPtr->thrust_wait;
// When the element "dies", in the death_func
// 'cycle_ion_trail', it is given new life a number of
// times, by setting life_span to thrust_wait.
SetPrimType (&DisplayArray[IonElementPtr->PrimIndex], POINT_PRIM);
// JMS: Damaged thruster emits differently colored particles
if (ShipInfoPtr->damage_flags & DAMAGE_THRUST)
{
SetPrimColor (&DisplayArray[IonElementPtr->PrimIndex],
START_ION_COLOR_DAMAGED);
}
else
{
SetPrimColor (&DisplayArray[IonElementPtr->PrimIndex],
START_ION_COLOR);
}
IonElementPtr->colorCycleIndex = 0;
IonElementPtr->current.image.frame =
DecFrameIndex (stars_in_space);
IonElementPtr->current.image.farray = &stars_in_space;
IonElementPtr->current.location = ElementPtr->current.location;
IonElementPtr->current.location.x +=
(COORD)COSINE (angle, r.extent.height);
IonElementPtr->current.location.y +=
(COORD)SINE (angle, r.extent.height);
IonElementPtr->death_func = cycle_ion_trail;
SetElementStarShip (IonElementPtr, StarShipPtr);
{
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
IonElementPtr->next = IonElementPtr->current;
--IonElementPtr->life_span;
IonElementPtr->state_flags |= PRE_PROCESS;
}
UnlockElement (hIonElement);
}
}
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;
}
}
// Preprocess function for spawning a ship into or out of battle.
// Used when a new ship warps in, or a ship escapes by warping out, but not
// when a Pkunk ship is reborn.
void
ship_transition (ELEMENT *ElementPtr)
{
if (ElementPtr->state_flags & PLAYER_SHIP)
{
if (ElementPtr->state_flags & APPEARING)
{
ElementPtr->life_span = HYPERJUMP_LIFE;
ElementPtr->preprocess_func = ship_transition;
ElementPtr->postprocess_func = NULL;
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], NO_PRIM);
ElementPtr->state_flags |= NONSOLID | FINITE_LIFE | CHANGING;
}
else if (ElementPtr->life_span < HYPERJUMP_LIFE)
{
if (ElementPtr->life_span == NORMAL_LIFE
&& ElementPtr->crew_level)
{
ElementPtr->current.image.frame =
ElementPtr->next.image.frame =
SetEquFrameIndex (
ElementPtr->current.image.farray[0],
ElementPtr->current.image.frame);
SetPrimType (&DisplayArray[ElementPtr->PrimIndex], STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
ZeroVelocityComponents (&ElementPtr->velocity);
ElementPtr->state_flags &= ~(NONSOLID | FINITE_LIFE);
ElementPtr->state_flags |= CHANGING;
ElementPtr->preprocess_func = ship_preprocess;
ElementPtr->postprocess_func = ship_postprocess;
}
return;
}
}
{
HELEMENT hShipImage;
ELEMENT *ShipImagePtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
LockElement (StarShipPtr->hShip, &ShipImagePtr);
if (!(ShipImagePtr->state_flags & NONSOLID))
{
ElementPtr->preprocess_func = NULL;
}
else if ((hShipImage = AllocElement ()))
{
#define TRANSITION_SPEED DISPLAY_TO_WORLD (40 << RESOLUTION_FACTOR) // JMS_GFX
#define TRANSITION_LIFE 1
COUNT angle;
PutElement (hShipImage);
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing);
LockElement (hShipImage, &ShipImagePtr);
ShipImagePtr->playerNr = NEUTRAL_PLAYER_NUM;
ShipImagePtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
ShipImagePtr->thrust_wait = TRANSITION_LIFE;
ShipImagePtr->life_span = ShipImagePtr->thrust_wait;
// When the element "dies", in the death_func
// 'cycle_ion_trail', it is given new life a number of
// times, by setting life_span to thrust_wait.
SetPrimType (&DisplayArray[ShipImagePtr->PrimIndex],
STAMPFILL_PRIM);
SetPrimColor (&DisplayArray[ShipImagePtr->PrimIndex],
START_ION_COLOR);
ShipImagePtr->colorCycleIndex = 0;
ShipImagePtr->current.image = ElementPtr->current.image;
ShipImagePtr->current.location = ElementPtr->current.location;
if (!(ElementPtr->state_flags & PLAYER_SHIP))
{
ShipImagePtr->current.location.x +=
COSINE (angle, TRANSITION_SPEED);
ShipImagePtr->current.location.y +=
SINE (angle, TRANSITION_SPEED);
ElementPtr->preprocess_func = NULL;
}
else if (ElementPtr->crew_level)
{
ShipImagePtr->current.location.x -=
COSINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.y -=
SINE (angle, TRANSITION_SPEED)
* (ElementPtr->life_span - 1);
ShipImagePtr->current.location.x =
WRAP_X (ShipImagePtr->current.location.x);
ShipImagePtr->current.location.y =
WRAP_Y (ShipImagePtr->current.location.y);
}
ShipImagePtr->preprocess_func = ship_transition;
ShipImagePtr->death_func = cycle_ion_trail;
SetElementStarShip (ShipImagePtr, StarShipPtr);
UnlockElement (hShipImage);
}
UnlockElement (StarShipPtr->hShip);
}
}
