RSSCombine Grab and Basebuilder

[MYGO.pl]

Hello, do someone can help me to combine 2 plugins to the same function & cmd
I'm using +grab for moving players and +grab for move objects from my basebuilder

Code:

---

#include <amxmodx>
#include <amxmisc>
#include <fakemeta>

new const VERSION[ ] = "1.2.4b1"
new const TRKCVAR[ ] = "grab_plus_version"
#define ADMIN ADMIN_LEVEL_A

new client_data[33][4]
#define GRABBED  0
#define GRABBER  1
#define GRAB_LEN 2
#define FLAGS    3
#define SF_FADEOUT            0x02

#define m_bitsDamageType 76

//Cvar Pointers
new p_enabled, p_players_only
new p_throw_force, p_min_dist, p_speed, p_grab_force
new p_glow_r, p_glow_b, p_glow_g, p_glow_a
new p_fade, p_glow

//Pseudo Constants
new MAXPLAYERS
new SVC_SCREENFADE, SVC_SCREENSHAKE, WTF_DAMAGE

public plugin_init( )
{
        register_plugin( "Grab+", VERSION, "Ian Cammarata" )
        register_cvar( TRKCVAR, VERSION, FCVAR_SERVER )
        set_cvar_string( TRKCVAR, VERSION )
       
        p_enabled = register_cvar( "gp_enabled", "1" )
        p_players_only = register_cvar( "gp_players_only", "0" )
       
        p_min_dist = register_cvar ( "gp_min_dist", "90" )
        p_throw_force = register_cvar( "gp_throw_force", "1500" )
        p_grab_force = register_cvar( "gp_grab_force", "8" )
        p_speed = register_cvar( "gp_speed", "5" )
       
        p_glow_r = register_cvar( "gp_glow_r", "50" )
        p_glow_g = register_cvar( "gp_glow_g", "0" )
        p_glow_b = register_cvar( "gp_glow_b", "0" )
        p_glow_a = register_cvar( "gp_glow_a", "200" )
       
        p_fade = register_cvar( "gp_screen_fade", "1" )
        p_glow = register_cvar( "gp_glow", "1" )
       
        register_clcmd( "+grab", "grab", ADMIN, "bind a key to +grab" )
        register_clcmd( "-grab", "unset_grabbed" )
       
        register_event( "DeathMsg", "DeathMsg", "a" )
       
        register_forward( FM_PlayerPreThink, "fm_player_prethink" )
       
        register_dictionary( "grab_plus.txt" )
       
        MAXPLAYERS = get_maxplayers()
       
        SVC_SCREENFADE = get_user_msgid( "ScreenFade" )
        SVC_SCREENSHAKE = get_user_msgid( "ScreenShake" )
        WTF_DAMAGE = get_user_msgid( "Damage" )
}

public plugin_precache( )
{
        precache_sound( "player/PL_PAIN2.WAV" )
}

public fm_player_prethink(id)
{
    new target
    // Search for a target
    if (client_data[id][GRABBED] == -1)
    {
        new Float:orig[3], Float:ret[3]
        get_view_pos(id, orig)
        ret = vel_by_aim(id, 9999)

        ret[0] += orig[0]
        ret[1] += orig[1]
        ret[2] += orig[2]

        target = traceline(orig, ret, id, ret)

        if (0 < target <= MAXPLAYERS)
        {
            if (is_grabbed(target, id)) return FMRES_IGNORED
            set_grabbed(id, target)
        }
        else if (!get_pcvar_num(p_players_only))
        {
            new movetype
            if (target && pev_valid(target))
            {
                movetype = pev(target, pev_movetype)
                if (!(movetype == MOVETYPE_WALK || movetype == MOVETYPE_STEP || movetype == MOVETYPE_TOSS))
                    return FMRES_IGNORED
            }
            else
            {
                target = 0
                new ent = engfunc(EngFunc_FindEntityInSphere, -1, ret, 12.0)
                while (!target && ent > 0)
                {
                    movetype = pev(ent, pev_movetype)
                    if ((movetype == MOVETYPE_WALK || movetype == MOVETYPE_STEP || movetype == MOVETYPE_TOSS)
                        && ent != id)
                        target = ent
                    ent = engfunc(EngFunc_FindEntityInSphere, ent, ret, 12.0)
                }
            }
            if (target)
            {
                if (is_grabbed(target, id)) return FMRES_IGNORED
                set_grabbed(id, target)
            }
        }
    }

    target = client_data[id][GRABBED]
    // If they've grabbed something
    if (target > 0)
    {
        if (!pev_valid(target) || (pev(target, pev_health) < 1 && pev(target, pev_max_health)))
        {
            unset_grabbed(id)
            return FMRES_IGNORED
        }

        if (target > MAXPLAYERS) grab_think(id)
    }

    // If they're grabbed
    target = client_data[id][GRABBER]
    if (target > 0) grab_think(target)

    return FMRES_IGNORED
}


public grab_think( id ) //id of the grabber
{
        new target = client_data[id][GRABBED]
       
        //Keep grabbed clients from sticking to ladders
        if( pev( target, pev_movetype ) == MOVETYPE_FLY && !(pev( target, pev_button ) & IN_JUMP ) ) client_cmd( target, "+jump;wait;-jump" )
       
        //Move targeted client
        new Float:tmpvec[3], Float:tmpvec2[3], Float:torig[3], Float:tvel[3]
       
        get_view_pos( id, tmpvec )
       
        tmpvec2 = vel_by_aim( id, client_data[id][GRAB_LEN] )
       
        torig = get_target_origin_f( target )
       
        new force = get_pcvar_num( p_grab_force )
       
        tvel[0] = ( ( tmpvec[0] + tmpvec2[0] ) - torig[0] ) * force
        tvel[1] = ( ( tmpvec[1] + tmpvec2[1] ) - torig[1] ) * force
        tvel[2] = ( ( tmpvec[2] + tmpvec2[2] ) - torig[2] ) * force
       
        set_pev( target, pev_velocity, tvel )
}

stock Float:get_target_origin_f( id )
{
        new Float:orig[3]
        pev( id, pev_origin, orig )
       
        //If grabbed is not a player, move origin to center
        if( id > MAXPLAYERS )
        {
                new Float:mins[3], Float:maxs[3]
                pev( id, pev_mins, mins )
                pev( id, pev_maxs, maxs )
               
                if( !mins[2] ) orig[2] += maxs[2] / 2
        }
       
        return orig
}

public grab( id, level, cid )
{
        if( !cmd_access( id, level, cid, 1 ) || !get_pcvar_num( p_enabled ) ) return PLUGIN_HANDLED
       
        if ( !client_data[id][GRABBED] ) client_data[id][GRABBED] = -1       
        screenfade_in( id )
       
        return PLUGIN_HANDLED
}

public screenfade_in( id )
{
        if( get_pcvar_num( p_fade ) )
        {
                message_begin( MSG_ONE, SVC_SCREENFADE, _, id )
                write_short( 10000 ) //duration
                write_short( 0 ) //hold
                write_short( SF_FADE_IN + SF_FADE_ONLYONE ) //flags
                write_byte( get_pcvar_num( p_glow_r ) ) //r
                write_byte( get_pcvar_num( p_glow_g ) ) //g
                write_byte( get_pcvar_num( p_glow_b ) ) //b
                write_byte( get_pcvar_num( p_glow_a ) / 2 ) //a
                message_end( )
        }
}

public throw( id )
{
        new target = client_data[id][GRABBED]
        if( target > 0 )
        {
                set_pev( target, pev_velocity, vel_by_aim( id, get_pcvar_num(p_throw_force) ) )
                unset_grabbed( id )
                return PLUGIN_HANDLED
        }

        return PLUGIN_CONTINUE
}

public unset_grabbed( id )
{
        new target = client_data[id][GRABBED]
        if( target > 0 && pev_valid( target ) )
        {
                set_pev( target, pev_renderfx, kRenderFxNone )
                set_pev( target, pev_rendercolor, {255.0, 255.0, 255.0} )
                set_pev( target, pev_rendermode, kRenderNormal )
                set_pev( target, pev_renderamt, 16.0 )
               
                if( 0 < target <= MAXPLAYERS )
                        client_data[target][GRABBER] = 0
        }
        client_data[id][GRABBED] = 0
       
        if( get_pcvar_num( p_fade ) )
        {
                message_begin( MSG_ONE, SVC_SCREENFADE, _, id )
                write_short( 10000 ) //duration
                write_short( 0 ) //hold
                write_short( SF_FADEOUT ) //flags
                write_byte( get_pcvar_num( p_glow_r ) ) //r
                write_byte( get_pcvar_num( p_glow_g ) ) //g
                write_byte( get_pcvar_num( p_glow_b ) ) //b
                write_byte( get_pcvar_num( p_glow_a ) / 2 ) //a
                message_end( )
        }
}

//Grabs onto someone
public set_grabbed( id, target )
{
        if( get_pcvar_num( p_glow ) )
        {
                new Float:color[3]
                color[0] = get_pcvar_float( p_glow_r )
                color[1] = get_pcvar_float( p_glow_g )
                color[2] = get_pcvar_float( p_glow_b )
                set_pev( target, pev_renderfx, kRenderFxGlowShell )
                set_pev( target, pev_rendercolor, color )
                set_pev( target, pev_rendermode, kRenderTransColor )
                set_pev( target, pev_renderamt, get_pcvar_float( p_glow_a ) )
        }
       
        if( 0 < target <= MAXPLAYERS )
                client_data[target][GRABBER] = id
        client_data[id][FLAGS] = 0
        client_data[id][GRABBED] = target
        new Float:torig[3], Float:orig[3]
        pev( target, pev_origin, torig )
        pev( id, pev_origin, orig )
        client_data[id][GRAB_LEN] = floatround( get_distance_f( torig, orig ) )
        if( client_data[id][GRAB_LEN] < get_pcvar_num( p_min_dist ) ) client_data[id][GRAB_LEN] = get_pcvar_num( p_min_dist )
}


public is_grabbed( target, grabber )
{
        for( new i = 1; i <= MAXPLAYERS; i++ )
                if( client_data[i][GRABBED] == target )
                {
                        client_print( grabber, print_chat, "[AMXX] %L", grabber, "ALREADY" )
                        unset_grabbed( grabber )
                        return true
                }
        return false
}

public DeathMsg( )
        kill_grab( read_data( 2 ) )

public client_disconnect( id )
{
        kill_grab( id )
        return PLUGIN_CONTINUE
}

public kill_grab( id )
{
        //If given client has grabbed, or has a grabber, unset it
        if( client_data[id][GRABBED] )
                unset_grabbed( id )
        else if( client_data[id][GRABBER] )
                unset_grabbed( client_data[id][GRABBER] )
}

stock traceline( const Float:vStart[3], const Float:vEnd[3], const pIgnore, Float:vHitPos[3] )
{
        engfunc( EngFunc_TraceLine, vStart, vEnd, 0, pIgnore, 0 )
        get_tr2( 0, TR_vecEndPos, vHitPos )
        return get_tr2( 0, TR_pHit )
}

stock get_view_pos( const id, Float:vViewPos[3] )
{
        new Float:vOfs[3]
        pev( id, pev_origin, vViewPos )
        pev( id, pev_view_ofs, vOfs )               
       
        vViewPos[0] += vOfs[0]
        vViewPos[1] += vOfs[1]
        vViewPos[2] += vOfs[2]
}

stock Float:vel_by_aim( id, speed = 1 )
{
        new Float:v1[3], Float:vBlah[3]
        pev( id, pev_v_angle, v1 )
        engfunc( EngFunc_AngleVectors, v1, v1, vBlah, vBlah )
       
        v1[0] *= speed
        v1[1] *= speed
        v1[2] *= speed
       
        return v1
}

---

That the lines of the move objects of basebuilder

Code:

---

public cmdMoveEnt(id)
{
    if (g_BuildBan[id] == true)
        return PLUGIN_HANDLED
   
    if (g_iszombie[id] && !access(id, AFTER_BUILD))
              return PLUGIN_HANDLED
           
    if (!g_CanBuild && !access(id, AFTER_BUILD))
    {
        client_print (id, print_center, "%L", LANG_SERVER, "FAIL_TIME_UP")
        return PLUGIN_HANDLED
    }
   
    if (!g_isalive[id] && !access(id, DEAD_BUILD))
    {
        client_print (id, print_center, "%L", LANG_SERVER, "FAIL_DEAD")
        return PLUGIN_HANDLED
    }

    if (g_pEnt[id] && is_valid_ent(g_pEnt[id]))
        cmdStopEnt(id)
   
    new ent, bodypart
    get_user_aiming (id,ent,bodypart)
   
    if (!is_valid_ent(ent) || ent == g_iEntBarrier)
    {
        return PLUGIN_HANDLED
    }
   
    if (ent <= g_MaxPlayers && g_isalive[ent])
    {   
        return PLUGIN_HANDLED
    }
       
    if (IsBlockLocked(ent) || g_MovingEnt[ent])
    {
        return PLUGIN_HANDLED
    }

    if (get_pcvar_num(g_pcvar_claimable) == 1)
    {
        if (!g_EntOwner[ent])
        {
            if ((g_OwnedEnts[id]<get_pcvar_num(g_pcvar_maxclaimable)) || get_pcvar_num(g_pcvar_maxclaimable) == 0)
            {
                g_EntOwner[ent] = id
                g_OwnedEnts[id]++
            }
            else
            {
                client_print (id, print_center, "%L", LANG_SERVER, "FAIL_MAXOWNED", get_pcvar_num(g_pcvar_maxclaimable))
                //return PLUGIN_HANDLED
            }
        }
        else if (g_EntOwner[ent] != id && !access(id, AFTER_BUILD))
        {
            client_print (id, print_center, "%L", LANG_SERVER, "FAIL_ALREADYOWNED")
            return PLUGIN_HANDLED
        }
    }
   
    new tname[7], cname[10];
    entity_get_string(ent, EV_SZ_targetname, tname, 6);
    entity_get_string(ent, EV_SZ_classname, cname, 9);
    if (!equal(cname, "func_wall") || equal(tname, "ignore"))
    {
        return PLUGIN_HANDLED
    }
   
    new origin[3], entOrigin[3], Float:orig[3], Float:mins[3], Float:maxs[3], dist
   
    entity_get_vector(ent, EV_VEC_origin, orig);
    entity_get_vector(ent, EV_VEC_mins, mins);
    entity_get_vector(ent, EV_VEC_maxs, maxs);

    entOrigin[0] = floatround((mins[0] + maxs[0]) / 2 + orig[0]);
    entOrigin[1] = floatround((mins[1] + maxs[1]) / 2 + orig[1]);
    entOrigin[2] = floatround((mins[2] + maxs[2]) / 2 + orig[2]);
   
    get_user_origin(id, origin);

    dist = get_distance(origin, entOrigin);
   
    new max = get_pcvar_num(g_pcvar_entmaxdist)
    new min = get_pcvar_num(g_pcvar_entmindist)
    if (min) //min
    {
        if(dist < min) //minimum
            dist = get_pcvar_num(g_pcvar_entsetdist);
    }

    if (max) //maximum
    {
        if (dist > max)
            return PLUGIN_HANDLED
    }
   
    DispatchKeyValue(ent, "rendermode", "1");
    DispatchKeyValue(ent, "renderamt", "100");
    DispatchKeyValue(ent, "rendercolor", g_szColors[g_iGrabColor[id]])

    g_MovingEnt[ent] = true
    g_EntMover[ent] = id
    g_pEnt[id] = ent
    g_pDist[id] = dist
   
    if (!g_CanBuild && access(id, AFTER_BUILD))
    {
        new adminauthid[35],adminname[35]
        get_user_authid (id,adminauthid,34)
        get_user_name(id,adminname,34)
        Log("[MOVE] Admin: %s || SteamID: %s moved an entity", adminname, adminauthid)
    }
   
    return PLUGIN_HANDLED
}

---

Przeczytaj cały wpis