API tools faq
paste
Advertisement
georgik57

D7APIESP.sma

georgik57
Nov 16th, 2019
171
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Pawn 20.87 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. To do:
  3.  
  4. T = needs testing
  5. X = done
  6. - = cancelled
  7.  
  8. [ ] fix animation
  9. [ ] remove animation on spawn if not needed
  10. [X] fix colors
  11. [X] fix origin modifier
  12. [X?] fix not showing when too close to the wall
  13. [-] make EF_NODRAW(doesn't trigger fwFmAddToFullPack anymore)
  14. [X] make invisible and out of map
  15. [-] find better method for default sprite
  16. [ ] make fwNtInfoGet native
  17. [T] check iFwNtSet native
  18. [T] player iID bitsums in natives instead of simple numbers
  19. [X] bitsum show variable instead of 2d array
  20. [ ] const parameters where it's the case
  21. [X] remove alive status
  22. [X] only calculate sprite origin if g_iBsEntShow is set for specified players
  23. [X] remake sprite origin calculations
  24.     [X] support map camera origin
  25.     [ ] support any camera origin
  26. [ ] animate sprite manually
  27. [T] ability to choose sprite starting frame
  28. [T] ability to choose sprite end frame
  29. [T] ability to choose sprite framerate
  30. [T] ability to choose origin update rate
  31. [ ] check for valid model id
  32. [T] check for valid parameters
  33. [ ] only draw sprite in fwFmCheckVisibilityPre if it's being used by players
  34. [T] iFwNtSet return values
  35. [T] ability to not change g_iBsEntShow
  36. [T] only calculate sprite origin if iID2 is connected
  37. [T] default values where needed
  38.     [ ] find a way to set them on creation instead of in plugin_init
  39. [X] set g_iBsEntShow to 0 on client_putinserver for bots
  40. [X] optimize method of checking for bots
  41. [ ] fix bot flag clearing on disconnect allowing the native to trigger for that id
  42. [X] fix wrong camera origin when spectating
  43. [T] floatclamp for fEntScale
  44. [X] use FM_ClientDisconnect instead of client_disconnect
  45. [T] is_in_viewcone or similar check
  46.     [X] add support for camera
  47. [X] FM_UpdateClientData instead of Ham_Player_UpdateClientData
  48.     [T] add bot check
  49. [ ] nodraw entities in addtofullpack for players who don't need to see them
  50. [ ] min/max distance to draw
  51. [ ] fix wrong colors being shown sometimes
  52. [ ] don't draw esp of spectated player?
  53. [ ] fix 32 player not having or drawing the entity
  54. [ ]
  55. */
  56.  
  57. //#pragma dynamic 16384
  58.  
  59. /*================================================================================
  60.  [Plugin Customization]
  61. =================================================================================*/
  62.  
  63. const g_iConstMaxPlayers =      32 + 1  /* Server slots ¬ 32 */
  64. const g_iConstMaxEntities =     128 /* Is for max 4096 entities (128*32=4096) ¬ 128 */
  65.  
  66. /*================================================================================
  67.  Customization ends here! Yes, that's it. Editing anything beyond
  68.  here is not officially supported. Proceed at your own risk...
  69. =================================================================================*/
  70.  
  71. #include <amxmodx>
  72. #include <fakemeta>
  73. //#include <orpheu>
  74. //#include <orpheu_stocks>
  75.  
  76. #include <fakemeta_util>
  77. #include <xs>
  78.  
  79. #include <bitsums>
  80. #include <bitsums_array>
  81. #include <D7ESP_const>
  82.  
  83. #include <D7Debug>
  84.  
  85. /*================================================================================
  86.  [Global Variables]
  87. =================================================================================*/
  88.  
  89. /* Server Global */
  90. new g_iMaxPlayers;
  91.  
  92. /* Client Global */
  93. new Float:g_fVecOrigin[g_iConstMaxPlayers][g_iConstMaxPlayers][3],
  94.     Float:g_fScale[g_iConstMaxPlayers][g_iConstMaxPlayers]
  95.  
  96. /* Bitsum client */
  97. new g_iBsConnected,
  98.     g_iBsBot,
  99.     g_iBsVisible[g_iConstMaxPlayers];
  100.  
  101. /* Bitsum entity */
  102. new g_iBsArEspSprite[g_iConstMaxEntities]
  103.  
  104. new g_iBsEntShow[g_iConstMaxPlayers], g_iIDEntModel[g_iConstMaxPlayers][g_iConstMaxPlayers],
  105. g_iEntFrameStart[g_iConstMaxPlayers][g_iConstMaxPlayers],
  106. g_iEntFrameEnd[g_iConstMaxPlayers][g_iConstMaxPlayers],
  107. Float:g_fEntFrameRate[g_iConstMaxPlayers][g_iConstMaxPlayers],
  108. g_iEntFrame[g_iConstMaxPlayers][g_iConstMaxPlayers],
  109. Float:g_fEntScale[g_iConstMaxPlayers][g_iConstMaxPlayers]/* = { { 1.0, ... }, ... }*/,
  110. g_iEntRenderMode[g_iConstMaxPlayers][g_iConstMaxPlayers]/* = { { kRenderNormal, ... }, ... }*/,
  111. g_iEntRenderFx[g_iConstMaxPlayers][g_iConstMaxPlayers]/* = { { kRenderFxNone, ... }, ... }*/,
  112. Float:g_fEntRenderAmount[g_iConstMaxPlayers][g_iConstMaxPlayers]/* = { { 255.0, ... }, ... }*/,
  113. Float:g_fEntOriginUpdateRate[g_iConstMaxPlayers][g_iConstMaxPlayers],
  114. g_iVecEntRenderColor[g_iConstMaxPlayers][g_iConstMaxPlayers][3]/* = { { { 255, 255, 255 }, ... }, ... }*/,
  115. Float:g_fVecEntOriginModifier[g_iConstMaxPlayers][g_iConstMaxPlayers][3],
  116. g_iIDEntCamera[g_iConstMaxPlayers];
  117.  
  118. #define is_user_valid(%1)           (1 <= (%1) <= g_iMaxPlayers)
  119.  
  120. new g_iIDFwFmPrecacheModel, g_szDefaultSprite[64];
  121.  
  122. public plugin_precache()
  123. {
  124.     g_iIDFwFmPrecacheModel = register_forward(FM_PrecacheModel, "fwFmPrecacheModel", 1)
  125. }
  126.  
  127. public fwFmPrecacheModel(const szFile[])
  128. {
  129.     if (!equali(szFile[strlen(szFile) - 4], ".spr"))
  130.         return;
  131.    
  132.     new iCountFrames = engfunc(EngFunc_ModelFrames, engfunc(EngFunc_ModelIndex, szFile));
  133.    
  134.     static iCountFramesMax;
  135.    
  136.     if (iCountFramesMax < iCountFrames/*!iCountFramesMax || iCountFrames > 1 && (iCountFramesMax < 2 || iCountFramesMax > iCountFrames)*/)
  137.     {
  138.         iCountFramesMax = iCountFrames;
  139.        
  140.         formatex(g_szDefaultSprite, charsmax(g_szDefaultSprite), szFile)
  141.     }
  142.    
  143.     //ftD7Log(_, _, "[fwFmPrecacheModel] szFile: ^"%s^". iCountFrames: %d. iCountFramesMax: %d.", szFile, iCountFrames, iCountFramesMax)
  144. }
  145.  
  146. new const g_szPluginVersion[] = "1.3.5";
  147.  
  148. public plugin_init()
  149. {
  150.     register_plugin("[D7] API: ESP", g_szPluginVersion, "DarkGL, schmurgel1983, D i 5 7 i n c T")
  151.    
  152.     register_forward(FM_AddToFullPack, "fwFmAddToFullPack", 1)
  153.     register_forward(FM_CheckVisibility, "fwFmCheckVisibilityPre")
  154.     //register_forward(FM_ClientConnect, "fwFmClientConnect", 1)
  155.     register_forward(FM_ClientDisconnect, "fwFmClientDisconnectPre")
  156.     register_forward(FM_ClientDisconnect, "fwFmClientDisconnect", 1)
  157.     register_forward(FM_SetView, "fwFmSetView", true)
  158.     register_forward(FM_UpdateClientData, "fwFmUpdateClientDataPre")
  159.    
  160.     //OrpheuRegisterHook(OrpheuGetEngineFunction("pfnSetView", "SetView"), "fwOpSetView", OrpheuHookPost);
  161.    
  162.     g_iMaxPlayers = get_maxplayers();
  163.    
  164.     new iID2;//, iBsIDs1
  165.    
  166.     for (new iID = 1; iID <= g_iMaxPlayers; iID++)
  167.     {
  168. /*      bitsum_add(iBsIDs1, iID)
  169.        
  170.         ftD7Log(_, _, "[plugin_init] iID: %d.^n\
  171.         Power(1 << %d)(d/i/u): %d/%i/%u. ftIsPowerOfTwo: %s.^n\
  172.         Power sum(d/i/u): %d/%i/%u. ftIsPowerOfTwo: %s.",
  173.         iID, iID - 1, (1 << (iID - 1)), (1 << (iID - 1)), (1 << (iID - 1)), ftIsPowerOfTwo(1 << (iID - 1)) ? "YES" : "NO",
  174.         iBsIDs1, iBsIDs1, iBsIDs1, ftIsPowerOfTwo(iBsIDs1) ? "YES" : "NO")
  175.         */
  176.         for (iID2 = 1; iID2 <= g_iMaxPlayers; iID2++)
  177.         {
  178.             g_fEntScale[iID][iID2] = 1.0;
  179.             g_fEntRenderAmount[iID][iID2] = 255.0;
  180.             //g_iVecEntRenderColor[iID][iID2] = { 255, 255, 255 };
  181. /*         
  182.             ftD7Log(_, _, "[plugin_init] iID2: %d.^n\
  183.             (1 << %d) | (1 << %d) = (d/i/u)%d/%i/%u.%s",
  184.             iID2, iID - 1, iID2 - 1,
  185.             (1 << (iID - 1)) | (1 << (iID2 - 1)),
  186.             (1 << (iID - 1)) | (1 << (iID2 - 1)),
  187.             (1 << (iID - 1)) | (1 << (iID2 - 1)),
  188.             (iID2 != g_iMaxPlayers) ? "" : "^n")*/
  189.         }
  190.     }
  191. }
  192. /*
  193. ftIsPowerOfTwo(x)
  194. {
  195.     return ((x != 0) && ((x & (~x + 1)) == x));
  196. }*/
  197.  
  198. public fwFmSetView(const iID, const iIDEnt)
  199. {
  200.     g_iIDEntCamera[iID] = iIDEnt;
  201.    
  202.     //ftD7Log(_, _, "[fwFmSetView] iID: %d. iIDEnt: %d.", iID, iIDEnt)
  203. }
  204. /*
  205. public fwOpSetView(const iID, const iIDEnt)
  206. {
  207.     g_iIDEntCamera[iID] = iIDEnt;
  208.    
  209.     //ftD7Log(_, _, "[fwOpSetView] iID: %d. iIDEnt: %d.", iID, iIDEnt)
  210. }*/
  211.  
  212. public plugin_cfg() //plugin_cfg
  213. {
  214.     unregister_forward(FM_PrecacheModel, g_iIDFwFmPrecacheModel, 1)
  215.    
  216.     //ftD7Log(_, _, "[ftCreateEntities] g_szDefaultSprite: ^"%s^".", g_szDefaultSprite)
  217.    
  218.     //g_szDefaultSprite = "sprites/ballsmoke.spr";
  219.    
  220.     new iIDAllocString = engfunc(EngFunc_AllocString, "env_sprite");
  221.    
  222.     for (new iID = 1; iID <= g_iMaxPlayers; iID++)
  223.     {
  224.         new iIDEnt = engfunc(EngFunc_CreateNamedEntity, iIDAllocString)
  225.        
  226.         //ftD7Log(_, _, "[ftCreateEntities] iIDEnt: %d. iIDAllocString: %d.", iIDEnt, iIDAllocString)
  227.        
  228.         if (!pev_valid(iIDEnt))
  229.         {
  230.             //ftD7Log(_, _, "[ftCreateEntities] iIDEnt: %d. INVALID!", iIDEnt)
  231.            
  232.             continue;
  233.         }
  234.        
  235.         //ftD7Log(_, _, "[ftCreateEntities] iIDEnt: %d. VALID!", iIDEnt)
  236.        
  237.         engfunc(EngFunc_SetModel, iIDEnt, g_szDefaultSprite)
  238.        
  239.         set_pev(iIDEnt, pev_animtime, get_gametime())
  240.         set_pev(iIDEnt, pev_framerate, random_float(10.0, 15.0))
  241.         set_pev(iIDEnt, pev_spawnflags, SF_SPRITE_STARTON)
  242.        
  243.         dllfunc(DLLFunc_Spawn, iIDEnt)
  244.        
  245.         set_pev(iIDEnt, pev_owner, iID)
  246.         set_pev(iIDEnt, pev_solid, SOLID_NOT)
  247.         set_pev(iIDEnt, pev_movetype, MOVETYPE_NONE)
  248.         set_pev(iIDEnt, pev_rendermode, kRenderTransTexture)
  249.         set_pev(iIDEnt, pev_renderamt, 0.0)
  250.         //set_pev(iIDEnt, pev_effects, pev(iIDEnt, pev_effects) | EF_NODRAW)
  251.        
  252.         engfunc(EngFunc_SetOrigin, iIDEnt, Float:{ 9000.0, 9000.0, 9000.0 })//4096.0
  253.        
  254.         add_bitsum_array(g_iBsArEspSprite, iIDEnt)
  255.     }
  256. }
  257.  
  258. public plugin_natives()
  259. {
  260.     register_library("D7ESP")
  261.    
  262.     register_native("iNtD7ESPGet", "fwNtGet")
  263.     register_native("iNtD7ESPSet", "iFwNtSet")
  264.    
  265.     set_native_filter("fwFilterNative")
  266. }
  267.  
  268. public fwFilterNative(const szName[], const iID, const iTrap)
  269. {
  270.     if (!iTrap)
  271.         return PLUGIN_HANDLED;
  272.        
  273.     return PLUGIN_CONTINUE;
  274. }
  275.  
  276. public fwNtGet(const iIDPlugin, const iCountParams)
  277. {
  278.    
  279. }
  280.  
  281. public iFwNtSet(const iIDPlugin, const iCountParams)
  282. {
  283.     new iBsIDs1 = get_param(g_iIDParamBsIDs1);
  284.    
  285.     //clamp(iBsIDs1, 0, (1 << 31))
  286.    
  287.     if (!iBsIDs1)
  288.         return 1;
  289.    
  290.     iBsIDs1 &= ~g_iBsBot;
  291.    
  292.     if (!iBsIDs1)
  293.         return 0;
  294.    
  295.     //ftD7Log("a", _, "[iFwNtSet] iBsIDs1: %d.", iBsIDs1)
  296.    
  297.     new iBsIDsAdd = get_param(g_iIDParamBsIDsAdd),
  298.     iBsIDsRemove = get_param(g_iIDParamBsIDsRemove),
  299.     iBsIDsChange = get_param(g_iIDParamBsIDsChange),
  300.     iID;
  301.    
  302.     //if (iBsIDsAdd != g_iParamDontChange)
  303.         //clamp(iBsIDsAdd, 0, (1 << 31))
  304.    
  305.     //if (iBsIDsRemove != g_iParamDontChange)
  306.         //clamp(iBsIDsRemove, 0, (1 << 31))
  307.    
  308.     //ftD7Log("a", _, "[iFwNtSet] iBsIDsAdd: %d. iBsIDsRemove: %d. iBsIDsChange: %d.", iBsIDsAdd, iBsIDsRemove, iBsIDsChange)
  309.    
  310.     for (iID = 1; iID <= g_iMaxPlayers; iID++)
  311.     {
  312.         if (iBsIDsAdd != g_iParamDontChange && iBsIDsRemove != g_iParamDontChange || !iBsIDsAdd && !iBsIDsRemove)
  313.             break;
  314.         else if (!bitsum_get(iBsIDs1, iID))
  315.             continue;
  316.        
  317.         if (iBsIDsAdd != g_iParamDontChange)
  318.             g_iBsEntShow[iID] |= iBsIDsAdd;
  319.        
  320.         if (iBsIDsRemove != g_iParamDontChange)
  321.             g_iBsEntShow[iID] &= ~iBsIDsRemove;
  322.     }
  323.    
  324.     if (iBsIDsChange != g_iParamDontChange)
  325.     {
  326.         //clamp(iBsIDsChange, 0, (1 << 31))
  327.        
  328.         if (!iBsIDsChange)
  329.             return 0;
  330.     }
  331.    
  332.     new iIDEntModel = get_param(g_iIDParamIDModel),
  333.     iEntFrameStart = get_param(g_iIDParamFrameStart),
  334.     iEntFrameEnd = get_param(g_iIDParamFrameEnd),
  335.     Float:fEntFrameRate = get_param_f(g_iIDParamFrameRate),
  336.     Float:fEntScale = get_param_f(g_iIDParamScale),
  337.     iEntRenderMode = get_param(g_iIDParamRenderMode),
  338.     iEntRenderFx = get_param(g_iIDParamRenderFx),
  339.     Float:fEntRenderAmount = get_param_f(g_iIDParamRenderAmount),
  340.     Float:fEntOriginUpdateRate = get_param_f(g_iIDParamOriginUpdateRate),
  341.     iReturn, iID2;
  342.    
  343.     static iVecEntRenderColor[4], Float:fVecEntOriginModifier[4];
  344.     get_array(g_iIDParamRenderColor, iVecEntRenderColor, charsmax(iVecEntRenderColor))
  345.     get_array_f(g_iIDParamOriginModifier, fVecEntOriginModifier, charsmax(fVecEntOriginModifier))
  346.    
  347.     if (iEntFrameStart != g_iParamDontChange)
  348.         if (iEntFrameStart < 0)
  349.         {
  350.             iEntFrameStart = 0;
  351.            
  352.             iReturn++;
  353.         }
  354.    
  355.     if (iEntFrameEnd != g_iParamDontChange)
  356.         if (iEntFrameEnd < 0)
  357.         {
  358.             iEntFrameEnd = 0;
  359.            
  360.             iReturn++;
  361.         }
  362.    
  363.     if (iEntFrameStart != g_iParamDontChange
  364.     && iEntFrameEnd != g_iParamDontChange
  365.     && iEntFrameStart < iEntFrameEnd)
  366.     {
  367.         new iTemp = iEntFrameStart;
  368.        
  369.         iEntFrameStart = iEntFrameEnd;
  370.         iEntFrameEnd = iTemp;
  371.        
  372.         iReturn++;
  373.     }
  374.    
  375.     if (fEntFrameRate != g_fParamDontChange
  376.     && fEntFrameRate < 0.0)
  377.     {
  378.         fEntFrameRate = 0.0;
  379.        
  380.         iReturn++;
  381.     }
  382.    
  383.     if (fEntScale != g_fParamDontChange)
  384.         floatclamp(fEntScale, 0.000001, 1.0)
  385.    
  386.     if (iEntRenderMode != g_iParamDontChange)
  387.         clamp(iEntRenderMode, kRenderNormal, kRenderTransAdd)
  388.    
  389.     if (iEntRenderFx != g_iParamDontChange)
  390.         clamp(iEntRenderFx, kRenderFxNone, kRenderFxClampMinScale)
  391.    
  392.     if (fEntRenderAmount != g_fParamDontChange)
  393.         floatclamp(fEntRenderAmount, 0.0, 255.0)
  394.    
  395.     if (fEntOriginUpdateRate != g_fParamDontChange
  396.     && fEntOriginUpdateRate < 0.0)
  397.     {
  398.         fEntOriginUpdateRate = 0.0;
  399.        
  400.         iReturn++;
  401.     }
  402.    
  403.     if (iVecEntRenderColor[0] != g_iParamDontChange)
  404.     {
  405.         clamp(iVecEntRenderColor[0], 0, 255);
  406.         clamp(iVecEntRenderColor[1], 0, 255);
  407.         clamp(iVecEntRenderColor[2], 0, 255);
  408.     }
  409.    
  410.     if (fVecEntOriginModifier[0] != g_fParamDontChange)
  411.     {
  412.         floatclamp(fVecEntOriginModifier[0], -4096.0, 4096.0);
  413.         floatclamp(fVecEntOriginModifier[1], -4096.0, 4096.0);
  414.         floatclamp(fVecEntOriginModifier[2], -4096.0, 4096.0);
  415.     }
  416.    
  417.     for (iID = 1; iID <= g_iMaxPlayers; iID++)
  418.     {
  419.         if (!bitsum_get(iBsIDs1, iID))
  420.             continue;
  421.        
  422.         for (iID2 = 1; iID2 <= g_iMaxPlayers; iID2++)
  423.         {
  424.             if (iBsIDsChange != g_iParamDontChange)
  425.             {
  426.                 if (!bitsum_get(iBsIDsChange, iID2))
  427.                     continue;
  428.             }
  429.             else
  430.             {
  431.                 if (!bitsum_get(g_iBsEntShow[iID], iID2))
  432.                     continue;
  433.             }
  434.            
  435.             if (iIDEntModel != g_iParamDontChange)
  436.                 g_iIDEntModel[iID][iID2] = iIDEntModel;
  437.            
  438.             if (iEntFrameStart != g_iParamDontChange)
  439.                 g_iEntFrameStart[iID][iID2] = iEntFrameStart;
  440.            
  441.             if (iEntFrameEnd != g_iParamDontChange)
  442.                 g_iEntFrameEnd[iID][iID2] = iEntFrameEnd;
  443.            
  444.             if (fEntFrameRate != g_fParamDontChange)
  445.             {
  446.                 g_fEntFrameRate[iID][iID2] = fEntFrameRate;
  447.             }
  448.            
  449.             g_iEntFrame[iID][iID2] = !g_fEntFrameRate[iID][iID2] ? random_num(iEntFrameStart, iEntFrameEnd) : iEntFrameStart;
  450.            
  451.             if (fEntScale != g_fParamDontChange)
  452.                 g_fEntScale[iID][iID2] = fEntScale;
  453.            
  454.             if (iEntRenderMode != g_iParamDontChange)
  455.                 g_iEntRenderMode[iID][iID2] = iEntRenderMode;
  456.            
  457.             if (iEntRenderFx != g_iParamDontChange)
  458.                 g_iEntRenderFx[iID][iID2] = iEntRenderFx;
  459.            
  460.             if (fEntRenderAmount != g_fParamDontChange)
  461.                 g_fEntRenderAmount[iID][iID2] = fEntRenderAmount;
  462.            
  463.             if (fEntOriginUpdateRate != g_fParamDontChange)
  464.                 g_fEntOriginUpdateRate[iID][iID2] = fEntOriginUpdateRate;
  465.            
  466.             if (iVecEntRenderColor[0] != g_iParamDontChange)
  467.             {
  468.                 g_iVecEntRenderColor[iID][iID2][0] = iVecEntRenderColor[0];
  469.                 g_iVecEntRenderColor[iID][iID2][1] = iVecEntRenderColor[1];
  470.                 g_iVecEntRenderColor[iID][iID2][2] = iVecEntRenderColor[2];
  471.             }
  472.            
  473.             if (fVecEntOriginModifier[0] != g_fParamDontChange)
  474.             {
  475.                 g_fVecEntOriginModifier[iID][iID2][0] = fVecEntOriginModifier[0];
  476.                 g_fVecEntOriginModifier[iID][iID2][1] = fVecEntOriginModifier[1];
  477.                 g_fVecEntOriginModifier[iID][iID2][2] = fVecEntOriginModifier[2];
  478.             }
  479.         }
  480.     }
  481.     /*
  482.     ftD7Log("a", _, "[iFwNtSet] iIDEntModel: %d. fEntScale: %.2f. \
  483.     fVecEntOriginModifier: %.2f, %.2f, %.2f. iEntRenderMode: %d. iEntRenderFx: %d. fEntRenderAmount: %.2f. \
  484.     iVecEntRenderColor: %d, %d, %d.", iIDEntModel, fEntScale,
  485.     fVecEntOriginModifier[0], fVecEntOriginModifier[1], fVecEntOriginModifier[2],
  486.     iEntRenderMode, iEntRenderFx, fEntRenderAmount,
  487.     iVecEntRenderColor[0], iVecEntRenderColor[1], iVecEntRenderColor[2])*/
  488.     //
  489.     //if ( != -1)
  490.         //[iID][iID2] = ;
  491.    
  492.     return iReturn;
  493. }
  494.  
  495. public client_putinserver(iID)
  496. {
  497.     add_bitsum(g_iBsConnected, iID)
  498. }
  499.  
  500. //public fwFmClientConnect(const iID)
  501. public client_authorized(iID)
  502. {
  503.     if (is_user_bot(iID))
  504.     {
  505.         bitsum_add(g_iBsBot, iID)
  506.        
  507.         g_iBsEntShow[iID] = 0;
  508.     }
  509. }
  510.  
  511. public fwFmClientDisconnectPre(const iID)
  512. {
  513.     del_bitsum(g_iBsConnected, iID)
  514. }
  515.  
  516. public fwFmClientDisconnect(const iID)
  517. {
  518.     bitsum_del(g_iBsBot, iID)
  519. }
  520.  
  521. public fwFmUpdateClientDataPre(const iID)
  522. //public client_PreThink(iID)
  523. {
  524.     if (!get_bitsum(g_iBsConnected, iID) || get_bitsum(g_iBsBot, iID))
  525.         return;
  526.    
  527.     static Float:fVecOrigin[3], Float:fVecOriginCamera[3];
  528.    
  529.     pev(iID, pev_origin, fVecOrigin)
  530.     pev(g_iIDEntCamera[iID], pev_origin, fVecOriginCamera)
  531.    
  532.     if (g_iIDEntCamera[iID] == iID)
  533.     {
  534.         new iIDiuser2 = pev(iID, pev_iuser2);
  535.        
  536.         static Float:fVecViewOffset[3];
  537.        
  538.         pev(!iIDiuser2 ? iID : iIDiuser2, pev_view_ofs, fVecViewOffset)
  539.         xs_vec_add(fVecOriginCamera, fVecViewOffset, fVecOriginCamera)
  540.         //fVecOriginCamera[0] += fVecViewOffset[0];
  541.         //fVecOriginCamera[1] += fVecViewOffset[1];
  542.         //fVecOriginCamera[2] += fVecViewOffset[2];
  543.     }
  544.    
  545.     static Float:fVecOrigin2[3];
  546.    
  547.     new iIDTraceHandle;
  548.    
  549.     for (new iID2 = 1; iID2 <= g_iMaxPlayers; iID2++)
  550.     {
  551.         if (!get_bitsum(g_iBsEntShow[iID], iID2)
  552.         || !get_bitsum(g_iBsConnected, iID2))
  553.             continue;
  554.        
  555.         pev(iID2, pev_origin, fVecOrigin2)
  556.        
  557.         if (g_iIDEntCamera[iID] == iID && !fm_is_in_viewcone(iID, fVecOrigin2))
  558.         {
  559.             bitsum_del(g_iBsVisible[iID], iID2)
  560.            
  561.             continue;
  562.         }
  563.         else
  564.             add_bitsum(g_iBsVisible[iID], iID2)
  565.        
  566.         iIDTraceHandle = create_tr2();
  567.        
  568.         engfunc(EngFunc_TraceLine, fVecOriginCamera, fVecOrigin2, IGNORE_MONSTERS, iID, iIDTraceHandle)
  569.         get_tr2(iIDTraceHandle, TR_vecEndPos, g_fVecOrigin[iID][iID2])
  570.        
  571.         free_tr2(iIDTraceHandle)
  572.        
  573.         xs_vec_add(g_fVecOrigin[iID][iID2], g_fVecEntOriginModifier[iID][iID2], g_fVecOrigin[iID][iID2])/*
  574.        
  575.         if (!task_exists(iID))
  576.         {
  577.             static Float:fVecViewOffset[3];
  578.             pev(iID2, pev_view_ofs, fVecViewOffset)
  579.             xs_vec_add(fVecOrigin2, fVecViewOffset, fVecViewOffset)
  580.            
  581.             message_begin(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, iID)
  582.             write_byte(TE_BEAMPOINTS)
  583.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[0])
  584.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[1])
  585.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[2])
  586.             engfunc(EngFunc_WriteCoord, fVecViewOffset[0])
  587.             engfunc(EngFunc_WriteCoord, fVecViewOffset[1])
  588.             engfunc(EngFunc_WriteCoord, fVecViewOffset[2])
  589.             write_short(g_iIDEntModel[iID][iID2])
  590.             write_byte(0)
  591.             write_byte(1)
  592.             write_byte(1)
  593.             write_byte(1)
  594.             write_byte(0)
  595.             write_byte(g_iVecEntRenderColor[iID][iID2][0]) // r, g, b
  596.             write_byte(g_iVecEntRenderColor[iID][iID2][1]) // r, g, b
  597.             write_byte(g_iVecEntRenderColor[iID][iID2][2]) // r, g, b
  598.             write_byte(255) // brightness
  599.             write_byte(150) // speed
  600.             message_end()
  601.         }*/
  602.        
  603.         xs_vec_sub(fVecOriginCamera, fVecOrigin2, fVecOrigin)
  604.         xs_vec_sub(g_fVecOrigin[iID][iID2], fVecOriginCamera, fVecOrigin2)
  605.        
  606.         g_fScale[iID][iID2] = vector_length(fVecOrigin2) / vector_length(fVecOrigin);
  607.         g_fScale[iID][iID2] *= g_fEntScale[iID][iID2];
  608.        
  609.         if (g_fScale[iID][iID2] <= 0.003905)
  610.             g_fScale[iID][iID2] = 0.003907;/*
  611.        
  612.         if (!task_exists(iID))
  613.         {
  614.             message_begin(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, _, iID)
  615.             write_byte(TE_BEAMPOINTS)
  616.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[0])
  617.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[1])
  618.             engfunc(EngFunc_WriteCoord, fVecOriginCamera[2])
  619.             engfunc(EngFunc_WriteCoord, g_fVecOrigin[iID][iID2][0])
  620.             engfunc(EngFunc_WriteCoord, g_fVecOrigin[iID][iID2][1])
  621.             engfunc(EngFunc_WriteCoord, g_fVecOrigin[iID][iID2][2])
  622.             write_short(g_iIDEntModel[iID][iID2])
  623.             write_byte(0)
  624.             write_byte(1)
  625.             write_byte(1)
  626.             write_byte(1)
  627.             write_byte(0)
  628.             write_byte(g_iVecEntRenderColor[iID][iID2][0]) // r, g, b
  629.             write_byte(g_iVecEntRenderColor[iID][iID2][1]) // r, g, b
  630.             write_byte(g_iVecEntRenderColor[iID][iID2][2]) // r, g, b
  631.             write_byte(255) // brightness
  632.             write_byte(150) // speed
  633.             message_end()
  634.         }*/
  635.     }/*
  636.    
  637.     if (!task_exists(iID))
  638.         set_task(0.1, "fwTaskSkipMessages", iID)*/
  639. }/*
  640.  
  641. public fwTaskSkipMessages()
  642. {
  643.  
  644. }*/
  645.  
  646. public fwFmAddToFullPack(const iIDESHandle, const e, const iIDEnt, const iIDHost, const iBsFlags, const player, const pSet)
  647. {
  648.     if (!is_user_valid(iIDHost)
  649.     || !get_bitsum(g_iBsConnected, iIDHost)
  650.     || get_bitsum(g_iBsBot, iIDHost)
  651.     || player
  652.     || !get_bitsum_array(g_iBsArEspSprite, iIDEnt))
  653.         return;
  654.    
  655. /*  new Float:fGameTime = get_gametime();
  656.    
  657.     if (fGameTime - pev(iIDHost, pev_fuser4) >= 5.0)
  658.     {
  659.         ftD7Log(_, _, "[fwFmAddToFullPack] iIDHost: %d. %u.", iIDHost, get_bitsum_array(g_iBsArEspSprite, iIDEnt))
  660.        
  661.         set_pev(iIDHost, pev_fuser4, fGameTime)
  662.     }
  663.     */
  664.    
  665.     new iIDEntOwner = get_es(iIDESHandle, ES_Owner);
  666.    
  667.     if (!get_bitsum(g_iBsConnected, iIDEntOwner)
  668.     || !get_bitsum(g_iBsEntShow[iIDHost], iIDEntOwner)
  669.     || !get_bitsum(g_iBsVisible[iIDHost], iIDEntOwner))
  670.         return;
  671.    
  672.     //set_es(iIDESHandle, ES_Effects, (get_es(iIDESHandle, ES_Effects) & ~EF_NODRAW))
  673.     set_es(iIDESHandle, ES_Origin, g_fVecOrigin[iIDHost][iIDEntOwner])
  674.     set_es(iIDESHandle, ES_ModelIndex, g_iIDEntModel[iIDHost][iIDEntOwner])
  675.     set_es(iIDESHandle, ES_Scale, g_fScale[iIDHost][iIDEntOwner])
  676.     //set_es(iIDESHandle, ES_AnimTime, 1.0)
  677.     //set_es(iIDESHandle, ES_FrameRate, random_float(10.0, 15.0))
  678.     set_es(iIDESHandle, ES_RenderMode, g_iEntRenderMode[iIDHost][iIDEntOwner])
  679.     set_es(iIDESHandle, ES_RenderFx, g_iEntRenderFx[iIDHost][iIDEntOwner])
  680.     set_es(iIDESHandle, ES_RenderAmt, g_fEntRenderAmount[iIDHost][iIDEntOwner])
  681.     set_es(iIDESHandle, ES_RenderColor, g_iVecEntRenderColor[iIDHost][iIDEntOwner])
  682. }
  683.  
  684. public fwFmCheckVisibilityPre(const iIDEnt, const pSet)
  685. {
  686.     if (!pev_valid(iIDEnt) || !get_bitsum_array(g_iBsArEspSprite, iIDEnt))
  687.         return FMRES_IGNORED;
  688.    
  689.     forward_return(FMV_CELL, 1)
  690.    
  691.     return FMRES_SUPERCEDE;
  692. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!