API tools faq
paste
FlacoBey

Untitled

FlacoBey
Jun 16th, 2019
162
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.77 KB | None | 0 0
raw download clone embed print report
  1. #pragma semicolon 1
  2. #pragma newdecls required
  3.  
  4. #include <sdktools>
  5. #include <sdkhooks>
  6.  
  7. Handle sdkSetAttack;
  8.  
  9. float weapon_autoshotgun = 1650.0;
  10. float weapon_hunting_rifle = 660.0;
  11. float weapon_pistol = 880.0;
  12. float weapon_pistol_magnum = 1980.0;
  13. float weapon_pumpshotgun = 1650.0;
  14. float weapon_rifle = 1100.0;
  15. float weapon_rifle_ak47 = 1100.0;
  16. float weapon_rifle_desert = 1100.0;
  17. float weapon_rifle_m60 = 1320.0;
  18. float weapon_rifle_sg552 = 1100.0;
  19. float weapon_shotgun_chrome = 1540.0;
  20. float weapon_shotgun_spas = 1540.0;
  21. float weapon_smg = 880.0;
  22. float weapon_smg_mp5 = 880.0;
  23. float weapon_smg_silenced = 880.0;
  24. float weapon_sniper_awp = 1100.0;
  25. float weapon_sniper_military = 1320.0;
  26. float weapon_sniper_scout = 1320.0;
  27.  
  28. float weapon_grenade_launcher  = 2200.0;
  29. float weapon_pipe_bomb = 2200.0;
  30.  
  31. float melee = 176.0;
  32.  
  33. int iChance = 2;
  34.  
  35. public void OnPluginStart()
  36. {
  37.     Handle hGameConf = LoadGameConfigFile("SetAttackSurvivorCommons");
  38.     StartPrepSDKCall(SDKCall_Entity);
  39.     if( PrepSDKCall_SetFromConf(hGameConf, SDKConf_Signature, "SetAttackToSurvivors") == false )
  40.         SetFailState("Could not load the \"SetAttackToSurvivors\" gamedata signature.");
  41.     sdkSetAttack = EndPrepSDKCall();
  42. }
  43.  
  44. public void OnClientPutInServer(int client)
  45. {
  46.     SDKHook(client, SDKHook_FireBulletsPost, FireBullets);
  47. }
  48.  
  49. public void FireBullets(int client, int shots, const char[] weaponname)
  50. {
  51.     if(!bIsSurvivor(client)) return;
  52.     float vPos[3], vTargetPos[3];
  53.     GetClientEyePosition(client, vPos);
  54.     if(strcmp(weaponname, "weapon_melee") == 0)
  55.     {
  56.         for(int i = 33; i <= 2048; i++)
  57.         {
  58.             if(IsCommonInfected(i))
  59.             {
  60.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  61.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  62.                 if(IsVisibleTo(vPos, vTargetPos))
  63.                 {
  64.                     if(fTargetDistance < melee)
  65.                     {
  66.                         SDKCall(sdkSetAttack, i);
  67.                     }
  68.                 }
  69.                 else
  70.                 {
  71.                     if(GetRandomInt(0, 100) <= iChance)
  72.                     {
  73.                         if(fTargetDistance < melee)
  74.                         {
  75.                             SDKCall(sdkSetAttack, i);
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.         }
  81.     }
  82.     else if(strcmp(weaponname, "weapon_autoshotgun") == 0)
  83.     {
  84.         for(int i = 33; i <= 2048; i++)
  85.         {
  86.             if(IsCommonInfected(i))
  87.             {
  88.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  89.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  90.                 if(IsVisibleTo(vPos, vTargetPos))
  91.                 {
  92.                     if(fTargetDistance < weapon_autoshotgun)
  93.                     {
  94.                         SDKCall(sdkSetAttack, i);
  95.                     }
  96.                 }
  97.                 else
  98.                 {
  99.                     if(GetRandomInt(0, 100) <= iChance)
  100.                     {
  101.                         if(fTargetDistance < weapon_autoshotgun)
  102.                         {
  103.                             SDKCall(sdkSetAttack, i);
  104.                         }
  105.                     }
  106.                 }
  107.             }
  108.         }
  109.     }
  110.     else if(strcmp(weaponname, "weapon_hunting_rifle") == 0)
  111.     {
  112.         for(int i = 33; i <= 2048; i++)
  113.         {
  114.             if(IsCommonInfected(i))
  115.             {
  116.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  117.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  118.                 if(IsVisibleTo(vPos, vTargetPos))
  119.                 {
  120.                     if(fTargetDistance < weapon_hunting_rifle)
  121.                     {
  122.                         SDKCall(sdkSetAttack, i);
  123.                     }
  124.                 }
  125.                 else
  126.                 {
  127.                     if(GetRandomInt(0, 100) <= iChance)
  128.                     {
  129.                         if(fTargetDistance < weapon_hunting_rifle)
  130.                         {
  131.                             SDKCall(sdkSetAttack, i);
  132.                         }
  133.                     }
  134.                 }
  135.             }
  136.         }
  137.     }
  138.     else if(strcmp(weaponname, "weapon_pistol") == 0)
  139.     {
  140.         for(int i = 33; i <= 2048; i++)
  141.         {
  142.             if(IsCommonInfected(i))
  143.             {
  144.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  145.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  146.                 if(IsVisibleTo(vPos, vTargetPos))
  147.                 {
  148.                     if(fTargetDistance < weapon_pistol)
  149.                     {
  150.                         SDKCall(sdkSetAttack, i);
  151.                     }
  152.                 }
  153.                 else
  154.                 {
  155.                     if(GetRandomInt(0, 100) <= iChance)
  156.                     {
  157.                         if(fTargetDistance < weapon_pistol)
  158.                         {
  159.                             SDKCall(sdkSetAttack, i);
  160.                         }
  161.                     }
  162.                 }
  163.             }
  164.         }
  165.     }
  166.     else if(strcmp(weaponname, "weapon_pistol_magnum") == 0)
  167.     {
  168.         for(int i = 33; i <= 2048; i++)
  169.         {
  170.             if(IsCommonInfected(i))
  171.             {
  172.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  173.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  174.                 if(IsVisibleTo(vPos, vTargetPos))
  175.                 {
  176.                     if(fTargetDistance < weapon_pistol_magnum)
  177.                     {
  178.                         SDKCall(sdkSetAttack, i);
  179.                     }
  180.                 }
  181.                 else
  182.                 {
  183.                     if(GetRandomInt(0, 100) <= iChance)
  184.                     {
  185.                         if(fTargetDistance < weapon_pistol_magnum)
  186.                         {
  187.                             SDKCall(sdkSetAttack, i);
  188.                         }
  189.                     }
  190.                 }
  191.             }
  192.         }
  193.     }
  194.     else if(strcmp(weaponname, "weapon_pumpshotgun") == 0)
  195.     {
  196.         for(int i = 33; i <= 2048; i++)
  197.         {
  198.             if(IsCommonInfected(i))
  199.             {
  200.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  201.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  202.                 if(IsVisibleTo(vPos, vTargetPos))
  203.                 {
  204.                     if(fTargetDistance < weapon_pumpshotgun)
  205.                     {
  206.                         SDKCall(sdkSetAttack, i);
  207.                     }
  208.                 }
  209.                 else
  210.                 {
  211.                     if(GetRandomInt(0, 100) <= iChance)
  212.                     {
  213.                         if(fTargetDistance < weapon_pumpshotgun)
  214.                         {
  215.                             SDKCall(sdkSetAttack, i);
  216.                         }
  217.                     }
  218.                 }
  219.             }
  220.         }
  221.     }
  222.     else if(strcmp(weaponname, "weapon_rifle") == 0)
  223.     {
  224.         for(int i = 33; i <= 2048; i++)
  225.         {
  226.             if(IsCommonInfected(i))
  227.             {
  228.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  229.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  230.                 if(IsVisibleTo(vPos, vTargetPos))
  231.                 {
  232.                     if(fTargetDistance < weapon_rifle)
  233.                     {
  234.                         SDKCall(sdkSetAttack, i);
  235.                     }
  236.                 }
  237.                 else
  238.                 {
  239.                     if(GetRandomInt(0, 100) <= iChance)
  240.                     {
  241.                         if(fTargetDistance < weapon_rifle)
  242.                         {
  243.                             SDKCall(sdkSetAttack, i);
  244.                         }
  245.                     }
  246.                 }
  247.             }
  248.         }
  249.     }
  250.     else if(strcmp(weaponname, "weapon_rifle_ak47") == 0)
  251.     {
  252.         for(int i = 33; i <= 2048; i++)
  253.         {
  254.             if(IsCommonInfected(i))
  255.             {
  256.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  257.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  258.                 if(IsVisibleTo(vPos, vTargetPos))
  259.                 {
  260.                     if(fTargetDistance < weapon_rifle_ak47)
  261.                     {
  262.                         SDKCall(sdkSetAttack, i);
  263.                     }
  264.                 }
  265.                 else
  266.                 {
  267.                     if(GetRandomInt(0, 100) <= iChance)
  268.                     {
  269.                         if(fTargetDistance < weapon_rifle_ak47)
  270.                         {
  271.                             SDKCall(sdkSetAttack, i);
  272.                         }
  273.                     }
  274.                 }
  275.             }
  276.         }
  277.     }
  278.     else if(strcmp(weaponname, "weapon_rifle_desert") == 0)
  279.     {
  280.         for(int i = 33; i <= 2048; i++)
  281.         {
  282.             if(IsCommonInfected(i))
  283.             {
  284.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  285.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  286.                 if(IsVisibleTo(vPos, vTargetPos))
  287.                 {
  288.                     if(fTargetDistance < weapon_rifle_desert)
  289.                     {
  290.                         SDKCall(sdkSetAttack, i);
  291.                     }
  292.                 }
  293.                 else
  294.                 {
  295.                     if(GetRandomInt(0, 100) <= iChance)
  296.                     {
  297.                         if(fTargetDistance < weapon_rifle_desert)
  298.                         {
  299.                             SDKCall(sdkSetAttack, i);
  300.                         }
  301.                     }
  302.                 }
  303.             }
  304.         }
  305.     }
  306.     else if(strcmp(weaponname, "weapon_rifle_m60") == 0)
  307.     {
  308.         for(int i = 33; i <= 2048; i++)
  309.         {
  310.             if(IsCommonInfected(i))
  311.             {
  312.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  313.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  314.                 if(IsVisibleTo(vPos, vTargetPos))
  315.                 {
  316.                     if(fTargetDistance < weapon_rifle_m60)
  317.                     {
  318.                         SDKCall(sdkSetAttack, i);
  319.                     }
  320.                 }
  321.                 else
  322.                 {
  323.                     if(GetRandomInt(0, 100) <= iChance)
  324.                     {
  325.                         if(fTargetDistance < weapon_rifle_m60)
  326.                         {
  327.                             SDKCall(sdkSetAttack, i);
  328.                         }
  329.                     }
  330.                 }
  331.             }
  332.         }
  333.     }
  334.     else if(strcmp(weaponname, "weapon_rifle_sg552") == 0)
  335.     {
  336.         for(int i = 33; i <= 2048; i++)
  337.         {
  338.             if(IsCommonInfected(i))
  339.             {
  340.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  341.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  342.                 if(IsVisibleTo(vPos, vTargetPos))
  343.                 {
  344.                     if(fTargetDistance < weapon_rifle_sg552)
  345.                     {
  346.                         SDKCall(sdkSetAttack, i);
  347.                     }
  348.                 }
  349.                 else
  350.                 {
  351.                     if(GetRandomInt(0, 100) <= iChance)
  352.                     {
  353.                         if(fTargetDistance < weapon_rifle_sg552)
  354.                         {
  355.                             SDKCall(sdkSetAttack, i);
  356.                         }
  357.                     }
  358.                 }
  359.             }
  360.         }
  361.     }
  362.     else if(strcmp(weaponname, "weapon_shotgun_chrome") == 0)
  363.     {
  364.         for(int i = 33; i <= 2048; i++)
  365.         {
  366.             if(IsCommonInfected(i))
  367.             {
  368.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  369.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  370.                 if(IsVisibleTo(vPos, vTargetPos))
  371.                 {
  372.                     if(fTargetDistance < weapon_shotgun_chrome)
  373.                     {
  374.                         SDKCall(sdkSetAttack, i);
  375.                     }
  376.                 }
  377.                 else
  378.                 {
  379.                     if(GetRandomInt(0, 100) <= iChance)
  380.                     {
  381.                         if(fTargetDistance < weapon_shotgun_chrome)
  382.                         {
  383.                             SDKCall(sdkSetAttack, i);
  384.                         }
  385.                     }
  386.                 }
  387.             }
  388.         }
  389.     }
  390.     else if(strcmp(weaponname, "weapon_shotgun_spas") == 0)
  391.     {
  392.         for(int i = 33; i <= 2048; i++)
  393.         {
  394.             if(IsCommonInfected(i))
  395.             {
  396.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  397.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  398.                 if(IsVisibleTo(vPos, vTargetPos))
  399.                 {
  400.                     if(fTargetDistance < weapon_shotgun_spas)
  401.                     {
  402.                         SDKCall(sdkSetAttack, i);
  403.                     }
  404.                 }
  405.                 else
  406.                 {
  407.                     if(GetRandomInt(0, 100) <= iChance)
  408.                     {
  409.                         if(fTargetDistance < weapon_shotgun_spas)
  410.                         {
  411.                             SDKCall(sdkSetAttack, i);
  412.                         }
  413.                     }
  414.                 }
  415.             }
  416.         }
  417.     }
  418.     else if(strcmp(weaponname, "weapon_smg") == 0)
  419.     {
  420.         for(int i = 33; i <= 2048; i++)
  421.         {
  422.             if(IsCommonInfected(i))
  423.             {
  424.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  425.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  426.                 if(IsVisibleTo(vPos, vTargetPos))
  427.                 {
  428.                     if(fTargetDistance < weapon_smg)
  429.                     {
  430.                         SDKCall(sdkSetAttack, i);
  431.                     }
  432.                 }
  433.                 else
  434.                 {
  435.                     if(GetRandomInt(0, 100) <= iChance)
  436.                     {
  437.                         if(fTargetDistance < weapon_smg)
  438.                         {
  439.                             SDKCall(sdkSetAttack, i);
  440.                         }
  441.                     }
  442.                 }
  443.             }
  444.         }
  445.     }
  446.     else if(strcmp(weaponname, "weapon_smg_mp5") == 0)
  447.     {
  448.         for(int i = 33; i <= 2048; i++)
  449.         {
  450.             if(IsCommonInfected(i))
  451.             {
  452.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  453.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  454.                 if(IsVisibleTo(vPos, vTargetPos))
  455.                 {
  456.                     if(fTargetDistance < weapon_smg_mp5)
  457.                     {
  458.                         SDKCall(sdkSetAttack, i);
  459.                     }
  460.                 }
  461.                 else
  462.                 {
  463.                     if(GetRandomInt(0, 100) <= iChance)
  464.                     {
  465.                         if(fTargetDistance < weapon_smg_mp5)
  466.                         {
  467.                             SDKCall(sdkSetAttack, i);
  468.                         }
  469.                     }
  470.                 }
  471.             }
  472.         }
  473.     }
  474.     else if(strcmp(weaponname, "weapon_smg_silenced") == 0)
  475.     {
  476.         for(int i = 33; i <= 2048; i++)
  477.         {
  478.             if(IsCommonInfected(i))
  479.             {
  480.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  481.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  482.                 if(IsVisibleTo(vPos, vTargetPos))
  483.                 {
  484.                     if(fTargetDistance < weapon_smg_silenced)
  485.                     {
  486.                         SDKCall(sdkSetAttack, i);
  487.                     }
  488.                 }
  489.                 else
  490.                 {
  491.                     if(GetRandomInt(0, 100) <= iChance)
  492.                     {
  493.                         if(fTargetDistance < weapon_smg_silenced)
  494.                         {
  495.                             SDKCall(sdkSetAttack, i);
  496.                         }
  497.                     }
  498.                 }
  499.             }
  500.         }
  501.     }
  502.     else if(strcmp(weaponname, "weapon_sniper_awp") == 0)
  503.     {
  504.         for(int i = 33; i <= 2048; i++)
  505.         {
  506.             if(IsCommonInfected(i))
  507.             {
  508.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  509.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  510.                 if(IsVisibleTo(vPos, vTargetPos))
  511.                 {
  512.                     if(fTargetDistance < weapon_sniper_awp)
  513.                     {
  514.                         SDKCall(sdkSetAttack, i);
  515.                     }
  516.                 }
  517.                 else
  518.                 {
  519.                     if(GetRandomInt(0, 100) <= iChance)
  520.                     {
  521.                         if(fTargetDistance < weapon_sniper_awp)
  522.                         {
  523.                             SDKCall(sdkSetAttack, i);
  524.                         }
  525.                     }
  526.                 }
  527.             }
  528.         }
  529.     }
  530.     else if(strcmp(weaponname, "weapon_sniper_military") == 0)
  531.     {
  532.         for(int i = 33; i <= 2048; i++)
  533.         {
  534.             if(IsCommonInfected(i))
  535.             {
  536.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  537.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  538.                 if(IsVisibleTo(vPos, vTargetPos))
  539.                 {
  540.                     if(fTargetDistance < weapon_sniper_military)
  541.                     {
  542.                         SDKCall(sdkSetAttack, i);
  543.                     }
  544.                 }
  545.                 else
  546.                 {
  547.                     if(GetRandomInt(0, 100) <= iChance)
  548.                     {
  549.                         if(fTargetDistance < weapon_sniper_military)
  550.                         {
  551.                             SDKCall(sdkSetAttack, i);
  552.                         }
  553.                     }
  554.                 }
  555.             }
  556.         }
  557.     }
  558.     else if(strcmp(weaponname, "weapon_sniper_scout") == 0)
  559.     {
  560.         for(int i = 33; i <= 2048; i++)
  561.         {
  562.             if(IsCommonInfected(i))
  563.             {
  564.                 GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  565.                 float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  566.                 if(IsVisibleTo(vPos, vTargetPos))
  567.                 {
  568.                     if(fTargetDistance < weapon_sniper_scout)
  569.                     {
  570.                         SDKCall(sdkSetAttack, i);
  571.                     }
  572.                 }
  573.                 else
  574.                 {
  575.                     if(GetRandomInt(0, 100) <= iChance)
  576.                     {
  577.                         if(fTargetDistance < weapon_sniper_scout)
  578.                         {
  579.                             SDKCall(sdkSetAttack, i);
  580.                         }
  581.                     }
  582.                 }
  583.             }
  584.         }
  585.     }
  586. }
  587.  
  588. public void OnEntityDestroyed(int entity)
  589. {
  590.     if(IsValidEntity(entity) && IsValidEdict(entity))
  591.     {
  592.         char sTypeEx[36];
  593.         GetEntityClassname(entity, sTypeEx, sizeof(sTypeEx));
  594.         if(strcmp(sTypeEx, "grenade_launcher_projectile") == 0)
  595.         {
  596.             float vPos[3], vTargetPos[3];
  597.             GetEntPropVector(entity, Prop_Send, "m_vecOrigin", vPos);
  598.             for(int i = 33; i <= 2048; i++)
  599.             {
  600.                 if(IsCommonInfected(i))
  601.                 {
  602.                     GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  603.                     float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  604.                     if(fTargetDistance <= weapon_grenade_launcher)
  605.                     {
  606.                         SDKCall(sdkSetAttack, i);
  607.                     }
  608.                 }
  609.             }
  610.         }
  611.         else if(strcmp(sTypeEx, "pipe_bomb_projectile") == 0)
  612.         {
  613.             float vPos[3], vTargetPos[3];
  614.             GetEntPropVector(entity, Prop_Send, "m_vecOrigin", vPos);
  615.             for(int i = 33; i <= 2048; i++)
  616.             {
  617.                 if(IsCommonInfected(i))
  618.                 {
  619.                     GetEntPropVector(i, Prop_Send, "m_vecOrigin", vTargetPos);
  620.                     float fTargetDistance = GetVectorDistance(vPos, vTargetPos);
  621.                     if(fTargetDistance <= weapon_pipe_bomb)
  622.                     {
  623.                         SDKCall(sdkSetAttack, i);
  624.                     }
  625.                 }
  626.             }
  627.         }
  628.     }
  629. }
  630.  
  631. static bool IsVisibleTo(float position[3], float targetposition[3])
  632. {
  633.     float vAngles[3], vLookAt[3];
  634.    
  635.     MakeVectorFromPoints(position, targetposition, vLookAt);
  636.     GetVectorAngles(vLookAt, vAngles);
  637.  
  638.     Handle trace = TR_TraceRayFilterEx(position, vAngles, MASK_SHOT, RayType_Infinite, _TraceFilter);
  639.    
  640.     bool isVisible = false;
  641.     if (TR_DidHit(trace))
  642.     {
  643.         float vStart[3];
  644.         TR_GetEndPosition(vStart, trace);
  645.        
  646.         if ((GetVectorDistance(position, vStart, false) + 25.0) >= GetVectorDistance(position, targetposition))
  647.         {
  648.             isVisible = true;
  649.         }
  650.     }
  651.    
  652.     return isVisible;
  653. }
  654.  
  655. public bool _TraceFilter(int entity, int contentsMask)
  656. {
  657.     if (IsValidEntity(entity))
  658.     {
  659.         return false;
  660.     }
  661.     return true;
  662. }
  663.  
  664. stock bool bIsSurvivor(int client)
  665. {
  666.     return client > 0 && client <= MaxClients && IsClientInGame(client) && GetClientTeam(client) == 2 && !IsClientInKickQueue(client) && IsPlayerAlive(client);
  667. }
  668.  
  669. stock bool IsCommonInfected(int entity)
  670. {
  671.     if (entity > 33 && IsValidEntity(entity) && IsValidEdict(entity))
  672.     {
  673.         char entType[64];
  674.         GetEdictClassname(entity, entType, sizeof(entType));
  675.         return StrEqual(entType, "infected");
  676.     }
  677.     return false;
  678. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!