/*==================================================================================================
LIBRARIES.
==================================================================================================*/

#include <amxmodx>
#include <engine>
#include <hamsandwich>
#include <xs>

#include <ipci/Ascend>
#include <ipci/Core>
#include <ipci/FXLib>

#include <xtension/Special>


#include <amxmisc>
#include <fun>
#include <fakemeta>

#include <ipci/ascend>
#include <ipci/dragonball>
#include <xs>




/*==================================================================================================
ADDITIONAL MATERIAL.
==================================================================================================*/

#define SPECIAL_VALREQSTATE 1
#define SPECIAL_NULREQSTATE 0

stock SpecialXtension:__sx_Mafuba;

// Sequence
static __int_Sequence[2], __int_Capsule;

// Effects
static __int_Gibs[3], __int_Trail, __int_Lightning;

// Conditions

/*==================================================================================================
START OF THE SPECIAL.
==================================================================================================*/

public plugin_init()
{
    register_forward(FM_AddToFullPack, "@FM_AddToFullPack", ._post = true);

    RegisterHam(Ham_Use, "func_button", "@Ham_Use");
    RegisterHam(Ham_TakeDamage, "info_target", "@Ham_TakeDamage");

    //register_clcmd("say c", "@CreateMafubaBeamEntity");

    register_think("capsule_jar", "@Think_Jar");

    register_touch("worldspawn", "capsule_jar", "@Touch_Jar");

    //register_forward( FM_Touch, "@EntityTouch" );

    register_touch("mafuba", "*", "Mafuba_Touch"); //This way, is will only run if the entity is "Mafuba"

    register_touch( "mafubaphase2", "world", "Mafubaphase2_touch")

    register_message(get_user_msgid("Explosion"), "ExplosionDetected");

    register_clcmd("say w", "rocket_explode");
}

public plugin_precache()
{
    precache_model("models/capsule.mdl");
    precache_model("models/ricecooker.mdl");

    precache_model("sprites/mafuba.spr");

    __int_Trail = precache_model("sprites/auratrail.spr");

    __int_Lightning = precache_model("sprites/lgtning.spr");

    __int_Gibs[0] = precache_model("models/teil1.mdl");
    __int_Gibs[1] = precache_model("models/teil2.mdl");
    __int_Gibs[2] = precache_model("models/teil3.mdl");

    precache_sound("weapons/mafuba/capsule_click.wav");
    precache_sound("weapons/mafuba/capsule_bounce.wav");
    precache_sound("weapons/mafuba/capsule_decompression.wav");

    precache_sound("weapons/mafuba/jar_use.wav");
    precache_sound("weapons/mafuba/jar_break.wav");

    precache_sound("weapons/powerup.wav");
    precache_sound("weapons/mafuba/player_scream.wav");

    precache_model( "sprites/mafubatrail2.spr" );
    precache_model( "sprites/sv_ff_t.spr" );

    precache_sound("common/wpn_select.wav");
}

public Mafuba_Touch(ent, id)
{
    if(!pev_valid(ent))
        return
    if(!is_user_alive(id)) //Check if the touched thing is a player or not
        return

    if(id == pev(ent, pev_owner)) //Prevent owner from touch it (Put yourself in your own trap is so silly)
        return

    if(!task_exists(ent+9999))
    {
        set_task(1.0, "removeEntity", ent+9999); //Prevent from touching multiple time
        set_task(2.0, "Phase2", pev_owner); //Prevent from touching multiple time
    }
}

public Mafubaphase2_touch(ent, id)
{
   if(!pev_valid(ent))
        return
}


public removeEntity(ent) remove_entity(ent-9999); //Shorten


public @CreateMafubaBeamEntityphase2(__int_Entity, const __int_Owner, const Float:__float_Scale, const __int_Velocity)
{
    __int_Entity = create_entity("env_sprite");

    set_task(0.1, "AIM", __int_Entity,_,_,"b")

    entity_set_model(__int_Entity, "sprites/mafuba.spr");

    entity_set_int(__int_Entity, EV_INT_spawnflags, SF_SPRITE_STARTON);

    DispatchSpawn(__int_Entity);

    entity_set_int(__int_Entity, EV_INT_renderfx, kRenderFxGlowShell);
    entity_set_int(__int_Entity, EV_INT_rendermode, kRenderTransAdd);

    entity_set_float(__int_Entity, EV_FL_animtime, get_gametime());
    entity_set_float(__int_Entity, EV_FL_framerate, float(10));

    entity_set_string(__int_Entity, EV_SZ_classname, "mafubaphase2");

    entity_set_float(__int_Entity, EV_FL_renderamt, float(254));

    entity_set_float(__int_Entity, EV_FL_scale, __float_Scale);

    entity_set_int(__int_Entity, EV_INT_movetype, MOVETYPE_FLY);

    entity_set_size(__int_Entity, Float:{-8.000_000, -8.000_000, -8.000_000}, Float:{8.000_000, 8.000_000, 8.000_000});

    entity_set_int(__int_Entity, EV_INT_solid, SOLID_TRIGGER);

    //entity_set_edict(__int_Entity, EV_ENT_owner, __int_Owner);
    set_pev(__int_Entity,pev_owner, __int_Owner)
    entity_set_edict(__int_Entity, EV_ENT_pContainingEntity, __int_Entity);

    static Float:__float_Origin[3];
    entity_get_vector(__int_Owner, EV_VEC_origin, __float_Origin);

    entity_set_origin(__int_Entity, __float_Origin);

    static Float:__float_Velocity[3];
    velocity_by_aim(__int_Owner, __int_Velocity, __float_Velocity);

    entity_set_vector(__int_Entity, EV_VEC_velocity, __float_Velocity);


    message_begin( MSG_BROADCAST,SVC_TEMPENTITY )
    write_byte( TE_BEAMFOLLOW )
    write_short( __int_Entity )
    write_short( engfunc( EngFunc_ModelIndex,"sprites/sv_ff_t.spr" ) )
    write_byte( 30 )// 持续时间[] life in 0.1's
    write_byte( 10 )// 宽度[] line width in 0.1's
    write_byte( 255 )// Red
    write_byte( 255 )// Green
    write_byte( 255 )// Blue
    write_byte( 255 )// Brightness
    message_end( )
}


public @CreateMafubaBeamEntity(__int_Entity, const __int_Owner, const Float:__float_Scale, const __int_Velocity)
{
    __int_Entity = create_entity("env_sprite");

    entity_set_model(__int_Entity, "sprites/mafuba.spr");

    entity_set_int(__int_Entity, EV_INT_spawnflags, SF_SPRITE_STARTON);

    DispatchSpawn(__int_Entity);

    entity_set_int(__int_Entity, EV_INT_renderfx, kRenderFxGlowShell);
    entity_set_int(__int_Entity, EV_INT_rendermode, kRenderTransAdd);

    entity_set_float(__int_Entity, EV_FL_animtime, get_gametime());
    entity_set_float(__int_Entity, EV_FL_framerate, float(10));

    entity_set_string(__int_Entity, EV_SZ_classname, "mafuba");

    entity_set_float(__int_Entity, EV_FL_renderamt, float(254));

    entity_set_float(__int_Entity, EV_FL_scale, __float_Scale);

    entity_set_int(__int_Entity, EV_INT_movetype, MOVETYPE_FLY);

    entity_set_size(__int_Entity, Float:{-8.000_000, -8.000_000, -8.000_000}, Float:{8.000_000, 8.000_000, 8.000_000});

    entity_set_int(__int_Entity, EV_INT_solid, SOLID_TRIGGER);

    //entity_set_edict(__int_Entity, EV_ENT_owner, __int_Owner);
    set_pev(__int_Entity,pev_owner, __int_Owner)
    entity_set_edict(__int_Entity, EV_ENT_pContainingEntity, __int_Entity);

    static Float:__float_Origin[3];
    entity_get_vector(__int_Owner, EV_VEC_origin, __float_Origin);

    entity_set_origin(__int_Entity, __float_Origin);

    static Float:__float_Velocity[3];
    velocity_by_aim(__int_Owner, __int_Velocity, __float_Velocity);

    entity_set_vector(__int_Entity, EV_VEC_velocity, __float_Velocity);
    set_task(0.1, "follow_enemy", __int_Entity,_,_,"b")


    message_begin( MSG_BROADCAST,SVC_TEMPENTITY )
    write_byte( TE_BEAMFOLLOW )
    write_short( __int_Entity )
    write_short( engfunc( EngFunc_ModelIndex,"sprites/mafubatrail2.spr" ) )
    write_byte( 10 )// 持续时间[] life in 0.1's
    write_byte( 30 )// 宽度[] line width in 0.1's
    write_byte( 255 )// Red
    write_byte( 255 )// Green
    write_byte( 255 )// Blue
    write_byte( 255 )// Brightness
    message_end( )
}


public Phase2(id)
{
    @CreateMafubaBeamEntityphase2(100, pev_owner, 1.0, 100);
    console_print(0, "phase2 start");
}


public AIM(id)
{
    if (is_valid_ent(id))
    {
        new Float:Velocity[3]
        VelocityByAim(pev_owner, 500, Velocity)
        entity_set_vector(id, EV_VEC_velocity, Velocity)
        new Float:NewAngle[3]
        entity_get_vector(id, EV_VEC_v_angle, NewAngle)
        entity_set_vector(id, EV_VEC_angles, NewAngle)
    }
}



public follow_enemy(ball)
{
    static tid, id, closest[2]
    closest[0] = 0
    closest[1]= 6000
    id = pev(ball, pev_owner)
    tid = pev(ball, pev_iuser1)

    if(tid == 0)
    {
        new user_team = get_user_team(id)
        new pl[32], num, Float:flAngles[3], Float:flForward[3],
        Float:vector[3], Float:fired_particle_start_origin[3], Float:flVecSrc2[3],
        Float:maxdist, Float:flVecDest[3]
        get_players(pl,num,"a")

        pev(id, pev_v_angle, flAngles)
        angle_vector(flAngles, ANGLEVECTOR_FORWARD, flForward)

        pev(id, pev_origin, fired_particle_start_origin)
        pev(id, pev_view_ofs, vector)

        // get the fired particle start origin
        xs_vec_add(fired_particle_start_origin, vector, fired_particle_start_origin)

        for(new i = 0; i<num;i++)
        {
            tid = pl[i]
            if(tid == id && get_user_team(tid) == user_team) continue

            pev(tid, pev_origin, flVecSrc2)

            maxdist = get_distance_f(fired_particle_start_origin, flVecSrc2)

            flVecDest[0] = fired_particle_start_origin[0] + (flForward[0] * maxdist);
            flVecDest[1] = fired_particle_start_origin[1] + (flForward[1] * maxdist);
            flVecDest[2] = fired_particle_start_origin[2] + (flForward[2] * maxdist);

            if(get_distance_f(flVecDest, flVecSrc2) < closest[1]*1.0)
            {
                closest[0] = tid
            } else closest[1] = floatround(get_distance_f(flVecDest, flVecSrc2))
        }
    } else if(!is_user_alive(tid))
    {
        new Float:orig[3], Float:Torig[3]

        pev(ball, pev_origin, orig)

        new pl[32], num

        get_players(pl,num,"a")
        for(new i;i<num;i++)
        {
            tid = pl[i]

            pev(tid, pev_origin, Torig)

            if(get_distance_f(orig, Torig) < closest[1]*1.0)
                closest[0] = tid
            else
                closest[1] = floatround(get_distance_f(orig, Torig))
        }
    }
    if(closest[0] != 0) tid = closest[0]

    if(!is_user_alive(tid))
    {
        remove_task(ball)
        engfunc(EngFunc_RemoveEntity, ball)
        return
    }
    new Float:origin[3], Float:AimVec[3], Float:speed = 800.0

    pev(tid, pev_origin, AimVec)

    entity_get_vector(ball, EV_VEC_origin, origin)

    new Float:iNewVelocity[3]

    new Float:velocityVec[3], Float:length

    velocityVec[0] = AimVec[0]-origin[0]
    velocityVec[1] = AimVec[1]-origin[1]
    velocityVec[2] = AimVec[2]-origin[2]

    length = floatsqroot(velocityVec[0]*velocityVec[0] + velocityVec[1]*velocityVec[1] + velocityVec[2]*velocityVec[2])
    // Stupid Check but lets make sure you don't devide by 0
    if ( length < 1.0 ) length = 1.0

    velocityVec[0] = velocityVec[0]*speed/length
    velocityVec[1] = velocityVec[1]*speed/length
    velocityVec[2] = velocityVec[2]*speed/length

    new Float:args[3]
    pev(ball, pev_velocity, args)
    iNewVelocity[0] = (velocityVec[0] + (args[0] * 2.0)) / 3.0
    iNewVelocity[1] = (velocityVec[1] + (args[1] * 2.0)) / 3.0
    iNewVelocity[2] = (velocityVec[2] + (args[2] * 2.0)) / 3.0

    set_pev(ball, pev_velocity, iNewVelocity)
}

public client_connect(__int_Index)
{
    @RemoveData(__int_Index);
}

public client_disconnect(__int_Index)
{
    @RemoveData(__int_Index);
}

public @ClientReSpawned(__int_Index)
{
    if(is_user_alive(__int_Index))
    {
        __int_Capsule |= (1 << __int_Index);
    }
}

public @SpecialCreation()
{
    beginSpecialCreation("Mafuba", "", "@CallBackMafuba", "special_mafuba");

    addSpecialCharge(   .ControlSequence = IN_ATTACK,
                .SecsForFullCharge = float(8),
                .KiPerStep = float(6),
                .CanMove = false);

    addSpecialCharge(   .ControlSequence = IN_ATTACK2,
                .SecsForFullCharge = float(1),
                .KiPerStep = float(0),
                .CanMove = true);

    __sx_Mafuba = endSpecialCreation();
}

public @CallBackMafuba(__int_Index, CSpecialState:__Status, __int_Control, Float:__float_Charge)
{
    switch(__Status)
    {
        case ssCharge:
        {
            if(__int_Control == IN_ATTACK2)
            {
                if(@IsPlayerBusy(__int_Index)
                || getClientINFREEFALL(__int_Index)
                || @ReturnAnimation(__int_Index, 1))
                {
                    return SPECIAL_NULREQSTATE;
                }

                if(__float_Charge == float(-1))
                {
                    set_pdata_int(__int_Index, 200, false);

                    @StopAnimation(__int_Index, 2);
                }

                if(__float_Charge == float(0))
                {
                    set_pdata_int(__int_Index, 200, true);

                    @StartAnimation(__int_Index, 0);
                }

                if(__float_Charge == 0.300_000 && __int_Capsule & (1 << __int_Index))
                {
                    emit_sound(__int_Index, CHAN_WEAPON, "weapons/mafuba/capsule_click.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
                }
            }

            else
            {
                if(getClientPOWERUP(__int_Index) && getClientXFROZEN(__int_Index))
                {
                    setClientFLY(__int_Index, false);
                }

                if(@IsPlayerBusy(__int_Index)
                || getClientFLY(__int_Index)
                || getClientTURBO(__int_Index)
                || ~entity_get_int(__int_Index, EV_INT_flags) & FL_ONGROUND)
                {
                    return SPECIAL_NULREQSTATE;
                }

                if(__float_Charge == 0.050_000)
                {
                    set_task(0.5, "@fxWorldLight", __int_Index, _, _, "b");

                    message_begin(MSG_ALL, get_user_msgid("Powerup"));
                    {
                        write_byte(__int_Index);

                        write_byte(0);
                        write_byte(0);
                        write_byte(0);
                    }
                    message_end();

                    emit_sound(__int_Index, CHAN_WEAPON, "common/null.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

                    emit_sound(__int_Index, CHAN_ITEM, "weapons/powerup.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
                }

                if(__float_Charge == 0.700_000)
                {
                    set_rendering(__int_Index, kRenderFxGlowShell, 0, _, 0, _, 10);
                }

                else if(__float_Charge == 0.325_000 || __float_Charge == 0.987_500)
                {
                    AddFx(__int_Index, "fxBlow");
                    AddFx(__int_Index, "fxScreenShake", float(5), float(1), float(5));
                }
            }

            entity_set_float(__int_Index, EV_FL_fuser2, __float_Charge);

            return SPECIAL_VALREQSTATE;
        }

        case ssChargeReleased:
        {
            if(__int_Control == IN_ATTACK2)
            {
                if(__float_Charge >= 0.325_000)
                {
                    @StartAnimation(__int_Index, 1);

                    if(__int_Capsule & (1 << __int_Index))
                    {
                        @ThrowCapsule(__int_Index, (120 * floatround(__float_Charge * float(10))));
                    }

                    else
                    {
                        client_print(__int_Index, print_center, "You don't have more capsules.");
                    }
                }

                else
                {
                    set_pdata_int(__int_Index, 200, false);

                    @StopAnimation(__int_Index, 2);
                }
            }

            else
            {
                if(__float_Charge >= 0.900_000)
                {
                    @CreateMafubaBeamEntity(100, __int_Index, 1.0, 800);
                    emit_sound(__int_Index, CHAN_AUTO, "weapons/mafuba/player_scream.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
                }

                emit_sound(__int_Index, CHAN_ITEM, "common/null.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

                @RemoveChargeReferences(__int_Index);
            }
        }

        case ssChargeAborted:
        {
            if(__int_Control == IN_ATTACK2)
            {
                set_pdata_int(__int_Index, 200, false);

                @StopAnimation(__int_Index, 2);
            }

            else
            {
                emit_sound(__int_Index, CHAN_ITEM, "common/null.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

                @RemoveChargeReferences(__int_Index);
            }

            return SPECIAL_NULREQSTATE;
        }

        case ssForceAbort:
        {
            if(__int_Control == IN_ATTACK2)
            {
                set_pdata_int(__int_Index, 200, false);

                @StopAnimation(__int_Index, 2);
            }

            else
            {
                emit_sound(__int_Index, CHAN_ITEM, "common/null.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

                @RemoveChargeReferences(__int_Index);
            }
        }
    }

    return SPECIAL_VALREQSTATE;
}

public @ThrowCapsule(const __int_Index, const __int_Strengh)
{
    static __int_Entity;
    __int_Entity = create_entity("info_target");

    entity_set_string(__int_Entity, EV_SZ_classname, "capsule_jar");

    entity_set_model(__int_Entity, "models/capsule.mdl");

    DispatchKeyValue(__int_Entity, "health", "10");

    entity_set_int(__int_Entity, EV_INT_spawnflags, entity_get_int(__int_Entity, EV_INT_spawnflags) & SF_NORESPAWN);

    DispatchSpawn(__int_Entity);

    entity_set_float(__int_Entity, EV_FL_nextthink, (get_gametime() + 0.01));

    entity_set_float(__int_Entity, EV_FL_scale, 0.6);

    entity_set_int(__int_Entity, EV_INT_solid, SOLID_TRIGGER);

    entity_set_int(__int_Entity, EV_INT_movetype, MOVETYPE_BOUNCE);

    entity_set_size(__int_Entity, Float:{-0.500_000, -0.500_000, -0.500_000}, Float:{0.500_000, 0.500_000, 0.500_000});

    static Float:__float_Origin[3], Float:__float_Velocity[3];
    entity_get_vector(__int_Index, EV_VEC_origin, __float_Origin);
    entity_set_origin(__int_Entity, __float_Origin);

    velocity_by_aim(__int_Index, __int_Strengh, __float_Velocity);

    __float_Velocity[2] += float(100);

    entity_set_vector(__int_Entity, EV_VEC_avelocity, Float:{200.0, 400.0, 600.0});
    entity_set_vector(__int_Entity, EV_VEC_velocity, __float_Velocity);

    message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
    {
        write_byte(TE_BEAMFOLLOW);

        write_short(__int_Entity);
        write_short(__int_Trail);

        write_byte(5);
        write_byte(1);

        write_byte(255);
        write_byte(255);
        write_byte(255);

        write_byte(100);
    }
    message_end();

    __int_Capsule &= ~(1 << __int_Index);
}

public @SpawnJar(__int_Entity)
{
    if(is_valid_ent(__int_Entity))
    {
        entity_set_model(__int_Entity, "models/ricecooker.mdl");

        entity_set_int(__int_Entity, EV_INT_solid, SOLID_BBOX);

        entity_set_int(__int_Entity, EV_INT_movetype, MOVETYPE_TOSS);

        entity_set_size(__int_Entity, Float:{-0.500_000, -0.500_000, -0.500_000}, Float:{0.500_000, 0.500_000, 0.500_000});

        entity_set_float(__int_Entity, EV_FL_scale, float(1));

        entity_set_float(__int_Entity, EV_FL_animtime, get_gametime());
        entity_set_float(__int_Entity, EV_FL_framerate, 1.0);

        entity_set_int(__int_Entity, EV_INT_effects, EF_MUZZLEFLASH);

        entity_set_float(__int_Entity, EV_FL_takedamage, float(1));

        static Float:__float_Origin[3], __int_Origin[3];
        entity_get_vector(__int_Entity, EV_VEC_origin, __float_Origin);
        FVecIVec(__float_Origin, __int_Origin);

        message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
        {
            write_byte(TE_DLIGHT);

            write_coord(__int_Origin[0]);
            write_coord(__int_Origin[1]);
            write_coord(__int_Origin[2]);

            write_byte(10);
            write_byte(255);
            write_byte(255);
            write_byte(255);
            write_byte(30);
            write_byte(1);
        }
        message_end();

        message_begin(MSG_ALL, 98);
        {
            write_byte(2);
            write_short(__int_Entity);

            write_coord(__int_Origin[0]);
            write_coord(__int_Origin[1]);
            write_coord(__int_Origin[2]);

            write_short(200);
        }
        message_end();

        message_begin(MSG_ALL, 115, __int_Origin);
        {
            write_byte(3);
            write_byte(__int_Entity);
        }
        message_end();

        message_begin(MSG_ALL, 106, __int_Origin);
        {
            write_short(__int_Entity);
            write_byte(10);
        }
        message_end();

        entity_set_int(__int_Entity, EV_INT_sequence, 1);

        emit_sound(__int_Entity, CHAN_WEAPON, "weapons/mafuba/capsule_decompression.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

        static __int_Use;
        __int_Use = create_entity("func_button");

        entity_set_int(__int_Use, EV_INT_movetype, MOVETYPE_FOLLOW);
        entity_set_edict(__int_Use, EV_ENT_aiment, __int_Entity);

        entity_set_edict(__int_Use, EV_ENT_euser1, __int_Entity);

        entity_set_string(__int_Use, EV_SZ_classname, "mafuba_use");

        entity_set_edict(__int_Entity, EV_ENT_euser3, __int_Use);
    }
}

public @FM_AddToFullPack(__int_Handle, __int_Edict, __int_Entity, __int_Host, __int_Flags, __int_Player, __int_Set)
{
    if(__int_Player
    && __int_Entity == __int_Host
    && (is_user_alive(__int_Host) && !is_user_bot(__int_Host)))
    {
        if(__int_Sequence[0] & (1 << __int_Entity))
        {
            entity_set_float(__int_Entity, EV_FL_animtime, get_gametime());
            set_es(__int_Handle, ES_Sequence, 90);
            entity_set_float(__int_Entity, EV_FL_framerate, 0.380_000);

            if(entity_get_float(__int_Entity, EV_FL_fuser2) == float(1))
            {
                entity_set_float(__int_Entity, EV_FL_framerate, float(0));
            }
        }

        if(__int_Sequence[1] & (1 << __int_Entity))
        {
            entity_set_float(__int_Entity, EV_FL_framerate, float(2));

            static Float:__int_Frame[2];

            __int_Frame[0] = __int_Frame[1];
            __int_Frame[1] = entity_get_float(__int_Entity, EV_FL_frame);

            if(__int_Frame[0] > __int_Frame[1])
            {
                set_pdata_int(__int_Entity, 200, false);

                @StopAnimation(__int_Entity, 2);
            }
        }
    }

    return FMRES_IGNORED;
}

public @Think_Jar(__int_Entity)
{
    if(is_valid_ent(__int_Entity))
    {
        if(task_exists(__int_Entity))
        {
            remove_task(__int_Entity);
        }

        static Float:__float_Start[3], Float:__float_End[3];
        entity_get_vector(__int_Entity, EV_VEC_origin, __float_Start);

        __float_End[0] = __float_Start[0];
        __float_End[1] = __float_Start[1];
        __float_End[2] = (__float_Start[2] - float(9999));

        static __int_Trace;
        engfunc(EngFunc_TraceLine, __float_Start, __float_End, IGNORE_MONSTERS, 0, __int_Trace);

        static Float:__float_Angles[3];
        get_tr2(__int_Trace, TR_vecPlaneNormal, __float_Angles);

        vector_to_angle(__float_Angles, __float_Angles);

        __float_Angles[0] -= float(90);

        entity_set_vector(__int_Entity, EV_VEC_angles, __float_Angles);

        set_task(2.500_000, "@fxLight", __int_Entity);
        set_task(float(3), "@SpawnJar", __int_Entity);
    }
}

public @Touch_Jar(__int_Touched, __int_Toucher)
{
    if(is_valid_ent(__int_Toucher))
    {
        static Float:__float_Velocity[3];
        entity_get_vector(__int_Toucher, EV_VEC_velocity, __float_Velocity);

        __float_Velocity[0] /= 2.500_000;
        __float_Velocity[1] /= 2.500_000;
        __float_Velocity[2] /= 2.500_000;

        entity_set_vector(__int_Toucher, EV_VEC_velocity, __float_Velocity);

        entity_set_float(__int_Toucher, EV_FL_nextthink, (get_gametime() + 0.01));

        emit_sound(__int_Toucher, random_num(0, 7), "weapons/mafuba/capsule_bounce.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
    }
}

public @Ham_Use(__int_Entity, __int_Index)
{
    if(entity_get_int(entity_get_edict(__int_Entity, EV_ENT_euser1), EV_INT_iuser3) != 1)
    {
        static __int_Classname[32];
        entity_get_string(__int_Entity, EV_SZ_classname, __int_Classname, sizeof(__int_Classname)-1);

        if(equal(__int_Classname, "mafuba_use"))
        {
            emit_sound(__int_Index, CHAN_ITEM, "weapons/mafuba/jar_use.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);

            entity_set_int(entity_get_edict(__int_Entity, EV_ENT_euser1), EV_INT_sequence, entity_get_int(entity_get_edict(__int_Entity, EV_ENT_euser1), EV_INT_sequence) == 0 ? 1 : 0);
        }
    }
}

public @Ham_TakeDamage(__int_Victim, __int_Inflictor, __int_Attacker, Float:__float_Damage, __int_Bits)
{
    static __int_Classname[32];
    entity_get_string(__int_Victim, EV_SZ_classname, __int_Classname, sizeof(__int_Classname)-1);

    if(equal(__int_Classname, "capsule_jar"))
    {
        if((entity_get_float(__int_Victim, EV_FL_health) - __float_Damage) < float(0))
        {
            SetHamParamFloat(4, float(0));

            if(!task_exists(__int_Victim))
            {
                entity_set_int(__int_Victim, EV_INT_iuser3, 1);

                static __int_Data[2];
                __int_Data[0] = __int_Victim;
                __int_Data[1] = __int_Attacker;

                set_rendering(__int_Victim, kRenderFxGlowShell, _, _, _, _, 20);

                set_task(0.5, "@fxLightning", __int_Victim, _, _, "a", 8);
                set_task(float(5), "@fxKillJar", __int_Victim, __int_Data, 2);

                emit_sound(__int_Victim, CHAN_ITEM, "weapons/mafuba/jar_break.wav", VOL_NORM, ATTN_NORM, 0 ,PITCH_NORM);
            }
        }
    }
}

/*==================================================================================================
EFFECTS.
==================================================================================================*/

public @fxKillJar(__int_Data[])
{
    if(is_valid_ent(__int_Data[0]))
    {
        static Float:__float_Origin[3];
        entity_get_vector(__int_Data[0], EV_VEC_origin, __float_Origin);

        for(new __int_Models = 0; __int_Models < 3; __int_Models++)
        {
            message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
            {
                write_byte(TE_MODEL);
                write_coord(floatround(__float_Origin[0]));
                write_coord(floatround(__float_Origin[1]));
                write_coord(floatround(__float_Origin[2]));

                write_coord(random_num(random_num(-200, -300), random_num(200, 300)));
                write_coord(random_num(random_num(-200, -300), random_num(200, 300)));
                write_coord(random_num(250, 300));

                write_angle(random_num(0, 360));

                write_short(__int_Gibs[__int_Models]);
                write_byte(0);
                write_byte(200);
            }
            message_end();
        }

        message_begin(MSG_ALL, 98);
        {
            write_byte(2);
            write_short(__int_Data[0]);

            write_coord(floatround(__float_Origin[0]));
            write_coord(floatround(__float_Origin[1]));
            write_coord(floatround(__float_Origin[2]));

            write_short(60);
        }
        message_end();

        if(is_valid_ent(entity_get_edict(__int_Data[0], EV_ENT_euser3)))
        {
            remove_entity(entity_get_edict(__int_Data[0], EV_ENT_euser3));
        }

        ExecuteHam(Ham_Killed, __int_Data[0], __int_Data[1], 0);
    }
}

public @fxLightning(__int_Entity)
{
    if(is_valid_ent(__int_Entity))
    {
        static Float:__float_Origin[3];
        entity_get_vector(__int_Entity, EV_VEC_origin, __float_Origin);

        message_begin(MSG_ALL, SVC_TEMPENTITY);
        {
            write_byte(TE_BEAMPOINTS);
            write_coord(floatround(__float_Origin[0]));
            write_coord(floatround(__float_Origin[1]));
            write_coord(floatround(__float_Origin[2]));

            write_coord(floatround(__float_Origin[0] + random_float(-11.0, 11.0)));
            write_coord(floatround(__float_Origin[1] + random_float(-11.0, 11.0)));
            write_coord(floatround(__float_Origin[2] + random_float(0.0, 11.0)));

            write_short(__int_Lightning);

            write_byte(1);
            write_byte(10);
            write_byte(10);
            write_byte(5);
            write_byte(125);
            write_byte(255);

            write_byte(255);
            write_byte(255);
            write_byte(255);

            write_byte(150);
        }
        message_end();
    }
}

public @fxLight(__int_Entity)
{
    if(is_valid_ent(__int_Entity))
    {
        static Float:__float_Origin[3];
        entity_get_vector(__int_Entity, EV_VEC_origin, __float_Origin);

        static __int_Players;
        __int_Players = -1;

        while((__int_Players = find_ent_in_sphere(__int_Players, __float_Origin, float(15))))
        {
            if(is_user_alive(__int_Players) && is_user_connected(__int_Players))
            {
                static Float:__float_Origin[3];
                entity_get_vector(__int_Players, EV_VEC_origin, __float_Origin);

                __float_Origin[2] += float(100);

                entity_set_origin(__int_Players, __float_Origin);
            }
        }

        entity_set_int(__int_Entity, EV_INT_effects, EF_LIGHT);
    }
}

public @fxWorldLight(__int_Index)
{
    if(is_user_alive(__int_Index))
    {
        static __int_Origin[3];
        get_user_origin(__int_Index, __int_Origin);

        message_begin(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, __int_Index);
        {
            write_byte(TE_DLIGHT);

            write_coord(__int_Origin[0]);
            write_coord(__int_Origin[1]);
            write_coord(__int_Origin[2]);

            write_byte(12);

            write_byte(entity_get_float(__int_Index, EV_FL_fuser2) < 0.699_999 ? 255 : 0);
            write_byte(255);
            write_byte(entity_get_float(__int_Index, EV_FL_fuser2) < 0.699_999 ? 255 : 0);

            write_byte(255);
            write_byte(floatround(2.500_000));
        }
        message_end();

        static Float:__float_Charge;
        __float_Charge = entity_get_float(__int_Index, EV_FL_fuser2);

        if(__float_Charge >= 0.325_000)
        {
            set_rendering(.index = __int_Index,
                .fx = kRenderFxGlowShell,
                .r = (__float_Charge < 0.700_000 ? 255 : 0),
                .g = _,
                .b = (__float_Charge < 0.700_000 ? 255 : 0),
                .render = kRenderNormal,
                .amount = (__float_Charge < 0.700_000 ? 6 : 8));
        }
    }
}

/*==================================================================================================
POST-USE.
==================================================================================================*/

public @RemoveData(const __int_Index)
{
    @StopAnimation(__int_Index, 2);

    __int_Capsule &= ~(1 << __int_Index);

    if(is_valid_ent(entity_get_edict(__int_Index, EV_ENT_euser1)))
    {
        remove_entity(entity_get_edict(__int_Index, EV_ENT_euser1));
    }
}

public @IsPlayerBusy(const __int_Index)
{
    if(getClientPOWERUP(__int_Index) && !getClientXFROZEN(__int_Index)
    || getClientSWOOPING(__int_Index)
    || getClientBLOCK(__int_Index)
    || getClientATKSHOOT(__int_Index)
    || getClientMELEE(__int_Index)
    || getClientMELEEPUSHBACK(__int_Index)
    || getClientTHROWAWAY(__int_Index)
    || getClientTHROW(__int_Index)
    || getClientWALLGND(__int_Index))
    {
        return 1;
    }

    return 0;
}

public @RemoveChargeReferences(const __int_Index)
{
    if(task_exists(__int_Index))
    {
        remove_task(__int_Index);
    }

    message_begin(MSG_ALL, get_user_msgid("StopPowerup"));
    {
        write_byte(__int_Index);
    }
    message_end();

    set_rendering(__int_Index, kRenderFxNone, _, _, _, kRenderNormal);
}

public @ReturnAnimation(const __int_Index, const __int_Wich)
{
    return (__int_Sequence[__int_Wich] & (1 << __int_Index)); // Handle.
}

public @StartAnimation(const __int_Index, const __int_Wich)
{
    if(__int_Wich == 0) // Hold.
    {
        __int_Sequence[0] |= (1 << __int_Index);
    }

    else // Throw.
    {
        __int_Sequence[1] |= (1 << __int_Index);
    }
}

public @StopAnimation(const __int_Index, const __int_Wich)
{
    if(__int_Wich == 0) // Hold.
    {
        __int_Sequence[0] &= ~(1 << __int_Index);
    }

    else if(__int_Wich == 1) // Throw.
    {
        __int_Sequence[1] &= ~(1 << __int_Index);
    }

    else // Both.
    {
        __int_Sequence[0] &= ~(1 << __int_Index);
        __int_Sequence[1] &= ~(1 << __int_Index);
    }
}

/*==================================================================================================
END OF THE SPECIAL.
==================================================================================================*/