zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-19 10:51:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom-gles/src/g_heretic/a_hereticweaps.cpp
Randy Heit 21a7564c98 - Fixed: Mace SpawnID was assigned to the MacePowered actor instead. 
- Fixed: Sorcerer2FX1's SpawnID was not restricted to Heretic.


SVN r1097 (trunk)
2008-07-31 18:08:30 +00:00

2232 lines
61 KiB
C++
Raw Blame History

#include "templates.h"
#include "actor.h"
#include "info.h"
#include "s_sound.h"
#include "m_random.h"
#include "a_pickups.h"
#include "a_hereticglobal.h"
#include "d_player.h"
#include "p_pspr.h"
#include "p_local.h"
#include "gstrings.h"
#include "p_effect.h"
#include "gstrings.h"
#include "p_enemy.h"
#include "gi.h"
#include "r_translate.h"
#include "a_specialspot.h"
#include "thingdef/thingdef.h"
static FRandom pr_sap ("StaffAtkPL1");
static FRandom pr_sap2 ("StaffAtkPL2");
static FRandom pr_fgw ("FireWandPL1");
static FRandom pr_fgw2 ("FireWandPL2");
static FRandom pr_boltspark ("BoltSpark");
static FRandom pr_spawnmace ("SpawnMace");
static FRandom pr_macerespawn ("MaceRespawn");
static FRandom pr_maceatk ("FireMacePL1");
static FRandom pr_gatk ("GauntletAttack");
static FRandom pr_bfx1 ("BlasterFX1");
static FRandom pr_ripd ("RipperD");
static FRandom pr_fb1 ("FireBlasterPL1");
static FRandom pr_bfx1t ("BlasterFX1Tick");
static FRandom pr_hrfx2 ("HornRodFX2");
static FRandom pr_rp ("RainPillar");
static FRandom pr_fsr1 ("FireSkullRodPL1");
static FRandom pr_storm ("SkullRodStorm");
static FRandom pr_impact ("RainImpact");
static FRandom pr_pfx1 ("PhoenixFX1");
static FRandom pr_pfx2 ("PhoenixFX2");
static FRandom pr_fp2 ("FirePhoenixPL2");
#define FLAME_THROWER_TICS (10*TICRATE)
#define USE_BLSR_AMMO_1 1
#define USE_BLSR_AMMO_2 5
#define USE_SKRD_AMMO_1 1
#define USE_SKRD_AMMO_2 5
#define USE_PHRD_AMMO_1 1
#define USE_PHRD_AMMO_2 1
#define USE_MACE_AMMO_1 1
#define USE_MACE_AMMO_2 5
extern bool P_AutoUseChaosDevice (player_t *player);
// Base Heretic weapon class ------------------------------------------------
IMPLEMENT_STATELESS_ACTOR (AHereticWeapon, Heretic, -1, 0)
PROP_Weapon_Kickback (150)
END_DEFAULTS
// --- Staff ----------------------------------------------------------------
//----------------------------------------------------------------------------
//
// PROC A_StaffAttackPL1
//
//----------------------------------------------------------------------------
void A_StaffAttack (AActor *actor)
{
angle_t angle;
int damage;
int slope;
player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player))
{
return;
}
int index = CheckIndex (2, NULL);
if (index < 0) return;
damage = EvalExpressionI (StateParameters[index], actor);
const PClass *puff = PClass::FindClass ((ENamedName)StateParameters[index+1]);
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
angle = actor->angle;
angle += pr_sap.Random2() << 18;
slope = P_AimLineAttack (actor, angle, MELEERANGE, &linetarget);
P_LineAttack (actor, angle, MELEERANGE, slope, damage, NAME_Melee, puff, true);
if (linetarget)
{
//S_StartSound(player->mo, sfx_stfhit);
// turn to face target
actor->angle = R_PointToAngle2 (actor->x,
actor->y, linetarget->x, linetarget->y);
}
}
//----------------------------------------------------------------------------
//
// PROC A_FireGoldWandPL1
//
//----------------------------------------------------------------------------
void A_FireGoldWandPL1 (AActor *actor)
{
angle_t angle;
int damage;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
angle_t pitch = P_BulletSlope(actor);
damage = 7+(pr_fgw()&7);
angle = actor->angle;
if (player->refire)
{
angle += pr_fgw.Random2() << 18;
}
P_LineAttack (actor, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, "GoldWandPuff1");
S_Sound (actor, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM);
}
//----------------------------------------------------------------------------
//
// PROC A_FireGoldWandPL2
//
//----------------------------------------------------------------------------
void A_FireGoldWandPL2 (AActor *actor)
{
int i;
angle_t angle;
int damage;
fixed_t momz;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
angle_t pitch = P_BulletSlope(actor);
momz = FixedMul (GetDefaultByName("GoldWandFX2")->Speed,
finetangent[FINEANGLES/4-((signed)pitch>>ANGLETOFINESHIFT)]);
P_SpawnMissileAngle (actor, PClass::FindClass("GoldWandFX2"), actor->angle-(ANG45/8), momz);
P_SpawnMissileAngle (actor, PClass::FindClass("GoldWandFX2"), actor->angle+(ANG45/8), momz);
angle = actor->angle-(ANG45/8);
for(i = 0; i < 5; i++)
{
damage = 1+(pr_fgw2()&7);
P_LineAttack (actor, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, "GoldWandPuff2");
angle += ((ANG45/8)*2)/4;
}
S_Sound (actor, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM);
}
//----------------------------------------------------------------------------
//
// PROC A_FireCrossbowPL1
//
//----------------------------------------------------------------------------
void A_FireCrossbowPL1 (AActor *actor)
{
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX1"));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX3"), actor->angle-(ANG45/10));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX3"), actor->angle+(ANG45/10));
}
//----------------------------------------------------------------------------
//
// PROC A_FireCrossbowPL2
//
//----------------------------------------------------------------------------
void A_FireCrossbowPL2(AActor *actor)
{
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = actor->player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX2"));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX2"), actor->angle-(ANG45/10));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX2"), actor->angle+(ANG45/10));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX3"), actor->angle-(ANG45/5));
P_SpawnPlayerMissile (actor, PClass::FindClass("CrossbowFX3"), actor->angle+(ANG45/5));
}
//---------------------------------------------------------------------------
//
// PROC A_GauntletAttack
//
//---------------------------------------------------------------------------
void A_GauntletAttack (AActor *actor)
{
angle_t angle;
int damage;
int slope;
int randVal;
fixed_t dist;
player_t *player;
const PClass *pufftype;
int power;
AActor *linetarget;
if (NULL == (player = actor->player))
{
return;
}
int index = CheckIndex (1, NULL);
if (index < 0) return;
power = EvalExpressionI (StateParameters[index], actor);
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
player->psprites[ps_weapon].sx = ((pr_gatk()&3)-2) * FRACUNIT;
player->psprites[ps_weapon].sy = WEAPONTOP + (pr_gatk()&3) * FRACUNIT;
angle = actor->angle;
if (power)
{
damage = pr_gatk.HitDice (2);
dist = 4*MELEERANGE;
angle += pr_gatk.Random2() << 17;
pufftype = PClass::FindClass("GauntletPuff2");
}
else
{
damage = pr_gatk.HitDice (2);
dist = MELEERANGE+1;
angle += pr_gatk.Random2() << 18;
pufftype = PClass::FindClass("GauntletPuff1");
}
slope = P_AimLineAttack (actor, angle, dist, &linetarget);
P_LineAttack (actor, angle, dist, slope, damage, NAME_Melee, pufftype);
if (!linetarget)
{
if (pr_gatk() > 64)
{
player->extralight = !player->extralight;
}
S_Sound (actor, CHAN_AUTO, "weapons/gauntletson", 1, ATTN_NORM);
return;
}
randVal = pr_gatk();
if (randVal < 64)
{
player->extralight = 0;
}
else if (randVal < 160)
{
player->extralight = 1;
}
else
{
player->extralight = 2;
}
if (power)
{
P_GiveBody (actor, damage>>1);
S_Sound (actor, CHAN_AUTO, "weapons/gauntletspowhit", 1, ATTN_NORM);
}
else
{
S_Sound (actor, CHAN_AUTO, "weapons/gauntletshit", 1, ATTN_NORM);
}
// turn to face target
angle = R_PointToAngle2 (actor->x, actor->y,
linetarget->x, linetarget->y);
if (angle-actor->angle > ANG180)
{
if ((int)(angle-actor->angle) < -ANG90/20)
actor->angle = angle+ANG90/21;
else
actor->angle -= ANG90/20;
}
else
{
if (angle-actor->angle > ANG90/20)
actor->angle = angle-ANG90/21;
else
actor->angle += ANG90/20;
}
actor->flags |= MF_JUSTATTACKED;
}
// --- Mace -----------------------------------------------------------------
#define MAGIC_JUNK 1234
void A_FireMacePL1B (AActor *);
void A_FireMacePL1 (AActor *);
void A_MacePL1Check (AActor *);
void A_MaceBallImpact (AActor *);
void A_MaceBallImpact2 (AActor *);
void A_FireMacePL2 (AActor *);
void A_DeathBallImpact (AActor *);
// The mace itself ----------------------------------------------------------
class AMace : public AHereticWeapon
{
DECLARE_ACTOR (AMace, AHereticWeapon)
protected:
bool DoRespawn ();
};
class AMacePowered : public AMace
{
DECLARE_STATELESS_ACTOR (AMacePowered, AMace)
};
FState AMace::States[] =
{
#define S_WMCE 0
S_NORMAL (WMCE, 'A', -1, NULL , NULL),
#define S_MACEREADY (S_WMCE+1)
S_NORMAL (MACE, 'A', 1, A_WeaponReady , &States[S_MACEREADY]),
#define S_MACEDOWN (S_MACEREADY+1)
S_NORMAL (MACE, 'A', 1, A_Lower , &States[S_MACEDOWN]),
#define S_MACEUP (S_MACEDOWN+1)
S_NORMAL (MACE, 'A', 1, A_Raise , &States[S_MACEUP]),
#define S_MACEATK1 (S_MACEUP+1)
S_NORMAL (MACE, 'B', 4, NULL , &States[S_MACEATK1+1]),
S_NORMAL (MACE, 'C', 3, A_FireMacePL1 , &States[S_MACEATK1+2]),
S_NORMAL (MACE, 'D', 3, A_FireMacePL1 , &States[S_MACEATK1+3]),
S_NORMAL (MACE, 'E', 3, A_FireMacePL1 , &States[S_MACEATK1+4]),
S_NORMAL (MACE, 'F', 3, A_FireMacePL1 , &States[S_MACEATK1+5]),
S_NORMAL (MACE, 'C', 4, A_ReFire , &States[S_MACEATK1+6]),
S_NORMAL (MACE, 'D', 4, NULL , &States[S_MACEATK1+7]),
S_NORMAL (MACE, 'E', 4, NULL , &States[S_MACEATK1+8]),
S_NORMAL (MACE, 'F', 4, NULL , &States[S_MACEATK1+9]),
S_NORMAL (MACE, 'B', 4, NULL , &States[S_MACEREADY]),
#define S_MACEATK2 (S_MACEATK1+10)
S_NORMAL (MACE, 'B', 4, NULL , &States[S_MACEATK2+1]),
S_NORMAL (MACE, 'D', 4, A_FireMacePL2 , &States[S_MACEATK2+2]),
S_NORMAL (MACE, 'B', 4, NULL , &States[S_MACEATK2+3]),
S_NORMAL (MACE, 'A', 8, A_ReFire , &States[S_MACEREADY])
};
IMPLEMENT_ACTOR (AMace, Heretic, -1, 31)
PROP_Flags (MF_SPECIAL)
PROP_SpawnState (0)
PROP_Weapon_SelectionOrder (1400)
PROP_Weapon_Flags (WIF_BOT_REACTION_SKILL_THING|WIF_BOT_EXPLOSIVE)
PROP_Weapon_AmmoUse1 (USE_MACE_AMMO_1)
PROP_Weapon_AmmoGive1 (50)
PROP_Weapon_UpState (S_MACEUP)
PROP_Weapon_DownState (S_MACEDOWN)
PROP_Weapon_ReadyState (S_MACEREADY)
PROP_Weapon_AtkState (S_MACEATK1)
PROP_Weapon_HoldAtkState (S_MACEATK1+1)
PROP_Weapon_YAdjust (15)
PROP_Weapon_MoveCombatDist (27000000)
PROP_Weapon_AmmoType1 ("MaceAmmo")
PROP_Weapon_SisterType ("MacePowered")
PROP_Weapon_ProjectileType ("MaceFX2")
PROP_Inventory_PickupMessage("$TXT_WPNMACE")
END_DEFAULTS
IMPLEMENT_STATELESS_ACTOR (AMacePowered, Heretic, -1, 0)
PROP_Weapon_Flags (WIF_POWERED_UP|WIF_BOT_REACTION_SKILL_THING|WIF_BOT_EXPLOSIVE)
PROP_Weapon_AmmoUse1 (USE_MACE_AMMO_2)
PROP_Weapon_AmmoGive1 (0)
PROP_Weapon_AtkState (S_MACEATK2)
PROP_Weapon_HoldAtkState (S_MACEATK2)
PROP_Weapon_SisterType ("Mace")
PROP_Weapon_ProjectileType ("MaceFX4")
END_DEFAULTS
// Mace FX1 -----------------------------------------------------------------
class AMaceFX1 : public AActor
{
DECLARE_ACTOR (AMaceFX1, AActor)
};
FState AMaceFX1::States[] =
{
#define S_MACEFX1 0
S_NORMAL (FX02, 'A', 4, A_MacePL1Check , &States[S_MACEFX1+1]),
S_NORMAL (FX02, 'B', 4, A_MacePL1Check , &States[S_MACEFX1+0]),
#define S_MACEFXI1 (S_MACEFX1+2)
S_BRIGHT (FX02, 'F', 4, A_MaceBallImpact , &States[S_MACEFXI1+1]),
S_BRIGHT (FX02, 'G', 4, NULL , &States[S_MACEFXI1+2]),
S_BRIGHT (FX02, 'H', 4, NULL , &States[S_MACEFXI1+3]),
S_BRIGHT (FX02, 'I', 4, NULL , &States[S_MACEFXI1+4]),
S_BRIGHT (FX02, 'J', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (AMaceFX1, Heretic, -1, 154)
PROP_RadiusFixed (8)
PROP_HeightFixed (6)
PROP_SpeedFixed (20)
PROP_Damage (2)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_HERETICBOUNCE|MF2_THRUGHOST|MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_Flags3 (MF3_WARNBOT)
PROP_SpawnState (S_MACEFX1)
PROP_DeathState (S_MACEFXI1)
PROP_SeeSound ("weapons/maceshoot")
END_DEFAULTS
// Mace FX2 -----------------------------------------------------------------
class AMaceFX2 : public AActor
{
DECLARE_ACTOR (AMaceFX2, AActor)
};
FState AMaceFX2::States[] =
{
#define S_MACEFX2 0
S_NORMAL (FX02, 'C', 4, NULL , &States[S_MACEFX2+1]),
S_NORMAL (FX02, 'D', 4, NULL , &States[S_MACEFX2+0]),
#define S_MACEFXI2 (S_MACEFX2+2)
S_BRIGHT (FX02, 'F', 4, A_MaceBallImpact2 , &AMaceFX1::States[S_MACEFXI1+1])
};
IMPLEMENT_ACTOR (AMaceFX2, Heretic, -1, 156)
PROP_RadiusFixed (8)
PROP_HeightFixed (6)
PROP_SpeedFixed (10)
PROP_Damage (6)
PROP_Gravity (FRACUNIT/8)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF)
PROP_Flags2 (MF2_HERETICBOUNCE|MF2_THRUGHOST|MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_SpawnState (S_MACEFX2)
PROP_DeathState (S_MACEFXI2)
END_DEFAULTS
// Mace FX3 -----------------------------------------------------------------
class AMaceFX3 : public AMaceFX1
{
DECLARE_ACTOR (AMaceFX3, AMaceFX1)
};
FState AMaceFX3::States[] =
{
#define S_MACEFX3 0
S_NORMAL (FX02, 'A', 4, NULL , &States[S_MACEFX3+1]),
S_NORMAL (FX02, 'B', 4, NULL , &States[S_MACEFX3+0])
};
IMPLEMENT_ACTOR (AMaceFX3, Heretic, -1, 155)
PROP_SpeedFixed (7)
PROP_Damage (4)
PROP_Gravity (FRACUNIT/8)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF)
PROP_Flags2 (MF2_HERETICBOUNCE|MF2_THRUGHOST|MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_SpawnState (S_MACEFX3)
END_DEFAULTS
// Mace FX4 -----------------------------------------------------------------
class AMaceFX4 : public AActor
{
DECLARE_ACTOR (AMaceFX4, AActor)
public:
int DoSpecialDamage (AActor *target, int damage);
};
FState AMaceFX4::States[] =
{
#define S_MACEFX4 0
S_NORMAL (FX02, 'E', 99, NULL , &States[S_MACEFX4+0]),
#define S_MACEFXI4 (S_MACEFX4+1)
S_BRIGHT (FX02, 'C', 4, A_DeathBallImpact , &AMaceFX1::States[S_MACEFXI1+1])
};
IMPLEMENT_ACTOR (AMaceFX4, Heretic, -1, 153)
PROP_RadiusFixed (8)
PROP_HeightFixed (6)
PROP_SpeedFixed (7)
PROP_Damage (18)
PROP_Gravity (FRACUNIT/8)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF)
PROP_Flags2 (MF2_HERETICBOUNCE|MF2_THRUGHOST|MF2_TELESTOMP|MF2_PCROSS|MF2_IMPACT)
PROP_SpawnState (S_MACEFX4)
PROP_DeathState (S_MACEFXI4)
END_DEFAULTS
int AMaceFX4::DoSpecialDamage (AActor *target, int damage)
{
if ((target->flags2 & MF2_BOSS) || (target->flags3 & MF3_DONTSQUASH) || target->IsTeammate (this->target))
{ // Don't allow cheap boss kills and don't instagib teammates
return damage;
}
else if (target->player)
{ // Player specific checks
if (target->player->mo->flags2 & MF2_INVULNERABLE)
{ // Can't hurt invulnerable players
return -1;
}
if (P_AutoUseChaosDevice (target->player))
{ // Player was saved using chaos device
return -1;
}
}
return 1000000; // Something's gonna die
}
// Mace spawn spot ----------------------------------------------------------
void A_SpawnMace (AActor *);
class AMaceSpawner : public ASpecialSpot
{
DECLARE_ACTOR (AMaceSpawner, ASpecialSpot)
};
FState AMaceSpawner::States[] =
{
S_NORMAL (TNT1, 'A', 1, NULL, &States[1]),
S_NORMAL (TNT1, 'A', -1, A_SpawnMace, NULL)
};
IMPLEMENT_ACTOR (AMaceSpawner, Heretic, 2002, 0)
PROP_Flags (MF_NOSECTOR|MF_NOBLOCKMAP)
PROP_SpawnState (0)
END_DEFAULTS
// Every mace spawn spot will execute this action. The first one
// will build a list of all mace spots in the level and spawn a
// mace. The rest of the spots will do nothing.
void A_SpawnMace (AActor *self)
{
if (self->target != NULL)
{ // Another spot already did it
return;
}
AActor *spot = NULL;
DSpotState *state = DSpotState::GetSpotState();
if (state != NULL) spot = state->GetRandomSpot(RUNTIME_TYPE(self), true);
if (spot == NULL) return;
if (!deathmatch && pr_spawnmace() < 64)
{ // Sometimes doesn't show up if not in deathmatch
return;
}
AActor *mace = Spawn<AMace> (self->x, self->y, self->z, ALLOW_REPLACE);
if (mace)
{
mace->SetOrigin (spot->x, spot->y, spot->z);
mace->z = mace->floorz;
// We want this mace to respawn.
mace->flags &= ~MF_DROPPED;
}
}
// FIXME: Generalize this so that it doesn't depend on item specific implementation!
// AMace::DoRespawn
// Moves the mace to a different spot when it respawns
bool AMace::DoRespawn ()
{
AActor *spot = NULL;
DSpotState *state = DSpotState::GetSpotState();
if (state != NULL) spot = state->GetRandomSpot(RUNTIME_CLASS(AMaceSpawner));
if (spot != NULL)
{
SetOrigin (spot->x, spot->y, spot->z);
z = floorz;
}
return true;
}
//----------------------------------------------------------------------------
//
// PROC A_FireMacePL1B
//
//----------------------------------------------------------------------------
void A_FireMacePL1B (AActor *actor)
{
AActor *ball;
angle_t angle;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
ball = Spawn<AMaceFX2> (actor->x, actor->y, actor->z + 28*FRACUNIT
- actor->floorclip, ALLOW_REPLACE);
ball->momz = 2*FRACUNIT+/*((player->lookdir)<<(FRACBITS-5))*/
finetangent[FINEANGLES/4-(actor->pitch>>ANGLETOFINESHIFT)];
angle = actor->angle;
ball->target = actor;
ball->angle = angle;
ball->z += 2*finetangent[FINEANGLES/4-(actor->pitch>>ANGLETOFINESHIFT)];
angle >>= ANGLETOFINESHIFT;
ball->momx = (actor->momx>>1)+FixedMul(ball->Speed, finecosine[angle]);
ball->momy = (actor->momy>>1)+FixedMul(ball->Speed, finesine[angle]);
S_Sound (ball, CHAN_BODY, "weapons/maceshoot", 1, ATTN_NORM);
P_CheckMissileSpawn (ball);
}
//----------------------------------------------------------------------------
//
// PROC A_FireMacePL1
//
//----------------------------------------------------------------------------
void A_FireMacePL1 (AActor *actor)
{
AActor *ball;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
if (pr_maceatk() < 28)
{
A_FireMacePL1B (actor);
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
player->psprites[ps_weapon].sx = ((pr_maceatk()&3)-2)*FRACUNIT;
player->psprites[ps_weapon].sy = WEAPONTOP+(pr_maceatk()&3)*FRACUNIT;
ball = P_SpawnPlayerMissile (actor, RUNTIME_CLASS(AMaceFX1),
actor->angle+(((pr_maceatk()&7)-4)<<24));
if (ball)
{
ball->special1 = 16; // tics till dropoff
}
}
//----------------------------------------------------------------------------
//
// PROC A_MacePL1Check
//
//----------------------------------------------------------------------------
void A_MacePL1Check (AActor *ball)
{
if (ball->special1 == 0)
{
return;
}
ball->special1 -= 4;
if (ball->special1 > 0)
{
return;
}
ball->special1 = 0;
ball->flags &= ~MF_NOGRAVITY;
ball->gravity = FRACUNIT/8;
// [RH] Avoid some precision loss by scaling the momentum directly
#if 0
angle_t angle = ball->angle>>ANGLETOFINESHIFT;
ball->momx = FixedMul(7*FRACUNIT, finecosine[angle]);
ball->momy = FixedMul(7*FRACUNIT, finesine[angle]);
#else
float momscale = sqrtf ((float)ball->momx * (float)ball->momx +
(float)ball->momy * (float)ball->momy);
momscale = 458752.f / momscale;
ball->momx = (int)(ball->momx * momscale);
ball->momy = (int)(ball->momy * momscale);
#endif
ball->momz -= ball->momz>>1;
}
//----------------------------------------------------------------------------
//
// PROC A_MaceBallImpact
//
//----------------------------------------------------------------------------
void A_MaceBallImpact (AActor *ball)
{
if ((ball->health != MAGIC_JUNK) && (ball->flags & MF_INBOUNCE))
{ // Bounce
ball->health = MAGIC_JUNK;
ball->momz = (ball->momz * 192) >> 8;
ball->flags2 &= ~MF2_BOUNCETYPE;
ball->SetState (ball->SpawnState);
S_Sound (ball, CHAN_BODY, "weapons/macebounce", 1, ATTN_NORM);
}
else
{ // Explode
ball->momx = ball->momy = ball->momz = 0;
ball->flags |= MF_NOGRAVITY;
ball->gravity = FRACUNIT;
S_Sound (ball, CHAN_BODY, "weapons/macehit", 1, ATTN_NORM);
}
}
//----------------------------------------------------------------------------
//
// PROC A_MaceBallImpact2
//
//----------------------------------------------------------------------------
void A_MaceBallImpact2 (AActor *ball)
{
AActor *tiny;
angle_t angle;
if (ball->flags & MF_INBOUNCE)
{
fixed_t floordist = ball->z - ball->floorz;
fixed_t ceildist = ball->ceilingz - ball->z;
fixed_t vel;
if (floordist <= ceildist)
{
vel = MulScale32 (ball->momz, ball->Sector->floorplane.c);
}
else
{
vel = MulScale32 (ball->momz, ball->Sector->ceilingplane.c);
}
if (vel < 2)
{
goto boom;
}
// Bounce
ball->momz = (ball->momz * 192) >> 8;
ball->SetState (ball->SpawnState);
tiny = Spawn<AMaceFX3> (ball->x, ball->y, ball->z, ALLOW_REPLACE);
angle = ball->angle+ANG90;
tiny->target = ball->target;
tiny->angle = angle;
angle >>= ANGLETOFINESHIFT;
tiny->momx = (ball->momx>>1)+FixedMul(ball->momz-FRACUNIT,
finecosine[angle]);
tiny->momy = (ball->momy>>1)+FixedMul(ball->momz-FRACUNIT,
finesine[angle]);
tiny->momz = ball->momz;
P_CheckMissileSpawn (tiny);
tiny = Spawn<AMaceFX3> (ball->x, ball->y, ball->z, ALLOW_REPLACE);
angle = ball->angle-ANG90;
tiny->target = ball->target;
tiny->angle = angle;
angle >>= ANGLETOFINESHIFT;
tiny->momx = (ball->momx>>1)+FixedMul(ball->momz-FRACUNIT,
finecosine[angle]);
tiny->momy = (ball->momy>>1)+FixedMul(ball->momz-FRACUNIT,
finesine[angle]);
tiny->momz = ball->momz;
P_CheckMissileSpawn (tiny);
}
else
{ // Explode
boom:
ball->momx = ball->momy = ball->momz = 0;
ball->flags |= MF_NOGRAVITY;
ball->flags2 &= ~MF2_BOUNCETYPE;
ball->gravity = FRACUNIT;
}
}
//----------------------------------------------------------------------------
//
// PROC A_FireMacePL2
//
//----------------------------------------------------------------------------
void A_FireMacePL2 (AActor *actor)
{
AActor *mo;
player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
mo = P_SpawnPlayerMissile (actor, 0,0,0, RUNTIME_CLASS(AMaceFX4), actor->angle, &linetarget);
if (mo)
{
mo->momx += actor->momx;
mo->momy += actor->momy;
mo->momz = 2*FRACUNIT+
clamp<fixed_t>(finetangent[FINEANGLES/4-(actor->pitch>>ANGLETOFINESHIFT)], -5*FRACUNIT, 5*FRACUNIT);
if (linetarget)
{
mo->tracer = linetarget;
}
}
S_Sound (actor, CHAN_WEAPON, "weapons/maceshoot", 1, ATTN_NORM);
}
//----------------------------------------------------------------------------
//
// PROC A_DeathBallImpact
//
//----------------------------------------------------------------------------
void A_DeathBallImpact (AActor *ball)
{
int i;
AActor *target;
angle_t angle = 0;
bool newAngle;
AActor *linetarget;
if ((ball->z <= ball->floorz) && P_HitFloor (ball))
{ // Landed in some sort of liquid
ball->Destroy ();
return;
}
if (ball->flags & MF_INBOUNCE)
{
fixed_t floordist = ball->z - ball->floorz;
fixed_t ceildist = ball->ceilingz - ball->z;
fixed_t vel;
if (floordist <= ceildist)
{
vel = MulScale32 (ball->momz, ball->Sector->floorplane.c);
}
else
{
vel = MulScale32 (ball->momz, ball->Sector->ceilingplane.c);
}
if (vel < 2)
{
goto boom;
}
// Bounce
newAngle = false;
target = ball->tracer;
if (target)
{
if (!(target->flags&MF_SHOOTABLE))
{ // Target died
ball->tracer = NULL;
}
else
{ // Seek
angle = R_PointToAngle2(ball->x, ball->y,
target->x, target->y);
newAngle = true;
}
}
else
{ // Find new target
angle = 0;
for (i = 0; i < 16; i++)
{
P_AimLineAttack (ball, angle, 10*64*FRACUNIT, &linetarget);
if (linetarget && ball->target != linetarget)
{
ball->tracer = linetarget;
angle = R_PointToAngle2 (ball->x, ball->y,
linetarget->x, linetarget->y);
newAngle = true;
break;
}
angle += ANGLE_45/2;
}
}
if (newAngle)
{
ball->angle = angle;
angle >>= ANGLETOFINESHIFT;
ball->momx = FixedMul (ball->Speed, finecosine[angle]);
ball->momy = FixedMul (ball->Speed, finesine[angle]);
}
ball->SetState (ball->SpawnState);
S_Sound (ball, CHAN_BODY, "weapons/macestop", 1, ATTN_NORM);
}
else
{ // Explode
boom:
ball->momx = ball->momy = ball->momz = 0;
ball->flags |= MF_NOGRAVITY;
ball->gravity = FRACUNIT;
S_Sound (ball, CHAN_BODY, "weapons/maceexplode", 1, ATTN_NORM);
}
}
// --- Blaster (aka Claw) ---------------------------------------------------
void A_FireBlasterPL1 (AActor *);
void A_FireBlasterPL2 (AActor *);
void A_SpawnRippers (AActor *);
// Blaster ------------------------------------------------------------------
class ABlaster : public AHereticWeapon
{
DECLARE_ACTOR (ABlaster, AHereticWeapon)
};
class ABlasterPowered : public ABlaster
{
DECLARE_STATELESS_ACTOR (ABlasterPowered, ABlaster)
};
FState ABlaster::States[] =
{
#define S_BLSR 0
S_NORMAL (WBLS, 'A', -1, NULL , NULL),
#define S_BLASTERREADY (S_BLSR+1)
S_NORMAL (BLSR, 'A', 1, A_WeaponReady , &States[S_BLASTERREADY]),
#define S_BLASTERDOWN (S_BLASTERREADY+1)
S_NORMAL (BLSR, 'A', 1, A_Lower , &States[S_BLASTERDOWN]),
#define S_BLASTERUP (S_BLASTERDOWN+1)
S_NORMAL (BLSR, 'A', 1, A_Raise , &States[S_BLASTERUP]),
#define S_BLASTERATK1 (S_BLASTERUP+1)
S_NORMAL (BLSR, 'B', 3, NULL , &States[S_BLASTERATK1+1]),
S_NORMAL (BLSR, 'C', 3, NULL , &States[S_BLASTERATK1+2]),
S_NORMAL (BLSR, 'D', 2, A_FireBlasterPL1 , &States[S_BLASTERATK1+3]),
S_NORMAL (BLSR, 'C', 2, NULL , &States[S_BLASTERATK1+4]),
S_NORMAL (BLSR, 'B', 2, NULL , &States[S_BLASTERATK1+5]),
S_NORMAL (BLSR, 'A', 0, A_ReFire , &States[S_BLASTERREADY]),
#define S_BLASTERATK2 (S_BLASTERATK1+6)
S_NORMAL (BLSR, 'B', 0, NULL , &States[S_BLASTERATK2+1]),
S_NORMAL (BLSR, 'C', 0, NULL , &States[S_BLASTERATK2+2]),
S_NORMAL (BLSR, 'D', 3, A_FireBlasterPL2 , &States[S_BLASTERATK2+3]),
S_NORMAL (BLSR, 'C', 4, NULL , &States[S_BLASTERATK2+4]),
S_NORMAL (BLSR, 'B', 4, NULL , &States[S_BLASTERATK2+5]),
S_NORMAL (BLSR, 'A', 0, A_ReFire , &States[S_BLASTERREADY])
};
IMPLEMENT_ACTOR (ABlaster, Heretic, 53, 28)
PROP_Flags (MF_SPECIAL)
PROP_Flags5 (MF5_BLOODSPLATTER)
PROP_SpawnState (S_BLSR)
PROP_Weapon_SelectionOrder (500)
PROP_Weapon_AmmoUse1 (USE_BLSR_AMMO_1)
PROP_Weapon_AmmoGive1 (30)
PROP_Weapon_UpState (S_BLASTERUP)
PROP_Weapon_DownState (S_BLASTERDOWN)
PROP_Weapon_ReadyState (S_BLASTERREADY)
PROP_Weapon_AtkState (S_BLASTERATK1)
PROP_Weapon_HoldAtkState (S_BLASTERATK1+2)
PROP_Weapon_YAdjust (15)
PROP_Weapon_MoveCombatDist (27000000)
PROP_Weapon_AmmoType1 ("BlasterAmmo")
PROP_Weapon_SisterType ("BlasterPowered")
PROP_Inventory_PickupMessage("$TXT_WPNBLASTER")
END_DEFAULTS
IMPLEMENT_STATELESS_ACTOR (ABlasterPowered, Heretic, -1, 0)
PROP_Weapon_Flags (WIF_POWERED_UP)
PROP_Weapon_AmmoUse1 (USE_BLSR_AMMO_2)
PROP_Weapon_AmmoGive1 (0)
PROP_Weapon_AtkState (S_BLASTERATK2)
PROP_Weapon_HoldAtkState (S_BLASTERATK2+2)
PROP_Weapon_SisterType ("Blaster")
PROP_Weapon_ProjectileType ("BlasterFX1")
END_DEFAULTS
// Blaster FX 1 -------------------------------------------------------------
class ABlasterFX1 : public AActor
{
DECLARE_ACTOR (ABlasterFX1, AActor)
public:
void Tick ();
int DoSpecialDamage (AActor *target, int damage);
};
FState ABlasterFX1::States[] =
{
#define S_BLASTERFX1 0
S_NORMAL (ACLO, 'E', 200, NULL , &States[S_BLASTERFX1+0]),
#define S_BLASTERFXI1 (S_BLASTERFX1+1)
S_BRIGHT (FX18, 'A', 3, A_SpawnRippers , &States[S_BLASTERFXI1+1]),
S_BRIGHT (FX18, 'B', 3, NULL , &States[S_BLASTERFXI1+2]),
S_BRIGHT (FX18, 'C', 4, NULL , &States[S_BLASTERFXI1+3]),
S_BRIGHT (FX18, 'D', 4, NULL , &States[S_BLASTERFXI1+4]),
S_BRIGHT (FX18, 'E', 4, NULL , &States[S_BLASTERFXI1+5]),
S_BRIGHT (FX18, 'F', 4, NULL , &States[S_BLASTERFXI1+6]),
S_BRIGHT (FX18, 'G', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (ABlasterFX1, Heretic, -1, 0)
PROP_RadiusFixed (12)
PROP_HeightFixed (8)
PROP_SpeedFixed (184)
PROP_Damage (2)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_SpawnState (S_BLASTERFX1)
PROP_DeathState (S_BLASTERFXI1)
PROP_DeathSound ("weapons/blasterhit")
END_DEFAULTS
int ABlasterFX1::DoSpecialDamage (AActor *target, int damage)
{
if (target->IsKindOf (PClass::FindClass ("Ironlich")))
{ // Less damage to Ironlich bosses
damage = pr_bfx1() & 1;
if (!damage)
{
return -1;
}
}
return damage;
}
// Blaster smoke ------------------------------------------------------------
class ABlasterSmoke : public AActor
{
DECLARE_ACTOR (ABlasterSmoke, AActor)
};
FState ABlasterSmoke::States[] =
{
#define S_BLASTERSMOKE 0
S_NORMAL (FX18, 'H', 4, NULL , &States[S_BLASTERSMOKE+1]),
S_NORMAL (FX18, 'I', 4, NULL , &States[S_BLASTERSMOKE+2]),
S_NORMAL (FX18, 'J', 4, NULL , &States[S_BLASTERSMOKE+3]),
S_NORMAL (FX18, 'K', 4, NULL , &States[S_BLASTERSMOKE+4]),
S_NORMAL (FX18, 'L', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (ABlasterSmoke, Heretic, -1, 0)
PROP_Flags (MF_NOBLOCKMAP|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_CANNOTPUSH)
PROP_RenderStyle (STYLE_Translucent)
PROP_Alpha (HR_SHADOW)
PROP_SpawnState (S_BLASTERSMOKE)
END_DEFAULTS
// Ripper -------------------------------------------------------------------
class ARipper : public AActor
{
DECLARE_ACTOR (ARipper, AActor)
public:
int DoSpecialDamage (AActor *target, int damage);
};
FState ARipper::States[] =
{
#define S_RIPPER 0
S_NORMAL (FX18, 'M', 4, NULL , &States[S_RIPPER+1]),
S_NORMAL (FX18, 'N', 5, NULL , &States[S_RIPPER+0]),
#define S_RIPPERX (S_RIPPER+2)
S_BRIGHT (FX18, 'O', 4, NULL , &States[S_RIPPERX+1]),
S_BRIGHT (FX18, 'P', 4, NULL , &States[S_RIPPERX+2]),
S_BRIGHT (FX18, 'Q', 4, NULL , &States[S_RIPPERX+3]),
S_BRIGHT (FX18, 'R', 4, NULL , &States[S_RIPPERX+4]),
S_BRIGHT (FX18, 'S', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (ARipper, Heretic, -1, 157)
PROP_RadiusFixed (8)
PROP_HeightFixed (6)
PROP_SpeedFixed (14)
PROP_Damage (1)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_RIP|MF2_PCROSS|MF2_IMPACT)
PROP_Flags3 (MF3_WARNBOT)
PROP_SpawnState (S_RIPPER)
PROP_DeathState (S_RIPPERX)
PROP_DeathSound ("weapons/blasterpowhit")
END_DEFAULTS
int ARipper::DoSpecialDamage (AActor *target, int damage)
{
if (target->IsKindOf (PClass::FindClass ("Ironlich")))
{ // Less damage to Ironlich bosses
damage = pr_ripd() & 1;
if (!damage)
{
return -1;
}
}
return damage;
}
// Blaster Puff -------------------------------------------------------------
class ABlasterPuff : public AActor
{
DECLARE_ACTOR (ABlasterPuff, AActor)
};
FState ABlasterPuff::States[] =
{
#define S_BLASTERPUFF1 0
S_BRIGHT (FX17, 'A', 4, NULL , &States[S_BLASTERPUFF1+1]),
S_BRIGHT (FX17, 'B', 4, NULL , &States[S_BLASTERPUFF1+2]),
S_BRIGHT (FX17, 'C', 4, NULL , &States[S_BLASTERPUFF1+3]),
S_BRIGHT (FX17, 'D', 4, NULL , &States[S_BLASTERPUFF1+4]),
S_BRIGHT (FX17, 'E', 4, NULL , NULL),
#define S_BLASTERPUFF2 (S_BLASTERPUFF1+5)
S_BRIGHT (FX17, 'F', 3, NULL , &States[S_BLASTERPUFF2+1]),
S_BRIGHT (FX17, 'G', 3, NULL , &States[S_BLASTERPUFF2+2]),
S_BRIGHT (FX17, 'H', 4, NULL , &States[S_BLASTERPUFF2+3]),
S_BRIGHT (FX17, 'I', 4, NULL , &States[S_BLASTERPUFF2+4]),
S_BRIGHT (FX17, 'J', 4, NULL , &States[S_BLASTERPUFF2+5]),
S_BRIGHT (FX17, 'K', 4, NULL , &States[S_BLASTERPUFF2+6]),
S_BRIGHT (FX17, 'L', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (ABlasterPuff, Heretic, -1, 0)
PROP_Flags (MF_NOBLOCKMAP|MF_NOGRAVITY)
PROP_Flags3 (MF3_PUFFONACTORS)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_BLASTERPUFF2)
PROP_CrashState (S_BLASTERPUFF1)
END_DEFAULTS
//----------------------------------------------------------------------------
//
// PROC A_FireBlasterPL1
//
//----------------------------------------------------------------------------
void A_FireBlasterPL1 (AActor *actor)
{
angle_t angle;
int damage;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = actor->player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
angle_t pitch = P_BulletSlope(actor);
damage = pr_fb1.HitDice (4);
angle = actor->angle;
if (player->refire)
{
angle += pr_fb1.Random2() << 18;
}
P_LineAttack (actor, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, RUNTIME_CLASS(ABlasterPuff));
S_Sound (actor, CHAN_WEAPON, "weapons/blastershoot", 1, ATTN_NORM);
}
//----------------------------------------------------------------------------
//
// PROC A_FireBlasterPL2
//
//----------------------------------------------------------------------------
void A_FireBlasterPL2 (AActor *actor)
{
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = actor->player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
P_SpawnPlayerMissile (actor, RUNTIME_CLASS(ABlasterFX1));
S_Sound (actor, CHAN_WEAPON, "weapons/blastershoot", 1, ATTN_NORM);
}
//----------------------------------------------------------------------------
//
// PROC A_SpawnRippers
//
//----------------------------------------------------------------------------
void A_SpawnRippers (AActor *actor)
{
int i;
angle_t angle;
AActor *ripper;
for(i = 0; i < 8; i++)
{
ripper = Spawn<ARipper> (actor->x, actor->y, actor->z, ALLOW_REPLACE);
angle = i*ANG45;
ripper->target = actor->target;
ripper->angle = angle;
angle >>= ANGLETOFINESHIFT;
ripper->momx = FixedMul (ripper->Speed, finecosine[angle]);
ripper->momy = FixedMul (ripper->Speed, finesine[angle]);
P_CheckMissileSpawn (ripper);
}
}
//----------------------------------------------------------------------------
//
// PROC P_BlasterMobjThinker
//
// Thinker for the ultra-fast blaster PL2 ripper-spawning missile.
//
//----------------------------------------------------------------------------
void ABlasterFX1::Tick ()
{
int i;
fixed_t xfrac;
fixed_t yfrac;
fixed_t zfrac;
int changexy;
PrevX = x;
PrevY = y;
PrevZ = z;
// Handle movement
if (momx || momy || (z != floorz) || momz)
{
xfrac = momx>>3;
yfrac = momy>>3;
zfrac = momz>>3;
changexy = xfrac | yfrac;
for (i = 0; i < 8; i++)
{
if (changexy)
{
if (!P_TryMove (this, x + xfrac, y + yfrac, true))
{ // Blocked move
P_ExplodeMissile (this, BlockingLine, BlockingMobj);
return;
}
}
z += zfrac;
if (z <= floorz)
{ // Hit the floor
z = floorz;
P_HitFloor (this);
P_ExplodeMissile (this, NULL, NULL);
return;
}
if (z + height > ceilingz)
{ // Hit the ceiling
z = ceilingz - height;
P_ExplodeMissile (this, NULL, NULL);
return;
}
if (changexy && (pr_bfx1t() < 64))
{
Spawn<ABlasterSmoke> (x, y, MAX<fixed_t> (z - 8 * FRACUNIT, floorz), ALLOW_REPLACE);
}
}
}
// Advance the state
if (tics != -1)
{
tics--;
while (!tics)
{
if (!SetState (state->GetNextState ()))
{ // mobj was removed
return;
}
}
}
}
// --- Skull rod ------------------------------------------------------------
void A_FireSkullRodPL1 (AActor *);
void A_FireSkullRodPL2 (AActor *);
void A_SkullRodPL2Seek (AActor *);
void A_AddPlayerRain (AActor *);
void A_HideInCeiling (AActor *);
void A_SkullRodStorm (AActor *);
void A_RainImpact (AActor *);
// Skull (Horn) Rod ---------------------------------------------------------
class ASkullRod : public AHereticWeapon
{
DECLARE_ACTOR (ASkullRod, AHereticWeapon)
};
class ASkullRodPowered : public ASkullRod
{
DECLARE_STATELESS_ACTOR (ASkullRodPowered, ASkullRod)
};
FState ASkullRod::States[] =
{
#define S_WSKL 0
S_NORMAL (WSKL, 'A', -1, NULL , NULL),
#define S_HORNRODREADY (S_WSKL+1)
S_NORMAL (HROD, 'A', 1, A_WeaponReady , &States[S_HORNRODREADY]),
#define S_HORNRODDOWN (S_HORNRODREADY+1)
S_NORMAL (HROD, 'A', 1, A_Lower , &States[S_HORNRODDOWN]),
#define S_HORNRODUP (S_HORNRODDOWN+1)
S_NORMAL (HROD, 'A', 1, A_Raise , &States[S_HORNRODUP]),
#define S_HORNRODATK1 (S_HORNRODUP+1)
S_NORMAL (HROD, 'A', 4, A_FireSkullRodPL1 , &States[S_HORNRODATK1+1]),
S_NORMAL (HROD, 'B', 4, A_FireSkullRodPL1 , &States[S_HORNRODATK1+2]),
S_NORMAL (HROD, 'B', 0, A_ReFire , &States[S_HORNRODREADY]),
#define S_HORNRODATK2 (S_HORNRODATK1+3)
S_NORMAL (HROD, 'C', 2, NULL , &States[S_HORNRODATK2+1]),
S_NORMAL (HROD, 'D', 3, NULL , &States[S_HORNRODATK2+2]),
S_NORMAL (HROD, 'E', 2, NULL , &States[S_HORNRODATK2+3]),
S_NORMAL (HROD, 'F', 3, NULL , &States[S_HORNRODATK2+4]),
S_NORMAL (HROD, 'G', 4, A_FireSkullRodPL2 , &States[S_HORNRODATK2+5]),
S_NORMAL (HROD, 'F', 2, NULL , &States[S_HORNRODATK2+6]),
S_NORMAL (HROD, 'E', 3, NULL , &States[S_HORNRODATK2+7]),
S_NORMAL (HROD, 'D', 2, NULL , &States[S_HORNRODATK2+8]),
S_NORMAL (HROD, 'C', 2, A_ReFire , &States[S_HORNRODREADY])
};
IMPLEMENT_ACTOR (ASkullRod, Heretic, 2004, 30)
PROP_Flags (MF_SPECIAL)
PROP_SpawnState (S_WSKL)
PROP_Weapon_SelectionOrder (200)
PROP_Weapon_AmmoUse1 (USE_SKRD_AMMO_1)
PROP_Weapon_AmmoGive1 (50)
PROP_Weapon_UpState (S_HORNRODUP)
PROP_Weapon_DownState (S_HORNRODDOWN)
PROP_Weapon_ReadyState (S_HORNRODREADY)
PROP_Weapon_AtkState (S_HORNRODATK1)
PROP_Weapon_YAdjust (15)
PROP_Weapon_MoveCombatDist (27000000)
PROP_Weapon_AmmoType1 ("SkullRodAmmo")
PROP_Weapon_SisterType ("SkullRodPowered")
PROP_Weapon_ProjectileType ("HornRodFX1")
PROP_Inventory_PickupMessage("$TXT_WPNSKULLROD")
END_DEFAULTS
IMPLEMENT_STATELESS_ACTOR (ASkullRodPowered, Heretic, -1, 0)
PROP_Weapon_Flags (WIF_POWERED_UP)
PROP_Weapon_AmmoUse1 (USE_SKRD_AMMO_2)
PROP_Weapon_AmmoGive1 (0)
PROP_Weapon_AtkState (S_HORNRODATK2)
PROP_Weapon_SisterType ("SkullRod")
PROP_Weapon_ProjectileType ("HornRodFX2")
END_DEFAULTS
// Horn Rod FX 1 ------------------------------------------------------------
class AHornRodFX1 : public AActor
{
DECLARE_ACTOR (AHornRodFX1, AActor)
};
FState AHornRodFX1::States[] =
{
#define S_HRODFX1 0
S_BRIGHT (FX00, 'A', 6, NULL , &States[S_HRODFX1+1]),
S_BRIGHT (FX00, 'B', 6, NULL , &States[S_HRODFX1+0]),
#define S_HRODFXI1 (S_HRODFX1+2)
S_BRIGHT (FX00, 'H', 5, NULL , &States[S_HRODFXI1+1]),
S_BRIGHT (FX00, 'I', 5, NULL , &States[S_HRODFXI1+2]),
S_BRIGHT (FX00, 'J', 4, NULL , &States[S_HRODFXI1+3]),
S_BRIGHT (FX00, 'K', 4, NULL , &States[S_HRODFXI1+4]),
S_BRIGHT (FX00, 'L', 3, NULL , &States[S_HRODFXI1+5]),
S_BRIGHT (FX00, 'M', 3, NULL , NULL)
};
IMPLEMENT_ACTOR (AHornRodFX1, Heretic, -1, 160)
PROP_RadiusFixed (12)
PROP_HeightFixed (8)
PROP_SpeedFixed (22)
PROP_Damage (3)
PROP_Flags (MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_WINDTHRUST|MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_Flags3 (MF3_WARNBOT)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_HRODFX1)
PROP_DeathState (S_HRODFXI1)
PROP_SeeSound ("weapons/hornrodshoot")
PROP_DeathSound ("weapons/hornrodhit")
END_DEFAULTS
// Horn Rod FX 2 ------------------------------------------------------------
class AHornRodFX2 : public AActor
{
DECLARE_ACTOR (AHornRodFX2, AActor)
public:
int DoSpecialDamage (AActor *target, int damage);
};
FState AHornRodFX2::States[] =
{
#define S_HRODFX2 0
S_BRIGHT (FX00, 'C', 3, NULL , &States[S_HRODFX2+1]),
S_BRIGHT (FX00, 'D', 3, A_SkullRodPL2Seek , &States[S_HRODFX2+2]),
S_BRIGHT (FX00, 'E', 3, NULL , &States[S_HRODFX2+3]),
S_BRIGHT (FX00, 'F', 3, A_SkullRodPL2Seek , &States[S_HRODFX2+0]),
#define S_HRODFXI2 (S_HRODFX2+4)
S_BRIGHT (FX00, 'H', 5, A_AddPlayerRain , &States[S_HRODFXI2+1]),
S_BRIGHT (FX00, 'I', 5, NULL , &States[S_HRODFXI2+2]),
S_BRIGHT (FX00, 'J', 4, NULL , &States[S_HRODFXI2+3]),
S_BRIGHT (FX00, 'K', 3, NULL , &States[S_HRODFXI2+4]),
S_BRIGHT (FX00, 'L', 3, NULL , &States[S_HRODFXI2+5]),
S_BRIGHT (FX00, 'M', 3, NULL , &States[S_HRODFXI2+6]),
S_NORMAL (FX00, 'G', 1, A_HideInCeiling , &States[S_HRODFXI2+7]),
S_NORMAL (FX00, 'G', 1, A_SkullRodStorm , &States[S_HRODFXI2+7])
};
IMPLEMENT_ACTOR (AHornRodFX2, Heretic, -1, 0)
PROP_RadiusFixed (12)
PROP_HeightFixed (8)
PROP_SpeedFixed (22)
PROP_Damage (10)
PROP_SpawnHealth (4*35)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_HRODFX2)
PROP_DeathState (S_HRODFXI2)
PROP_SeeSound ("weapons/hornrodshoot")
PROP_DeathSound ("weapons/hornrodpowhit")
END_DEFAULTS
int AHornRodFX2::DoSpecialDamage (AActor *target, int damage)
{
if (target->IsKindOf (PClass::FindClass("Sorcerer2")) && pr_hrfx2() < 96)
{ // D'Sparil teleports away
P_DSparilTeleport (target);
return -1;
}
return damage;
}
// Rain pillar 1 ------------------------------------------------------------
class ARainPillar : public AActor
{
DECLARE_ACTOR (ARainPillar, AActor)
public:
int DoSpecialDamage (AActor *target, int damage);
};
FState ARainPillar::States[] =
{
#define S_RAINPLR 0
S_BRIGHT (FX22, 'A', -1, NULL , NULL),
#define S_RAINPLRX (S_RAINPLR+1)
S_BRIGHT (FX22, 'B', 4, A_RainImpact , &States[S_RAINPLRX+1]),
S_BRIGHT (FX22, 'C', 4, NULL , &States[S_RAINPLRX+2]),
S_BRIGHT (FX22, 'D', 4, NULL , &States[S_RAINPLRX+3]),
S_BRIGHT (FX22, 'E', 4, NULL , &States[S_RAINPLRX+4]),
S_BRIGHT (FX22, 'F', 4, NULL , NULL),
#define S_RAINAIRXPLR (S_RAINPLRX+5)
S_BRIGHT (FX22, 'G', 4, NULL , &States[S_RAINAIRXPLR+1]),
S_BRIGHT (FX22, 'H', 4, NULL , &States[S_RAINAIRXPLR+2]),
S_BRIGHT (FX22, 'I', 4, NULL , NULL),
};
IMPLEMENT_ACTOR (ARainPillar, Heretic, -1, 0)
PROP_RadiusFixed (5)
PROP_HeightFixed (12)
PROP_SpeedFixed (12)
PROP_Damage (5)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_RAINPLR)
PROP_DeathState (S_RAINPLRX)
END_DEFAULTS
int ARainPillar::DoSpecialDamage (AActor *target, int damage)
{
if (target->flags2 & MF2_BOSS)
{ // Decrease damage for bosses
damage = (pr_rp() & 7) + 1;
}
return damage;
}
// Rain tracker "inventory" item --------------------------------------------
class ARainTracker : public AInventory
{
DECLARE_STATELESS_ACTOR (ARainTracker, AInventory)
public:
void Serialize (FArchive &arc);
AActor *Rain1, *Rain2;
};
IMPLEMENT_STATELESS_ACTOR (ARainTracker, Any, -1, 0)
PROP_Inventory_FlagsSet (IF_UNDROPPABLE)
END_DEFAULTS
void ARainTracker::Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc << Rain1 << Rain2;
}
//----------------------------------------------------------------------------
//
// PROC A_FireSkullRodPL1
//
//----------------------------------------------------------------------------
void A_FireSkullRodPL1 (AActor *actor)
{
AActor *mo;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
mo = P_SpawnPlayerMissile (actor, RUNTIME_CLASS(AHornRodFX1));
// Randomize the first frame
if (mo && pr_fsr1() > 128)
{
mo->SetState (mo->state->GetNextState());
}
}
//----------------------------------------------------------------------------
//
// PROC A_FireSkullRodPL2
//
// The special2 field holds the player number that shot the rain missile.
// The special1 field holds the id of the rain sound.
//
//----------------------------------------------------------------------------
void A_FireSkullRodPL2 (AActor *actor)
{
player_t *player;
AActor *MissileActor;
AActor *linetarget;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
P_SpawnPlayerMissile (actor, 0,0,0, RUNTIME_CLASS(AHornRodFX2), actor->angle, &linetarget, &MissileActor);
// Use MissileActor instead of the return value from
// P_SpawnPlayerMissile because we need to give info to the mobj
// even if it exploded immediately.
if (MissileActor != NULL)
{
MissileActor->special2 = (int)(player - players);
if (linetarget)
{
MissileActor->tracer = linetarget;
}
S_Sound (MissileActor, CHAN_WEAPON, "weapons/hornrodpowshoot", 1, ATTN_NORM);
}
}
//----------------------------------------------------------------------------
//
// PROC A_SkullRodPL2Seek
//
//----------------------------------------------------------------------------
void A_SkullRodPL2Seek (AActor *actor)
{
P_SeekerMissile (actor, ANGLE_1*10, ANGLE_1*30);
}
//----------------------------------------------------------------------------
//
// PROC A_AddPlayerRain
//
//----------------------------------------------------------------------------
void A_AddPlayerRain (AActor *actor)
{
ARainTracker *tracker;
if (actor->target == NULL || actor->target->health <= 0)
{ // Shooter is dead or nonexistant
return;
}
tracker = actor->target->FindInventory<ARainTracker> ();
// They player is only allowed two rainstorms at a time. Shooting more
// than that will cause the oldest one to terminate.
if (tracker != NULL)
{
if (tracker->Rain1 && tracker->Rain2)
{ // Terminate an active rain
if (tracker->Rain1->health < tracker->Rain2->health)
{
if (tracker->Rain1->health > 16)
{
tracker->Rain1->health = 16;
}
tracker->Rain1 = NULL;
}
else
{
if (tracker->Rain2->health > 16)
{
tracker->Rain2->health = 16;
}
tracker->Rain2 = NULL;
}
}
}
else
{
tracker = static_cast<ARainTracker *> (actor->target->GiveInventoryType (RUNTIME_CLASS(ARainTracker)));
}
// Add rain mobj to list
if (tracker->Rain1)
{
tracker->Rain2 = actor;
}
else
{
tracker->Rain1 = actor;
}
actor->special1 = S_FindSound ("misc/rain");
}
//----------------------------------------------------------------------------
//
// PROC A_SkullRodStorm
//
//----------------------------------------------------------------------------
void A_SkullRodStorm (AActor *actor)
{
fixed_t x;
fixed_t y;
AActor *mo;
ARainTracker *tracker;
if (actor->health-- == 0)
{
S_StopSound (actor, CHAN_BODY);
if (actor->target == NULL)
{ // Player left the game
actor->Destroy ();
return;
}
tracker = actor->target->FindInventory<ARainTracker> ();
if (tracker != NULL)
{
if (tracker->Rain1 == actor)
{
tracker->Rain1 = NULL;
}
else if (tracker->Rain2 == actor)
{
tracker->Rain2 = NULL;
}
}
actor->Destroy ();
return;
}
if (pr_storm() < 25)
{ // Fudge rain frequency
return;
}
x = actor->x + ((pr_storm()&127) - 64) * FRACUNIT;
y = actor->y + ((pr_storm()&127) - 64) * FRACUNIT;
mo = Spawn<ARainPillar> (x, y, ONCEILINGZ, ALLOW_REPLACE);
mo->Translation = multiplayer ?
TRANSLATION(TRANSLATION_PlayersExtra,actor->special2) : 0;
mo->target = actor->target;
mo->momx = 1; // Force collision detection
mo->momz = -mo->Speed;
mo->special2 = actor->special2; // Transfer player number
P_CheckMissileSpawn (mo);
if (actor->special1 != -1 && !S_IsActorPlayingSomething (actor, CHAN_BODY, -1))
{
S_Sound (actor, CHAN_BODY|CHAN_LOOP, actor->special1, 1, ATTN_NORM);
}
}
//----------------------------------------------------------------------------
//
// PROC A_RainImpact
//
//----------------------------------------------------------------------------
void A_RainImpact (AActor *actor)
{
if (actor->z > actor->floorz)
{
actor->SetState (&ARainPillar::States[S_RAINAIRXPLR]);
}
else if (pr_impact() < 40)
{
P_HitFloor (actor);
}
}
//----------------------------------------------------------------------------
//
// PROC A_HideInCeiling
//
//----------------------------------------------------------------------------
void A_HideInCeiling (AActor *actor)
{
actor->z = actor->ceilingz + 4*FRACUNIT;
}
// --- Phoenix Rod ----------------------------------------------------------
void A_FirePhoenixPL1 (AActor *);
void A_InitPhoenixPL2 (AActor *);
void A_FirePhoenixPL2 (AActor *);
void A_ShutdownPhoenixPL2 (AActor *);
void A_PhoenixPuff (AActor *);
void A_FlameEnd (AActor *);
void A_FloatPuff (AActor *);
// Phoenix Rod --------------------------------------------------------------
class APhoenixRod : public AHereticWeapon
{
DECLARE_ACTOR (APhoenixRod, AHereticWeapon)
public:
void Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc << FlameCount;
}
int FlameCount; // for flamethrower duration
};
class APhoenixRodPowered : public APhoenixRod
{
DECLARE_STATELESS_ACTOR (APhoenixRodPowered, APhoenixRod)
public:
void EndPowerup ();
};
FState APhoenixRod::States[] =
{
#define S_WPHX 0
S_NORMAL (WPHX, 'A', -1, NULL , NULL),
#define S_PHOENIXREADY (S_WPHX+1)
S_NORMAL (PHNX, 'A', 1, A_WeaponReady , &States[S_PHOENIXREADY]),
#define S_PHOENIXDOWN (S_PHOENIXREADY+1)
S_NORMAL (PHNX, 'A', 1, A_Lower , &States[S_PHOENIXDOWN]),
#define S_PHOENIXUP (S_PHOENIXDOWN+1)
S_NORMAL (PHNX, 'A', 1, A_Raise , &States[S_PHOENIXUP]),
#define S_PHOENIXATK1 (S_PHOENIXUP+1)
S_NORMAL (PHNX, 'B', 5, NULL , &States[S_PHOENIXATK1+1]),
S_NORMAL (PHNX, 'C', 7, A_FirePhoenixPL1 , &States[S_PHOENIXATK1+2]),
S_NORMAL (PHNX, 'D', 4, NULL , &States[S_PHOENIXATK1+3]),
S_NORMAL (PHNX, 'B', 4, NULL , &States[S_PHOENIXATK1+4]),
S_NORMAL (PHNX, 'B', 0, A_ReFire , &States[S_PHOENIXREADY]),
#define S_PHOENIXATK2 (S_PHOENIXATK1+5)
S_NORMAL (PHNX, 'B', 3, A_InitPhoenixPL2 , &States[S_PHOENIXATK2+1]),
S_BRIGHT (PHNX, 'C', 1, A_FirePhoenixPL2 , &States[S_PHOENIXATK2+2]),
S_NORMAL (PHNX, 'B', 4, A_ReFire , &States[S_PHOENIXATK2+3]),
S_NORMAL (PHNX, 'B', 4, A_ShutdownPhoenixPL2 , &States[S_PHOENIXREADY])
};
IMPLEMENT_ACTOR (APhoenixRod, Heretic, 2003, 29)
PROP_Flags (MF_SPECIAL)
PROP_SpawnState (S_WPHX)
PROP_Weapon_Flags (WIF_NOAUTOFIRE|WIF_BOT_REACTION_SKILL_THING)
PROP_Weapon_SelectionOrder (2600)
PROP_Weapon_AmmoUse1 (USE_PHRD_AMMO_1)
PROP_Weapon_AmmoGive1 (2)
PROP_Weapon_UpState (S_PHOENIXUP)
PROP_Weapon_DownState (S_PHOENIXDOWN)
PROP_Weapon_ReadyState (S_PHOENIXREADY)
PROP_Weapon_AtkState (S_PHOENIXATK1)
PROP_Weapon_YAdjust (15)
PROP_Weapon_MoveCombatDist (18350080)
PROP_Weapon_AmmoType1 ("PhoenixRodAmmo")
PROP_Weapon_SisterType ("PhoenixRodPowered")
PROP_Weapon_ProjectileType ("PhoenixFX1")
PROP_Inventory_PickupMessage("$TXT_WPNPHOENIXROD")
END_DEFAULTS
IMPLEMENT_STATELESS_ACTOR (APhoenixRodPowered, Heretic, -1, 0)
PROP_Weapon_Flags (WIF_NOAUTOFIRE|WIF_POWERED_UP|WIF_BOT_MELEE)
PROP_Weapon_AmmoUse1 (USE_PHRD_AMMO_2)
PROP_Weapon_AmmoGive1 (0)
PROP_Weapon_AtkState (S_PHOENIXATK2)
PROP_Weapon_HoldAtkState (S_PHOENIXATK2+1)
PROP_Weapon_MoveCombatDist (0)
PROP_Weapon_SisterType ("PhoenixRod")
PROP_Weapon_ProjectileType ("PhoenixFX2")
END_DEFAULTS
void APhoenixRodPowered::EndPowerup ()
{
P_SetPsprite (Owner->player, ps_weapon, &APhoenixRod::States[S_PHOENIXREADY]);
DepleteAmmo (bAltFire);
Owner->player->refire = 0;
S_StopSound (Owner, CHAN_WEAPON);
Owner->player->ReadyWeapon = SisterWeapon;
}
// Phoenix FX 1 -------------------------------------------------------------
FState APhoenixFX1::States[] =
{
#define S_PHOENIXFX1 0
S_BRIGHT (FX04, 'A', 4, A_PhoenixPuff , &States[S_PHOENIXFX1+0]),
#define S_PHOENIXFXI1 (S_PHOENIXFX1+1)
S_BRIGHT (FX08, 'A', 6, A_Explode , &States[S_PHOENIXFXI1+1]),
S_BRIGHT (FX08, 'B', 5, NULL , &States[S_PHOENIXFXI1+2]),
S_BRIGHT (FX08, 'C', 5, NULL , &States[S_PHOENIXFXI1+3]),
S_BRIGHT (FX08, 'D', 4, NULL , &States[S_PHOENIXFXI1+4]),
S_BRIGHT (FX08, 'E', 4, NULL , &States[S_PHOENIXFXI1+5]),
S_BRIGHT (FX08, 'F', 4, NULL , &States[S_PHOENIXFXI1+6]),
S_BRIGHT (FX08, 'G', 4, NULL , &States[S_PHOENIXFXI1+7]),
S_BRIGHT (FX08, 'H', 4, NULL , NULL)
};
IMPLEMENT_ACTOR (APhoenixFX1, Heretic, -1, 163)
PROP_RadiusFixed (11)
PROP_HeightFixed (8)
PROP_SpeedFixed (20)
PROP_Damage (20)
PROP_DamageType (NAME_Fire)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_THRUGHOST|MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_PHOENIXFX1)
PROP_DeathState (S_PHOENIXFXI1)
PROP_SeeSound ("weapons/phoenixshoot")
PROP_DeathSound ("weapons/phoenixhit")
END_DEFAULTS
int APhoenixFX1::DoSpecialDamage (AActor *target, int damage)
{
if (target->IsKindOf (PClass::FindClass("Sorcerer2")) && pr_hrfx2() < 96)
{ // D'Sparil teleports away
P_DSparilTeleport (target);
return -1;
}
return damage;
}
// Phoenix puff -------------------------------------------------------------
FState APhoenixPuff::States[] =
{
S_NORMAL (FX04, 'B', 4, NULL , &States[1]),
S_NORMAL (FX04, 'C', 4, NULL , &States[2]),
S_NORMAL (FX04, 'D', 4, NULL , &States[3]),
S_NORMAL (FX04, 'E', 4, NULL , &States[4]),
S_NORMAL (FX04, 'F', 4, NULL , NULL),
};
IMPLEMENT_ACTOR (APhoenixPuff, Heretic, -1, 0)
PROP_Flags (MF_NOBLOCKMAP|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_CANNOTPUSH)
PROP_RenderStyle (STYLE_Translucent)
PROP_Alpha (HR_SHADOW)
PROP_SpawnState (0)
END_DEFAULTS
// Phoenix FX 2 -------------------------------------------------------------
class APhoenixFX2 : public AActor
{
DECLARE_ACTOR (APhoenixFX2, AActor)
public:
int DoSpecialDamage (AActor *target, int damage);
};
FState APhoenixFX2::States[] =
{
#define S_PHOENIXFX2 0
S_BRIGHT (FX09, 'A', 2, NULL , &States[S_PHOENIXFX2+1]),
S_BRIGHT (FX09, 'B', 2, NULL , &States[S_PHOENIXFX2+2]),
S_BRIGHT (FX09, 'A', 2, NULL , &States[S_PHOENIXFX2+3]),
S_BRIGHT (FX09, 'B', 2, NULL , &States[S_PHOENIXFX2+4]),
S_BRIGHT (FX09, 'A', 2, NULL , &States[S_PHOENIXFX2+5]),
S_BRIGHT (FX09, 'B', 2, A_FlameEnd , &States[S_PHOENIXFX2+6]),
S_BRIGHT (FX09, 'C', 2, NULL , &States[S_PHOENIXFX2+7]),
S_BRIGHT (FX09, 'D', 2, NULL , &States[S_PHOENIXFX2+8]),
S_BRIGHT (FX09, 'E', 2, NULL , &States[S_PHOENIXFX2+9]),
S_BRIGHT (FX09, 'F', 2, NULL , NULL),
#define S_PHOENIXFXI2 (S_PHOENIXFX2+10)
S_BRIGHT (FX09, 'G', 3, NULL , &States[S_PHOENIXFXI2+1]),
S_BRIGHT (FX09, 'H', 3, A_FloatPuff , &States[S_PHOENIXFXI2+2]),
S_BRIGHT (FX09, 'I', 4, NULL , &States[S_PHOENIXFXI2+3]),
S_BRIGHT (FX09, 'J', 5, NULL , &States[S_PHOENIXFXI2+4]),
S_BRIGHT (FX09, 'K', 5, NULL , NULL)
};
IMPLEMENT_ACTOR (APhoenixFX2, Heretic, -1, 0)
PROP_RadiusFixed (6)
PROP_HeightFixed (8)
PROP_SpeedFixed (10)
PROP_Damage (2)
PROP_DamageType (NAME_Fire)
PROP_Flags (MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY)
PROP_Flags2 (MF2_NOTELEPORT|MF2_PCROSS|MF2_IMPACT)
PROP_RenderStyle (STYLE_Add)
PROP_SpawnState (S_PHOENIXFX2)
PROP_DeathState (S_PHOENIXFXI2)
END_DEFAULTS
int APhoenixFX2::DoSpecialDamage (AActor *target, int damage)
{
if (target->player && pr_pfx2 () < 128)
{ // Freeze player for a bit
target->reactiontime += 4;
}
return damage;
}
//----------------------------------------------------------------------------
//
// PROC A_FirePhoenixPL1
//
//----------------------------------------------------------------------------
void A_FirePhoenixPL1 (AActor *actor)
{
angle_t angle;
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
AWeapon *weapon = actor->player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
P_SpawnPlayerMissile (actor, RUNTIME_CLASS(APhoenixFX1));
angle = actor->angle + ANG180;
angle >>= ANGLETOFINESHIFT;
actor->momx += FixedMul (4*FRACUNIT, finecosine[angle]);
actor->momy += FixedMul (4*FRACUNIT, finesine[angle]);
}
//----------------------------------------------------------------------------
//
// PROC A_PhoenixPuff
//
//----------------------------------------------------------------------------
void A_PhoenixPuff (AActor *actor)
{
AActor *puff;
angle_t angle;
//[RH] Heretic never sets the target for seeking
//P_SeekerMissile (actor, ANGLE_1*5, ANGLE_1*10);
puff = Spawn<APhoenixPuff> (actor->x, actor->y, actor->z, ALLOW_REPLACE);
angle = actor->angle + ANG90;
angle >>= ANGLETOFINESHIFT;
puff->momx = FixedMul (FRACUNIT*13/10, finecosine[angle]);
puff->momy = FixedMul (FRACUNIT*13/10, finesine[angle]);
puff->momz = 0;
puff = Spawn<APhoenixPuff> (actor->x, actor->y, actor->z, ALLOW_REPLACE);
angle = actor->angle - ANG90;
angle >>= ANGLETOFINESHIFT;
puff->momx = FixedMul (FRACUNIT*13/10, finecosine[angle]);
puff->momy = FixedMul (FRACUNIT*13/10, finesine[angle]);
puff->momz = 0;
}
//----------------------------------------------------------------------------
//
// PROC A_InitPhoenixPL2
//
//----------------------------------------------------------------------------
void A_InitPhoenixPL2 (AActor *actor)
{
if (actor->player != NULL)
{
APhoenixRod *flamethrower = static_cast<APhoenixRod *> (actor->player->ReadyWeapon);
if (flamethrower != NULL)
{
flamethrower->FlameCount = FLAME_THROWER_TICS;
}
}
}
//----------------------------------------------------------------------------
//
// PROC A_FirePhoenixPL2
//
// Flame thrower effect.
//
//----------------------------------------------------------------------------
void A_FirePhoenixPL2 (AActor *actor)
{
AActor *mo;
angle_t angle;
fixed_t x, y, z;
fixed_t slope;
FSoundID soundid;
player_t *player;
APhoenixRod *flamethrower;
if (NULL == (player = actor->player))
{
return;
}
soundid = "weapons/phoenixpowshoot";
flamethrower = static_cast<APhoenixRod *> (player->ReadyWeapon);
if (flamethrower == NULL || --flamethrower->FlameCount == 0)
{ // Out of flame
P_SetPsprite (player, ps_weapon, &APhoenixRod::States[S_PHOENIXATK2+3]);
player->refire = 0;
S_StopSound (actor, CHAN_WEAPON);
return;
}
angle = actor->angle;
x = actor->x + (pr_fp2.Random2() << 9);
y = actor->y + (pr_fp2.Random2() << 9);
z = actor->z + 26*FRACUNIT + finetangent[FINEANGLES/4-(actor->pitch>>ANGLETOFINESHIFT)];
z -= actor->floorclip;
slope = finetangent[FINEANGLES/4-(actor->pitch>>ANGLETOFINESHIFT)] + (FRACUNIT/10);
mo = Spawn<APhoenixFX2> (x, y, z, ALLOW_REPLACE);
mo->target = actor;
mo->angle = angle;
mo->momx = actor->momx + FixedMul (mo->Speed, finecosine[angle>>ANGLETOFINESHIFT]);
mo->momy = actor->momy + FixedMul (mo->Speed, finesine[angle>>ANGLETOFINESHIFT]);
mo->momz = FixedMul (mo->Speed, slope);
if (!player->refire || !S_IsActorPlayingSomething (actor, CHAN_WEAPON, -1))
{
S_Sound (actor, CHAN_WEAPON|CHAN_LOOP, soundid, 1, ATTN_NORM);
}
P_CheckMissileSpawn (mo);
}
//----------------------------------------------------------------------------
//
// PROC A_ShutdownPhoenixPL2
//
//----------------------------------------------------------------------------
void A_ShutdownPhoenixPL2 (AActor *actor)
{
player_t *player;
if (NULL == (player = actor->player))
{
return;
}
S_StopSound (actor, CHAN_WEAPON);
AWeapon *weapon = player->ReadyWeapon;
if (weapon != NULL)
{
if (!weapon->DepleteAmmo (weapon->bAltFire))
return;
}
}
//----------------------------------------------------------------------------
//
// PROC A_FlameEnd
//
//----------------------------------------------------------------------------
void A_FlameEnd (AActor *actor)
{
actor->momz += FRACUNIT*3/2;
}
//----------------------------------------------------------------------------
//
// PROC A_FloatPuff
//
//----------------------------------------------------------------------------
void A_FloatPuff (AActor *puff)
{
puff->momz += FRACUNIT*18/10;
}
Reference in a new issue View git blame Copy permalink