[Natsheh]

Hello community i made this topic to gather around all the useful stocks and function that had been created/written by the community, feel free to post/create any useful global functions/stocks that can help us coders with creating plugins and shorten our coding time : 3

~ LIST ~

Seperate_Digital_Categories

PHP Code:

stock Seperate_Digital_Categories(const charSeperator=' ', const szString[], szValue[], len)
{
    new iStrLen = strlen(szString), index = -1, iCounts;

    while( ++index < iStrLen )
    {
        if(!isdigit(szString[ index ]))
        {
            continue;
        }

        iCounts++;
    }

    if(!iCounts)
    {
        return false;
    }

    const CATEGORY_SIZE = 3;

    new iSkip = (iCounts % CATEGORY_SIZE), iCategory = CATEGORY_SIZE - iSkip;

    index = -1;
    iCounts = 0;

    while( ++index < iStrLen )
    {
        if(!isdigit(szString[ index ]))
        {
            continue;
        }

        if(++iCounts)
        {
            if(iCounts > len)
            {
                szValue[ iCounts-1 ] = szString[ index ];
                break;
            }

            szValue[ iCounts-1 ] = szString[ index ];

            if((++iCategory % CATEGORY_SIZE) == 0)
            {
                iCounts++;
                szValue[ iCounts-1 ] = charSeperator;
            }
        }
    }

    return true;
} 


ExterminateFolderContent

PHP Code:

stock ExterminateFolderContent(const szFolder[]="myStupidFoler/", iTimeStamp=0)
{
    if(iTimeStamp <= 0) iTimeStamp = get_systime();

    new iDir, szFile[ 32 ] , szFullFile[ 128 ], iDeleted;

    if ( ( iDir = open_dir( szFolder , szFile , charsmax( szFile ) ) ) )
    {
        do
        {
            formatex( szFullFile , charsmax( szFullFile ) , "%s%s" , szFolder , szFile );
            if ( GetFileTime(szFullFile, FileTime_Created) < iTimeStamp ) 
            {
                if( delete_file( szFullFile ) == 1 )
                   iDeleted++;
            }
        }
        while ( next_file( iDir , szFile , charsmax( szFile ) ) )

        
        close_dir( iDir );
        return iDeleted;
    }
    else
    {
        log_error( AMX_ERR_NOTFOUND, "Directory's not found: %s" , szFolder );
        return -1;
    }

    return 0;
} 


GetTopPlayers

PHP Code:

GetTopPlayers(TopFraggersCount=3, TopFraggersList[MAX_PLAYERS], const funcComparePlayersStats[])
{
    static players[MAX_PLAYERS], pnum;
    get_players(players, pnum, "h");

    if(!pnum) return 0;

    if(TopFraggersCount > pnum) TopFraggersCount = pnum;

    new iListCount;

    for(new j, i, player, chosen, iPointer, iFuncID = get_func_id(funcComparePlayersStats); j < TopFraggersCount; j++)
    {
        chosen = players[ (iPointer=0) ];

        for(i = 1; i < pnum; i++)
        {
            player = players[ i ];

            if(callfunc_begin_i(iFuncID) == 1)
            {
                callfunc_push_int(chosen);
                callfunc_push_int(player);
                if(callfunc_end() == 1)
                {
                    chosen = player;
                    iPointer = i;
                }
            }
        }

        players[ iPointer ] = players[ --pnum ];
        TopFraggersList[ iListCount++ ] = chosen;
    }

    return iListCount;
} 


entity_explosion_knockback

PHP Code:

/* Requires XS & Engine & FM include file */
stock entity_explosion_knockback(victim, Float:fExpOrigin[3], Float:fExpShockwaveRadius=500.0, Float:fExpShockwavePower=500.0)
{
    new Float:fOrigin[3], Float:fDistVec[3];
    if(pev(victim, pev_solid) == SOLID_BSP)
    {
        get_brush_entity_origin(victim, fOrigin);
    }
    else
    {
        pev(victim, pev_origin, fOrigin);
    }

    xs_vec_sub(fOrigin, fExpOrigin, fDistVec);

    new Float:fTemp;
    // victim is in the range of the shockwave explosion!
    if((fTemp=xs_vec_len(fDistVec)) <= fExpShockwaveRadius)
    {
        new Float:fPower = fExpShockwavePower * ( 1.0 - ( fTemp / floatmax(fExpShockwaveRadius, 1.0) ) ), Float:fVelo[3], Float:fKnockBackVelo[3];
        if(fTemp == 0.0)
        {
            xs_vec_set(fDistVec, random_float(-1.0,1.0), random_float(-1.0,1.0), 1.0);
        }

        pev(victim, pev_velocity, fVelo);
        xs_vec_normalize(fDistVec, fKnockBackVelo);
        xs_vec_mul_scalar(fKnockBackVelo, fPower, fKnockBackVelo);
        xs_vec_add(fVelo, fKnockBackVelo, fVelo);
        set_pev(victim, pev_velocity, fVelo);
    }
} 


find_location_around_origin

PHP Code:

find_location_around_origin(Float:fOrigin[3], const Float:fMaxs[3], const Float:fMins[3], const Float:fDistance, const bool:bRandom=false, &Array:pArrayLocations = any:-1)
{
    floor_origin(fOrigin, fOrigin);
    fOrigin[2] += floatabs(fMins[2]);

    static iTr2, Float:fTestOrigin[3], Float:fStart[3], Float:fEnd[3], Float:fYShift, Float:fXShift, i, d, iSafe;

    static iOrder[][][3] =
    {
        { {  0,  0,  1 }, {  0,  0, -1 } }, // Inner line
        { {  1,  1,  1 }, {  1,  1, -1 } }, // 4 square lines SIDES
        { { -1, -1,  1 }, { -1, -1, -1 } },
        { { -1,  1,  1 }, { -1,  1, -1 } },
        { {  1, -1,  1 }, {  1, -1, -1 } },
        { {  1,  1,  1 }, { -1,  1,  1 } }, // 4 square lines TOP
        { {  1,  1,  1 }, {  1, -1,  1 } },
        { { -1, -1,  1 }, { -1,  1,  1 } },
        { { -1, -1,  1 }, {  1, -1,  1 } },
        { {  1,  1, -1 }, { -1,  1, -1 } }, // 4 square lines BOTTOM
        { {  1,  1, -1 }, {  1, -1, -1 } },
        { { -1, -1, -1 }, { -1,  1, -1 } },
        { { -1, -1, -1 }, {  1, -1, -1 } },
        { {  1,  1,  1 }, { -1,  1, -1 } }, // front cross
        { {  1,  1, -1 }, { -1,  1,  1 } },
        { {  1, -1,  1 }, { -1, -1, -1 } }, // back cross
        { {  1, -1, -1 }, { -1, -1,  1 } },
        { {  1,  1,  1 }, {  1, -1, -1 } }, // right cross
        { {  1,  1, -1 }, {  1, -1,  1 } },
        { { -1,  1,  1 }, { -1, -1, -1 } }, // left cross
        { { -1,  1, -1 }, { -1, -1,  1 } },
        { {  1,  1,  1 }, { -1, -1,  1 } }, // up cross
        { {  1, -1,  1 }, { -1,  1,  1 } },
        { {  1,  1, -1 }, { -1, -1, -1 } }, // down cross
        { {  1, -1, -1 }, { -1,  1, -1 } }
    };

    fXShift = (fMaxs[0] - fMins[0]) ;
    fYShift = (fMaxs[1] - fMins[1]) ;

    const sizeofOrder = sizeof iOrder;

    iTr2 = create_tr2();

    fTestOrigin[1] = fOrigin[1] + fDistance;
    fTestOrigin[2] = fOrigin[2];

    static Float:fAngle, Float:fvBegin[3], Array:pTempArray=Invalid_Array;

    if(bRandom || pArrayLocations != Array:-1)
    {
        pTempArray = ArrayCreate(3, 1);
    }

    while( floatabs(fTestOrigin[1] - fOrigin[1]) <= fDistance  )
    {
        fAngle = floatasin( (fTestOrigin[1] - fOrigin[1]) / fDistance, degrees );
        fvBegin[0] = floatcos(fAngle,degrees) * fDistance;
        fvBegin[1] = floatsin(fAngle,degrees) * fDistance;
        fTestOrigin[0] = fOrigin[0] + fvBegin[0];

        while( get_distance_f(fTestOrigin, fOrigin) <= fDistance )
        {
            for( i = iSafe = 0; i < sizeofOrder; i++ )
            {
                for( d = 0; d < 3; d++ )
                {
                    switch( iOrder[i][0][d] )
                    {
                        case -1: fStart[d] = fTestOrigin[d] + fMins[d];
                        case 0: fStart[d] = fTestOrigin[d];
                        case 1: fStart[d] = fTestOrigin[d] + fMaxs[d];
                    }

                    switch( iOrder[i][1][d] )
                    {
                        case -1: fEnd[d] = fTestOrigin[d] + fMins[d];
                        case 0: fEnd[d] = fTestOrigin[d];
                        case 1: fEnd[d] = fTestOrigin[d] + fMaxs[d];
                    }
                }

                // Traces...
                engfunc(EngFunc_TraceLine, fStart, fEnd, DONT_IGNORE_MONSTERS, -1, iTr2);

                if(get_tr2(iTr2, TR_pHit) == -1 && get_tr2(iTr2, TR_InOpen) && !get_tr2(iTr2, TR_StartSolid) && !get_tr2(iTr2, TR_AllSolid))
                {
                    iSafe++;
                    continue;
                }
                break;
            }

            if(iSafe >= sizeofOrder)
            {
                if(pTempArray == Invalid_Array)
                {
                    xs_vec_copy(fTestOrigin, fOrigin);
                    free_tr2(iTr2);
                    return 1;
                }

                ArrayPushArray(pTempArray, fTestOrigin);
            }

            fTestOrigin[0] -= fXShift;
        }

        fTestOrigin[1] -= fYShift;
    }

    if(pTempArray != Invalid_Array)
    {
        if((i=ArraySize(pTempArray)) && bRandom)
        {
            ArrayGetArray(pTempArray, random(i), fOrigin);
        }

        if(pArrayLocations == any:-1)
        {
            ArrayDestroy(pTempArray);
        }
        else
        {
            pArrayLocations = pTempArray;
        }

        pTempArray = Invalid_Array;
        free_tr2(iTr2);
        return i;
    }

    free_tr2(iTr2);
    return 0;
} 


[Natsheh]

Reserved!

[fysiks]

I don't think that this is all that helpful. It's an entirely too vauge grouping and will just get lost.

"Seperate_Digital_Categories", what in the world does that mean?

Exterminate"? I don't think that that word has any usefulness in the context of programming. The concept of deleting or removing something based on "before or after a certain date" is known as pruning IIRC. Also, the default values that you've assigned to this function make it do absolutely nothing which doesn't make any sense. If a default value doesn't actually do anything then it shouldn't exist.

I don't think that low-level stocks should be writing anything to any files, calling process should be the one to do that.

[Natsheh]

Originally Posted by fysiks I don't think that this is all that helpful. It's an entirely too vauge grouping and will just get lost.

I have to disagree with you, i think this thread would be very helpful and will make stuff much easier among programming plugins, because you don't have to rethink the whole logarithm and consume time for something already been done.

Originally Posted by fysiks "Seperate_Digital_Categories", what in the world does that mean?

its a simple function divides/separates 3 numbers in a string into a single digital houses. ex: "1000000" will be "1 000 000"

Originally Posted by fysiks Exterminate"? I don't think that that word has any usefulness in the context of programming. The concept of deleting or removing something based on "before or after a certain date" is known as pruning IIRC. Also, the default values that you've assigned to this function make it do absolutely nothing which doesn't make any sense. If a default value doesn't actually do anything then it shouldn't exist.

You are correct i just copied that from an old thread, feel free to improve it.

Originally Posted by fysiks I don't think that low-level stocks should be writing anything to any files, calling process should be the one to do that.

IN addition this topic is going to be extreme helpful for new beginners.

[fysiks]

Perhaps you should provide documentation about what you think your functions do so people don't have to guess based on the confusing function names.

Originally Posted by Natsheh its a simple function divides/separates 3 numbers in a string into a single digital houses. ex: "1000000" will be "1 000 000"

The one posted here that was created by Bugsy is much better for reusable code. The delimiter to be used can easily be added as the fourth parameter with a default value of ','.

Originally Posted by Natsheh You are correct i just copied that from an old thread, feel free to improve it.

I'm unable to edit your post.

Originally Posted by Natsheh IN addition this topic is going to be extreme helpful for new beginners.

That is debatable. If you teach poor or confusing code, they'll learn those same bad habits. But I guess that's the nature of the internet, both good and bad exist.

[Natsheh]

Originally Posted by fysiks Perhaps you should provide documentation about what you think your functions do so people don't have to guess based on the confusing function names.

I highly agree with you, i will find a free time to work on the documentation.

Originally Posted by fysiks The one posted here that was created by Bugsy is much better for reusable code. The delimiter to be used can easily be added as the fourth parameter with a default value of ','.

The difference between my function and bugsy function that bugsy function deals with integers while my code deal with strings, and it can be useful to dig out my numbers out of characters.

Originally Posted by fysiks I'm unable to edit your post.

You can notify me with a post, and I'll edit the first post after all this thread was meant for everyone to contribute.

[fysiks]

Originally Posted by Natsheh The difference between my function and bugsy function that bugsy function deals with integers while my code deal with strings, and it can be useful to dig out my numbers out of characters.

That doesn't make any sense. Where would that even be used?

[EFFx]

randomOriginAroundEntity

Spoiler

PHP Code:

randomOriginAroundEntity(ent, original[3], Float:Radius)
{
    static range, origin[3], counter, i;
    range = floatround(Radius);

    for (i = 1; i <= 5; i++) {
        counter = 1;

        origin[0] = original[0] + random_num(-range, range);
        origin[1] = original[1] + random_num(-range, range);
        origin[2] = original[2];
        origin[2] = ground_z(origin, ent);

        while (get_distance(origin, original) > range) 
        {
            origin[0] = original[0] + random_num(-range, range);
            origin[1] = original[1] + random_num(-range, range);
            origin[2] = original[2];

            if (++counter >= 10) origin[2] = ground_z(origin, ent, 1);
            else origin[2] = ground_z(origin, ent);
        }

        // origin is origins generated
    }
}

ground_z(origin[3], ent, skip = 0, recursion = 0)
{
    origin[2] += random_num(5, 80);

    if (!pev_valid(ent)) return origin[2];

    new Float:tempOrigin[3];

    IVecFVec(origin, tempOrigin);
    set_pev(ent, pev_origin, tempOrigin);
    engfunc(EngFunc_DropToFloor, ent);

    if (!skip && !engfunc(EngFunc_EntIsOnFloor, ent)) {
        if (recursion >= 10) skip = 1;

        return ground_z(origin, ent, skip, ++recursion);
    }

    pev(ent, pev_origin, tempOrigin);

    return floatround(tempOrigin[2]);
} 


get_time_played

Spoiler

Convert a certain time to year/month/day/hours/minutes/seconds

PHP Code:

get_time_played(iTime, &iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond) 
{ 
    iTime -= 31536000 * (iYear = iTime / 31536000) 
    iTime -= 2678400 * (iMonth = iTime / 2678400) 
    iTime -= 86400 * (iDay = iTime / 86400) 
    iTime -= 3600 * (iHour = iTime / 3600) 
    iTime -= 60 * (iMinute = iTime / 60) 
    iSecond = iTime 
    
    return 1
} 


Get wall thickness from Arkshine

Spoiler

PHP Code:

getWallThickness(const player)
{
    new Float:source[3], Float:direction[3], Float:end[3]
    new Float:fraction
    
    pev(player, pev_origin, source)
    pev(player, pev_view_ofs, direction)
    xs_vec_add(source, direction, source)
    
    pev(player, pev_v_angle, direction)
    engfunc(EngFunc_MakeVectors, direction)
    global_get(glb_v_forward, direction)
    
    xs_vec_mul_scalar(direction, 9999.0, end)
    xs_vec_add(source, end, end)
    
    engfunc(EngFunc_TraceLine, source, end, IGNORE_MONSTERS, player, 0)
    get_tr2(0, TR_flFraction, fraction)
    if(fraction == 1.0)
    {
        return 0
    }
    get_tr2(0, TR_vecEndPos, end)
    
    new Float:fStartOfWall[3]
    xs_vec_copy(end, fStartOfWall)

    xs_vec_mul_scalar(direction, 2.0, direction)
    xs_vec_add(end, direction, source)
    xs_vec_mul_scalar(direction, 9999.0, direction)
    xs_vec_add(source, direction, end)
    
    engfunc(EngFunc_TraceLine, source, end, IGNORE_MONSTERS | IGNORE_GLASS, player, 0)
    get_tr2(0, TR_flFraction, fraction)

    if((fraction == 1.0) || get_tr2(0, TR_AllSolid))
    {
        return 0
    }
    end = source
    get_tr2(0, TR_vecEndPos, source)
    
    engfunc(EngFunc_TraceLine, source, end, IGNORE_MONSTERS | IGNORE_GLASS, player, 0)
    get_tr2(0, TR_vecEndPos, end)
    return floatround(vector_distance(fStartOfWall, end))
} 


formatLowNumber:

Spoiler

Just a simple stock to add a little detail on too low values.
If a message has 0.1, instead of 0.100 as default %0.3f will display
It will convert to only 0.1
Converts 0.101 to 0.1
Converts 0.111 to 0.1
Converts 0.010 to 0.01
Converts 0.011 to 0.01
0.001 stays 0.001

PHP Code:

formatLowNumber(szNumber[], iLen, Float:fValue)
{
    formatex(szNumber, iLen, "%0.3f", fValue)
    for(new i, bool:bFound, szValue[1];i < strlen(szNumber) - 1;i++)
    {
        szValue[0] = szNumber[i]
        if(!bFound && isdigit(szValue[0]) && (str_to_num(szValue) != 0))
        {
            bFound = true
            continue
        }
        
        if(bFound)
        {
            szNumber[i] = EOS
        }
    }
    format(szNumber, iLen, "%s", szNumber)
} 


moveEntityTowardsAnotherEntity // throw an entity towards another

Spoiler

PHP Code:

moveEntityTowardsAnotherEntity(iEntityToFly, iEntityVictim)
{
    static Float:fGrapplerOrigin[3], Float:fUsrOrigin[3]
    pev(iEntityToFly, pev_origin, fGrapplerOrigin)
    pev(iEntityVictim, pev_origin, fUsrOrigin)
        
    new Float:fDist = vector_distance(fGrapplerOrigin, fUsrOrigin)
    if(fDist >= 30.0)
    {
        const Float:fSpeed = 400.0
        fVelocity[0] = (fGrapplerOrigin[0] - fUsrOrigin[0]) * (2.0 * fSpeed) / fDist
        fVelocity[1] = (fGrapplerOrigin[1] - fUsrOrigin[1]) * (2.0 * fSpeed) / fDist
        fVelocity[2] = (fGrapplerOrigin[2] - fUsrOrigin[2]) * (2.0 * fSpeed) / fDist

        fVelocity[2] += 300.0
    }
    set_pev(iEntityToFly, pev_velocity, fVelocity)
} 


Radius Damage by Exolent

Spoiler

PHP Code:

RadiuzDamage( iEntity, Float:flDamage, Float:flRadius ) {
    new Float:vExplodeAt[ 3 ];
    pev( iEntity, pev_origin, vExplodeAt );
    
    new id = FM_NULLENT, Float:flTakeDamage, Float:vOrigin[ 3 ], Float:flAdjustedDamage;
    
    while( ( id = engfunc( EngFunc_FindEntityInSphere, id, vExplodeAt, flRadius ) ) != 0 ) {
        if( id == iEntity )
            continue;
        
        pev( id, pev_takedamage, flTakeDamage );
        if( flTakeDamage == DAMAGE_NO )
            continue;
        
        if( is_user_alive( id ) ) {
            pev( id, pev_origin, vOrigin );
            
            flAdjustedDamage = flDamage - get_distance_f( vExplodeAt, vOrigin ) * flDamage / flRadius;
            
            ExecuteHamB( Ham_TakeDamage, id, iEntity, iEntity, flAdjustedDamage, DMG_GENERIC );
        }
    }
} 


[bigdaddy424]

@EFFx on formatLowNumber can't you use floatround and then strip the zeros left?

[EFFx]

Originally Posted by bigdaddy424 @EFFx on formatLowNumber can't you use floatround and then strip the zeros left?

To be honest I didn't try. The original stock was checking whole string message and if inside it contains a low float number, it converts... like

"Something happened blabla 0.01 seconds or time"

The stock takes everything besides the low float number and converts it. Instead of just adding %0.2f and having 0.10 when the value is 0.1, it prints 0.1 instead. The older version also finds players name inside the message, to avoid having a low float number inside the players name and thinking it's the actual low number. If you add as example %0.5f and have a number 0.00100, it'll print 0.001 only.

Not sure if with floatround it'll do 100x faster than that stock, but I've found this a long time ago and used so many times.