Semiclip Ultimate

#include <assert.h>

#include "amxxmodule.h"
#include "entity_state.h"

static const size_t MaximumPlayers = 32U;

class Player
{
public:
    bool Solid;
    bool Restore;

    int Team;
};

static Player g_Player[MaximumPlayers + 1U];
static bool g_VariablesRegistered = false;
static cvar_t * g_pEffects = NULL;
static cvar_t * g_pTransparencyAmount = NULL;

void OnAmxxAttach(void)
{

}

void OnAmxxDetach(void)
{

}

void OnMetaAttach(void)
{
    static int Iterator = 0U;

    for (Iterator = 1U; Iterator <= gpGlobals->maxClients; Iterator++)
    {
        g_Player[Iterator].Solid = false;
        g_Player[Iterator].Restore = false;
        g_Player[Iterator].Team = 0U;
    }

    if (!g_VariablesRegistered)
    {
        static cvar_t Version = { "semiclip_extension", "Ultimate", FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_UNLOGGED | FCVAR_SPONLY };
        static cvar_t Effects = { "semiclip_effects", "1", FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_SPONLY };
        static cvar_t TransparencyAmount = { "semiclip_transparency_amount", "180", FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_SPONLY };

        CVAR_REGISTER(&Version);
        CVAR_REGISTER(&Effects);
        CVAR_REGISTER(&TransparencyAmount);

        g_pEffects = CVAR_GET_POINTER(Effects.name);
        g_pTransparencyAmount = CVAR_GET_POINTER(TransparencyAmount.name);

        assert(g_pEffects);
        assert(g_pTransparencyAmount);
    }
}

void OnMetaDetach(void)
{

}

void PlayerPreThink(edict_t * pPlayer)
{
    static int Client = 0U;
    static int Iterator = 0U;
    static int Flag = 0U;

    Client = ENTINDEX(pPlayer);

    if (Flag > Client)
    {
        for (Iterator = 1U; Iterator <= gpGlobals->maxClients; Iterator++)
        {
            if (!MF_IsPlayerAlive(Iterator))
            {
                g_Player[Iterator].Solid = false;

                continue;
            }

            pPlayer = MF_GetPlayerEdict(Iterator);

            g_Player[Iterator].Team = MF_GetPlayerTeamID(Iterator);
            g_Player[Iterator].Solid = pPlayer->v.solid == SOLID_SLIDEBOX ? true : false;
        }
    }

    Flag = Client;

    if (!g_Player[Client].Solid)
    {
        RETURN_META(MRES_IGNORED);
    }

    for (Iterator = 1U; Iterator <= gpGlobals->maxClients; Iterator++)
    {
        if (!g_Player[Iterator].Solid || Client == Iterator || g_Player[Iterator].Team != g_Player[Client].Team)
        {
            continue;
        }

        pPlayer = MF_GetPlayerEdict(Iterator);

        pPlayer->v.solid = SOLID_NOT;

        g_Player[Iterator].Restore = true;
    }

    RETURN_META(MRES_IGNORED);
}

void PlayerPostThink(edict_t *)
{
    static int Iterator = 0U;

    static edict_t * pPlayer = NULL;

    for (Iterator = 1U; Iterator <= gpGlobals->maxClients; Iterator++)
    {
        if (g_Player[Iterator].Restore)
        {
            pPlayer = MF_GetPlayerEdict(Iterator);

            pPlayer->v.solid = SOLID_SLIDEBOX;

            g_Player[Iterator].Restore = false;
        }
    }

    RETURN_META(MRES_IGNORED);
}

int AddToFullPack_Post(entity_state_s * pEntityState, int, edict_t * pEntity, edict_t * pHost, int, int Player, unsigned char *)
{
    if (Player)
    {
        static int Entity = 0U;
        static int Host = 0U;

        Entity = ENTINDEX(pEntity);
        Host = ENTINDEX(pHost);

        if (g_Player[Entity].Solid && g_Player[Host].Solid && g_Player[Entity].Team == g_Player[Host].Team)
        {
            if ((bool) g_pEffects->value)
            {
                pEntityState->rendermode = kRenderTransAlpha;
                pEntityState->renderamt = (int) g_pTransparencyAmount->value;
            }

            pEntityState->solid = SOLID_NOT;
        }
    }

    RETURN_META_VALUE(MRES_IGNORED, 0U);
}