/***
*
* Copyright (c) 1996-2001, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* This source code contains proprietary and confidential information of
* Valve LLC and its suppliers. Access to this code is restricted to
* persons who have executed a written SDK license with Valve. Any access,
* use or distribution of this code by or to any unlicensed person is illegal.
*
****/

#ifndef SHOCKBEAM_H
#define SHOCKBEAM_H

#define SHOCK_ALIENSHIP BIT(0) // flag for monster_alien_ship

//=========================================================
// Shockrifle projectile
//=========================================================
class CShock : public CBaseAnimating
{
public:
void Spawn(void);
void Precache();

static void Shoot(entvars_t *pevOwner, const Vector angles, const Vector vecStart, const Vector vecVelocity);
void Touch(CBaseEntity *pOther);
void EXPORT FlyThink();

// virtual int Save(CSave &save);
// virtual int Restore(CRestore &restore);
// static TYPEDESCRIPTION m_SaveData[];

void CreateEffects();
void ClearEffects();
void UpdateOnRemove();

CBeam *m_pBeam;
CBeam *m_pNoise;
CSprite *m_pSprite;

int EffectsCreated;

DECLARE_DATADESC();
};
#endif
//=========================================================
// shock - projectile shot from shockrifles.
//=========================================================

#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "schedule.h"
#include "nodes.h"
#include "effects.h"
#include "decals.h"
#include "soundent.h"
#include "game.h"
#include "weapons.h"
#include "gamerules.h"
#include "customentity.h"
#include "shock.h"

LINK_ENTITY_TO_CLASS(shock_beam, CShock)

BEGIN_DATADESC( CShock )
DEFINE_FIELD(m_pBeam, FIELD_CLASSPTR),
DEFINE_FIELD(m_pNoise, FIELD_CLASSPTR),
DEFINE_FIELD(m_pSprite, FIELD_CLASSPTR),
DEFINE_FUNCTION( Touch ),
DEFINE_FUNCTION( FlyThink ),
DEFINE_FUNCTION( CreateEffects ),
DEFINE_FUNCTION( ClearEffects ),
DEFINE_FUNCTION( UpdateOnRemove ),
END_DATADESC()

IMPLEMENT_SAVERESTORE(CShock, CBaseAnimating);

void CShock::Spawn(void)
{
Precache();
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
pev->classname = MAKE_STRING("shock_beam");
// SET_MODEL(ENT(pev), "sprites/shock.spr");
SET_MODEL(ENT(pev), "models/shock_effect.mdl");
UTIL_SetOrigin(this, pev->origin);

pev->dmg = 3;
UTIL_SetSize( pev, g_vecZero, g_vecZero );

SetThink( &CShock::FlyThink );
pev->nextthink = gpGlobals->time;
}

void CShock::Precache()
{
PRECACHE_MODEL("sprites/shockbeam.spr");
PRECACHE_MODEL("sprites/lgtning.spr");
PRECACHE_MODEL("models/shock_effect.mdl");
// PRECACHE_MODEL("sprites/shock.spr");
PRECACHE_SOUND("weapons/shock_impact_light.wav");
PRECACHE_SOUND("weapons/shock_impact_heavy.wav");
}

void CShock::FlyThink()
{
if (pev->waterlevel == 3)
{
entvars_t *pevOwner = VARS(pev->owner);
EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/shock_impact.wav", VOL_NORM, ATTN_NORM);
RadiusDamage(pev->origin, pev, pevOwner ? pevOwner : pev, pev->dmg * 3, 150, CLASS_NONE, DMG_SHOCK );
ClearEffects();
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = gpGlobals->time;
}
else
{
// had to do this, because spawnflag couldn't come through.
if( EffectsCreated == 0 )
{
CreateEffects();
EffectsCreated = 1;
}
pev->frame++;

pev->nextthink = gpGlobals->time + 0.01;
}
}

void CShock::Shoot(entvars_t *pevOwner, const Vector angles, const Vector vecStart, const Vector vecVelocity)
{
CShock *pShock = GetClassPtr((CShock *)NULL);
UTIL_SetOrigin(pShock, vecStart);
pShock->Spawn();

pShock->pev->velocity = vecVelocity;
pShock->pev->owner = ENT(pevOwner);
pShock->pev->angles = angles;

pShock->pev->nextthink = gpGlobals->time;
}

void CShock::Touch(CBaseEntity *pOther)
{
// Do not collide with the owner.
if (ENT(pOther->pev) == pev->owner)
return;

ClearEffects();

TraceResult tr = UTIL_GetGlobalTrace( );

Vector vecOrg = GetAbsOrigin() + tr.vecPlaneNormal * 3;

MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecOrg );
WRITE_BYTE(TE_DLIGHT);
WRITE_COORD(vecOrg.x); // X
WRITE_COORD(vecOrg.y); // Y
WRITE_COORD(vecOrg.z); // Z
if( pev->flags & SHOCK_ALIENSHIP )
WRITE_BYTE( 16 ); // radius * 0.1
else
WRITE_BYTE( 8 );
if( pev->flags & SHOCK_ALIENSHIP ) // red
{
WRITE_BYTE( 255 ); // r
WRITE_BYTE( 0 ); // g
WRITE_BYTE( 50 ); // b
}
else
{
WRITE_BYTE( 0 ); // r
WRITE_BYTE( 255 ); // g
WRITE_BYTE( 255 ); // b
}
WRITE_BYTE( 10 ); // time * 10
WRITE_BYTE( 10 ); // decay * 0.1
MESSAGE_END( );

CBaseMonster* pMonster = pOther->MyMonsterPointer();

if (pOther->pev->takedamage)
{
int damageType = DMG_SHOCK;
if (pMonster && !pMonster->IsAlive())
{
damageType |= DMG_CLUB;
}
ClearMultiDamage();
entvars_t *pevOwner = VARS(pev->owner);
entvars_t *pevAttacker = pevOwner ? pevOwner : pev;
pOther->TraceAttack(pevAttacker, pev->dmg, pev->velocity.Normalize(), &tr, damageType );
ApplyMultiDamage(pev, pevAttacker);
if (pOther->IsPlayer() && (UTIL_PointContents(pev->origin) != CONTENTS_WATER))
{
const Vector position = tr.vecEndPos;
MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, pOther->pev );
WRITE_BYTE( TE_SPARKS );
WRITE_COORD( position.x );
WRITE_COORD( position.y );
WRITE_COORD( position.z );
MESSAGE_END();
}
}


// splat sound
if( pev->flags & SHOCK_ALIENSHIP )
EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "weapons/shock_impact_heavy.wav", VOL_NORM, ATTN_NORM, 0, RANDOM_LONG(75,100));
else
EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "weapons/shock_impact_light.wav", 0.5, ATTN_NORM, 0, RANDOM_LONG(95,115));

entvars_t *pevOwner;
if ( pev->owner )
pevOwner = VARS( pev->owner );
else
pevOwner = NULL;

pev->owner = NULL; // can't traceline attack owner if this is set
RadiusDamage( GetAbsOrigin(), pev, pevOwner, 3, 150, CLASS_NONE, DMG_SHOCK );

pev->modelindex = 0;
pev->solid = SOLID_NOT;
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = gpGlobals->time + 0.01; // let the sound play
}

void CShock::CreateEffects()
{
m_pSprite = CSprite::SpriteCreate( "sprites/shockbeam.spr", pev->origin, FALSE );
m_pSprite->SetAttachment( edict(), 0 );
if( pev->flags & SHOCK_ALIENSHIP )
m_pSprite->pev->scale = 1.0;
else
m_pSprite->pev->scale = 0.35;

if( pev->flags & SHOCK_ALIENSHIP )
m_pSprite->SetTransparency( kRenderTransAdd, 255, 0, 50, 200, kRenderFxNoDissipation );
else
m_pSprite->SetTransparency( kRenderTransAdd, 80, 160, 255, 200, kRenderFxNoDissipation );
//m_pSprite->pev->spawnflags |= SF_SPRITE_TEMPORARY;
//m_pSprite->pev->flags |= FL_SKIPLOCALHOST;



m_pBeam = CBeam::BeamCreate( "sprites/lgtning.spr", 30 );

if (m_pBeam)
{
m_pBeam->EntsInit( entindex(), entindex() );
m_pBeam->PointEntInit( entindex(), entindex() );
m_pBeam->SetStartAttachment( 1 );
m_pBeam->SetEndAttachment( 2 );
m_pBeam->SetBrightness( 180 );
m_pBeam->SetScrollRate( 10 );
m_pBeam->SetNoise( 0 );
m_pBeam->SetFlags( BEAM_FSHADEOUT );
m_pBeam->SetColor( 0, 255, 255 );
//m_pBeam->pev->spawnflags = SF_BEAM_TEMPORARY;
m_pBeam->RelinkBeam();
}
else
{
ALERT(at_console, "Could not create shockbeam beam!\n");
}

m_pNoise = CBeam::BeamCreate( "sprites/lgtning.spr", 30 );

if (m_pNoise)
{
m_pNoise->EntsInit( entindex(), entindex() );
m_pNoise->PointEntInit( entindex(), entindex() );
m_pNoise->SetStartAttachment( 1 );
m_pNoise->SetEndAttachment( 2 );
m_pNoise->SetBrightness( 180 );
m_pNoise->SetScrollRate( 30 );
m_pNoise->SetNoise( 30 );
m_pNoise->SetFlags( BEAM_FSHADEOUT );
m_pNoise->SetColor( 255, 255, 173 );
//m_pNoise->pev->spawnflags = SF_BEAM_TEMPORARY;
m_pNoise->RelinkBeam();
}
else
{
ALERT(at_console, "Could not create shockbeam noise!\n");
}

}

void CShock::ClearEffects()
{
if (m_pBeam)
{
UTIL_Remove( m_pBeam );
m_pBeam = NULL;
}

if (m_pNoise)
{
UTIL_Remove( m_pNoise );
m_pNoise = NULL;
}

if (m_pSprite)
{
UTIL_Remove( m_pSprite );
m_pSprite = NULL;
}
}

void CShock::UpdateOnRemove()
{
CBaseAnimating::UpdateOnRemove();
ClearEffects();
}