regener

spriteFixer.sma

Sep 28th, 2020
721
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <amxmodx>
  2. #include <amxmisc>
  3. #include <fakemeta>
  4. #include <engine>
  5. #include <xs>
  6.  
  7. #include <hamsandwich>
  8.  
  9. #define PLUGIN "spriteFixer"
  10. #define VERSION "1.0"
  11. #define AUTHOR "AMXX.PL Team"
  12.  
  13. #define SPRITES_PER_PLAYER 3
  14.  
  15. #define AUTH_STEAM 2
  16.  
  17. new const spriteClass[] =   "spriteFix";
  18.  
  19. new pcv_dp_r_id_provider;
  20.  
  21. new bool:gbHaveSprite[MAX_PLAYERS];
  22. new giEntsIds[MAX_PLAYERS][SPRITES_PER_PLAYER];
  23. new Float:gfOffset[MAX_PLAYERS][SPRITES_PER_PLAYER][2];
  24. new Float:gfOffsetLen[MAX_PLAYERS][SPRITES_PER_PLAYER];
  25. new Float:gfPosition[MAX_PLAYERS][3];
  26. new Float: fBob[ MAX_PLAYERS ] ,
  27. Float: fBobUp[ MAX_PLAYERS ]
  28.  
  29.  
  30. public plugin_init() {
  31.     register_plugin(PLUGIN, VERSION, AUTHOR);
  32.  
  33.     register_forward(FM_AddToFullPack, "fwAddToFullPack", 0 );
  34.  
  35.     register_think( spriteClass, "fwSpriteThink");
  36.  
  37.     pcv_dp_r_id_provider = get_cvar_pointer("dp_r_id_provider");
  38.  
  39.     if( !pcv_dp_r_id_provider ){
  40.         state onlysteam;
  41.     }
  42.     else {
  43.         state dproto;
  44.     }
  45. }
  46.  
  47. public client_disconnect(id){
  48.     for(new i=0;i<SPRITES_PER_PLAYER;i++){
  49.         if(pev_valid(giEntsIds[id][i])){
  50.             remove_entity(giEntsIds[id][i]);
  51.         }
  52.         giEntsIds[id][i] = 0;
  53.     }
  54. }
  55.  
  56. public client_authorized(id){
  57.  
  58.     checkUserCvars( id );
  59.  
  60.     gbHaveSprite[id] = false;
  61. }
  62.  
  63. public checkUserCvars( id ){
  64.  
  65.     if( !is_user_steam( id ) ){
  66.  
  67.         fBob[ id ]      =   0.01;
  68.         fBobUp[ id ]    =   0.5;
  69.  
  70.         return PLUGIN_CONTINUE;
  71.     }
  72.  
  73.     query_client_cvar( id , "cl_bob" , "clBobResult" )
  74.     query_client_cvar( id , "cl_bobup" , "clBobUpResult" )
  75.  
  76.     return PLUGIN_CONTINUE;
  77. }
  78.  
  79. public clBobResult(id, const cvar[], const value[]){
  80.     fBob[ id ]  =   str_to_float( value );
  81. }
  82.  
  83. public clBobUpResult(id, const cvar[], const value[]){
  84.     fBobUp[ id ]    =   str_to_float( value );
  85. }
  86.  
  87. public resetUserCvars( id ){
  88.  
  89.     client_cmd( id , "cl_bob %f" , fBob[ id ] );
  90.     client_cmd( id , "cl_bobup %f" , fBobUp[ id ] );
  91.  
  92. }
  93.  
  94. public setUserCvars( id ){
  95.  
  96.     client_cmd( id , "cl_bob 0" );
  97.     client_cmd( id , "cl_bobup 0" );
  98.  
  99. }
  100.  
  101. public plugin_natives(){
  102.     register_native("addPlayerSprite","addSprite");
  103.  
  104.     register_native( "setSpriteFX" , "setSpriteFX" , 1 );
  105.     register_native( "setSpriteRender" , "setSpriteRender" , 1 );
  106.     register_native( "setSpriteColor" , "setSpriteColor" , 1 );
  107.     register_native( "setSpriteSequence" , "setSpriteSequence" , 1 );
  108.     register_native( "setSpriteScale" , "setSpriteScale" , 1 );
  109.     register_native( "setSpriteFrame" , "setSpriteFrame" , 1 );
  110.     register_native( "setSpriteFrameRate" , "setSpriteFrameRate" , 1 );
  111.     register_native( "setSpriteAmount" , "setSpriteAmount" , 1 );
  112.  
  113.     register_native( "setSpriteAngle" , "setSpriteAngle" , 1 );
  114. }
  115.  
  116. public setSpriteFX( id , indexSprite , fx ){
  117.  
  118.     if( checkSprite( id , indexSprite ) ){
  119.  
  120.         return PLUGIN_CONTINUE;
  121.  
  122.     }
  123.  
  124.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_renderfx , fx );
  125.  
  126.     return PLUGIN_CONTINUE;
  127. }
  128.  
  129. public setSpriteRender( id , indexSprite , render ){
  130.  
  131.     if( checkSprite( id , indexSprite ) ){
  132.  
  133.         return PLUGIN_CONTINUE;
  134.  
  135.     }
  136.  
  137.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_rendermode , render );
  138.  
  139.     return PLUGIN_CONTINUE;
  140.  
  141. }
  142.  
  143. public setSpriteColor( id , indexSprite , Float: fColor[ 3 ] ){
  144.  
  145.     if( checkSprite( id , indexSprite ) ){
  146.  
  147.         return PLUGIN_CONTINUE;
  148.  
  149.     }
  150.  
  151.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_rendercolor , fColor );
  152.  
  153.     return PLUGIN_CONTINUE;
  154. }
  155.  
  156. public setSpriteSequence( id , indexSprite , iSequence ){
  157.  
  158.     if( checkSprite( id , indexSprite ) ){
  159.  
  160.         return PLUGIN_CONTINUE;
  161.  
  162.     }
  163.  
  164.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_sequence , iSequence );
  165.  
  166.     return PLUGIN_CONTINUE;
  167. }
  168.  
  169. public setSpriteScale( id , indexSprite , Float: fScale ){
  170.  
  171.     if( checkSprite( id , indexSprite ) ){
  172.  
  173.         return PLUGIN_CONTINUE;
  174.  
  175.     }
  176.  
  177.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_scale , fScale );
  178.  
  179.     return PLUGIN_CONTINUE;
  180. }
  181.  
  182. public setSpriteFrameRate( id , indexSprite , Float: fFrameRate ){
  183.  
  184.     if( checkSprite( id , indexSprite ) ){
  185.  
  186.         return PLUGIN_CONTINUE;
  187.  
  188.     }
  189.  
  190.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_framerate , fFrameRate );
  191.  
  192.     return PLUGIN_CONTINUE;
  193. }
  194.  
  195. public setSpriteAmount( id , indexSprite , Float: fAmount ){
  196.  
  197.     if( checkSprite( id , indexSprite ) ){
  198.  
  199.         return PLUGIN_CONTINUE;
  200.  
  201.     }
  202.  
  203.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_renderamt , fAmount );
  204.  
  205.     return PLUGIN_CONTINUE;
  206. }
  207.  
  208. public setSpriteFrame( id , indexSprite , iFrame ){
  209.  
  210.     if( checkSprite( id , indexSprite ) ){
  211.  
  212.         return PLUGIN_CONTINUE;
  213.  
  214.     }
  215.  
  216.     set_pev( giEntsIds[ id ][ indexSprite - 1 ] , pev_frame , iFrame );
  217.  
  218.     return PLUGIN_CONTINUE;
  219. }
  220.  
  221. public setSpriteAngle( id , indexSprite , Float: fAngle ){
  222.  
  223.     if( checkSprite( id , indexSprite ) ){
  224.  
  225.         return PLUGIN_CONTINUE;
  226.  
  227.     }
  228.  
  229.     gfOffset[id][ indexSprite ][ 0 ]    =   fAngle;
  230.  
  231.     return PLUGIN_CONTINUE;
  232. }
  233.  
  234.  
  235. bool: checkSprite( id , indexSprite ){
  236.     return bool: ( indexSprite <= 0 || !pev_valid( giEntsIds[ id ][ indexSprite - 1 ] ) );
  237. }
  238.  
  239. public addSprite(plugin,params){
  240.     if(params < 7){
  241.         log_amx("addSprite - You provided less parameters than needed!");
  242.         return 0;
  243.     }
  244.     new ent = create_entity("env_sprite");
  245.  
  246.     new id = get_param(1);
  247.  
  248.     set_pev(ent, pev_classname, spriteClass );
  249.     set_pev(ent, pev_solid, SOLID_NOT);
  250.     set_pev( ent, pev_movetype, MOVETYPE_FLY );
  251.  
  252.     new szModel[256]
  253.     get_string(4, szModel, charsmax(szModel));
  254.  
  255.     entity_set_model(ent, szModel);
  256.     entity_set_size(ent, Float:{-1.0, -1.0, -1.0}, Float:{1.0, 1.0, 1.0});
  257.     set_rendering(ent, kRenderFxNone, 255, 255, 255, get_param( 9 ) ? kRenderTransAdd : kRenderNormal , 255 );
  258.  
  259.     set_pev(ent, pev_scale, get_param_f(2));
  260.     set_pev(ent, pev_owner, id);
  261.     set_pev(ent, pev_framerate, get_param_f(3));
  262.     //set_pev(ent, pev_sequence , 5);
  263.  
  264.     new Float:fLTime = get_param_f(7);
  265.  
  266.     new iIndex  =   addFixedSprite(id, ent, get_param_f(5), get_param_f(6), get_param_f(8), fLTime);
  267.  
  268.     if( !iIndex ){
  269.         remove_entity(ent);
  270.         return 0;
  271.     }
  272.  
  273.     if( !gbHaveSprite[ id ] ){
  274.         setUserCvars( id );
  275.     }
  276.  
  277.     gbHaveSprite[id] = true;
  278.  
  279.     if(fLTime >= 0.0){
  280.         set_pev(ent, pev_nextthink, get_gametime()+fLTime);
  281.     }
  282.     return iIndex;
  283. }
  284.  
  285. public ent_get(id){
  286.     for(new i=0;i<SPRITES_PER_PLAYER;i++){
  287.         if(giEntsIds[id][i] == 0){
  288.             return i;
  289.         }
  290.     }
  291.     return -1;
  292. }
  293.  
  294. /**
  295. * Dodaje do kolejki nowy byt
  296. *
  297. *   @param  id      Gracz
  298. *   @param  ent     Byt
  299. *   @param  fOffset     Przesuniecie katowe (tarcza zegara)
  300. *   @param  fOffsetLen  Odleglosc od srodka ekranu
  301. *   @param  fOffsetDistance Odleglosc od gracza
  302. */
  303. addFixedSprite(id, ent, const Float:fOffset, Float:fOffsetLen, Float:fOffsetDistance, Float:fLTime = -1.0){
  304.     new index = ent_get(id);
  305.     if(index == -1){
  306.         return 0;
  307.     }
  308.  
  309.     gfOffset[id][index][0] = fOffset;
  310.     gfOffset[id][index][1] = fOffsetLen;
  311.  
  312.     gfOffsetLen[id][index] = fOffsetDistance;
  313.     giEntsIds[id][index] = ent;
  314.  
  315.     if(fLTime >= 0.0)
  316.         set_pev(ent, pev_ltime, get_gametime()+fLTime);
  317.     else
  318.     set_pev(ent, pev_ltime, 0.0);
  319.  
  320.     getPosition(id);
  321.  
  322.     return index + 1;
  323. }
  324. removeFixedSprite(id, ent){
  325.     new index = -1;
  326.     for(new i=0;i<SPRITES_PER_PLAYER;i++){
  327.         if(giEntsIds[id][i] == ent){
  328.             index = i;
  329.             break;
  330.         }
  331.     }
  332.  
  333.     if(index < 0){
  334.         gbHaveSprite[id] = false;
  335.  
  336.         resetUserCvars( id );
  337.  
  338.         return;
  339.     }
  340.  
  341.     giEntsIds[id][index] = 0;
  342.     gfOffsetLen[id][index] = 0.0;
  343.  
  344.     xs_vec_copy(Float:{0.0,0.0,0.0}, gfOffset[id][index]);
  345. }
  346. public fwAddToFullPack(es_handle, e, ENT, HOST, hostflags, player, set){
  347.     if(player || !pev_valid( ENT ) ) return FMRES_IGNORED;
  348.  
  349.     new szClassName[ 64 ];
  350.  
  351.     pev( ENT , pev_classname , szClassName , charsmax( szClassName ) );
  352.  
  353.     if( !equal( szClassName , spriteClass ) ){
  354.         return FMRES_IGNORED;
  355.     }
  356.  
  357.     for(new i=0;i<SPRITES_PER_PLAYER;i++){
  358.  
  359.         if(giEntsIds[HOST][i] == ENT){
  360.  
  361.             getPosition( HOST );
  362.  
  363.             new Float:fAngles[3];
  364.             new Float:fVector[3];
  365.  
  366.             pev(HOST, pev_v_angle, fAngles);
  367.  
  368.             angle_vector(fAngles, ANGLEVECTOR_FORWARD, fVector);
  369.             xs_vec_mul_scalar(fVector, gfOffsetLen[HOST][i], fVector);
  370.  
  371.             fAngles[2] = gfOffset[HOST][i][0];
  372.             angle_vector(fAngles, ANGLEVECTOR_RIGHT, fAngles);
  373.  
  374.             xs_vec_mul_scalar(fAngles, gfOffset[HOST][i][1], fAngles);
  375.  
  376.             xs_vec_add(gfPosition[HOST], fVector, fVector);
  377.             xs_vec_add(fVector, fAngles, fVector);
  378.  
  379.             set_pev(giEntsIds[HOST][i], pev_origin, fVector);
  380.  
  381.             set_es( es_handle , ES_Origin , fVector );
  382.  
  383.             return FMRES_HANDLED;
  384.         }
  385.  
  386.     }
  387.  
  388.     set_es( es_handle , ES_Scale , 0.001 );
  389.     set_es( es_handle , ES_Origin , { 9999.0 , 9999.0 , 9999.0 } );
  390.  
  391.     return FMRES_HANDLED;
  392. }
  393. public fwSpriteThink(ent){
  394.     if(!pev_valid(ent))
  395.         return PLUGIN_CONTINUE;
  396.  
  397.     new Float:fNow = get_gametime();
  398.     new Float:fLTime;
  399.     if(pev(ent, pev_ltime, fLTime) && fLTime > 0.0 && fLTime <= fNow){
  400.         removeFixedSprite(pev(ent, pev_owner), ent);
  401.         remove_entity(ent);
  402.     }
  403.     else
  404.     set_pev(ent, pev_nextthink, fNow+0.1);
  405.     return PLUGIN_CONTINUE;
  406. }
  407. getPosition(id){
  408.     pev(id, pev_origin, gfPosition[id]);
  409.  
  410.     static Float:fOffset[3];
  411.     pev(id, pev_view_ofs, fOffset);
  412.  
  413.     xs_vec_add(gfPosition[id], fOffset, gfPosition[id]);
  414. }
  415.  
  416. stock bool: is_user_steam(id) <dproto>
  417. {
  418.     if( is_user_bot( id ) ){
  419.         return false;
  420.     }
  421.  
  422.     server_cmd("dp_clientinfo %d", id);
  423.     server_exec();
  424.  
  425.     static uClient;
  426.     uClient = get_pcvar_num(pcv_dp_r_id_provider);
  427.  
  428.     if ( uClient == AUTH_STEAM )
  429.         return true;
  430.  
  431.     return false;
  432. }
  433.  
  434. stock bool: is_user_steam(id) <onlysteam>
  435. {
  436.     return !is_user_bot( id );
  437.  
  438.     #pragma unused id
  439. }
  440.  
RAW Paste Data