code

enum PropTypeCheck
{
    PROP_NONE = 0,
    PROP_RIGID = 1,
    PROP_PHYSBOX = 2,
    PROP_WEAPON = 3,
    PROP_TF2OBJ = 4,//tf2 buildings
    PROP_RAGDOLL = 5,
    PROP_TF2PROJ = 6//tf2 projectiles
};

new bool:IsRagdoll[2048];
new bool:g_bIsWeaponGrabber[MAXPLAYERS + 1];
new bool:entitygravitysave[MAXPLAYERS + 1];
new Float:grabdistance[MAXPLAYERS + 1];
new Float:playeranglerotate[MAXPLAYERS + 1][3];
new Float:grabangle[MAXPLAYERS + 1][3];
new PropTypeCheck:grabentitytype[MAXPLAYERS + 1];

new keybuffer[MAXPLAYERS + 1];
new grabbedentref[MAXPLAYERS + 1] = {INVALID_ENT_REFERENCE, ...};
new entityownersave[MAXPLAYERS + 1] = {INVALID_ENT_REFERENCE, ...};

new Float:DeathTime[MAXPLAYERS+1];
new String:TargetDescription[2048][6][256];

public const Float:ZERO_VECTOR[3] = {0.0, 0.0, 0.0};

new bool:RoundCheck;

enum matrix3x4_t{

    Float:row0[4],
    Float:row1[4],
    Float:row2[4]

};
public RoundStart(Handle:Spawn_Event, const String:Spawn_Name[], bool:Spawn_Broadcast)
{
    for(new Client = 1; Client <= MaxClients; Client++)
    {
        if(IsClientInGame(Client))
        {
            Job[Client] = 0;
        }
    }
    GameCount = 20;
    if(RoundCheck == false)
    {
        GameStart = false;
        CreateTimer(1.0, Gameset, _, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE);
        RoundCheck = true;
    }
}
public Action:Round_End(Handle:event, const String:Name[], bool:Broadcast)
{
    RoundCheck = false;
}
public EventDeath(Handle:Spawn_Event, const String:Spawn_Name[], bool:Spawn_BroadCast)
{
    new client = GetClientOfUserId(GetEventInt(Spawn_Event, "userid"));
    new Entity = GetEntPropEnt(client, Prop_Send, "m_hRagdoll");

    AcceptEntityInput(Entity, "kill");

    new String:ModelName[256];
    GetClientModel(client, ModelName, 256);

    if(!IsModelPrecached(ModelName))
    {
        PrecacheModel(ModelName, true);
    }
    new Float:Pos[3];

    GetClientAbsOrigin(client, Pos);
    Pos[2] += 20.0;

    new String:TargetName[256];
    Format(TargetName, 256, "%N", client);

    new ragdoll = CreateEntityByName("prop_ragdoll");
    DispatchKeyValue(ragdoll, "targetname", TargetName);
    DispatchKeyValue(ragdoll, "model", ModelName);
    DispatchSpawn(ragdoll);
    SetEntPropEnt(client, Prop_Send, "m_hRagdoll", ragdoll);
    SetEntProp(ragdoll, Prop_Send, "m_nSolidType", 6);
    SetEntProp(ragdoll, Prop_Send, "m_CollisionGroup", 2);
    SetEntityModel(ragdoll, ModelName);
    TeleportEntity(ragdoll, Pos, NULL_VECTOR, NULL_VECTOR);
    SetEntPropVector(ragdoll, Prop_Send, "m_vecOrigin", Pos);

    IsRagdoll[client] = true;

    Format(TargetDescription[ragdoll][0], 256, "%f", DeathTime[client]);
}
public Action:WeaponSwitchHook(client, entity){

    decl String:weaponname[64];
    if (!IsValidEntity(entity)){

        g_bIsWeaponGrabber[client] = false;
        return Plugin_Continue;

    }
    GetEdictClassname(entity, weaponname, sizeof(weaponname));

    //magic number is bad but i am to sleepy to make new defines
    new rulecheck = 2;

    //현재 든 무기가 중력건 기능이 없거나, 기능을 가지고 있어도 물건을 들고있지 않은가
    if(!isWeaponGrabber(GetEntPropEnt(client, Prop_Data, "m_hActiveWeapon")) || EntRefToEntIndex(grabbedentref[client]) == -1 || !Phys_IsPhysicsObject(EntRefToEntIndex(grabbedentref[client]))){

        //든 물건이 없으므로, 바꾸기를 허락
        g_bIsWeaponGrabber[client] = isWeaponGrabber(entity);
        return Plugin_Continue;

    }else{

        //물건을 든 상태에서는 무기 바꾸기를 허락하지 않는다
        if(rulecheck == 0){

            return Plugin_Handled;

        }else{

            g_bIsWeaponGrabber[client] = isWeaponGrabber(entity);
            if(!g_bIsWeaponGrabber[client] || rulecheck == 1) release(client);
            return Plugin_Continue;

        }
    }
}
public PreThinkHook(Client)
{
    if(isClientConnectedIngameAlive(Client))
    {
        new buttons = GetClientButtons(Client);
        if((buttons & IN_ATTACK2))
        {
            if(grabbedentref[Client] == INVALID_ENT_REFERENCE)
            {
                grab(Client);
            }
            else
            {
                if(((buttons & IN_ATTACK2) && !(keybuffer[Client] & IN_ATTACK2)) || !g_bIsWeaponGrabber[Client])
                {
                    //물건을 내려놓는다. try to release something
                    release(Client);

                }
                else
                {
                    //물건을 잡은 상태를 유지한다 try to keep helding object
                    hold(Client);
                }
            }
        }
        else
        {
            keybuffer[Client] = keybuffer[Client] & ~IN_ATTACK2;
        }
    }
}
/*
public Action:OnPlayerRunCmd(Client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapon)
{
    if(isClientConnectedIngameAlive(Client))
    {
        if((buttons & IN_ATTACK2))
        {
            if(grabbedentref[Client] == INVALID_ENT_REFERENCE)
            {
                grab(Client);
            }
            else
            {
                if(((buttons & IN_ATTACK2) && !(keybuffer[Client] & IN_ATTACK2)) || !g_bIsWeaponGrabber[Client])
                {
                    //물건을 내려놓는다. try to release something
                    release(Client);

                }
                else
                {
                    //물건을 잡은 상태를 유지한다 try to keep helding object
                    hold(Client);
                }
            }
        }
        else
        {
            keybuffer[Client] = keybuffer[Client] & ~IN_ATTACK2;
        }
    }
}
*/
grab(client)
{
    new targetentity, Float:distancetoentity, Float:resultpos[3];

    targetentity = GetClientAimEntity(client, distancetoentity, resultpos);

    if(targetentity != -1)
    {
        new PropTypeCheck:entityType = entityTypeCheck(targetentity);

        if(entityType && !isClientConnectedIngameAlive(GetEntPropEnt(targetentity, Prop_Send, "m_hOwnerEntity")))
        {
            if(distancetoentity <= 200.0)
            {
                if(!clientcangrab(client)){

                    return;

                }
                if (entityType == PROP_TF2OBJ && GetEntPropEnt(targetentity, Prop_Send, "m_hBuilder") != client)
                    return;

                grabentitytype[client] = entityType;

                if(entityType == PROP_RIGID){

                    SetEntProp(targetentity, Prop_Data, "m_bFirstCollisionAfterLaunch", false);

                }

                new lastowner = GetEntPropEnt(targetentity, Prop_Send, "m_hOwnerEntity");

                if(lastowner != INVALID_ENT_REFERENCE){

                    entityownersave[client] = EntIndexToEntRef(lastowner);

                }else{

                    entityownersave[client] = INVALID_ENT_REFERENCE;

                }

                SetEntPropEnt(targetentity, Prop_Send, "m_hOwnerEntity", client);
                grabbedentref[client] = EntIndexToEntRef(targetentity);

                SetEntPropEnt(targetentity, Prop_Data, "m_hParent", client);

                //SetEntProp(targetentity, Prop_Data, "m_iEFlags", GetEntProp(targetentity, Prop_Data, "m_iEFlags") | EFL_NO_PHYSCANNON_INTERACTION);

                entitygravitysave[client] = Phys_IsGravityEnabled(targetentity);

                Phys_EnableGravity(targetentity, false);

                decl Float:clienteyeangle[3], Float:entityangle[3];//, Float:entityposition[3];
                GetEntPropVector(grabbedentref[client], Prop_Send, "m_angRotation", entityangle);
                GetClientEyeAngles(client, clienteyeangle);

                playeranglerotate[client][0] = 0.0;
                playeranglerotate[client][1] = 0.0;
                playeranglerotate[client][2] = 0.0;

                grabangle[client][0] = 0.0;
                grabangle[client][1] = 0.0;
                grabangle[client][2] = 0.0;

                grabdistance[client] = 100.0;
                /* GetEntPropVector(grabbedentref[client], Prop_Send, "m_vecOrigin", entityposition);
                grabpos[client][0] = entityposition[0] - resultpos[0];
                grabpos[client][1] = entityposition[1] - resultpos[1];
                grabpos[client][2] = entityposition[2] - resultpos[2]; */

                new matrix[matrix3x4_t];

                matrix3x4FromAnglesNoOrigin(clienteyeangle, matrix);

                decl Float:temp[3];

                MatrixAngles(matrix, temp);

                TransformAnglesToLocalSpace(entityangle, grabangle[client], matrix);

                keybuffer[client] = keybuffer[client] | IN_ATTACK2;

                decl Float:entityposition[3], Float:clientposition[3], Float:vector[3];
                GetEntPropVector(targetentity, Prop_Send, "m_vecOrigin", entityposition);
                GetClientEyePosition(client, clientposition);
                MakeVectorFromPoints(entityposition, clientposition, vector);
                NormalizeVector(vector, vector);
                ScaleVector(vector, 400.0);

                decl Float:ZeroSpeed[3];
                ZeroVector(ZeroSpeed);
                Phys_SetVelocity(targetentity, vector, ZeroSpeed);
//              decl String:netclass[64];
//              GetEntityNetClass(targetentity, netclass, sizeof(netclass));
                if(FindDataMapInfo(targetentity, "m_hPhysicsAttacker") != -1) SetEntPropEnt(targetentity, Prop_Data, "m_hPhysicsAttacker", client);
                if(FindDataMapInfo(targetentity, "m_flLastPhysicsInfluenceTime") != -1) SetEntPropFloat(targetentity, Prop_Data, "m_flLastPhysicsInfluenceTime", GetGameTime());
                PrintToChatAll("DEBUG");
            }
        }
    }
}
release(client){

    if(EntRefToEntIndex(grabbedentref[client]) != -1)
    {
        Phys_EnableGravity(EntRefToEntIndex(grabbedentref[client]), entitygravitysave[client]);
        SetEntPropEnt(grabbedentref[client], Prop_Send, "m_hOwnerEntity", EntRefToEntIndex(entityownersave[client]));
    }
    grabbedentref[client] = INVALID_ENT_REFERENCE;
    keybuffer[client] = keybuffer[client] | IN_ATTACK2;
}
hold(client)
{
    //물건을 어디로 끌어갈지 정한다
    decl Float:resultpos[3], Float:resultvecnormal[3];
    GetClientAimPosition(client, grabdistance[client], resultpos, resultvecnormal, tracerayfilterrocket, client);

    decl Float:entityposition[3], Float:clientposition[3], Float:vector[3];
    GetEntPropVector(grabbedentref[client], Prop_Send, "m_vecOrigin", entityposition);
    GetClientEyePosition(client, clientposition);
    decl Float:clienteyeangle[3];
    GetClientEyeAngles(client, clienteyeangle);

    decl Float:clienteyeangleafterchange[3];

    clienteyeangleafterchange[0] = clienteyeangle[0] + playeranglerotate[client][0];
    clienteyeangleafterchange[1] = clienteyeangle[1] + playeranglerotate[client][1];
    clienteyeangleafterchange[2] = clienteyeangle[2] + playeranglerotate[client][2];

    decl playerlocalspace[matrix3x4_t], playerlocalspaceafterchange[matrix3x4_t];

    matrix3x4FromAnglesNoOrigin(clienteyeangle, playerlocalspace);
    matrix3x4FromAnglesNoOrigin(clienteyeangleafterchange, playerlocalspaceafterchange);

    decl Float:resultangle[3];

    TransformAnglesToWorldSpace(grabangle[client], resultangle, playerlocalspaceafterchange);
    TransformAnglesToLocalSpace(resultangle, grabangle[client], playerlocalspace);

    ZeroVector(playeranglerotate[client]);

    MakeVectorFromPoints(entityposition, resultpos, vector);
    ScaleVector(vector, grabdistance[client]*10);

    //decl Float:entityangle[3], Float:angvelocity[3];
    // GetEntPropVector(grabbedentref[client], Prop_Data, "m_angAbsRotation", entityangle);

    // decl targetanglespace[matrix3x4_t], Float:angletomove[3];
    // matrix3x4FromAnglesNoOrigin(resultangle, targetanglespace);
    // TransformAnglesToLocalSpace(entityangle, angletomove, targetanglespace);

    //angvelocity[0] = entityangle[0] - resultangle[0];
    //angvelocity[1] = entityangle[1] - resultangle[1];
    //angvelocity[2] = entityangle[2] - resultangle[2];

    //ZeroVector(angvelocity);
    // NegateVector(angletomove);

    if(grabentitytype[client] != PROP_RAGDOLL){

        TeleportEntity(grabbedentref[client], NULL_VECTOR, resultangle, NULL_VECTOR);

    }

    Phys_SetVelocity(EntRefToEntIndex(grabbedentref[client]), vector, ZERO_VECTOR, true);

    if(grabentitytype[client] == PROP_RIGID || grabentitytype[client] == PROP_PHYSBOX || grabentitytype[client] == PROP_RAGDOLL){

        SetEntPropEnt(grabbedentref[client], Prop_Data, "m_hPhysicsAttacker", client);
        SetEntPropFloat(grabbedentref[client], Prop_Data, "m_flLastPhysicsInfluenceTime", GetGameTime());

    }
    if(grabentitytype[client] == PROP_RIGID){

        SetEntProp(grabbedentref[client], Prop_Data, "m_bThrownByPlayer", true);

    }
}
PropTypeCheck:entityTypeCheck(entity)
{
    new String:classname[64];
    GetEdictClassname(entity, classname, 64);

    if(StrContains(classname, "prop_physics", false)  != -1)
    {
        return PROP_RIGID;
    }
    else if(StrContains(classname, "func_physbox", false)  != -1)
    {
        return PROP_PHYSBOX;
    }
    else if(StrContains(classname, "prop_ragdoll", false)  != -1)
    {
        return PROP_RAGDOLL;
    }
    else if(StrContains(classname, "weapon_", false)  != -1)
    {
        return PROP_WEAPON;
    }
    else if(StrContains(classname, "tf_projectile", false)  != -1)
    {
        return PROP_TF2PROJ
    }
    else if(StrEqual(classname, "obj_sentrygun", false) || StrEqual(classname, "obj_dispenser", false) || StrEqual(classname, "obj_teleporter", false))
    {
        return PROP_TF2OBJ;
    }
    else
    {
        return PROP_NONE;
    }
}
stock matrix3x4FromAnglesNoOrigin(Float:angle[3], matrix[matrix3x4_t]){

    decl Float:fwd[3], Float:right[3], Float:up[3];

    new Float:origin[3] = {0.0, 0.0, 0.0};

    GetAngleVectors(angle, fwd, right, up);

    matrix3x4_tFromVector(fwd, right, up, origin, matrix);

}
stock TransformAnglesToWorldSpace(Float:inputangle[3], Float:outputangle[3], parentmatrix[matrix3x4_t]){

    decl angtoparent[matrix3x4_t], angtoworld[matrix3x4_t];

    matrix3x4FromAnglesNoOrigin(inputangle, angtoparent);

    ConcatTransforms( parentmatrix, angtoparent, angtoworld);

    MatrixAngles(angtoworld, outputangle);

}
stock TransformAnglesToLocalSpace(Float:angle[3], Float:out[3], parentMatrix[matrix3x4_t]){

    decl angToWorld[matrix3x4_t], worldToParent[matrix3x4_t], localMatrix[matrix3x4_t];

    MatrixInvert( parentMatrix, worldToParent );

    matrix3x4FromAnglesNoOrigin( angle, angToWorld );

    ConcatTransforms( worldToParent, angToWorld, localMatrix );

    MatrixAngles( localMatrix, out );

}
stock matrix3x4_tFromVector(Float:fwd[3], Float:right[3], Float:up[3], Float:origin[3], matrix[matrix3x4_t]){

    matrix[row0][0] = fwd[0];
    matrix[row0][1] = right[0];
    matrix[row0][2] = up[0];
    matrix[row0][3] = origin[0];

    matrix[row1][0] = fwd[1];
    matrix[row1][1] = right[1];
    matrix[row1][2] = up[1];
    matrix[row1][3] = origin[1];

    matrix[row2][0] = fwd[2];
    matrix[row2][1] = right[2];
    matrix[row2][2] = up[2];
    matrix[row2][3] = origin[2];

}
stock ConcatTransforms(const in1[matrix3x4_t], const in2[matrix3x4_t], out[matrix3x4_t]){

    out[row0][0] = in1[row0][0] * in2[row0][0] + in1[row0][1] * in2[row1][0] + in1[row0][2] * in2[row2][0];
    out[row0][1] = in1[row0][0] * in2[row0][1] + in1[row0][1] * in2[row1][1] + in1[row0][2] * in2[row2][1];
    out[row0][2] = in1[row0][0] * in2[row0][2] + in1[row0][1] * in2[row1][2] + in1[row0][2] * in2[row2][2];
    out[row0][3] = in1[row0][0] * in2[row0][3] + in1[row0][1] * in2[row1][3] + in1[row0][2] * in2[row2][3] + in1[row0][3];

    out[row1][0] = in1[row1][0] * in2[row0][0] + in1[row1][1] * in2[row1][0] + in1[row1][2] * in2[row2][0];
    out[row1][1] = in1[row1][0] * in2[row0][1] + in1[row1][1] * in2[row1][1] + in1[row1][2] * in2[row2][1];
    out[row1][2] = in1[row1][0] * in2[row0][2] + in1[row1][1] * in2[row1][2] + in1[row1][2] * in2[row2][2];
    out[row1][3] = in1[row1][0] * in2[row0][3] + in1[row1][1] * in2[row1][3] + in1[row1][2] * in2[row2][3] + in1[row1][3];

    out[row2][0] = in1[row2][0] * in2[row0][0] + in1[row2][1] * in2[row1][0] + in1[row2][2] * in2[row2][0];
    out[row2][1] = in1[row2][0] * in2[row0][1] + in1[row2][1] * in2[row1][1] + in1[row2][2] * in2[row2][1];
    out[row2][2] = in1[row2][0] * in2[row0][2] + in1[row2][1] * in2[row1][2] + in1[row2][2] * in2[row2][2];
    out[row2][3] = in1[row2][0] * in2[row0][3] + in1[row2][1] * in2[row1][3] + in1[row2][2] * in2[row2][3] + in1[row2][3];

}
stock MatrixAngles(angtoworld[matrix3x4_t], Float:outputangle[3]){

    decl Float:fwd[3], Float:right[3], Float:up[3];

    fwd[0] = angtoworld[row0][0];
    fwd[1] = angtoworld[row1][0];
    fwd[2] = angtoworld[row2][0];
    right[0] = angtoworld[row0][1];
    right[1] = angtoworld[row1][1];
    right[2] = angtoworld[row2][1];
    up[0] = 0.0;
    up[1] = 0.0;
    up[2] = angtoworld[row2][2];

    new Float:xyDist = SquareRoot(fwd[0] * fwd[0] + fwd[1] * fwd[1]);

    if ( xyDist > 0.001 ){

        // (yaw)    y = ATAN( forward.y, forward.x );       -- in our space, forward is the X axis
        outputangle[1] = RadToDeg( ArcTangent2( fwd[1], fwd[0] ) );
        // (pitch)  x = ATAN( -forward.z, sqrt(forward.x*forward.x+forward.y*forward.y) );
        outputangle[0] = RadToDeg( ArcTangent2( fwd[2] * -1, xyDist ) );
        // (roll)   z = ATAN( left.z, up.z );
        outputangle[2] = RadToDeg( ArcTangent2( right[2], up[2] ) );

    }else{// forward is mostly Z, gimbal lock-

        // (yaw)    y = ATAN( -left.x, left.y );            -- forward is mostly z, so use right for yaw
        outputangle[1] = RadToDeg( ArcTangent2( right[0]  * -1, right[1] ) );
        // (pitch)  x = ATAN( -forward.z, sqrt(forward.x*forward.x+forward.y*forward.y) );
        outputangle[0] = RadToDeg( ArcTangent2( fwd[2]  * -1, xyDist ) );
        // Assume no roll in this case as one degree of freedom has been lost (i.e. yaw == roll)
        outputangle[2] = 0.0;

    }

}
stock MatrixInvert(in1[matrix3x4_t], out[matrix3x4_t]){

    out[row0][0] = in1[row0][0];
    out[row0][1] = in1[row1][0];
    out[row0][2] = in1[row2][0];

    out[row1][0] = in1[row0][1];
    out[row1][1] = in1[row1][1];
    out[row1][2] = in1[row2][1];

    out[row2][0] = in1[row0][2];
    out[row2][1] = in1[row1][2];
    out[row2][2] = in1[row2][2];

    decl Float:tmp[3], Float:outrow0[3], Float:outrow1[3], Float:outrow2[3];
    tmp[0] = in1[row0][3];
    tmp[1] = in1[row1][3];
    tmp[2] = in1[row2][3];

    outrow0[0] = out[row0][0];
    outrow0[1] = out[row0][1];
    outrow0[2] = out[row0][2];

    outrow1[0] = out[row1][0];
    outrow1[1] = out[row1][1];
    outrow1[2] = out[row1][2];

    outrow2[0] = out[row2][0];
    outrow2[1] = out[row2][1];
    outrow2[2] = out[row2][2];

    out[row0][3] = -GetVectorDotProduct(tmp, outrow0);
    out[row1][3] = -GetVectorDotProduct(tmp, outrow1);
    out[row2][3] = -GetVectorDotProduct(tmp, outrow2);

}