Boost-Fix by NumB

/**
 *
 * Boost Fix
 *  by Numb
 *
 *
 * Description:
 *  This plugin fixes the collision-box glitch which allows players to boost each other
 *  through the ceiling, and therefor get teleported to whatever is above it. Also it
 *  removes the glitch of players wagging up and down when standing on top of an other
 *  ducked player. One more thing what this plugin does, is removes the ability of ducked
 *  player to jump, if there is another player standing on top.
 *
 *
 * Requires:
 *  FakeMeta
 *  HamSandWich
 *
 *
 * Additional info:
 *  Tested in Counter-Strike 1.6 with amxmodx 1.8.2 (dev build hg21).
 *
 *
 * Notes:
 *  This plugin may not fix all of the conditions due to what players can boost each
 *  other through solid objects. People with high ping may encounter some strange effects
 *  when jumping on top of other players, but those effects are only client-side.
 *
 *
 * Change-Log:
 *
 *  + 1.0
 *  - First release.
 *
 *
 * Downloads:
 *  Amx Mod X forums: https://forums.alliedmods.net/showthread.php?p=1801106#post1801106
 *
**/


#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

#define PLUGIN_NAME "Boost Fix"
#define PLUGIN_VERSION  "1.0"
#define PLUGIN_AUTHOR   "Numb"

#define ENTITY_LIMIT 1381 // realy it's 1380, but we need +1

#define SetPlayerBit(%1,%2)    ( %1 |=  ( 1 << ( %2 & 31 ) ) )
#define ClearPlayerBit(%1,%2)  ( %1 &= ~( 1 << ( %2 & 31 ) ) )
#define CheckPlayerBit(%1,%2)  ( %1 &   ( 1 << ( %2 & 31 ) ) )


new g_iAlive;
new g_iMaxPlayers;
new g_iBoostFix[ENTITY_LIMIT];
new g_iBlocksChanged;
new g_iFMFwd_PostThink_Pre;

public plugin_precache()
    precache_model("models/w_awp.mdl");

public plugin_init()
{
    register_plugin(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR);

    g_iMaxPlayers = clamp(get_maxplayers(), 1, 32);
    new iAllocString = engfunc(EngFunc_AllocString, "info_target");

    new iEnt, bool:bError;
    for( new iPlrId=1; iPlrId<=g_iMaxPlayers; iPlrId++ )
    {
        if( (iEnt=engfunc(EngFunc_CreateNamedEntity, iAllocString))>0 )
        {
            if( g_iBoostFix[iPlrId]>=ENTITY_LIMIT )
            {
                set_pev(iEnt, pev_flags, FL_KILLME);
                bError = true;
                break;
            }

            set_pev(iEnt, pev_classname,  "boost_fix");
            set_pev(iEnt, pev_solid,      SOLID_NOT);
            set_pev(iEnt, pev_movetype,   MOVETYPE_NONE);
            set_pev(iEnt, pev_rendermode, kRenderTransAlpha);
            set_pev(iEnt, pev_renderamt,  0.0);

            engfunc(EngFunc_SetModel, iEnt, "models/w_awp.mdl");
            engfunc(EngFunc_SetSize, iEnt, Float:{-16.015625, -16.015625, -7.0}, Float:{16.015625, 16.015625, 7.0});

            g_iBoostFix[iPlrId] = iEnt;
            g_iBoostFix[iEnt] = iPlrId;
        }
        else
        {
            bError = true;
            break;
        }
    }

    if( bError )
        log_amx("Could not create all boost-fix blocks - stopping plugin activity");
    else
    {
        register_forward(FM_PlayerPreThink, "FM_PlayerPreThink_Post", 1);
        register_forward(FM_AddToFullPack,  "FM_AddToFullPack_Pre",   0);

        RegisterHam(Ham_Spawn,  "player", "Ham_Spawn_player_Post",  1);
        RegisterHam(Ham_Killed, "player", "Ham_Killed_player_Post", 1);
    }
}

public plugin_pause()
{
    g_iAlive = 0;

    if( g_iFMFwd_PostThink_Pre )
    {
        unregister_forward(FM_PlayerPostThink, g_iFMFwd_PostThink_Pre, 0);
        g_iFMFwd_PostThink_Pre = 0;
    }

    if( g_iBlocksChanged>0 )
    {
        for( new iPlrId=1; iPlrId<=g_iMaxPlayers; iPlrId++ )
        {
            if( CheckPlayerBit(g_iBlocksChanged, iPlrId) )
                set_pev(g_iBoostFix[iPlrId], pev_solid, SOLID_NOT);
        }
    }

    g_iBlocksChanged = 0;
}

public plugin_unpause()
{
    new iPlayers[32], iPlayerNum;
    get_players(iPlayers, iPlayerNum, "a");
    for( new iPlayer; iPlayer<iPlayerNum; iPlayer++ )
        SetPlayerBit(g_iAlive, iPlayers[iPlayer]);
}

public client_disconnect(iPlrId)
    ClearPlayerBit(g_iAlive, iPlrId);

public FM_PlayerPreThink_Post(iPlrId)
{
    if( CheckPlayerBit(g_iAlive, iPlrId) )
    {
        g_iBlocksChanged = 0;

        static Float:s_fPlrOrigin[3], Float:s_fOrigin[3], bool:s_bDucked, s_iPlrId;
        pev(iPlrId, pev_origin, s_fPlrOrigin);
        if( pev(iPlrId, pev_flags)&FL_DUCKING )
            s_bDucked = true;
        else
            s_bDucked = false;

        for( s_iPlrId=1; s_iPlrId<=g_iMaxPlayers; s_iPlrId++ )
        {
            if( iPlrId==s_iPlrId )
            {
                if( g_iBoostFix[s_iPlrId] && check_should_fix_boost(s_iPlrId, s_fPlrOrigin, s_bDucked) )
                {
                    s_fOrigin = s_fPlrOrigin;
                    s_fOrigin[2] += (s_bDucked?61.03125:83.03125);
                }
                else
                    continue;
            }
            else if( CheckPlayerBit(g_iAlive, s_iPlrId) && g_iBoostFix[s_iPlrId] )
            {
                pev(s_iPlrId, pev_origin, s_fOrigin);

                if( s_fPlrOrigin[2]<s_fOrigin[2] )
                {
                    if( s_bDucked )
                    {
                        if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                            s_fOrigin[2] -= 25.0;
                        else
                            s_fOrigin[2] -= 43.0;
                    }
                    else
                    {
                        if( !g_iBlocksChanged )
                            g_iBlocksChanged = -1;

                        continue;
                    }
                }
                else if( s_fPlrOrigin[2]>s_fOrigin[2] )
                {
                    if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                        s_fOrigin[2] += 25.0;
                    else
                        continue;

                    if( pev(iPlrId, pev_groundentity)==s_iPlrId )
                        set_pev(iPlrId, pev_groundentity, g_iBoostFix[s_iPlrId]);
                }
                else
                    continue;
            }
            else
                continue;

            set_pev(g_iBoostFix[s_iPlrId], pev_solid, SOLID_BBOX);
            engfunc(EngFunc_SetOrigin, g_iBoostFix[s_iPlrId], s_fOrigin);

            if( g_iBlocksChanged<0 )
                g_iBlocksChanged = 0;

            SetPlayerBit(g_iBlocksChanged, s_iPlrId);
        }

        if( g_iBlocksChanged )
        {
            if( g_iFMFwd_PostThink_Pre )
                unregister_forward(FM_PlayerPostThink, g_iFMFwd_PostThink_Pre, 0);
            g_iFMFwd_PostThink_Pre = register_forward(FM_PlayerPostThink, "FM_PlayerPostThink_Pre", 0);
        }
    }
}

public FM_PlayerPostThink_Pre(iPlrId)
{
    if( g_iBlocksChanged<0 )
        g_iBlocksChanged = 0;

    static s_iPlrId, Float:s_fPlrOrigin[3], s_iFlags, bool:s_bDucked, bool:s_bNotOnGround, Float:s_fOrigin[3];
    pev(iPlrId, pev_origin, s_fPlrOrigin);
    s_iFlags = pev(iPlrId, pev_flags);
    if( s_iFlags&FL_DUCKING )
        s_bDucked = true;
    else
        s_bDucked = false;
    if( s_iFlags&FL_ONGROUND )
        s_bNotOnGround = false;
    else
        s_bNotOnGround = true;
    for( s_iPlrId=1; s_iPlrId<=g_iMaxPlayers; s_iPlrId++ )
    {
        if( CheckPlayerBit(g_iBlocksChanged, s_iPlrId) )
            set_pev(g_iBoostFix[s_iPlrId], pev_solid, SOLID_NOT);

        if( s_bNotOnGround && CheckPlayerBit(g_iAlive, s_iPlrId) )
        {
            pev(s_iPlrId, pev_origin, s_fOrigin);
            if( is_user_below(s_fPlrOrigin, s_fOrigin) )
            {
                if( s_bDucked )
                {
                    if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                        s_fPlrOrigin[0] -= fix_origin_if_needed(iPlrId, s_fPlrOrigin, (s_fOrigin[2]-s_fPlrOrigin[2]), 50.031253, s_bDucked);
                    else
                        s_fPlrOrigin[0] -= fix_origin_if_needed(iPlrId, s_fPlrOrigin, (s_fOrigin[2]-s_fPlrOrigin[2]), 68.031253, s_bDucked);
                }
                else if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                    s_fPlrOrigin[0] -= fix_origin_if_needed(iPlrId, s_fPlrOrigin, (s_fOrigin[2]-s_fPlrOrigin[2]), 54.031253, s_bDucked);
                else
                    s_fPlrOrigin[0] -= fix_origin_if_needed(iPlrId, s_fPlrOrigin, (s_fOrigin[2]-s_fPlrOrigin[2]), 72.031253, s_bDucked);
            }
        }
    }
    g_iBlocksChanged = 0;

    if( g_iFMFwd_PostThink_Pre )
    {
        unregister_forward(FM_PlayerPostThink, g_iFMFwd_PostThink_Pre, 0);
        g_iFMFwd_PostThink_Pre = 0;
    }
}

public FM_AddToFullPack_Pre(iEsHandle, iE, iEnt, iHost, iHostFlags, iPlayer, iPSet)
{
    if( iEnt<=0 || iEnt>=ENTITY_LIMIT )
        return FMRES_IGNORED;
    else if( 0<iHost<=g_iMaxPlayers )
    {
        if( iEnt<=g_iMaxPlayers )
        {
            if( CheckPlayerBit(g_iAlive, iEnt) )
            {
                if( iHost==iEnt )
                {
                    static s_iPlrId;
                    s_iPlrId = pev(iHost, pev_groundentity);

                    if( 0<s_iPlrId<=g_iMaxPlayers )
                    {
                        if( CheckPlayerBit(g_iAlive, s_iPlrId) && g_iBoostFix[s_iPlrId] && pev(s_iPlrId, pev_flags)&FL_DUCKING )
                        {
                            forward_return(FMV_CELL, dllfunc(DLLFunc_AddToFullPack, iEsHandle, iE, iEnt, iHost, iHostFlags, iPlayer, iPSet));
                            set_es(iEsHandle, ES_OnGround, g_iBoostFix[s_iPlrId]);
                            return FMRES_SUPERCEDE;
                        }
                    }
                }
            }
        }
        else if( g_iBoostFix[iEnt] )
        {
            static s_iPlrId;
            s_iPlrId = g_iBoostFix[iEnt];

            if( !CheckPlayerBit(g_iAlive, s_iPlrId) )
                return FMRES_IGNORED;

            static Float:s_fOrigin[3];
            pev(s_iPlrId, pev_origin, s_fOrigin);

            if( iHost==s_iPlrId )
            {
                static bool:s_bDucked;
                if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                    s_bDucked = true;
                else
                    s_bDucked = false;
                if( check_should_fix_boost(s_iPlrId, s_fOrigin, s_bDucked) )
                    s_fOrigin[2] += (s_bDucked?61.03125:83.03125); //63.09375:85.09375);
                else
                    return FMRES_IGNORED;
            }
            else
            {
                static Float:s_fPlrOrigin[3];
                pev(iHost, pev_origin, s_fPlrOrigin);

                if( s_fPlrOrigin[2]<s_fOrigin[2] )
                {
                    if( pev(iHost, pev_flags)&FL_DUCKING )
                    {
                        if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                            s_fOrigin[2] -= 25.0;
                        else
                            s_fOrigin[2] -= 43.0;
                    }
                    else
                        return FMRES_IGNORED;
                }
                else if( s_fPlrOrigin[2]>s_fOrigin[2] )
                {
                    if( pev(s_iPlrId, pev_flags)&FL_DUCKING )
                        s_fOrigin[2] += 25.0;
                    else
                        return FMRES_IGNORED;
                }
                else
                    return FMRES_IGNORED;
            }

            engfunc(EngFunc_SetOrigin, iEnt, s_fOrigin);
            forward_return(FMV_CELL, dllfunc(DLLFunc_AddToFullPack, iEsHandle, iE, iEnt, iHost, iHostFlags, iPlayer, iPSet));
            set_es(iEsHandle, ES_Solid, SOLID_BBOX);
            return FMRES_SUPERCEDE;
        }
    }

    return FMRES_IGNORED;
}

public Ham_Spawn_player_Post(iPlrId)
{
    if( is_user_alive(iPlrId) )
        SetPlayerBit(g_iAlive, iPlrId);
    else
        ClearPlayerBit(g_iAlive, iPlrId);
}

public Ham_Killed_player_Post(iPlrId)
{
    if( is_user_alive(iPlrId) )
        SetPlayerBit(g_iAlive, iPlrId);
    else
        ClearPlayerBit(g_iAlive, iPlrId);
}

bool:is_user_below(Float:fPlrOrigin[3], Float:fOrigin[3])
{
    if( fPlrOrigin[2]>=fOrigin[2] )
        return false;

    if( -32.03125<(fPlrOrigin[0]-fOrigin[0])<32.03125 && -32.03125<(fPlrOrigin[1]-fOrigin[1])<32.03125 )
        return true;

    return false;
}

bool:check_should_fix_boost(iPlrId, Float:fPlrOrigin[3], bool:bDucked)
{
    static Float:s_fOtherOrigin[3], s_iPlayer;
    for( s_iPlayer=1; s_iPlayer<=g_iMaxPlayers; s_iPlayer++ )
    {
        if( iPlrId!=s_iPlayer && CheckPlayerBit(g_iAlive, s_iPlayer) )
        {
            pev(s_iPlayer, pev_origin, s_fOtherOrigin);

            if( bDucked || pev(s_iPlayer, pev_flags)&FL_DUCKING )
            {
                if( 0.0<is_user_on_top(fPlrOrigin, s_fOtherOrigin)<72.03125 )
                    return true;
            }

            /*if( bDucked )
            {
                if( 0.0<is_user_on_top(fPlrOrigin, s_fOtherOrigin)<((pev(s_iPlayer, pev_flags)&FL_DUCKING)?50.03125:54.03125) )
                    return true;
            }
            else if( 0.0<is_user_on_top(fPlrOrigin, s_fOtherOrigin)<((pev(s_iPlayer, pev_flags)&FL_DUCKING)?68.03125:72.03125) )
                return true;*/
        }
    }

    return false;
}

Float:is_user_on_top(Float:fPlrOrigin[3], Float:fOrigin[3])
{
    if( fPlrOrigin[2]<=fOrigin[2] )
        return 0.0;

    if( -32.03125<(fPlrOrigin[0]-fOrigin[0])<32.03125 && -32.03125<(fPlrOrigin[1]-fOrigin[1])<32.03125 )
        return (fPlrOrigin[2]-fOrigin[2]);

    return 0.0;
}

Float:fix_origin_if_needed(iPlrId, Float:fOrigin[3], Float:fDistance, Float:fDist, bool:bDucked)
{
    if( fDistance<fDist )
    {
        static Float:s_fEndPos[3], Float:s_fFraction;
        s_fEndPos = fOrigin;
        s_fEndPos[2] -= (fDist-fDistance);

        engfunc(EngFunc_TraceHull, s_fEndPos, s_fEndPos, DONT_IGNORE_MONSTERS, (bDucked?HULL_HEAD:HULL_HUMAN), iPlrId, 0);
        get_tr2(0, TR_flFraction, s_fFraction);

        if( s_fFraction==1.0 && !get_tr2(0, TR_StartSolid) && !get_tr2(0, TR_AllSolid) && get_tr2(0, TR_InOpen) )
        {
            set_pev(iPlrId, pev_origin, s_fEndPos);
            return (fDist-fDistance);
        }

        return 0.0;
    }

    return 0.0;
}