//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_weapon_spellbook.h"
#include "decals.h"
#include "tf_gamerules.h"
#include "tf_pumpkin_bomb.h"
// Client specific.
#ifdef CLIENT_DLL
#include "c_basedoor.h"
#include "c_tf_player.h"
#include "IEffects.h"
#include "bone_setup.h"
#include "c_tf_gamestats.h"
#include "iclientmode.h"
#include <vgui_controls/AnimationController.h>
#include "econ_notifications.h"
#include "gc_clientsystem.h"
#include "tf_logic_halloween_2014.h"
#include "tf_hud_itemeffectmeter.h"
extern void AddSubKeyNamed( KeyValues *pKeys, const char *pszName );
// Server specific.
#else
#include "doors.h"
#include "tf_player.h"
#include "tf_ammo_pack.h"
#include "tf_gamestats.h"
#include "ilagcompensationmanager.h"
#include "collisionutils.h"
#include "particle_parse.h"
#include "tf_projectile_base.h"
#include "tf_gamerules.h"
#include "tf_fx.h"
#include "takedamageinfo.h"
#include "halloween/zombie/zombie.h"
#include "halloween/eyeball_boss/eyeball_boss.h"
#include "halloween/halloween_base_boss.h"
#include "entity_healthkit.h"
#include "eyeball_boss/teleport_vortex.h"
#include "in_buttons.h"
#include "halloween/merasmus/merasmus.h"
#include "tf_weapon_grenade_pipebomb.h"
#include "tf_obj_dispenser.h"
#endif
ConVar tf_test_spellindex( "tf_test_spellindex", "-1", FCVAR_CHEAT | FCVAR_REPLICATED, "Set to index to always get a specific spell" );
#ifdef GAME_DLL
ConVar tf_halloween_kart_rocketspell_speed( "tf_halloween_kart_rocketspell_speed", "1500", FCVAR_CHEAT );
ConVar tf_halloween_kart_rocketspell_lifetime( "tf_halloween_kart_rocketspell_lifetime", "0.5f", FCVAR_CHEAT );
ConVar tf_halloween_kart_rocketspell_force( "tf_halloween_kart_rocketspell_force", "900.0f", FCVAR_CHEAT );
#endif
extern ConVar tf_eyeball_boss_hover_height;
extern ConVar tf_halloween_kart_normal_speed;
extern ConVar tf_halloween_kart_dash_speed;
//=============================================================================
//
// Weapon Tables
//
// SpellBook --
IMPLEMENT_NETWORKCLASS_ALIASED( TFSpellBook, DT_TFWeaponSpellBook )
BEGIN_NETWORK_TABLE( CTFSpellBook, DT_TFWeaponSpellBook )
#ifdef CLIENT_DLL
RecvPropInt( RECVINFO( m_iSelectedSpellIndex ) ),
RecvPropInt( RECVINFO( m_iSpellCharges ) ),
RecvPropFloat( RECVINFO( m_flTimeNextSpell ) ),
RecvPropBool( RECVINFO( m_bFiredAttack ) ),
#else
SendPropInt( SENDINFO( m_iSelectedSpellIndex ) ),
SendPropInt( SENDINFO( m_iSpellCharges ) ),
SendPropFloat( SENDINFO( m_flTimeNextSpell ) ),
SendPropBool( SENDINFO( m_bFiredAttack ) ),
#endif
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CTFSpellBook )
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( tf_weapon_spellbook, CTFSpellBook );
PRECACHE_WEAPON_REGISTER( tf_weapon_spellbook );
// -- SpellBook
#define SPELL_EMPTY -1
#define SPELL_UNKNOWN -2
#define SPELL_BOXING_GLOVE "models/props_halloween/hwn_spell_boxing_glove.mdl"
//=============================================================================
// Spell Data Structures
//=============================================================================
enum SpellType_t
{
SPELL_ROCKET,
SPELL_JAR, // Explodes on Contact
SPELL_SELF,
};
struct spell_data_t
{
spell_data_t(
const char *pSpellUiName,
int iSpellCharges,
SpellType_t eSpelltype,
const char *pSpellEntityName,
bool (*pCastSpell)(CTFPlayer*),
const char *pszCastSound,
float flSpeedScale,
int iCastContext,
int iSpellContext,
const char *pIconName,
bool bAutoCast = false
) {
m_pSpellUiName = pSpellUiName;
m_eSpellType = eSpelltype;
m_pSpellEntityName = pSpellEntityName;
m_iSpellCharges = iSpellCharges;
m_pCastSpell = pCastSpell;
m_pszCastSound = pszCastSound;
m_flSpeedScale = flSpeedScale;
m_iCastContext = iCastContext;
m_iSpellContext = iSpellContext;
m_pIconName = pIconName;
m_bAutoCast = bAutoCast;
}
const char * m_pSpellUiName;
SpellType_t m_eSpellType;
const char *m_pSpellEntityName;
int m_iSpellCharges;
const char *m_pszCastSound;
float m_flSpeedScale;
int m_iCastContext; // context for the spell caster
int m_iSpellContext; // context for enemies who witness the spell
bool (*m_pCastSpell)(CTFPlayer*);
const char *m_pIconName;
bool m_bAutoCast;
};
static const spell_data_t g_NormalSpellList[] =
{
spell_data_t( "#TF_Spell_Fireball", 2, SPELL_ROCKET, "tf_projectile_spellfireball", NULL, "Halloween.spell_fireball_cast", 1.f,MP_CONCEPT_PLAYER_CAST_BOMB_HEAD_CURSE, MP_CONCEPT_PLAYER_SPELL_BOMB_HEAD_CURSE, "spellbook_fireball" ),
spell_data_t( "#TF_Spell_Bats", 2, SPELL_JAR, "tf_projectile_spellbats", NULL, "Halloween.spell_bat_cast", 1.f, MP_CONCEPT_PLAYER_CAST_MERASMUS_ZAP, MP_CONCEPT_PLAYER_SPELL_MERASMUS_ZAP, "spellbook_bats" ),
spell_data_t( "#TF_Spell_OverHeal", 1, SPELL_SELF, NULL, CTFSpellBook::CastSelfHeal, "Halloween.spell_overheal", 1.f, MP_CONCEPT_PLAYER_CAST_SELF_HEAL, MP_CONCEPT_PLAYER_SPELL_SELF_HEAL, "spellbook_overheal" ),
spell_data_t( "#TF_Spell_MIRV", 1, SPELL_JAR, "tf_projectile_spellmirv", NULL, "Halloween.spell_mirv_cast", 1.f, MP_CONCEPT_PLAYER_CAST_MIRV, MP_CONCEPT_PLAYER_SPELL_MIRV, "spellbook_mirv" ),
spell_data_t( "#TF_Spell_BlastJump", 2, SPELL_SELF, NULL, CTFSpellBook::CastRocketJump, "Halloween.spell_blastjump", 1.f, MP_CONCEPT_PLAYER_CAST_BLAST_JUMP, MP_CONCEPT_PLAYER_SPELL_BLAST_JUMP, "spellbook_blastjump"),
spell_data_t( "#TF_Spell_Stealth", 1, SPELL_SELF, NULL, CTFSpellBook::CastSelfStealth, "Halloween.spell_stealth", 1.f, MP_CONCEPT_PLAYER_CAST_STEALTH, MP_CONCEPT_PLAYER_SPELL_STEALTH, "spellbook_stealth"),
spell_data_t( "#TF_Spell_Teleport", 2, SPELL_JAR, "tf_projectile_spelltransposeteleport", NULL, "Halloween.spell_teleport", 1.f, MP_CONCEPT_PLAYER_CAST_TELEPORT, MP_CONCEPT_PLAYER_SPELL_TELEPORT, "spellbook_teleport"),
};
static const int g_NavMeshSpells = 2; // Number of spells in this list that require a navmesh, they must be at the end of this array
static const spell_data_t g_RareSpellList[] =
{
spell_data_t( "#TF_Spell_LightningBall", 1, SPELL_ROCKET, "tf_projectile_lightningorb", NULL, "Halloween.spell_lightning_cast", 0.4f, MP_CONCEPT_PLAYER_CAST_LIGHTNING_BALL, MP_CONCEPT_PLAYER_SPELL_LIGHTNING_BALL, "spellbook_lightning"),
spell_data_t( "#TF_Spell_Athletic", 1, SPELL_SELF, NULL, CTFSpellBook::CastSelfSpeedBoost, "Halloween.spell_athletic", 1.f, MP_CONCEPT_PLAYER_CAST_MOVEMENT_BUFF, MP_CONCEPT_PLAYER_SPELL_MOVEMENT_BUFF, "spellbook_athletic"),
spell_data_t( "#TF_Spell_Meteor", 1, SPELL_JAR, "tf_projectile_spellmeteorshower", NULL, "Halloween.spell_meteor_cast", 1.f, MP_CONCEPT_PLAYER_CAST_METEOR_SWARM, MP_CONCEPT_PLAYER_SPELL_METEOR_SWARM, "spellbook_meteor"),
spell_data_t( "#TF_Spell_SpawnBoss", 1, SPELL_JAR, "tf_projectile_spellspawnboss", NULL, "Halloween.Merasmus_Spell", 1.f, MP_CONCEPT_PLAYER_CAST_MONOCULOUS, MP_CONCEPT_PLAYER_SPELL_MONOCULOUS, "spellbook_boss"),
spell_data_t( "#TF_Spell_SkeletonHorde", 1, SPELL_JAR, "tf_projectile_spellspawnhorde", NULL, "Halloween.spell_skeleton_horde_cast", 1.f, MP_CONCEPT_PLAYER_CAST_SKELETON_HORDE, MP_CONCEPT_PLAYER_SPELL_SKELETON_HORDE, "spellbook_skeleton"),
};
static const spell_data_t g_KartSpellList[] =
{
// Kart Spells
spell_data_t( "#TF_Spell_Fireball", 1, SPELL_ROCKET, "tf_projectile_spellkartorb", NULL, "Halloween.spell_fireball_cast", 1.f, MP_CONCEPT_PLAYER_CAST_MERASMUS_ZAP, MP_CONCEPT_PLAYER_SPELL_MERASMUS_ZAP, "../hud/Punchglove_icon" ),
spell_data_t( "#TF_Spell_BlastJump", 1, SPELL_SELF, NULL, CTFSpellBook::CastKartRocketJump, "Halloween.spell_blastjump", 1.f, MP_CONCEPT_PLAYER_CAST_BLAST_JUMP, MP_CONCEPT_PLAYER_SPELL_BLAST_JUMP, "../hud/Parachute_icon"),
spell_data_t( "#TF_Spell_OverHeal", 1, SPELL_SELF, NULL, CTFSpellBook::CastKartUber, "Halloween.spell_overheal", 1.f, MP_CONCEPT_PLAYER_CAST_SELF_HEAL, MP_CONCEPT_PLAYER_SPELL_SELF_HEAL, "spellbook_overheal" ),
spell_data_t( "#TF_Spell_BombHead", 1, SPELL_SELF, NULL, CTFSpellBook::CastKartBombHead, "Halloween.spell_overheal", 1.f, MP_CONCEPT_PLAYER_CAST_FIREBALL, MP_CONCEPT_PLAYER_SPELL_FIREBALL, "../hud/bombhead_icon" ),
};
// Do not allow all spells in doomsday
static const int g_doomsdayNormalSpellIndexList[] =
{
0, //Fireball
0, //Fireball x2
2, //overheal
4, //Jump
5, //Stealth
};
static const int g_doomsdayRareSpellIndexList[] =
{
ARRAYSIZE( g_NormalSpellList ) + 0, // Lightning
ARRAYSIZE( g_NormalSpellList ) + 1, // Mini
ARRAYSIZE( g_NormalSpellList ) + 2, // Meteor
ARRAYSIZE( g_NormalSpellList ) + 0, // Lightning
ARRAYSIZE( g_NormalSpellList ) + 1, // Mini
ARRAYSIZE( g_NormalSpellList ) + 2, // Meteor
ARRAYSIZE( g_NormalSpellList ) + 3 // Boss / Monoculus. Smaller chance
};
// Regular SpellList
// teleport and summons removed
static const int g_generalSpellIndexList[] =
{
0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
ARRAYSIZE ( g_NormalSpellList ) + 0,
ARRAYSIZE ( g_NormalSpellList ) + 1,
ARRAYSIZE ( g_NormalSpellList ) + 2
};
int GetTotalSpellCount( CTFPlayer *pPlayer )
{
int iSpellCount = ARRAYSIZE( g_NormalSpellList ) + ARRAYSIZE( g_RareSpellList );
if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
iSpellCount += ARRAYSIZE( g_KartSpellList );
}
return iSpellCount;
}
bool IsRareSpell( int iSpellIndex )
{
if ( tf_test_spellindex.GetInt() > 0 )
{
iSpellIndex = tf_test_spellindex.GetInt();
}
return ( ( iSpellIndex >= ARRAYSIZE( g_NormalSpellList ) ) && ( iSpellIndex < ARRAYSIZE( g_NormalSpellList ) + ARRAYSIZE( g_RareSpellList ) ) );
}
const spell_data_t* GetSpellData( int iSpellIndex )
{
if ( tf_test_spellindex.GetInt() > -1 )
{
iSpellIndex = tf_test_spellindex.GetInt();
}
if ( iSpellIndex < 0 )
return NULL;
const int nNormalSpellCount = ARRAYSIZE( g_NormalSpellList );
if ( iSpellIndex < nNormalSpellCount )
return &g_NormalSpellList[ iSpellIndex ];
const int nRareSpellRange = nNormalSpellCount + ARRAYSIZE( g_RareSpellList );
if ( iSpellIndex < nRareSpellRange )
return &g_RareSpellList[ iSpellIndex - nNormalSpellCount ];
const int nKartSpellRange = nRareSpellRange + ARRAYSIZE( g_KartSpellList );
if ( iSpellIndex < nKartSpellRange )
return &g_KartSpellList[ iSpellIndex - nRareSpellRange];
return NULL;
}
int GetSpellIndexFromContext( int iContext )
{
const int nNormalSpellCount = ARRAYSIZE( g_NormalSpellList );
for ( int i=0; i<nNormalSpellCount; ++i )
{
if ( g_NormalSpellList[i].m_iSpellContext == iContext )
{
return i;
}
}
const int nRareSpellCount = ARRAYSIZE( g_RareSpellList );
for ( int i=0; i<nRareSpellCount; ++i )
{
if ( g_RareSpellList[i].m_iSpellContext == iContext )
{
return i + nNormalSpellCount;
}
}
return -1;
}
//=============================================================================
#ifdef CLIENT_DLL
//=============================================================================
// Ui Hud
//=============================================================================
extern ConVar cl_hud_minmode;
DECLARE_HUDELEMENT_DEPTH( CHudSpellMenu, 2 );
CHudSpellMenu::CHudSpellMenu( const char *pElementName ) : CHudElement( pElementName ), BaseClass ( NULL, "HudSpellMenu" )
{
Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetHiddenBits( HIDEHUD_MISCSTATUS | HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
m_iNextRollTime = 0;
m_flRollTickGap = 0.05f;
m_bTickSoundA = false;
m_bKillstreakMeterDrawing = false;
m_pSpellIcon = new vgui::ImagePanel( this, "SpellIcon" );
m_pKeyBinding = new CExLabel( this, "ActionText", "" );
ListenForGameEvent( "inventory_updated" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "localplayer_changeclass" );
ListenForGameEvent( "post_inventory_application" );
}
//-----------------------------------------------------------------------------
void CHudSpellMenu::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
KeyValues *pConditions = NULL;
if ( m_bKillstreakMeterDrawing )
{
pConditions = new KeyValues( "conditions" );
if ( pConditions )
{
AddSubKeyNamed( pConditions, "if_killstreak_visible" );
}
}
// load control settings...
LoadControlSettings( "resource/UI/HudSpellSelection.res", NULL, NULL, pConditions );
SetVisible( false );
UpdateSpellText( -1, -1 );
if ( pConditions )
{
pConditions->deleteThis();
}
}
//=============================================================================
void CHudSpellMenu::OnTick( void )
{
bool bKillstreakMeterDrawing = false;
CHudItemEffectMeter *pMeter = NULL;
for ( int i = 0; i < IHudItemEffectMeterAutoList::AutoList().Count(); ++i )
{
pMeter = static_cast<CHudItemEffectMeter*>( IHudItemEffectMeterAutoList::AutoList()[i] );
if ( pMeter->IsKillstreakMeter() ) // we found the killstreak meter
{
if ( pMeter->IsEnabled() )
{
bKillstreakMeterDrawing = true;
}
break;
}
}
if ( m_bKillstreakMeterDrawing != bKillstreakMeterDrawing )
{
m_bKillstreakMeterDrawing = bKillstreakMeterDrawing;
InvalidateLayout( false, true );
}
vgui::ivgui()->RemoveTickSignal( GetVPanel() );
}
//=============================================================================
void CHudSpellMenu::FireGameEvent( IGameEvent * event )
{
if ( FStrEq( event->GetName(), "post_inventory_application" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) ||
FStrEq( event->GetName(), "localplayer_changeclass" ) ||
FStrEq( event->GetName(), "inventory_updated" ) )
{
vgui::ivgui()->AddTickSignal( GetVPanel(), 10 );
}
}
//=============================================================================
bool CHudSpellMenu::ShouldDraw( void )
{
if ( TFGameRules() && TFGameRules()->IsUsingSpells() )
{
if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() && ( TFGameRules()->State_Get() != GR_STATE_RND_RUNNING ) )
return false;
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer && pPlayer->IsAlive() && !pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
{
CTFSpellBook *pSpellBook = dynamic_cast<CTFSpellBook*>( pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
UpdateSpellText( pSpellBook->m_iSelectedSpellIndex, pSpellBook->m_iSpellCharges );
return CHudElement::ShouldDraw();
}
}
}
return false;
}
//=============================================================================
void CHudSpellMenu::UpdateSpellText( int iSpellIndex, int iChargeCount )
{
if ( iSpellIndex == SPELL_EMPTY || ( iChargeCount <= 0 && iSpellIndex != SPELL_UNKNOWN ) )
{
SetDialogVariable( "counttext", "..." );
//SetDialogVariable( "selectedspell", g_pVGuiLocalize->Find( pSpellData->m_pSpellUiName ) );
m_pSpellIcon->SetImage( "spellbook_nospell" );
m_flRollTickGap = 0.01f;
m_iNextRollTime = 0;
m_pKeyBinding->SetVisible( false );
return;
}
m_pSpellIcon->SetVisible( true );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
static wchar_t wLabel[256];
if ( iSpellIndex == SPELL_UNKNOWN )
{
if ( m_iNextRollTime > gpGlobals->curtime )
return;
m_iNextRollTime = gpGlobals->curtime + m_flRollTickGap;
m_flRollTickGap += 0.015f;
static int s_iRandSpell = 0;
s_iRandSpell = ( s_iRandSpell + 1 ) % GetTotalSpellCount( pLocalPlayer );
const spell_data_t *pSpellData = GetSpellData( s_iRandSpell );
SetDialogVariable( "counttext", "?" );
m_pSpellIcon->SetImage( pSpellData->m_pIconName );
pLocalPlayer->EmitSound( m_bTickSoundA ? "Halloween.spelltick_a" : "Halloween.spelltick_b" );
m_bTickSoundA = !m_bTickSoundA;
m_iPrevSelectedSpell = SPELL_UNKNOWN;
m_pKeyBinding->SetVisible( false );
}
else
{
m_flRollTickGap = 0.01f;
m_iNextRollTime = 0;
const spell_data_t *pSpellData = GetSpellData( iSpellIndex );
if ( pSpellData )
{
SetDialogVariable( "counttext", iChargeCount );
m_pSpellIcon->SetImage( pSpellData->m_pIconName );
if ( m_iPrevSelectedSpell != iSpellIndex && iSpellIndex != SPELL_EMPTY )
{
pLocalPlayer->EmitSound( "Halloween.spelltick_set" );
}
m_iPrevSelectedSpell = iSpellIndex;
m_pKeyBinding->SetVisible( !cl_hud_minmode.GetBool() );
// Action Key Text
wchar_t wKeyReplaced[256];
UTIL_ReplaceKeyBindings( g_pVGuiLocalize->Find( "#TF_Spell_Action" ), 0, wKeyReplaced, sizeof( wKeyReplaced ) );
SetDialogVariable( "actiontext", wKeyReplaced );
}
}
}
//-----------------------------------------------------------------------------
// CEquipSpellbookNotification
//-----------------------------------------------------------------------------
void CEquipSpellbookNotification::Accept()
{
m_bHasTriggered = true;
CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
if ( !pLocalInv )
{
MarkForDeletion();
return;
}
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
{
MarkForDeletion();
return;
}
// try to equip non-stock-spellbook first
static CSchemaItemDefHandle pItemDef_Spellbook( "Basic Spellbook" );
static CSchemaItemDefHandle pItemDef_Diary( "Secret Diary" );
static CSchemaItemDefHandle pItemDef_FancySpellbook( "Halloween Spellbook" );
Assert( pItemDef_Spellbook );
Assert( pItemDef_Diary );
Assert( pItemDef_FancySpellbook );
CEconItemView *pSpellBook = NULL;
if ( pItemDef_Spellbook && pItemDef_Diary && pItemDef_FancySpellbook )
{
for ( int i = 0 ; i < pLocalInv->GetItemCount() ; ++i )
{
CEconItemView *pItem = pLocalInv->GetItem( i );
Assert( pItem );
if ( pItem->GetItemDefinition() == pItemDef_Spellbook
|| pItem->GetItemDefinition() == pItemDef_Diary
|| pItem->GetItemDefinition() == pItemDef_FancySpellbook
) {
pSpellBook = pItem;
break;
}
}
}
// Default item becomes a spellbook in this mode
itemid_t iItemId = INVALID_ITEM_ID;
if ( pSpellBook )
{
iItemId = pSpellBook->GetItemID();
}
TFInventoryManager()->EquipItemInLoadout( pLocalPlayer->GetPlayerClass()->GetClassIndex(), LOADOUT_POSITION_ACTION, iItemId );
// Tell the GC to tell server that we should respawn if we're in a respawn room
GCSDK::CGCMsg< GCSDK::MsgGCEmpty_t > msg( k_EMsgGCRespawnPostLoadoutChange );
GCClientSystem()->BSendMessage( msg );
MarkForDeletion();
}
//===========================================================================================
void CEquipSpellbookNotification::UpdateTick()
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
CTFSpellBook *pSpellBook = dynamic_cast<CTFSpellBook*>( pLocalPlayer->Weapon_OwnsThisID( TF_WEAPON_SPELLBOOK ) );
if ( pSpellBook )
{
MarkForDeletion();
}
}
}
#endif // CLIENT_DLL
//===========================================================================================
//
// CTFSpellBook
//
//===========================================================================================
CTFSpellBook::CTFSpellBook()
{
m_iSelectedSpellIndex = -1;
m_iSpellCharges = 0;
m_flTimeNextSpell = 0;
m_bFiredAttack = false;
#ifdef CLIENT_DLL
m_flTimeNextErrorSound = 0;
m_hHandEffect = NULL;
m_hHandEffectWeapon = NULL;
#endif // CLIENT_DLL
#ifdef GAME_DLL
m_pStoredLastWpn = NULL;
m_iPreviouslyCastSpell = -1;
#endif // GAME_DLL
}
void CTFSpellBook::Precache()
{
PrecacheScriptSound( "Halloween.Merasmus_Spell" );
PrecacheScriptSound( "Weapon_SniperRailgun_Large.SingleCrit" );
PrecacheScriptSound( "Halloween.spelltick_a" );
PrecacheScriptSound( "Halloween.spelltick_b" );
PrecacheScriptSound( "Halloween.spelltick_set" );
PrecacheScriptSound( "Halloween.spell_athletic" );
PrecacheScriptSound( "Halloween.spell_bat_cast" );
PrecacheScriptSound( "Halloween.spell_bat_impact" );
PrecacheScriptSound( "Halloween.spell_blastjump" );
PrecacheScriptSound( "Halloween.spell_fireball_cast" );
PrecacheScriptSound( "Halloween.spell_fireball_impact" );
PrecacheScriptSound( "Halloween.spell_lightning_cast" );
PrecacheScriptSound( "Halloween.spell_lightning_impact" );
PrecacheScriptSound( "Halloween.spell_meteor_cast" );
PrecacheScriptSound( "Halloween.spell_meteor_impact" );
PrecacheScriptSound( "Halloween.spell_mirv_cast" );
PrecacheScriptSound( "Halloween.spell_mirv_explode_primary" );
PrecacheScriptSound( "Halloween.spell_mirv_explode_secondary" );
PrecacheScriptSound( "Halloween.spell_skeleton_horde_cast" );
PrecacheScriptSound( "Halloween.spell_skeleton_horde_rise" );
PrecacheScriptSound( "Halloween.spell_spawn_boss" );
PrecacheScriptSound( "Halloween.spell_stealth" );
PrecacheScriptSound( "Halloween.spell_teleport" );
PrecacheScriptSound( "Halloween.spell_overheal" );
PrecacheParticleSystem( "merasmus_zap" );
PrecacheParticleSystem( "spell_cast_wheel_red" );
PrecacheParticleSystem( "spell_cast_wheel_blue" );
PrecacheParticleSystem( "Explosion_bubbles" );
PrecacheParticleSystem( "ExplosionCore_buildings" );
PrecacheParticleSystem( "water_splash01" );
PrecacheParticleSystem( "healshot_trail_blue" );
PrecacheParticleSystem( "healshot_trail_red" );
PrecacheParticleSystem( "xms_snowburst" );
PrecacheParticleSystem( "bomibomicon_ring" );
PrecacheParticleSystem( "bombinomicon_burningdebris" );
PrecacheParticleSystem( "merasmus_tp_bits" );
PrecacheParticleSystem( "spell_fireball_tendril_parent_red" );
PrecacheParticleSystem( "spell_fireball_tendril_parent_blue" );
PrecacheParticleSystem( "spell_fireball_small_blue" );
PrecacheParticleSystem( "spell_fireball_small_red" );
PrecacheParticleSystem( "spell_lightningball_parent_blue" );
PrecacheParticleSystem( "spell_lightningball_parent_red" );
PrecacheParticleSystem( "spell_lightningball_hit_blue" );
PrecacheParticleSystem( "spell_lightningball_hit_red" );
PrecacheParticleSystem( "eyeboss_tp_vortex" );
PrecacheParticleSystem( "spell_overheal_red" );
PrecacheParticleSystem( "spell_overheal_blue" );
PrecacheParticleSystem( "spell_teleport_red" );
PrecacheParticleSystem( "spell_teleport_blue" );
PrecacheParticleSystem( "spell_batball_red" );
PrecacheParticleSystem( "spell_batball_blue" );
PrecacheParticleSystem( "spell_batball_throw_red" );
PrecacheParticleSystem( "spell_batball_throw_blue" );
PrecacheParticleSystem( "spell_batball_impact_red" );
PrecacheParticleSystem( "spell_batball_impact_blue" );
PrecacheParticleSystem( "spell_pumpkin_mirv_goop_red" );
PrecacheParticleSystem( "spell_pumpkin_mirv_goop_blue" );
PrecacheParticleSystem( "spell_skeleton_goop_green" );
PrecacheParticleSystem( "spellbook_rainbow" );
PrecacheParticleSystem( "spellbook_major_burning" );
PrecacheParticleSystem( "spellbook_minor_burning" );
PrecacheModel( "models/props_mvm/mvm_human_skull_collide.mdl" );
PrecacheModel( "models/props_lakeside_event/bomb_temp_hat.mdl" );
PrecacheModel( SPELL_BOXING_GLOVE );
PrecacheModel( "models/props_halloween/bombonomicon.mdl" ); // bomb head spell
PrecacheParticleSystem( "halloween_rockettrail" );
PrecacheParticleSystem( "ExplosionCore_MidAir" );
#ifdef GAME_DLL
CEyeballBoss::PrecacheEyeballBoss();
CZombie::PrecacheZombie();
#endif // GAME_DLL
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
void CTFSpellBook::PrimaryAttack()
{
// cast spell
if ( m_flTimeNextSpell > gpGlobals->curtime )
return;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
bool bCastSuccessful = false;
bCastSuccessful = CanCastSpell( pPlayer );
if ( bCastSuccessful )
{
#ifdef GAME_DLL
SpeakSpellConceptIfAllowed();
// We need to do this before PrimaryAttack so we use the right spell index
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
CastKartSpell();
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, ACT_KART_ACTION_SHOOT );
}
else
{
CastSpell( pPlayer, m_iSelectedSpellIndex );
BaseClass::PrimaryAttack();
}
#endif
#ifdef GAME_DLL
// set a default time cast time if none added
if ( m_flTimeNextSpell < gpGlobals->curtime )
{
m_flTimeNextSpell = gpGlobals->curtime + 0.5f;
}
#endif // GAME_DLL
}
#ifdef CLIENT_DLL
else
{
if ( m_flTimeNextErrorSound < gpGlobals->curtime )
{
m_flTimeNextErrorSound = gpGlobals->curtime + 0.5f;
pPlayer->EmitSound( "Player.DenyWeaponSelection" );
}
}
#endif // CLIENT_DLL
}
//-----------------------------------------------------------------------------
void CTFSpellBook::ItemBusyFrame( void )
{
#ifdef CLIENT_DLL
if ( m_hHandEffectWeapon && m_hHandEffect )
return;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( IsFirstPersonView() )
{
m_hHandEffectWeapon = pPlayer->GetViewModel();
}
else
{
m_hHandEffectWeapon = pPlayer;
}
if ( !m_hHandEffectWeapon )
return;
if ( UsingViewModel() && !g_pClientMode->ShouldDrawViewModel() )
{
// Prevent effects when the ViewModel is hidden with r_drawviewmodel=0
return;
}
C_BaseAnimating* pBase = (C_BaseAnimating*)m_hHandEffectWeapon.Get();
int iAttachment = pBase->C_BaseAnimating::LookupAttachment( "effect_hand_R" );
// Start the muzzle flash, if a system hasn't already been started.
if ( iAttachment > 0 )
{
const char *pszEffectName = GetHandEffect( GetAttributeContainer()->GetItem(), m_iSelectedSpellIndex >= ARRAYSIZE( g_NormalSpellList ) );
if ( pszEffectName )
{
m_hHandEffect = pBase->ParticleProp()->Create( pszEffectName, PATTACH_POINT_FOLLOW, iAttachment );
}
}
else
{
if ( m_hHandEffect )
{
m_hHandEffectWeapon->ParticleProp()->StopEmission( m_hHandEffect );
m_hHandEffectWeapon = NULL;
m_hHandEffect = NULL;
}
}
#endif
}
//-----------------------------------------------------------------------------
void CTFSpellBook::ItemHolsterFrame( void )
{
#ifdef CLIENT_DLL
if ( !m_hHandEffectWeapon )
return;
// Stop the muzzle flash.
if ( m_hHandEffect )
{
m_hHandEffectWeapon->ParticleProp()->StopEmission( m_hHandEffect );
m_hHandEffectWeapon = NULL;
m_hHandEffect = NULL;
}
#endif
#ifdef GAME_DLL
m_bFiredAttack = false;
#endif
}
//-----------------------------------------------------------------------------
void CTFSpellBook::ItemPostFrame( void )
{
BaseClass::ItemPostFrame();
#ifdef CLIENT_DLL
// attempt to attack then switch back
if ( !m_bFiredAttack && m_iSpellCharges > 0 )
{
PrimaryAttack();
if ( m_hHandEffect )
{
m_hHandEffectWeapon->ParticleProp()->StopEmission( m_hHandEffect );
m_hHandEffectWeapon = NULL;
m_hHandEffect = NULL;
}
}
#endif
#ifdef GAME_DLL
if ( tf_test_spellindex.GetInt() > -1 )
{
SetSelectedSpell( tf_test_spellindex.GetInt() );
}
// attempt to attack then switch back
if ( !m_bFiredAttack && m_iSpellCharges > 0 )
{
PrimaryAttack();
m_bFiredAttack = true;
}
else
{
if ( m_flTimeNextSpell > gpGlobals->curtime )
return;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( pPlayer->Weapon_Switch( pPlayer->GetLastWeapon() ) )
{
if ( m_pStoredLastWpn != NULL && pPlayer->Weapon_CanSwitchTo( m_pStoredLastWpn.Get() ) )
{
pPlayer->Weapon_SetLast( m_pStoredLastWpn.Get() );
m_pStoredLastWpn = NULL;
}
else
{
pPlayer->Weapon_SetLast( NULL );
}
m_bFiredAttack = false;
}
}
#endif //GAME_DLL
}
//-----------------------------------------------------------------------------
/* static */ const char* CTFSpellBook::GetHandEffect( CEconItemView *pItem, int iTier )
{
// if fancy spellbook //1069
int defIndex = pItem->GetItemDefIndex();
if ( defIndex == 1069 )
{
if ( iTier > 0 )
{
return "spellbook_major_burning";
}
else
{
return "spellbook_minor_burning";
}
}
else if ( defIndex == 5605 ) // secret diary
{
return "spellbook_rainbow";
}
else // else Basic SpellBook
{
if ( iTier > 0 )
{
return "spellbook_major_fire";
}
else
{
return "spellbook_minor_fire";
}
}
}
//-----------------------------------------------------------------------------
bool CTFSpellBook::HasASpellWithCharges()
{
return tf_test_spellindex.GetInt() > -1 || m_iSpellCharges > 0 || m_iSelectedSpellIndex == SPELL_UNKNOWN;
}
//-----------------------------------------------------------------------------
bool CTFSpellBook::CanCastSpell( CTFPlayer *pPlayer )
{
if ( !pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART) && !pPlayer->CanAttack() )
return false;
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) )
return false;
if ( tf_test_spellindex.GetInt() > -1 && tf_test_spellindex.GetInt() < GetTotalSpellCount( pPlayer ) )
return true;
return m_iSpellCharges > 0 && m_iSelectedSpellIndex >= 0 && m_iSelectedSpellIndex < GetTotalSpellCount( pPlayer );
}
//-----------------------------------------------------------------------------
void CTFSpellBook::PaySpellCost( CTFPlayer *pPlayer )
{
m_iSpellCharges--;
}
//-----------------------------------------------------------------------------
void CTFSpellBook::ClearSpell()
{
m_iSpellCharges = 0;
#ifdef GAME_DLL
// If rolling for a spell, clear that too
m_iNextSpell = SPELL_EMPTY;
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
CBaseEntity *CTFSpellBook::FireJar( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
TossJarThink();
}
else
{
SetContextThink( &CTFJar::TossJarThink, gpGlobals->curtime + 0.01f, "TOSS_JAR_THINK" );
}
#endif
return NULL;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFSpellBook::TossJarThink( void )
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
// Self casts
const spell_data_t *pSpellData = GetSpellData( m_iPreviouslyCastSpell );
if ( !pSpellData )
return;
if ( pSpellData->m_eSpellType == SPELL_SELF )
{
// Self casts
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( pSpellData->m_iSpellContext, ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
// Play a sound immediately for self-cast spells
EmitSound( pSpellData->m_pszCastSound );
pSpellData->m_pCastSpell( pPlayer );
return;
}
Vector vecForward, vecRight, vecUp;
AngleVectors( pPlayer->EyeAngles(), &vecForward, &vecRight, &vecUp );
float fRight = 8.f;
if ( IsViewModelFlipped() )
{
fRight *= -1;
}
Vector vecSrc = pPlayer->Weapon_ShootPosition();
// Make spell toss position at the hand
vecSrc = vecSrc + (vecUp * -9.0f) + (vecRight * 7.0f) + (vecForward * 3.0f);
Vector vecVelocity = GetVelocityVector( vecForward, vecRight, vecUp ) * pSpellData->m_flSpeedScale;
QAngle angForward = pPlayer->EyeAngles();
// Halloween Hack
// Eye Angles slighty higher
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
// Add More up for Jar
angForward = pPlayer->GetAbsAngles();
if ( pSpellData->m_eSpellType == SPELL_JAR )
{
angForward.x -= 10.0f;
}
AngleVectors( angForward, &vecForward, &vecRight, &vecUp );
vecVelocity = vecForward * tf_halloween_kart_rocketspell_speed.GetFloat();
}
trace_t trace;
Vector vecEye = pPlayer->EyePosition();
CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
UTIL_TraceHull( vecEye, vecSrc, -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, &traceFilter, &trace );
// If we started in solid, don't let them fire at all
if ( trace.startsolid )
return;
// Play a sound when we actually cast the projectile
EmitSound( pSpellData->m_pszCastSound );
switch ( pSpellData->m_eSpellType )
{
case SPELL_ROCKET :
{
//QAngle angForward;
//GetProjectileFireSetup( pPlayer, Vector(0,0,0), &vecSrc, &angForward, false );
CreateSpellRocket( trace.endpos, angForward, vecVelocity, GetAngularImpulse(), pPlayer, GetTFWpnData() );
}
break;
case SPELL_JAR :
{
CreateSpellJar( trace.endpos, angForward, vecVelocity, GetAngularImpulse(), pPlayer, GetTFWpnData() );
}
break;
case SPELL_SELF :
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFSpellBook::CreateSpellRocket( const Vector &position, const QAngle &angles, const Vector &velocity,
const AngularImpulse &angVelocity, CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
const spell_data_t* pSpellData = GetSpellData( m_iPreviouslyCastSpell );
if ( !pSpellData )
{
return;
}
ASSERT( pSpellData->m_eSpellType == SPELL_ROCKET );
CTFProjectile_Rocket *pRocket = static_cast<CTFProjectile_Rocket*>( CBaseEntity::CreateNoSpawn( pSpellData->m_pSpellEntityName, position, angles, pOwner ) );
if ( pRocket )
{
pRocket->SetOwnerEntity( pOwner );
pRocket->SetLauncher( this );
Vector vForward;
AngleVectors( angles, &vForward, NULL, NULL );
pRocket->SetAbsVelocity( vForward * velocity.Length() );
pRocket->SetDamage( weaponInfo.GetWeaponData(TF_WEAPON_PRIMARY_MODE).m_nDamage );
pRocket->ChangeTeam( pOwner ? pOwner->GetTeamNumber() : TEAM_UNASSIGNED );
IPhysicsObject *pPhysicsObject = pRocket->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->AddVelocity( &velocity, &angVelocity );
}
DispatchSpawn( pRocket );
}
}
//-----------------------------------------------------------------------------
void CTFSpellBook::CreateSpellJar( const Vector &position, const QAngle &angles, const Vector &velocity,
const AngularImpulse &angVelocity, CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo )
{
const spell_data_t* pSpellData = GetSpellData( m_iPreviouslyCastSpell );
if ( !pSpellData )
{
return;
}
ASSERT( pSpellData->m_eSpellType == SPELL_JAR );
CTFProjectile_Jar *pGrenade = static_cast<CTFProjectile_Jar*>( CBaseEntity::CreateNoSpawn( pSpellData->m_pSpellEntityName, position, angles, pOwner ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
IPhysicsObject *pPhys = pGrenade->VPhysicsGetObject();
if ( pPhys )
{
pPhys->SetMass( 5.0f );
}
pGrenade->InitGrenade( velocity, vec3_origin, pOwner, weaponInfo );
pGrenade->m_flFullDamage = 0;
pGrenade->ApplyLocalAngularVelocityImpulse( vec3_origin );
}
}
//-----------------------------------------------------------------------------
void CTFSpellBook::RollNewSpell( int iTier, bool bForceReroll /*= false*/ )
{
// do not do anything if we already have a spell for low tier, always roll for high tier
if ( m_iSpellCharges > 0 && iTier == 0 && !bForceReroll )
return;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
int iNextSpell = SPELL_EMPTY;
// Halloween 2014
// This is dumb, make spell lists better somehow
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
iNextSpell = RandomInt( ARRAYSIZE( g_NormalSpellList ) + ARRAYSIZE( g_RareSpellList ), GetTotalSpellCount( pPlayer ) - 1 );
}
else if ( iTier == 0 )
{
// Doomsday has special spell list
if ( TFGameRules() && TFGameRules()->GetHalloweenScenario( ) == CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY )
{
iNextSpell = g_doomsdayNormalSpellIndexList[ RandomInt( 0, ARRAYSIZE( g_doomsdayNormalSpellIndexList ) - 1 ) ];
}
// Helltower has normal spell list
else if ( TFGameRules() && TFGameRules()->GetHalloweenScenario( ) == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER )
{
iNextSpell = RandomInt( 0, ARRAYSIZE( g_NormalSpellList ) - 1 );
}
// everyone else uses special list
else
{
iNextSpell = g_generalSpellIndexList[ RandomInt( 0, ARRAYSIZE( g_generalSpellIndexList ) - 1 ) ];
}
}
else // rare spell should not be the else
{
// Doomsday has special spell list
if ( TFGameRules() && TFGameRules()->GetHalloweenScenario( ) == CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY )
{
iNextSpell = g_doomsdayRareSpellIndexList[ RandomInt( 0, ARRAYSIZE( g_doomsdayRareSpellIndexList ) - 1 ) ];
}
else
{
// g_NavMeshSpells
// If there's no Nav mesh do not allow the upper range of spells (summons)
int iIndexReduction = 1;
if ( ( TheNavMesh == NULL ) || ( TheNavMesh->GetNavAreaCount() <= 0 ) )
{
iIndexReduction += g_NavMeshSpells;
}
iNextSpell = RandomInt( ARRAYSIZE( g_NormalSpellList ), GetTotalSpellCount( pPlayer ) - 1 );
}
}
const float flRollTime = 2.f;
m_iNextSpell = iNextSpell;
SetSelectedSpell( SPELL_UNKNOWN );
SetContextThink( &CTFSpellBook::RollNewSpellFinish, gpGlobals->curtime + flRollTime, "SpellRollFinish" );
}
//-----------------------------------------------------------------------------
void CTFSpellBook::RollNewSpellFinish( void )
{
SetSelectedSpell( m_iNextSpell );
if ( m_iNextSpell < 0 )
return;
// response rules
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
{
return;
}
int iConcept = MP_CONCEPT_NONE;
if ( m_iNextSpell < ARRAYSIZE( g_NormalSpellList ) )
{
iConcept = MP_CONCEPT_PLAYER_SPELL_PICKUP_COMMON;
}
else
{
iConcept = MP_CONCEPT_PLAYER_SPELL_PICKUP_RARE;
}
if ( iConcept != MP_CONCEPT_NONE )
{
pPlayer->SpeakConceptIfAllowed( iConcept );
}
}
//-----------------------------------------------------------------------------
void CTFSpellBook::SetSelectedSpell( int index )
{
m_iSelectedSpellIndex = index;
const spell_data_t *pSpellData = GetSpellData( m_iSelectedSpellIndex );
m_iSpellCharges = pSpellData ? pSpellData->m_iSpellCharges : 0;
if ( pSpellData && pSpellData->m_bAutoCast )
{
PrimaryAttack();
}
}
//-----------------------------------------------------------------------------
void CTFSpellBook::SpeakSpellConceptIfAllowed()
{
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer || m_iSpellCharges <= 0 )
return;
const spell_data_t *pSpellData = GetSpellData( m_iSelectedSpellIndex );
if ( pSpellData )
{
pPlayer->SpeakConceptIfAllowed( pSpellData->m_iCastContext );
}
}
//------------------------------------------------------------------------------------------------------------------------------------
// KART FUNCTIONS
//------------------------------------------------------------------------------------------------------------------------------------
void CTFSpellBook::CastKartSpell()
{
#ifdef GAME_DLL
// cast spell time
if ( m_flTimeNextSpell > gpGlobals->curtime )
return;
CTFPlayer *pPlayer = GetTFPlayerOwner();
if ( !pPlayer )
return;
if ( m_iSpellCharges <= 0 )
{
if ( tf_test_spellindex.GetInt() < 0 || tf_test_spellindex.GetInt() > GetTotalSpellCount( pPlayer ) )
return;
}
// Save off what we cast for jar think
PaySpellCost( pPlayer );
m_iPreviouslyCastSpell = m_iSelectedSpellIndex;
FireProjectile( pPlayer );
m_flTimeNextSpell = gpGlobals->curtime + 0.5f;
// Create one off spell effect in front of the player
Vector origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
if ( GetTeamNumber() == TF_TEAM_RED )
{
TE_TFParticleEffect( filter, 0.0, "spell_cast_wheel_red", origin + Vector( 0, 0, 100 ), vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
}
else
{
TE_TFParticleEffect( filter, 0.0, "spell_cast_wheel_blue", origin + Vector( 0, 0, 100 ), vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
}
#endif
}
//-----------------------------------------------------------------------------
// Individual spells
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastSpell( CTFPlayer *pPlayer, int iSpellIndex )
{
if ( CanCastSpell( pPlayer ) )
{
PaySpellCost( pPlayer );
const spell_data_t *pSpellData = GetSpellData( m_iSelectedSpellIndex );
if ( !pSpellData)
return false;
if ( IsRareSpell( iSpellIndex ) )
{
if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_RARE_SPELL );
}
}
// Save off what we cast for jar think
m_iPreviouslyCastSpell = m_iSelectedSpellIndex;
// Create one off spell effect in front of the player
Vector origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
//const spell_data_t *pSpellData = GetSpellData( m_iSelectedSpellIndex );
if ( pSpellData && !FStrEq( pSpellData->m_pSpellUiName, "#TF_Spell_Stealth" ) ) // do NOT create for Stealth
{
if ( GetTeamNumber() == TF_TEAM_RED )
{
TE_TFParticleEffect( filter, 0.0, "spell_cast_wheel_red", origin + Vector( 0, 0, 100 ), vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
}
else
{
TE_TFParticleEffect( filter, 0.0, "spell_cast_wheel_blue", origin + Vector( 0, 0, 100 ), vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
}
}
return true;
}
return false;
}
#endif
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastSelfHeal( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
Vector origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
const char* pszEffectName = pPlayer->GetTeamNumber() == TF_TEAM_RED ? "spell_overheal_red" : "spell_overheal_blue";
TE_TFParticleEffect( filter, 0.0, pszEffectName, origin, vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
//pPlayer->EmitSound( "BaseExplosionEffect.Sound" );
// Collect players and cause knockback to enemies
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pPlayer, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, origin, 250.0f, FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CBaseCombatCharacter *pBaseTarget = NULL;
CTFPlayer *pTarget = ToTFPlayer( pListOfEntities[i] );
if ( !pTarget )
{
pBaseTarget = dynamic_cast<CBaseCombatCharacter*>( pListOfEntities[i] );
}
else
{
pBaseTarget = pTarget;
}
if ( !pBaseTarget || !pTarget || !pTarget->IsAlive() )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( origin, pBaseTarget->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
if ( trace.DidHitWorld() )
continue;
Vector vecDir = pBaseTarget->WorldSpaceCenter() - origin;
VectorNormalize( vecDir );
// help allies
if ( pBaseTarget->GetTeamNumber() == pPlayer->GetTeamNumber() )
{
pBaseTarget->TakeHealth( 50, DMG_GENERIC );
if ( pTarget )
{
pTarget->m_Shared.AddCond( TF_COND_INVULNERABLE_USER_BUFF, 1, pPlayer );
pTarget->m_Shared.AddCond( TF_COND_HALLOWEEN_QUICK_HEAL, 3, pPlayer );
}
}
else // knockback enemies
{
if ( pTarget )
{
pTarget->ApplyAirBlastImpulse( vecDir * 300.0f );
}
else
{
pBaseTarget->ApplyAbsVelocityImpulse( vecDir * 300.0f );
}
}
}
#endif
return true;
}
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastRocketJump( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
const float flBlastRadius = 100.f;
// Set z to zero then add impulse
// make this proper jumping later
Vector vel = pPlayer->GetAbsVelocity();
if ( vel.z < 0 )
{
vel.z = 0;
}
pPlayer->SetAbsVelocity( vel );
Vector vForward( 0, 0, 800 );
pPlayer->ApplyAbsVelocityImpulse( vForward );
const Vector& origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
TE_TFParticleEffect( filter, 0.0, "bombinomicon_burningdebris", origin, vec3_angle );
TE_TFParticleEffect( filter, 0.0, "heavy_ring_of_fire", origin, vec3_angle );
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pPlayer, "foot_L" );
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pPlayer, "foot_R" );
// Give a little health to compensate for fall damage
pPlayer->TakeHealth( 25, DMG_GENERIC );
// Collect players and cause knockback to enemies
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pPlayer, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, origin, flBlastRadius, FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CBaseCombatCharacter *pBaseTarget = NULL;
CTFPlayer *pTarget = ToTFPlayer( pListOfEntities[i] );
if ( !pTarget )
{
pBaseTarget = dynamic_cast<CBaseCombatCharacter*>( pListOfEntities[i] );
}
else
{
pBaseTarget = pTarget;
}
if ( !pBaseTarget || !pTarget || !pTarget->IsAlive() || pBaseTarget->GetTeamNumber() == pPlayer->GetTeamNumber() )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( origin, pBaseTarget->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
if ( trace.DidHitWorld() )
continue;
Vector vecDir = pBaseTarget->WorldSpaceCenter() - origin;
VectorNormalize( vecDir );
pBaseTarget->RemoveFlag( FL_ONGROUND );
if ( pTarget )
{
pTarget->ApplyAirBlastImpulse( vecDir * 800.0f );
}
else
{
pBaseTarget->ApplyAbsVelocityImpulse( vecDir * 800.0f );
}
}
CTakeDamageInfo info;
info.SetAttacker( pPlayer );
info.SetInflictor( pPlayer );
info.SetDamage( 20.f );
info.SetDamageCustom( TF_DMG_CUSTOM_SPELL_BLASTJUMP );
info.SetDamagePosition( origin );
info.SetDamageType( DMG_BLAST );
CTFRadiusDamageInfo radiusinfo( &info, origin, flBlastRadius, pPlayer );
TFGameRules()->RadiusDamage( radiusinfo );
#endif
return true;
}
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastSelfSpeedBoost( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
// Give a little health
pPlayer->TakeHealth( 100, DMG_GENERIC );
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_TINY, 20, pPlayer );
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_SPEED_BOOST, 20, pPlayer );
#endif
return true;
}
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastSelfStealth( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
// Grant a small amount of health
pPlayer->TakeHealth( 40, DMG_GENERIC );
pPlayer->m_Shared.AddCond( TF_COND_STEALTHED_USER_BUFF, 8, pPlayer );
#endif
return true;
}
//********************************************************************************************************************************
//-----------------------------------------------------------------------------
// Kart Self Spells
//-----------------------------------------------------------------------------
bool CTFSpellBook::CastKartRocketJump( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
const float flBlastRadius = 250.f;
// Set z to zero then add impulse
// make this proper jumping later
Vector vel = pPlayer->GetAbsVelocity();
if ( vel.z < 0 )
{
vel.z = 0;
}
pPlayer->SetAbsVelocity( vel );
Vector vForward( 0, 0, 1200 );
pPlayer->ApplyAbsVelocityImpulse( vForward );
const Vector& origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
TE_TFParticleEffect( filter, 0.0, "bombinomicon_burningdebris", origin, vec3_angle );
TE_TFParticleEffect( filter, 0.0, "heavy_ring_of_fire", origin, vec3_angle );
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pPlayer, "foot_L" );
DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pPlayer, "foot_R" );
// Give a little health to compensate for fall damage
//pPlayer->TakeHealth( 25, DMG_GENERIC );
pPlayer->RemoveFlag( FL_ONGROUND );
pPlayer->m_Shared.AddCond( TF_COND_PARACHUTE_DEPLOYED );
// Collect players and cause knockback to enemies
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pPlayer, COLLISION_GROUP_PROJECTILE );
// Trace entity radius
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, origin, flBlastRadius, FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CTFPlayer *pTarget = ToTFPlayer( pListOfEntities[i] );
if ( !pTarget || !pTarget->IsAlive() || pTarget->GetTeamNumber() == pPlayer->GetTeamNumber() )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( origin, pTarget->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
if ( trace.DidHitWorld() )
continue;
Vector vecDir = pTarget->WorldSpaceCenter() - origin;
vecDir.NormalizeInPlace();
vecDir.z += 0.5f;
pTarget->AddHalloweenKartPushEvent( pPlayer, pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ), pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ), vecDir * tf_halloween_kart_normal_speed.GetFloat(), 30.0f );
}
#endif
return true;
}
bool CTFSpellBook::CastKartUber( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
Vector origin = pPlayer->GetAbsOrigin();
CPVSFilter filter( origin );
const char* pszEffectName = pPlayer->GetTeamNumber() == TF_TEAM_RED ? "spell_overheal_red" : "spell_overheal_blue";
TE_TFParticleEffect( filter, 0.0, pszEffectName, origin, vec3_angle, pPlayer, PATTACH_ABSORIGIN_FOLLOW );
//pPlayer->EmitSound( "BaseExplosionEffect.Sound" );
// Collect players and cause knockback to enemies
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pPlayer, COLLISION_GROUP_PROJECTILE );
pPlayer->m_Shared.AddCond( TF_COND_INVULNERABLE_USER_BUFF, 7, pPlayer );
pPlayer->AddKartDamage( -50 ); //Heal
#endif
return true;
}
bool CTFSpellBook::CastKartBombHead( CTFPlayer *pPlayer )
{
#ifdef GAME_DLL
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_BOMB_HEAD, 10, pPlayer );
#endif
return true;
}
//************************************************************************************************************************
// Spell Projectiles
//************************************************************************************************************************
class CTFProjectile_SpellFireball : public CTFProjectile_Rocket
{
public:
DECLARE_CLASS( CTFProjectile_SpellFireball, CTFProjectile_Rocket );
DECLARE_NETWORKCLASS();
virtual int GetWeaponID( void ) const { return TF_WEAPON_SPELLBOOK_PROJECTILE; }
virtual float GetDamageRadius() const { return 200.0f; }
virtual int GetCustomDamageType() const OVERRIDE { return m_bIsMeteor ? TF_DMG_CUSTOM_SPELL_METEOR : TF_DMG_CUSTOM_SPELL_FIREBALL; }
virtual bool IsDeflectable() OVERRIDE { return false; }
void SetMeteor( bool bIsMeteor ) { m_bIsMeteor = bIsMeteor; }
CTFProjectile_SpellFireball()
{
m_bIsMeteor = false;
#ifdef GAME_DLL
//m_pszExplodeParticleName = "ExplosionCore_buildings";
m_pszExplodeParticleName = "bombinomicon_burningdebris";
#endif // GAME_DLL
}
#ifdef GAME_DLL
virtual void Spawn() OVERRIDE
{
SetModelScale( 0.01f );
BaseClass::Spawn();
}
virtual int UpdateTransmitState() OVERRIDE { return SetTransmitState( FL_EDICT_PVSCHECK ); }
virtual void RocketTouch( CBaseEntity *pOther ) OVERRIDE
{
Assert( pOther );
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
return;
if ( pOther->GetParent() == GetOwnerEntity() )
return;
// Handle hitting skybox (disappear).
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
if( pTrace->surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// pass through ladders
if( pTrace->surface.flags & CONTENTS_LADDER )
return;
Explode( pTrace );
UTIL_Remove( this );
}
virtual void Explode( const trace_t *pTrace )
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit.
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + ( pTrace->plane.normal * 1.0f ) );
}
CTFPlayer *pThrower = ToTFPlayer( GetOwnerEntity() );
if ( pThrower )
{
const Vector &vecOrigin = GetAbsOrigin();
// Any effects from the initial explosion
if ( InitialExplodeEffects( pThrower, pTrace ) )
{
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
}
// Sounds
if ( GetExplodeEffectSound() )
{
EmitSound( GetExplodeEffectSound() );
}
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pThrower, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, vecOrigin, GetDamageRadius(), FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CBaseCombatCharacter *pBasePlayer = NULL;
CTFPlayer *pPlayer = ToTFPlayer( pListOfEntities[i] );
if ( !pPlayer )
{
pBasePlayer = dynamic_cast<CBaseCombatCharacter*>( pListOfEntities[i] );
}
else
{
pBasePlayer = pPlayer;
}
if ( !pBasePlayer || !pPlayer || !pPlayer->IsAlive() )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( vecOrigin, pPlayer->WorldSpaceCenter(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
//debugoverlay->AddLineOverlay( vecOrigin, pPlayer->WorldSpaceCenter(), 255, 0, 0, false, 10 );
if ( trace.DidHitWorld() )
continue;
// Effects on the individual players
ExplodeEffectOnTarget( pThrower, pPlayer, pBasePlayer );
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_FIREBALL, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
CTakeDamageInfo info;
info.SetAttacker( pThrower );
info.SetInflictor( this );
info.SetWeapon( GetLauncher() );
info.SetDamage( 10.f );
info.SetDamageCustom( GetCustomDamageType() );
info.SetDamagePosition( vecOrigin );
info.SetDamageType( DMG_BLAST );
CTFRadiusDamageInfo radiusinfo( &info, vecOrigin, GetDamageRadius(), pThrower );
TFGameRules()->RadiusDamage( radiusinfo );
}
else
{
pThrower->EmitSound( "Player.DenyWeaponSelection" );
}
}
// Grenade remove
//SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
// Remove the rocket.
UTIL_Remove( this );
SetTouch( NULL );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
}
virtual const char *GetProjectileModelName( void ) { return ""; } // We dont have a model by default, and that's OK
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) { return true; }
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget )
{
if ( pBaseTarget->GetTeamNumber() == GetTeamNumber() )
return;
if ( pTarget )
{
if ( pTarget->m_Shared.IsInvulnerable() )
return;
if ( pTarget->m_Shared.InCond( TF_COND_PHASE ) || pTarget->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return;
pTarget->m_Shared.SelfBurn( 5.0f );
}
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
CBaseEntity *pInflictor = GetLauncher();
CTakeDamageInfo info;
info.SetAttacker( pThrower );
info.SetInflictor( this );
info.SetWeapon( pInflictor );
info.SetDamage( 100.f );
info.SetDamageCustom( GetCustomDamageType() );
info.SetDamagePosition( GetAbsOrigin() );
info.SetDamageType( DMG_BURN );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pBaseTarget->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
Vector vecDir = pBaseTarget->WorldSpaceCenter() - GetAbsOrigin();
VectorNormalize( vecDir );
vecDir.z = 0.1f;
if ( pTarget )
{
pTarget->ApplyAirBlastImpulse( vecDir * 5 );
}
}
virtual const char *GetExplodeEffectParticle() const { return m_pszExplodeParticleName; }
void SetExplodeParticleName( const char *pszName ) { m_pszExplodeParticleName = pszName; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_fireball_impact"; }
#endif
#ifdef CLIENT_DLL
virtual const char *GetTrailParticleName( void )
{
return GetTeamNumber() == TF_TEAM_BLUE ? "spell_fireball_small_blue" : "spell_fireball_small_red";
}
#endif
private:
bool m_bIsMeteor;
#ifdef GAME_DLL
const char *m_pszExplodeParticleName;
#endif // GAME_DLL
};
// Fireball
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellFireball, DT_TFProjectile_SpellFireball )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellFireball, DT_TFProjectile_SpellFireball )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellfireball, CTFProjectile_SpellFireball );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellfireball);
// *************************************************************************************************************************
class CTFProjectile_SpellBats : public CTFProjectile_Jar
{
public:
DECLARE_CLASS( CTFProjectile_SpellBats, CTFProjectile_Jar );
DECLARE_NETWORKCLASS();
virtual int GetWeaponID( void ) const { return TF_WEAPON_SPELLBOOK_PROJECTILE; }
virtual float GetDamageRadius() const { return 250.0f; }
virtual float GetModelScale() const { return 0.01f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_BATS; }
virtual bool IsDeflectable() OVERRIDE { return false; }
#ifdef GAME_DLL
virtual void Spawn( void )
{
SetModelScale( GetModelScale() );
BaseClass::Spawn();
}
//-----------------------------------------------------------------------------
// Lightning Ball / Base
//-----------------------------------------------------------------------------
virtual void Explode( trace_t *pTrace, int bitsDamageType ) OVERRIDE
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit.
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + ( pTrace->plane.normal * 1.0f ) );
}
CTFPlayer *pThrower = ToTFPlayer( GetThrower() );
if ( pThrower )
{
const Vector& vecOrigin = GetAbsOrigin();
// Any effects from the initial explosion
if ( InitialExplodeEffects( pThrower, pTrace ) )
{
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
}
// Sounds
if ( GetExplodeEffectSound() )
{
EmitSound( GetExplodeEffectSound() );
}
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pThrower, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, vecOrigin, GetDamageRadius(), FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CBaseCombatCharacter *pBasePlayer = NULL;
CTFPlayer *pPlayer = ToTFPlayer( pListOfEntities[i] );
if ( !pPlayer )
{
pBasePlayer = dynamic_cast<CBaseCombatCharacter*>( pListOfEntities[i] );
}
else
{
pBasePlayer = pPlayer;
}
if ( !pBasePlayer || !pBasePlayer->IsAlive() )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( GetAbsOrigin(), pBasePlayer->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
if ( trace.DidHitWorld() )
continue;
// Effects on the individual players
ExplodeEffectOnTarget( pThrower, pPlayer, pBasePlayer );
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MERASMUS_ZAP, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
ApplyBlastDamage( pThrower, vecOrigin );
}
else
{
pThrower->EmitSound( "Player.DenyWeaponSelection" );
}
}
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
SetTouch( NULL );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
}
virtual void ApplyBlastDamage( CTFPlayer *pThrower, Vector vecOrigin )
{
CTakeDamageInfo info;
info.SetAttacker( pThrower );
info.SetInflictor( this );
info.SetWeapon( GetLauncher() );
info.SetDamage( 10.f );
info.SetDamageCustom( GetCustomDamageType() );
info.SetDamagePosition( vecOrigin );
info.SetDamageType( DMG_BLAST );
CTFRadiusDamageInfo radiusinfo( &info, vecOrigin, GetDamageRadius(), pThrower );
TFGameRules()->RadiusDamage( radiusinfo );
}
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace )
{
// Added Particle
Vector vecOrigin = GetAbsOrigin();
// Particle
CPVSFilter filter( vecOrigin );
TE_TFExplosion( filter, 0.0f, vecOrigin, pTrace->plane.normal, TF_WEAPON_GRENADE_PIPEBOMB, kInvalidEHandleExplosion, -1, SPECIAL1, INVALID_STRING_INDEX );
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget )
{
if ( pBaseTarget->GetTeamNumber() == GetTeamNumber() )
return;
if ( pTarget )
{
if ( pTarget->m_Shared.IsInvulnerable() )
return;
if ( pTarget->m_Shared.InCond( TF_COND_PHASE ) || pTarget->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return;
// Stun the target
pTarget->m_Shared.StunPlayer( 0.5, 0.5, TF_STUN_MOVEMENT, pThrower );
}
Vector vecDir = pBaseTarget->WorldSpaceCenter() - GetAbsOrigin();
VectorNormalize( vecDir );
if ( pTarget )
{
pTarget->ApplyAirBlastImpulse( vecDir * 200.0f + Vector(0, 0, 800 ) );
const char* pszEffectName = GetTeamNumber() == TF_TEAM_RED ? "spell_batball_red" : "spell_batball_blue";
DispatchParticleEffect( pszEffectName, PATTACH_ABSORIGIN_FOLLOW, pTarget );
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pTarget->m_Shared.MakeBleed( pThrower, pSpellBook, 3.0f );
}
}
else
{
pBaseTarget->ApplyAbsVelocityImpulse( vecDir * 1000.0f );
}
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
trace_t *pNewTrace = const_cast<trace_t*>( pTrace );
CBaseEntity *pInflictor = GetLauncher();
CTakeDamageInfo info;
info.SetAttacker( pThrower );
info.SetInflictor( this );
info.SetWeapon( pInflictor );
info.SetDamage( 40 );
info.SetDamageCustom( GetCustomDamageType() );
info.SetDamagePosition( GetAbsOrigin() );
info.SetDamageType( DMG_BURN );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pBaseTarget->DispatchTraceAttack( info, dir, pNewTrace );
ApplyMultiDamage();
}
virtual const char *GetExplodeEffectParticle() const { return GetTeamNumber() == TF_TEAM_RED ? "spell_batball_impact_red" : "spell_batball_impact_blue"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_bat_impact"; }
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return GetTeamNumber() == TF_TEAM_RED ? "spell_batball_throw_red" : "spell_batball_throw_blue"; }
#endif
};
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellBats, DT_TFProjectile_SpellBats )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellBats, DT_TFProjectile_SpellBats )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellbats, CTFProjectile_SpellBats );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellbats );
// *************************************************************************************************************************
class CTFProjectile_SpellSpawnZombie : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellSpawnZombie, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
CTFProjectile_SpellSpawnZombie()
{
#ifdef GAME_DLL
m_skeletonType = 0;
#endif // GAME_DLL
}
virtual float GetDamageRadius() const { return 1.0f; }
virtual void SetCustomPipebombModel() { SetModel( "models/props_mvm/mvm_human_skull_collide.mdl" ); }
virtual float GetModelScale() const { return 1.0f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_SKELETON; }
#ifdef GAME_DLL
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) { }
virtual void PipebombTouch( CBaseEntity *pOther ) { }
virtual void Explode( trace_t *pTrace, int bitsDamageType ) OVERRIDE
{
// no owner? spawn skeletons anyways
if ( !GetThrower() )
{
InitialExplodeEffects( NULL, pTrace );
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( GetAbsOrigin() );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), GetAbsOrigin(), vec3_angle );
}
// Sounds
if ( GetExplodeEffectSound() )
{
EmitSound( GetExplodeEffectSound() );
}
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
SetTouch( NULL );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
return;
}
BaseClass::Explode( pTrace, bitsDamageType );
}
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
// Pull in a little
Vector vSpawnPoint = ( pTrace->endpos + ( pTrace->plane.normal * 2.0f ) );
CZombie::SpawnAtPos( vSpawnPoint, 30.0f, GetTeamNumber(), pThrower, (CZombie::SkeletonType_t)m_skeletonType );
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) { }
virtual const char *GetExplodeEffectParticle() const
{
if ( GetTeamNumber() == TF_TEAM_HALLOWEEN )
{
return "spell_skeleton_goop_green";
}
return GetTeamNumber() == TF_TEAM_RED ? "spell_pumpkin_mirv_goop_red" : "spell_pumpkin_mirv_goop_blue";
}
virtual const char *GetExplodeEffectSound() const { return "Cleaver.ImpactFlesh"; }
void SetSkeletonType ( int iType ) { m_skeletonType = iType; }
int m_skeletonType;
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return "unusual_bubbles_green_fumes"; }
#endif
};
// Spawn Zombie
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellSpawnZombie, DT_TFProjectile_SpellSpawnZombie )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellSpawnZombie, DT_TFProjectile_SpellSpawnZombie )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellspawnzombie, CTFProjectile_SpellSpawnZombie );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellspawnzombie );
#ifdef GAME_DLL
CBaseEntity* CreateSpellSpawnZombie( CBaseCombatCharacter *pCaster, const Vector& vSpawnPosition, int nSkeletonType )
{
Vector offset = RandomVector( -32, 32 );
offset.z = 16;
CTFProjectile_SpellSpawnZombie *pGrenade = static_cast<CTFProjectile_SpellSpawnZombie*>( CBaseEntity::CreateNoSpawn( "tf_projectile_spellspawnzombie", vSpawnPosition + offset, RandomAngle( 0, 360 ), pCaster ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
Vector vecImpulse = RandomVector( -1, 1 );
VectorNormalize( vecImpulse );
vecImpulse.z = RandomFloat( 1.0f, 1.6f );
Vector vecVelocity = vecImpulse * RandomFloat( 250.0f, 300.0f );
AngularImpulse angVelocity = AngularImpulse( 300, 300, 100 );
pGrenade->InitGrenade( vecVelocity, angVelocity, pCaster, 0, 0 );
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
pGrenade->SetDetonateTimerLength( RandomFloat( 2.f, 2.5f ) );
pGrenade->SetSkeletonType( nSkeletonType );
}
return pGrenade;
}
#endif
// *************************************************************************************************************************
class CTFProjectile_SpellSpawnHorde : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellSpawnHorde, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
virtual float GetDamageRadius() const { return 1.0f; }
virtual void SetCustomPipebombModel() { SetModel( "models/props_mvm/mvm_human_skull_collide.mdl" ); }
virtual float GetModelScale() const { return 1.0f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_SKELETON; }
#ifdef GAME_DLL
//virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) { }
//virtual void PipebombTouch( CBaseEntity *pOther ) { }
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
// Spawn a tonne of extra skelatone grenades (mirv style)
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( !pSpellBook )
return false;
for ( int i = 0; i < 3; i++ )
{
Vector offset = RandomVector( -32, 32 );
offset.z = 16;
CreateSpellSpawnZombie( pThrower, GetAbsOrigin(), 0 );
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_SKELETON_HORDE, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) { }
virtual const char *GetExplodeEffectParticle() const { return GetTeamNumber() == TF_TEAM_RED ? "spell_pumpkin_mirv_goop_red" : "spell_pumpkin_mirv_goop_blue"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_skeleton_horde_rise"; }
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return "unusual_bubbles_green_fumes"; }
#endif
};
// Spawn Horde of Skels
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellSpawnHorde, DT_TFProjectile_SpellSpawnHorde )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellSpawnHorde, DT_TFProjectile_SpellSpawnHorde )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellspawnhorde, CTFProjectile_SpellSpawnHorde );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellspawnhorde);
// *************************************************************************************************************************
class CTFProjectile_SpellPumpkin : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellPumpkin, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
CTFProjectile_SpellPumpkin ()
{
#ifdef GAME_DLL
m_flImpactTime = gpGlobals->curtime + 1.0f;
#endif
}
virtual float GetDamageRadius() const { return 1.0f; }
virtual void SetCustomPipebombModel() { SetModel( "models/weapons/w_models/w_cannonball.mdl" ); }
virtual float GetModelScale() const { return 0.75f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_MIRV; }
#ifdef GAME_DLL
// ignore collisions early in its lifetime
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
if ( gpGlobals->curtime < m_flImpactTime )
return;
BaseClass::VPhysicsCollision( index, pEvent );
}
virtual void PipebombTouch( CBaseEntity *pOther )
{
if ( gpGlobals->curtime < m_flImpactTime )
return;
BaseClass::PipebombTouch( pOther );
}
virtual void ApplyBlastDamage ( CTFPlayer *pThrower, Vector vecOrigin ) { }
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
// Spawn a pumkin bomb here
// Set the angles to what I want
QAngle angle(0, RandomFloat( 0, 360 ) ,0);
CTFPumpkinBomb *pGrenade = static_cast<CTFPumpkinBomb*>( CBaseEntity::CreateNoSpawn( "tf_pumpkin_bomb", GetAbsOrigin(), angle, NULL ) );
if ( pGrenade )
{
pGrenade->SetInitParams( 0.60, 80.0f, 200.0f, GetTeamNumber(), 40.0f + RandomFloat(0 , 1.0f) );
DispatchSpawn( pGrenade );
pGrenade->SetSpell( true );
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MIRV, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) { }
virtual const char *GetExplodeEffectParticle() const { return GetTeamNumber() == TF_TEAM_RED ? "spell_pumpkin_mirv_goop_red" : "spell_pumpkin_mirv_goop_blue"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_mirv_explode_secondary"; }
float m_flImpactTime;
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return "unusual_bubbles_green_fumes"; }
#endif
};
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellPumpkin, DT_TFProjectile_SpellPumpkin )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellPumpkin, DT_TFProjectile_SpellPumpkin)
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellpumpkin, CTFProjectile_SpellPumpkin );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellpumpkin);
// *************************************************************************************************************************
class CTFProjectile_SpellMirv : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellMirv, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
virtual float GetDamageRadius() const { return 1.0f; }
virtual void SetCustomPipebombModel() { SetModel( "models/weapons/w_models/w_cannonball.mdl" ); }
virtual float GetModelScale() const { return 0.9f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_MIRV; }
#ifdef GAME_DLL
//virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) { }
//virtual void PipebombTouch( CBaseEntity *pOther ) { }
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
// Spawn a tonne of extra grenades (mirv style)
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( !pSpellBook )
return false;
// Create bomblets
Vector offset = Vector( 0, -100, 400 );
for ( int i = 0; i < 6; i++ )
{
AngularImpulse angVelocity = AngularImpulse( 0, 0, RandomFloat( 100, 300) );
switch ( i )
{
case 0: offset = Vector( 75, 110, 400 ); break;
case 1: offset = Vector( 75, -110, 400 ); break;
case 2: offset = Vector( -75, 110, 400 ); break;
case 3: offset = Vector( -75, -110, 400 ); break;
case 4: offset = Vector( 135, 0, 400 ); break;
case 5: offset = Vector( -135, 0, 400 ); break;
}
CTFProjectile_SpellPumpkin *pGrenade = static_cast<CTFProjectile_SpellPumpkin*>( CBaseEntity::CreateNoSpawn( "tf_projectile_spellpumpkin", GetAbsOrigin(), pThrower->EyeAngles(), pThrower ) );
if ( pGrenade )
{
// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
pGrenade->SetPipebombMode();
DispatchSpawn( pGrenade );
pGrenade->InitGrenade( offset, angVelocity, pThrower, pSpellBook->GetTFWpnData() );
pGrenade->m_flFullDamage = 0;
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
pGrenade->SetDetonateTimerLength( 2.0f + 0.05f * i );
}
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MIRV, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) { }
virtual const char *GetExplodeEffectParticle() const { return GetTeamNumber() == TF_TEAM_RED ? "spell_pumpkin_mirv_goop_red" : "spell_pumpkin_mirv_goop_blue"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_mirv_explode_primary"; }
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return "unusual_bubbles_green_fumes"; }
#endif
};
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellMirv, DT_TFProjectile_SpellMirv )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellMirv, DT_TFProjectile_SpellMirv)
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellmirv, CTFProjectile_SpellMirv );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellmirv);
// *************************************************************************************************************************
class CTFProjectile_SpellSpawnBoss : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellSpawnBoss, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
virtual float GetDamageRadius() const { return 1.0f; }
virtual void SetCustomPipebombModel() { SetModel( "models/props_mvm/mvm_human_skull_collide.mdl" ); }
virtual float GetModelScale() const { return 1.5f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_MONOCULUS; }
#ifdef GAME_DLL
//virtual void Explode( trace_t *pTrace, int bitsDamageType );
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
const Vector &vContactPoint = pTrace->endpos;
CHalloweenBaseBoss *pBoss = CHalloweenBaseBoss::SpawnBossAtPos( HALLOWEEN_BOSS_MONOCULUS, vContactPoint, pThrower->GetTeamNumber(), pThrower );
if ( pBoss )
{
float flDesiredHeight = tf_eyeball_boss_hover_height.GetFloat();
const Vector &vMins = pBoss->WorldAlignMins();
const Vector &vMaxs = pBoss->WorldAlignMaxs();
Vector vSize = vMaxs - vMins;
float flBossHeight = vSize.z;
float flBossHalfX = 0.5f * vSize.x;
float flBossHalfY = 0.5f * vSize.y;
static Vector vTest[] =
{
Vector( 0, 0, flBossHeight ),
Vector( flBossHalfX, flBossHalfY, flBossHeight ),
Vector( -flBossHalfX, -flBossHalfY, flBossHeight ),
Vector( flBossHalfX, -flBossHalfY, flBossHeight ),
Vector( -flBossHalfX, flBossHalfY, flBossHeight )
};
bool bFoundValidSpawnPos = false;
for ( int i=0; i<ARRAYSIZE( vTest ); ++i )
{
trace_t result;
float bloat = 5.0f;
Vector vStart = vContactPoint + vTest[i] + 30.f * pTrace->plane.normal;
Vector vEnd = vStart + Vector( 0, 0, flDesiredHeight );
CTraceFilterNoNPCsOrPlayer filter( pBoss, COLLISION_GROUP_NONE );
UTIL_TraceHull( vStart, vEnd, vMins - Vector( bloat, bloat, 0 ), vMaxs + Vector( bloat, bloat, bloat ), MASK_SOLID | CONTENTS_PLAYERCLIP, &filter, &result );
if ( !result.startsolid )
{
pBoss->SetAbsOrigin( result.endpos );
bFoundValidSpawnPos = true;
//NDebugOverlay::SweptBox( vStart, vEnd, vMins - Vector( bloat, bloat, 0 ), vMaxs + Vector( bloat, bloat, bloat ), vec3_angle, 0, 255, 0, 0, 5.f );
//NDebugOverlay::Sphere( result.endpos, 10.f, 0, 255, 0, true, 5.f );
break;
}
else
{
// Maybe we should play fail sound here?
//NDebugOverlay::SweptBox( vStart, vEnd, vMins - Vector( bloat, bloat, 0 ), vMaxs + Vector( bloat, bloat, bloat ), vec3_angle, 255, 0, 0, 0, 5.f );
//NDebugOverlay::Sphere( result.endpos, 10.f, 255, 0, 0, true, 5.f );
}
}
// couldn't find any valid position
if ( !bFoundValidSpawnPos )
{
UTIL_Remove( pBoss );
pBoss = NULL;
}
}
// refund the player the spell
if ( !pBoss )
{
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pSpellBook->SetSelectedSpell( GetSpellIndexFromContext( MP_CONCEPT_PLAYER_SPELL_MONOCULOUS ) );
}
return false;
}
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MONOCULOUS, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
return true;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) { }
virtual const char *GetExplodeEffectParticle() const { return "eyeboss_death"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_spawn_boss"; }
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return "unusual_bubbles_green_fumes"; }
#endif
};
// Spawn Boss
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellSpawnBoss, DT_TFProjectile_SpellSpawnBoss )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellSpawnBoss, DT_TFProjectile_SpellSpawnBoss )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellspawnboss, CTFProjectile_SpellSpawnBoss );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellspawnboss );
// *************************************************************************************************************************
#ifdef GAME_DLL
class CTFSpell_MeteorShowerSpawner : public CBaseEntity
{
public:
DECLARE_DATADESC();
DECLARE_CLASS( CTFSpell_MeteorShowerSpawner, CBaseEntity );
virtual void Spawn() OVERRIDE
{
m_flFinishTime = gpGlobals->curtime + 4.f;
SetContextThink( &CTFSpell_MeteorShowerSpawner::MeteorShowerThink, gpGlobals->curtime, "MeteorShowerThink" );
}
void MeteorShowerThink( void )
{
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
if ( pPlayer && m_flFinishTime > gpGlobals->curtime )
{
// the owner changed team? remove this
if ( pPlayer->GetTeamNumber() != GetTeamNumber() )
{
UTIL_Remove( this );
return;
}
// Determine our "height" offset range based on surface normal
Vector vecDir = Vector( 0.f, 0.f, 1.f );
float flOffsetMin = 400.f;
float flOffsetMax = 500.f;
if ( m_vecImpactNormal.z <= -0.6f ) // Ceiling?
{
flOffsetMin = 45.f;
flOffsetMax = 60.f;
vecDir.z = -1.f;
}
const float flRange = 200.f;
const float flRandomAngleOffset = 75.f;
const int nNumToSpawn = random->RandomInt( 1, 2 );
for ( int i = 0; i < nNumToSpawn; ++i )
{
// Vary start point away from surface center
Vector vecOnPlane = Vector( RandomFloat( -flRange, flRange ), RandomFloat( -flRange, flRange ), 0.f ).Normalized();
Vector vecPointOnPlane = GetAbsOrigin() + random->RandomFloat( -flRange, flRange ) * vecOnPlane;
const float flOffsetFromPlane = random->RandomFloat( flOffsetMin, flOffsetMax );
Vector vecEmit = vecPointOnPlane + flOffsetFromPlane * vecDir;
// debugoverlay->AddLineOverlay( GetAbsOrigin(), vecEmit, 255, 0, 0, false, 10 );
Vector vecVelocity = Vector( RandomFloat( -flRandomAngleOffset, flRandomAngleOffset ), RandomFloat( -flRandomAngleOffset, flRandomAngleOffset ), -700.f );
// Check for a spot
trace_t trace;
UTIL_TraceLine( GetAbsOrigin(), vecEmit, ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), NULL, COLLISION_GROUP_NONE, &trace );
if ( !trace.DidHit() )
{
SpawnMeteor( pPlayer, trace.endpos, vec3_angle, vecVelocity );
}
else
{
// Pull back and try again
vecEmit = trace.endpos + ( trace.plane.normal * 1.0f );
SpawnMeteor( pPlayer, vecEmit, vec3_angle, vecVelocity );
}
}
SetContextThink( &CTFSpell_MeteorShowerSpawner::MeteorShowerThink, gpGlobals->curtime + 0.2f, "MeteorShowerThink" );
return;
}
UTIL_Remove( this );
}
void SpawnMeteor( CTFPlayer *pOwner, const Vector &origin, const QAngle &angles, const Vector &velocity )
{
CTFProjectile_SpellFireball *pRocket = static_cast< CTFProjectile_SpellFireball* >( CBaseEntity::CreateNoSpawn( "tf_projectile_spellfireball", origin, angles, pOwner ) );
if ( pRocket )
{
pRocket->SetOwnerEntity( pOwner );
pRocket->SetLauncher( pOwner );
pRocket->SetAbsVelocity( velocity );
pRocket->SetDamage( 50.f );
pRocket->SetMeteor( true );
pRocket->ChangeTeam( GetTeamNumber() );
const char *pszParticle = GetTeamNumber() == TF_TEAM_BLUE ? "spell_fireball_tendril_parent_blue" : "spell_fireball_tendril_parent_red";
pRocket->SetExplodeParticleName( pszParticle );
IPhysicsObject *pPhysicsObject = pRocket->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->AddVelocity( &velocity, NULL );
}
DispatchSpawn( pRocket );
}
}
void SetImpaceNormal( Vector &vecNormal ) { m_vecImpactNormal = vecNormal; }
private:
float m_flFinishTime;
Vector m_vecImpactNormal;
};
// Meteor Shower
LINK_ENTITY_TO_CLASS( tf_spell_meteorshowerspawner, CTFSpell_MeteorShowerSpawner );
BEGIN_DATADESC( CTFSpell_MeteorShowerSpawner )
END_DATADESC()
#endif // GAME_DLL
// *************************************************************************************************************************
class CTFProjectile_SpellMeteorShower : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellMeteorShower, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
virtual float GetModelScale() const { return 0.01f; }
#ifdef GAME_DLL
virtual void Explode( trace_t *pTrace, int bitsDamageType ) OVERRIDE
{
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit.
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + ( pTrace->plane.normal * 1.0f ) );
}
Vector vecOrigin = GetAbsOrigin();
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
}
// Sounds
if ( GetExplodeEffectSound() )
{
EmitSound( GetExplodeEffectSound() );
}
CTFSpell_MeteorShowerSpawner *pSpawner = static_cast< CTFSpell_MeteorShowerSpawner* >( CBaseEntity::CreateNoSpawn( "tf_spell_meteorshowerspawner", vecOrigin, vec3_angle, GetThrower() ) );
if ( pSpawner )
{
pSpawner->SetImpaceNormal( pTrace->plane.normal );
pSpawner->ChangeTeam( GetTeamNumber() );
DispatchSpawn( pSpawner );
}
if ( TFGameRules() )
{
CTFPlayer *pThrower = ToTFPlayer( GetOwnerEntity() );
if ( pThrower )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_METEOR_SWARM, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
}
SetModelName( NULL_STRING );
AddSolidFlags( FSOLID_NOT_SOLID );
SetTouch( NULL );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
}
virtual const char *GetExplodeEffectParticle() const { return "bomibomicon_ring"; }
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_meteor_impact"; }
#endif // GAME_DLL
#ifdef CLIENT_DLL
virtual const char *GetTrailParticleName( void )
{
return GetTeamNumber() == TF_TEAM_BLUE ? "spell_fireball_small_blue" : "spell_fireball_small_red";
}
#endif
};
// Meteor Shower
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellMeteorShower, DT_TFProjectile_SpellMeteorShower )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellMeteorShower, DT_TFProjectile_SpellMeteorShower)
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellmeteorshower, CTFProjectile_SpellMeteorShower );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellmeteorshower );
// *************************************************************************************************************************
class CTFProjectile_SpellTransposeTeleport : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellTransposeTeleport, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
virtual void Spawn( void )
{
SetModelScale( 0.01f );
BaseClass::Spawn();
SetCollisionGroup( COLLISION_GROUP_PLAYER_MOVEMENT );
#ifdef GAME_DLL
SetContextThink( &CTFProjectile_SpellTransposeTeleport::RecordPosThink, gpGlobals->curtime + 0.05f, "RecordThink" );
#endif
}
// FIX
virtual int GetWeaponID( void ) const { return TF_PROJECTILE_SPELL; }
virtual float GetDamageRadius() const { return 5.0f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_TELEPORT; }
virtual unsigned int PhysicsSolidMaskForEntity( void ) const
{
return BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_PLAYERCLIP;
}
#ifdef GAME_DLL
void RecordPosThink( void )
{
m_vecTrailingPos.AddToTail( GetAbsOrigin() );
// Only retain 5 positions
if ( m_vecTrailingPos.Count() > 5 )
{
m_vecTrailingPos.Remove( 0 );
}
SetContextThink( &CTFProjectile_SpellTransposeTeleport::RecordPosThink, gpGlobals->curtime + 0.05f, "RecordThink" );
}
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
if ( !pThrower->IsAlive() )
return false;
// Grant a small amount of health
pThrower->TakeHealth( 30, DMG_GENERIC );
trace_t result;
CTraceFilterIgnoreTeammates traceFilter( this, COLLISION_GROUP_PLAYER_MOVEMENT, GetTeamNumber() );
unsigned int nMask = pThrower->GetTeamNumber() == TF_TEAM_RED ? CONTENTS_BLUETEAM : CONTENTS_REDTEAM;
nMask |= MASK_PLAYERSOLID;
m_vecTrailingPos.AddToTail( pTrace->endpos + ( pTrace->plane.normal * 50.f ) );
// Try a few spots
FOR_EACH_VEC_BACK( m_vecTrailingPos, i )
{
// Try positions starting with the current, and moving back in time a bit
Vector vecStart = m_vecTrailingPos[i];
UTIL_TraceHull( vecStart, vecStart, VEC_HULL_MIN, VEC_HULL_MAX, nMask, &traceFilter, &result );
if( !result.DidHit() )
{
// Place a teleport effect where they came from
const Vector& vecOrigin = pThrower->GetAbsOrigin();
CPVSFilter pvsFilter( vecOrigin );
TE_TFParticleEffect( pvsFilter, 0.0, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
// Move 'em!
pThrower->Teleport( &vecStart, &pThrower->GetAbsAngles(), NULL );
// Do a zoom effect
pThrower->SetFOV( pThrower, 0, 0.3f, 120 );
// Screen flash
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pThrower, fadeColor, 0.25, 0.4, FFADE_IN );
if ( TFGameRules() )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_TELEPORT, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
// Success!
return true;
}
}
return false;
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget )
{
// ...
}
virtual const char *GetExplodeEffectParticle() const { return "eyeboss_tp_player"; }
virtual const char *GetExplodeEffectSound() const { return "Building_Teleporter.Ready"; }
#endif
#ifdef CLIENT_DLL
virtual const char* GetTrailParticleName( void ) { return GetTeamNumber() == TF_TEAM_RED ? "spell_teleport_red" : "spell_teleport_blue"; }
#endif
private:
#ifdef GAME_DLL
CUtlVector< Vector > m_vecTrailingPos;
#endif
};
// Spawn Boss
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellTransposeTeleport, SpellTransposeTeleport )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellTransposeTeleport, SpellTransposeTeleport )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spelltransposeteleport, CTFProjectile_SpellTransposeTeleport );
PRECACHE_WEAPON_REGISTER( tf_projectile_spelltransposeteleport );
#ifdef GAME_DLL
void RemoveAll2013HalloweenTeleportSpellsInMidFlight( void )
{
CBaseEntity *pTeleport = NULL;
while ( ( pTeleport = gEntList.FindEntityByClassname( pTeleport, "tf_projectile_spelltransposeteleport" ) ) != NULL )
{
UTIL_Remove( pTeleport );
}
}
#endif
// *************************************************************************************************************************
class CTFProjectile_SpellLightningOrb : public CTFProjectile_SpellFireball
{
public:
DECLARE_CLASS( CTFProjectile_SpellLightningOrb, CTFProjectile_SpellFireball );
DECLARE_NETWORKCLASS();
~CTFProjectile_SpellLightningOrb()
{
#ifdef CLIENT_DLL
if ( m_pTrailParticle )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_pTrailParticle );
m_pTrailParticle = NULL;
}
#endif // CLIENT_DLL
}
#ifdef GAME_DLL
virtual void Spawn() OVERRIDE
{
BaseClass::Spawn();
// We dont want to collide with anything but the world
SetSolid( SOLID_NONE );
SetExplodeParticleName( GetTeamNumber() == TF_TEAM_BLUE ? "drg_cow_explosioncore_charged_blue" : "drg_cow_explosioncore_charged" );
SetContextThink( &CTFProjectile_SpellLightningOrb::ZapThink, gpGlobals->curtime + 0.25f, "ZapThink" );
SetContextThink( &CTFProjectile_SpellLightningOrb::VortexThink, gpGlobals->curtime + 0.2f, "VortexThink" );
SetContextThink( &CTFProjectile_SpellLightningOrb::ExplodeAndRemove, gpGlobals->curtime + 5.f, "ExplodeAndRemoveThink" );
SetDamage( 20.f );
}
virtual const char *GetProjectileModelName( void ) { return ""; } // We dont have a model by default, and that's OK
virtual float GetDamageRadius() const { return 200.f; }
virtual int GetCustomDamageType() const OVERRIDE { return TF_DMG_CUSTOM_SPELL_LIGHTNING; }
virtual void RocketTouch( CBaseEntity *pOther ) OVERRIDE
{
Assert( pOther );
if ( !pOther )
return;
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
return;
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
// Bounce off the world
if ( pOther->IsWorld() )
{
Vector vIntoSurface = pTrace->plane.normal * pTrace->plane.normal.Dot( GetAbsVelocity() );
SetAbsVelocity( GetAbsVelocity() + ( -1.5f * vIntoSurface ) );
return;
}
// Handle hitting skybox (disappear).
if ( pTrace->surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// pass through ladders
if( pTrace->surface.flags & CONTENTS_LADDER )
return;
if ( pOther->IsPlayer() )
return;
// Spell ends when we run into something
ExplodeAndRemove();
return;
}
virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
{
Zap( 16 );
return true;
}
virtual const char *GetExplodeEffectSound() const { return "Halloween.spell_lightning_impact"; }
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget ) OVERRIDE
{}
void ExplodeAndRemove()
{
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( GetAbsOrigin() );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), GetAbsOrigin(), vec3_angle );
EmitSound( filter, entindex(), GetExplodeEffectSound() );
}
// Go out with a bang
Zap( 16 );
SetContextThink( &CBaseGrenade::SUB_Remove, gpGlobals->curtime, "RemoveThink" );
return;
}
void ZapThink()
{
Zap( 2 );
SetContextThink( &CTFProjectile_SpellLightningOrb::ZapThink, gpGlobals->curtime + RandomFloat( 0.25f, 0.35f ), "ZapThink" );
}
void Zap( int nNumToZap )
{
CBaseEntity *pOwner = GetOwnerEntity();
if ( !pOwner )
return;
CTakeDamageInfo info;
info.SetAttacker( pOwner );
info.SetInflictor( this );
info.SetWeapon( GetLauncher() );
info.SetDamage( GetDamage() );
info.SetDamageCustom( GetCustomDamageType() );
info.SetDamagePosition( GetAbsOrigin() );
info.SetDamageType( DMG_BURN );
CBaseEntity *pListOfEntities[5];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 5, GetAbsOrigin(), GetDamageRadius(), FL_CLIENT | FL_FAKECLIENT | FL_NPC );
// Shuffle the list
for( int i = iEntities - 1; i > 0; --i )
{
V_swap( pListOfEntities[i], pListOfEntities[ RandomInt( 0, i ) ] );
}
// Zap as many targets as we're told to, if we can
int nHits = 0;
for ( int i = 0; i < iEntities && nHits < nNumToZap; ++i )
{
CBaseEntity* pTarget = pListOfEntities[i];
if ( !pTarget )
continue;
if ( !pTarget->IsAlive() )
continue;
if ( pOwner->InSameTeam( pTarget ) )
continue;
if ( !FVisible( pTarget, MASK_OPAQUE ) )
continue;
CTFPlayer *pTFPlayer = ToTFPlayer( pTarget );
if ( pTFPlayer )
{
if ( pTFPlayer->m_Shared.InCond( TF_COND_PHASE ) || pTFPlayer->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
continue;
if ( pTFPlayer->m_Shared.IsInvulnerable() )
continue;
}
CTraceFilterIgnoreTeammates tracefilter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
trace_t trace;
UTIL_TraceLine( GetAbsOrigin(), pTarget->GetAbsOrigin(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &tracefilter, &trace );
if ( trace.DidHitWorld() )
continue;
// Shoot a beam at them
CPVSFilter filter( pTarget->WorldSpaceCenter() );
Vector vStart = WorldSpaceCenter();
Vector vEnd = pTarget->EyePosition();
const char *pszHitEffect = GetTeamNumber() == TF_TEAM_BLUE ? "spell_lightningball_hit_blue" : "spell_lightningball_hit_red";
te_tf_particle_effects_control_point_t controlPoint = { PATTACH_ABSORIGIN, vEnd };
TE_TFParticleEffectComplex( filter, 0.0f, pszHitEffect, vStart, QAngle( 0, 0, 0 ), NULL, &controlPoint, pTFPlayer, PATTACH_CUSTOMORIGIN );
// Hurt 'em.
Vector dir;
AngleVectors( GetAbsAngles(), &dir );
pTarget->DispatchTraceAttack( info, dir, &trace );
ApplyMultiDamage();
++nHits;
}
// We zapped someone. Play a sound
if ( nHits > 0 )
{
pOwner->EmitSound( "TFPlayer.MedicChargedDeath" );
if ( TFGameRules() )
{
CTFPlayer *pThrower = ToTFPlayer( GetOwnerEntity() );
if ( pThrower )
{
TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_LIGHTNING_BALL, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
}
}
}
}
void VortexThink( void )
{
const int nMaxEnts = 32;
Vector vecPos = GetAbsOrigin();
CBaseEntity *pObjects[ nMaxEnts ];
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, vecPos, GetDamageRadius(), FL_CLIENT | FL_NPC );
// NDebugOverlay::Sphere( vecPos, GetDamageRadius(), 0, 255, 0, false, 0.35f );
// Iterate through sphere's contents
for ( int i = 0; i < nCount; i++ )
{
CBaseCombatCharacter *pEntity = pObjects[i]->MyCombatCharacterPointer();
if ( !pEntity )
continue;
if ( InSameTeam( pEntity ) )
continue;
if ( !FVisible( pEntity, MASK_OPAQUE ) )
continue;
// Draw player toward us
Vector vecSourcePos = pEntity->GetAbsOrigin();
Vector vecTargetPos = GetAbsOrigin();
Vector vecVelocity = ( vecTargetPos - vecSourcePos ) * 2.f;
vecVelocity.z += 50.f;
if ( pEntity->GetFlags() & FL_ONGROUND )
{
vecVelocity.z += 150.f;
pEntity->SetGroundEntity( NULL );
pEntity->SetGroundChangeTime( gpGlobals->curtime + 0.5f );
}
pEntity->Teleport( NULL, NULL, &vecVelocity );
}
SetContextThink( &CTFProjectile_SpellLightningOrb::VortexThink, gpGlobals->curtime + 0.2f, "VortexThink" );
return;
}
#endif
#ifdef CLIENT_DLL
virtual const char *GetTrailParticleName( void ) { return NULL; } // CRUTGUN!
virtual void CreateTrails( void )
{
BaseClass::CreateTrails();
if ( !m_pTrailParticle )
{
m_pTrailParticle = ParticleProp()->Create( ( GetTeamNumber() == TF_TEAM_BLUE ? "spell_lightningball_parent_blue" : "spell_lightningball_parent_red" ), PATTACH_ABSORIGIN_FOLLOW );
}
}
private:
CNewParticleEffect *m_pTrailParticle;
#endif // CLIENT_DLL
};
// Lightning ball
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellLightningOrb, DT_TFProjectile_SpellLightningOrb )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellLightningOrb, DT_TFProjectile_SpellLightningOrb )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_lightningorb, CTFProjectile_SpellLightningOrb );
PRECACHE_WEAPON_REGISTER( tf_projectile_lightningorb);
#ifdef CLIENT_DLL
#define CTFHellZap C_TFHellZap
#endif
#ifdef GAME_DLL
#include "tf_obj_dispenser.h"
#include "particle_parse.h"
#include "tf_fx.h"
#endif
class CTFHellZap : public CBaseEntity
{
DECLARE_CLASS( CTFHellZap, CBaseEntity )
DECLARE_NETWORKCLASS();
DECLARE_DATADESC();
public:
CTFHellZap()
#ifdef GAME_DLL
: m_eType( ZAP_ON_TOUCH )
#endif
{}
#ifdef GAME_DLL
enum EZapperType
{
ZAP_ON_TOUCH,
ZAP_ON_TEST,
};
virtual void Spawn()
{
m_bEnabled = true;
if ( m_iszCustomTouchTrigger != NULL_STRING )
{
m_hTouchTrigger = dynamic_cast<CDispenserTouchTrigger *> ( gEntList.FindEntityByName( NULL, m_iszCustomTouchTrigger ) );
if ( m_hTouchTrigger.Get() != NULL )
{
Assert( m_hTouchTrigger->GetOwnerEntity() == NULL );
m_hTouchTrigger->SetOwnerEntity( this ); //owned
}
}
}
void ZapAllTouching()
{
FOR_EACH_VEC_BACK( m_vecZapTargets, i )
{
CBaseEntity* pZapTarget = m_vecZapTargets[i].Get();
// Remove targets that have disappeared
if ( !pZapTarget )
{
m_vecZapTargets.Remove( i );
continue;
}
// Shoot a beam at them
CPVSFilter filter( pZapTarget->WorldSpaceCenter() );
Vector vStart = WorldSpaceCenter();
Vector vEnd = pZapTarget->WorldSpaceCenter();
te_tf_particle_effects_control_point_t controlPoint = { PATTACH_CUSTOMORIGIN, vEnd };
TE_TFParticleEffectComplex( filter, 0.0f, m_iszParticleName.ToCStr(), vStart, QAngle( 0, 0, 0 ), NULL, &controlPoint, this, PATTACH_CUSTOMORIGIN );
}
}
void ZapThink()
{
ZapAllTouching();
// Keep zapping if we have targets
if ( m_vecZapTargets.Count() )
{
SetContextThink( &CTFHellZap::ZapThink, gpGlobals->curtime + 0.25f, "ZapThink" );
}
}
virtual void StartTouch( CBaseEntity *pEntity )
{
m_vecZapTargets.AddToTail( pEntity );
if ( m_eType == ZAP_ON_TOUCH )
{
SetContextThink( &CTFHellZap::ZapThink, gpGlobals->curtime, "ZapThink" );
}
}
virtual void EndTouch( CBaseEntity *pEntity )
{
int nIndex = m_vecZapTargets.Find( pEntity );
if( nIndex != m_vecZapTargets.InvalidIndex() )
{
m_vecZapTargets.Remove( nIndex );
}
// No more targets. Stop thinking!
if ( m_vecZapTargets.Count() == 0 && m_eType == ZAP_ON_TOUCH )
{
SetContextThink( NULL, 0, "ZapThink" );
}
}
void InputEnable( inputdata_t &inputdata )
{
m_bEnabled = true;
if ( m_vecZapTargets.Count() > 0 && m_eType == ZAP_ON_TOUCH )
{
SetContextThink( &CTFHellZap::ZapThink, gpGlobals->curtime, "ZapThink" );
}
}
void InputDisable( inputdata_t &inputdata )
{
m_bEnabled = false;
SetContextThink( NULL, 0, "ZapThink" );
}
void InputZapAllTouching( inputdata_t &inputdata )
{
ZapAllTouching();
}
private:
EZapperType m_eType;
bool m_bEnabled;
EHANDLE m_hTouchTrigger;
string_t m_iszCustomTouchTrigger;
string_t m_iszParticleName;
CUtlVector< EHANDLE > m_vecZapTargets;
#endif
};
BEGIN_DATADESC( CTFHellZap )
#ifdef GAME_DLL
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_VOID, "ZapTouching", InputZapAllTouching ),
DEFINE_KEYFIELD( m_iszCustomTouchTrigger, FIELD_STRING, "touch_trigger" ),
DEFINE_KEYFIELD( m_iszParticleName, FIELD_STRING, "ParticleEffect" ),
DEFINE_KEYFIELD( m_eType, FIELD_INTEGER, "ZapperType" ),
#endif
END_DATADESC()
LINK_ENTITY_TO_CLASS( halloween_zapper, CTFHellZap );
IMPLEMENT_NETWORKCLASS_ALIASED( TFHellZap, DT_TFHellZap )
BEGIN_NETWORK_TABLE( CTFHellZap, DT_TFHellZap )
END_NETWORK_TABLE()
//*******************************************************************************************************************************************************
// Kart Spells
//*******************************************************************************************************************************************************
class CTFProjectile_SpellKartOrb: public CTFProjectile_SpellFireball
{
public:
DECLARE_CLASS( CTFProjectile_SpellKartOrb, CTFProjectile_SpellFireball );
DECLARE_NETWORKCLASS();
#ifdef GAME_DLL
virtual void Spawn() OVERRIDE
{
BaseClass::Spawn();
SetContextThink( &CTFProjectile_SpellKartOrb::ExplodeAndRemove, gpGlobals->curtime + tf_halloween_kart_rocketspell_lifetime.GetFloat(), "ExplodeAndRemoveThink" );
SetContextThink( &CTFProjectile_SpellKartOrb::MoveChecking, gpGlobals->curtime + 0.05f, "MoveCheckingThink" );
SetModel( SPELL_BOXING_GLOVE );
SetModelScale( 2.5f );
Vector mins( -20, -20, 0 );
Vector maxs( 20, 20, 20 );
UTIL_SetSize( this, mins, maxs );
}
virtual void RocketTouch( CBaseEntity *pOther ) OVERRIDE
{
Assert( pOther );
if ( !pOther )
return;
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
return;
// Handle hitting skybox (disappear).
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
if ( pTrace->surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// Bounce off the world
if ( pOther->IsWorld() )
{
Vector vOld = GetAbsVelocity();
//float flSpeed = vOld.Length();
Vector vNew = ( -2.0f * pTrace->plane.normal.Dot( vOld ) * pTrace->plane.normal + vOld );
vNew.NormalizeInPlace();
vNew *= tf_halloween_kart_rocketspell_speed.GetFloat();
SetAbsVelocity( vNew );
return;
}
// pass through ladders
if ( pTrace->surface.flags & CONTENTS_LADDER )
return;
if ( pOther->IsPlayer() )
ExplodeAndRemove();
// Spell ends when we run into something
//ExplodeAndRemove();
return;
}
void MoveChecking ()
{
// do a short trace down, if nothing is there, add a bit of downward velocity
trace_t pTrace;
Vector vecSpot = GetAbsOrigin() ;
UTIL_TraceLine( vecSpot, vecSpot - Vector(0, 0, 32), MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );
if ( pTrace.fraction >= 1.0 )
{
// Start moving down
SetAbsVelocity( GetAbsVelocity() - Vector( 0, 0, 128 ) );
}
SetContextThink( &CTFProjectile_SpellKartOrb::MoveChecking, gpGlobals->curtime + 0.05f, "MoveCheckingThink" );
}
void ExplodeAndRemove()
{
// Handle hitting skybox (disappear).
const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
if ( pTrace->surface.flags & SURF_SKY )
{
UTIL_Remove( this );
return;
}
// pass through ladders
if ( pTrace->surface.flags & CONTENTS_LADDER )
return;
Explode( pTrace );
UTIL_Remove( this );
}
// We dont deal actual damage, just Car damage
virtual void Explode( const trace_t *pTrace )
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit.
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + ( pTrace->plane.normal * 1.0f ) );
}
CTFPlayer *pThrower = ToTFPlayer( GetOwnerEntity() );
if ( pThrower )
{
const Vector &vecOrigin = GetAbsOrigin();
// Any effects from the initial explosion
if ( InitialExplodeEffects( pThrower, pTrace ) )
{
// Particle
if ( GetExplodeEffectParticle() )
{
CPVSFilter filter( vecOrigin );
TE_TFParticleEffect( filter, 0.0, GetExplodeEffectParticle(), vecOrigin, vec3_angle );
}
// Sounds
if ( GetExplodeEffectSound() )
{
EmitSound( GetExplodeEffectSound() );
}
// Treat this trace exactly like radius damage
CTraceFilterIgnorePlayers traceFilter( pThrower, COLLISION_GROUP_PROJECTILE );
// Splash pee on everyone nearby.
CBaseEntity *pListOfEntities[32];
int iEntities = UTIL_EntitiesInSphere( pListOfEntities, 32, vecOrigin, GetDamageRadius(), FL_CLIENT | FL_FAKECLIENT | FL_NPC );
for ( int i = 0; i < iEntities; ++i )
{
CBaseCombatCharacter *pBasePlayer = NULL;
CTFPlayer *pPlayer = ToTFPlayer( pListOfEntities[i] );
if ( !pPlayer )
{
pBasePlayer = dynamic_cast<CBaseCombatCharacter*>( pListOfEntities[i] );
}
else
{
pBasePlayer = pPlayer;
}
if ( !pBasePlayer || !pPlayer || !pPlayer->IsAlive() || InSameTeam(pPlayer) )
continue;
// Do a quick trace to see if there's any geometry in the way.
trace_t trace;
UTIL_TraceLine( vecOrigin, pPlayer->WorldSpaceCenter(), ( MASK_SHOT & ~( CONTENTS_HITBOX ) ), &traceFilter, &trace );
//debugoverlay->AddLineOverlay( vecOrigin, pPlayer->WorldSpaceCenter(), 255, 0, 0, false, 10 );
if ( trace.DidHitWorld() )
continue;
// Effects on the individual players
//ExplodeEffectOnTarget( pThrower, pPlayer, pBasePlayer );
// Apply Car Damage and a force
Vector vecDir = pPlayer->WorldSpaceCenter() - GetAbsOrigin();
vecDir.NormalizeInPlace();
Vector vecForward, vecRight, vecUp;
AngleVectors( pPlayer->GetAnimRenderAngles(), &vecForward, &vecRight, &vecUp );
vecDir += ( vecUp * 0.5f );
pPlayer->AddHalloweenKartPushEvent( pThrower, this, pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ), vecDir * tf_halloween_kart_rocketspell_force.GetFloat(), 50.0f );
}
}
else
{
pThrower->EmitSound( "Player.DenyWeaponSelection" );
}
}
}
virtual const char *GetExplodeEffectParticle() const { return "ExplosionCore_MidAir"; }
#endif
#ifdef CLIENT_DLL
virtual const char *GetTrailParticleName( void )
{
return "halloween_rockettrail";
}
#endif
};
// Kart Spell Orbs
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellKartOrb, DT_TFProjectile_SpellKartOrb )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellKartOrb, DT_TFProjectile_SpellKartOrb )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellkartorb, CTFProjectile_SpellKartOrb );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellkartorb );
class CTFProjectile_SpellKartBats : public CTFProjectile_SpellBats
{
public:
DECLARE_CLASS( CTFProjectile_SpellKartBats, CTFProjectile_SpellBats );
DECLARE_NETWORKCLASS();
#ifdef GAME_DLL
virtual void ApplyBlastDamage( CTFPlayer *pThrower, Vector vecOrigin )
{
}
virtual void ExplodeEffectOnTarget( CTFPlayer *pThrower, CTFPlayer *pTarget, CBaseCombatCharacter *pBaseTarget )
{
if ( pBaseTarget->GetTeamNumber() == GetTeamNumber() )
return;
if ( !pTarget )
return;
if ( pTarget->m_Shared.IsInvulnerable() )
return;
if ( pTarget->m_Shared.InCond( TF_COND_PHASE ) || pTarget->m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
return;
// Stun the target
pTarget->m_Shared.StunPlayer( 0.5, 0.5, TF_STUN_MOVEMENT, pThrower );
Vector vecDir = pBaseTarget->WorldSpaceCenter() - GetAbsOrigin();
VectorNormalize( vecDir );
Vector vecForward, vecRight, vecUp;
AngleVectors( pTarget->GetAnimRenderAngles(), &vecForward, &vecRight, &vecUp );
vecDir += ( vecUp * 0.5f );
if ( pTarget )
{
pTarget->AddHalloweenKartPushEvent( pThrower, this, pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ), vecDir * tf_halloween_kart_normal_speed.GetFloat() * 1.10f, 45.0f );
const char* pszEffectName = GetTeamNumber() == TF_TEAM_RED ? "spell_batball_red" : "spell_batball_blue";
DispatchParticleEffect( pszEffectName, PATTACH_ABSORIGIN_FOLLOW, pTarget );
}
}
#endif
};
IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellKartBats, DT_TFProjectile_SpellKartBats )
BEGIN_NETWORK_TABLE( CTFProjectile_SpellKartBats, DT_TFProjectile_SpellKartBats )
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_projectile_spellkartbats, CTFProjectile_SpellKartBats );
PRECACHE_WEAPON_REGISTER( tf_projectile_spellkartbats );
//// *************************************************************************************************************************
//class CTFProjectile_SpellKartPumpkin : public CTFProjectile_SpellPumpkin
//{
//public:
// DECLARE_CLASS( CTFProjectile_SpellKartPumpkin, CTFProjectile_SpellPumpkin );
// DECLARE_NETWORKCLASS();
//
//#ifdef GAME_DLL
// virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
// {
// // Spawn a pumkin bomb here
// // Set the angles to what I want
// QAngle angle( 0, RandomFloat( 0, 360 ), 0 );
// CTFPumpkinBomb *pGrenade = static_cast<CTFPumpkinBomb*>( CBaseEntity::CreateNoSpawn( "tf_pumpkin_bomb", GetAbsOrigin(), angle, NULL ) );
// if ( pGrenade )
// {
// pGrenade->SetInitParams( 0.60, 80.0f, 200.0f, GetTeamNumber(), 40.0f + RandomFloat( 0, 1.0f ) );
// DispatchSpawn( pGrenade );
// pGrenade->SetSpell( true );
// pGrenade->TakeDamage( CTakeDamageInfo( pThrower, pThrower, 10.f, DMG_CRUSH ) );
// }
//
// if ( TFGameRules() )
// {
// TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MIRV, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
// }
//
// return true;
// }
//#endif
//};
//
//IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellKartPumpkin, DT_TFProjectile_SpellKartPumpkin )
//BEGIN_NETWORK_TABLE( CTFProjectile_SpellKartPumpkin, DT_TFProjectile_SpellKartPumpkin )
//END_NETWORK_TABLE()
//
//LINK_ENTITY_TO_CLASS( tf_projectile_spellkartpumpkin, CTFProjectile_SpellKartPumpkin );
//PRECACHE_WEAPON_REGISTER( tf_projectile_spellkartpumpkin );
//
////*************
//// *************************************************************************************************************************
//class CTFProjectile_SpellKartMirv : public CTFProjectile_SpellMirv
//{
//public:
// DECLARE_CLASS( CTFProjectile_SpellKartMirv, CTFProjectile_SpellMirv );
// DECLARE_NETWORKCLASS();
//
//#ifdef GAME_DLL
//
// virtual bool InitialExplodeEffects( CTFPlayer *pThrower, const trace_t *pTrace ) OVERRIDE
// {
// // Spawn a tonne of extra grenades (mirv style)
// CTFSpellBook *pSpellBook = dynamic_cast<CTFSpellBook*>( pThrower->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
// if ( !pSpellBook )
// return false;
//
// // Create bomblets
// Vector offset = Vector( 0, -100, 400 );
//
// for ( int i = 0; i < 6; i++ )
// {
// AngularImpulse angVelocity = AngularImpulse( 0, 0, RandomFloat( 100, 300 ) );
//
// switch ( i )
// {
// case 0: offset = Vector( 75, 110, 400 ); break;
// case 1: offset = Vector( 75, -110, 400 ); break;
// case 2: offset = Vector( -75, 110, 400 ); break;
// case 3: offset = Vector( -75, -110, 400 ); break;
// case 4: offset = Vector( 135, 0, 400 ); break;
// case 5: offset = Vector( -135, 0, 400 ); break;
// }
//
// CTFProjectile_SpellPumpkin *pGrenade = static_cast<CTFProjectile_SpellPumpkin*>( CBaseEntity::CreateNoSpawn( "tf_projectile_spellkartpumpkin", GetAbsOrigin(), pThrower->EyeAngles(), pThrower ) );
// if ( pGrenade )
// {
// // Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly.
// pGrenade->SetPipebombMode();
// DispatchSpawn( pGrenade );
// pGrenade->InitGrenade( offset, angVelocity, pThrower, pSpellBook->GetTFWpnData() );
// pGrenade->m_flFullDamage = 0;
// pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
// pGrenade->SetDetonateTimerLength( 2.0f + 0.05f * i );
// }
// }
//
// if ( TFGameRules() )
// {
// TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SPELL_MIRV, ( pThrower->GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
// }
//
// return true;
// }
//#endif
//};
//
//IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SpellKartMirv, DT_TFProjectile_SpellKartMirv )
//BEGIN_NETWORK_TABLE( CTFProjectile_SpellKartMirv, DT_TFProjectile_SpellKartMirv )
//END_NETWORK_TABLE()
//
//LINK_ENTITY_TO_CLASS( tf_projectile_spellkartmirv, CTFProjectile_SpellKartMirv );
//PRECACHE_WEAPON_REGISTER( tf_projectile_spellkartmirv );