API tools faq
paste
Advertisement
Larceny

dzones Inc SA-MP

Larceny
Nov 6th, 2013
264
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.85 KB | None | 0 0
raw download clone embed print report
  1. /*----------------------------------------------------------------------------*\
  2.                     Dynamic Zones - Include
  3. @Descrição:
  4.     Esta include contém funções para ajudar no manuseio de gangzones.
  5. @Legal:
  6.     Este código-fonte está sob os termos de licença da Mozilla Public
  7.     License, v. 2.0. Se uma cópia do MPL não for distribuida com este
  8.     arquivo, você pode obter uma em http://mozilla.org/MPL/2.0/
  9.  
  10.     O inicial desenvolvedor deste código é Larceny.
  11.     Códigos criados pelos iniciais desenvolvedores são Copyright (C) 2012
  12.     Inicial desenvolvedor.
  13.     Todos os direitos reservados.
  14. @Versão:
  15.     1.0 - 14:23 02/08/2012 - linhas: 405
  16.     1.4 - 16:30 25/11/2012 - linhas: 732
  17. @Change-log:
  18.     1.0:
  19.         Primeira versão.
  20.     1.4:
  21.         Melhorias em loops, swap ao criar gangzones, documentação do código
  22. @Autor:
  23.     Larceny
  24. @Obrigado-a:
  25.     Y_Less ------------------------> Metódo de hook callbacks & swap func.
  26.     rjj/Ken -----------------------> Me deu a dica de usar swap
  27.     ipsBruno/BrunodaSilva ---------> Me deu a dica de usar swap
  28.     SA-MP Team --------------------> (c) SA-MP
  29. \*----------------------------------------------------------------------------*/
  30.  
  31. #include <a_samp>
  32.  
  33. #if defined _dzones_included
  34.     #endinput
  35. #endif
  36.  
  37. #define _dzones_included
  38.  
  39. /*
  40. native GetDynamicZoneArea(zoneid, &Float:minx, &Float:miny, &Float:maxx, &Float:maxy);
  41. native SetDynamicZoneArea(zoneid, Float:minx, Float:miny, Float:maxx, Float:maxy);
  42. native CreateDynamicZone(Float:minx, Float:miny, Float:maxx, Float:maxy, color);
  43. native FlashDynamicZoneForPlayer(playerid, zoneid, color);
  44. native IsDynamicZoneFlashingForPlayer(playerid, zoneid);
  45. native IsDynamicZoneVisibleForPlayer(playerid, zoneid);
  46. native StopFlashDynamicZoneForPlayer(playerid, zoneid);
  47. native ShowDynamicZoneForPlayer(playerid, zoneid);
  48. native HideDynamicZoneForPlayer(playerid, zoneid);
  49. native IsPlayerInDynamicZone(playerid, zoneid);
  50. native FlashDynamicZoneForAll(zoneid, color);
  51. native SetDynamicZoneColor(zoneid, color);
  52. native StopFlashDynamicZoneForAll(zoneid);
  53. native ShowDynamicZoneForAll(zoneid);
  54. native HideDynamicZoneForAll(zoneid);
  55. native GetDynamicZoneColor(zoneid);
  56. native DestroyDynamicZone(zoneid);
  57. native zexist(zoneid);
  58. */
  59.  
  60. /*----------------------------------------------------------------------------*\
  61.     Descrição:
  62.         - Variavéis globais do projeto
  63. \*----------------------------------------------------------------------------*/
  64. enum g_GANG_ZONE {
  65.     g_GANG_ZONE_ID,
  66.     g_GANG_ZONE_COLOR,
  67.     Float:g_GANG_ZONE_MINX,
  68.     Float:g_GANG_ZONE_MINY,
  69.     Float:g_GANG_ZONE_MAXX,
  70.     Float:g_GANG_ZONE_MAXY
  71. }
  72. new
  73.     gZoneData[ MAX_GANG_ZONES ][ g_GANG_ZONE ];
  74.  
  75. /*----------------------------------------------------------------------------*\
  76.     Descrição:
  77.         - Forwards do projeto
  78. \*----------------------------------------------------------------------------*/
  79. forward dzones_Check();
  80.  
  81. /*----------------------------------------------------------------------------*-
  82. Função:
  83.     swap
  84. Params:
  85.     num1 - Primeira variável.
  86.     num2 - Segunda variável.
  87. Return:
  88.     -
  89. Notas:
  90.     Troca os valores entre duas variáveis sem uma variavel intermediária.
  91.  
  92. (c) By Y_Less
  93. -*----------------------------------------------------------------------------*/
  94.  
  95. #define swap(%1,%2) \
  96.     %1 ^= %2, %2 ^= %1, %1 ^= %2
  97.  
  98. /*----------------------------------------------------------------------------*\
  99.     Descrição:
  100.         - Esta função cria uma dynamic gangzone.
  101.  
  102.     Params:
  103.         - Float:minx -> Minima coordenada X da gangzone
  104.         - Float:miny -> Minima coordenada Y da gangzone
  105.         - Float:maxx -> Maxima coordenada X da gangzone
  106.         - Float:maxy -> Maxima coordenada Y da gangzone
  107.         - color ------> Cor da gangzone (Hexadecimal)
  108.  
  109.     Return:
  110.         - Esta função retorna 0 caso o limite de gangzones for ultrapasado.
  111.         - Esta função retorna o id da gangzones criada caso criada
  112.           com sucesso.
  113. \*----------------------------------------------------------------------------*/
  114. stock CreateDynamicZone(Float:minx, Float:miny, Float:maxx, Float:maxy, color)
  115. {
  116.     new int_zone_id = SearchZones();
  117.     if (int_zone_id == INVALID_GANG_ZONE) {
  118.         print("ERROR: Maximum limit of zones exceeded. (dzones.inc)");
  119.         return 0;
  120.     }
  121.  
  122.     if(minx > maxx)
  123.         swap(minx, maxx);
  124.  
  125.     if(miny > maxy)
  126.         swap(miny, maxy);
  127.  
  128.     gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] = GangZoneCreate(minx,
  129.                                                                 miny,
  130.                                                                 maxx,
  131.                                                                 maxy);
  132.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MINX ] = minx;
  133.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MINY ] = miny;
  134.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXX ] = maxx;
  135.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXY ] = maxy;
  136.     gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ] = color;
  137.     return int_zone_id;
  138. }
  139.  
  140. /*----------------------------------------------------------------------------*\
  141.     Descrição:
  142.         - Esta função destrói uma dynamic gangzone.
  143.  
  144.     Params:
  145.         - int_zone_id -> ID da gangzone que será destruída
  146.  
  147.     Return:
  148.         - Esta função retorna 0 caso a gangzone for inválida.
  149.         - Esta função retorna 1 caso a gz for destruída com sucesso.
  150. \*----------------------------------------------------------------------------*/
  151. stock DestroyDynamicZone(int_zone_id)
  152. {
  153.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  154.         return 0;
  155.  
  156.     GangZoneDestroy(gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  157.     gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] = INVALID_GANG_ZONE;
  158.     return 1;
  159. }
  160.  
  161. /*----------------------------------------------------------------------------*\
  162.     Descrição:
  163.         - Esta função muda a posição de uma dynamic gangzone
  164.  
  165.     Params:
  166.         - int_zone_id -> ID da gangzone que mudará de posição
  167.         - Float:minx --> Minima coordenada X da gangzone
  168.         - Float:miny --> Minima coordenada Y da gangzone
  169.         - Float:maxx --> Maxima coordenada X da gangzone
  170.         - Float:maxy --> Maxima coordenada Y da gangzone
  171.  
  172.     Return:
  173.         - Esta função retorna 0 caso a gangzone for inválida.
  174.         - Esta função retorna 1 caso a gz for movida com sucesso.
  175. \*----------------------------------------------------------------------------*/
  176. stock SetDynamicZoneArea(int_zone_id, Float:minx, Float:miny, Float:maxx,
  177.                         Float:maxy)
  178. {
  179.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  180.         return 0;
  181.  
  182.     GangZoneDestroy(gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  183.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MINX ] = minx;
  184.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MINY ] = miny;
  185.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXX ] = maxx;
  186.     gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXY ] = maxy;
  187.     gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] = GangZoneCreate(minx,
  188.                                                                 miny,
  189.                                                                 maxx,
  190.                                                                 maxy);
  191.    
  192.     new str_zone_id[14];
  193.     for (new i; i < MAX_PLAYERS; i++) {
  194.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  195.         if (GetPVarInt(i, str_zone_id) == 1) {
  196.             GangZoneHideForPlayer(i,
  197.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  198.             GangZoneShowForPlayer(i,
  199.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  200.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ]);
  201.         }
  202.     }
  203.    
  204.     return 1;
  205. }
  206.  
  207. /*----------------------------------------------------------------------------*\
  208.     Descrição:
  209.         - Esta função obtém as coordenadas minx, miny, maxx, maxy tipo float
  210.           de uma dynamic gangzone, passada por referência.
  211.  
  212.     Params:
  213.         - int_zone_id -> ID da gangzone para obter as coordenadas
  214.         - Float:minx --> Minima coordenada X da gangzone, passada por ref.
  215.         - Float:miny --> Minima coordenada Y da gangzone, passada por ref.
  216.         - Float:maxx --> Maxima coordenada X da gangzone, passada por ref.
  217.         - Float:maxy --> Maxima coordenada Y da gangzone, passada por ref.
  218.  
  219.     Return:
  220.         - Esta função retorna 0 caso a gangzone for inválida.
  221.         - Esta função retorna 1 caso os valores forem passados.
  222. \*----------------------------------------------------------------------------*/
  223. stock GetDynamicZoneArea(int_zone_id, &Float:minx, &Float:miny, &Float:maxx,
  224.                         &Float:maxy)
  225. {
  226.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  227.         return 0;
  228.  
  229.     minx = gZoneData[ int_zone_id ][ g_GANG_ZONE_MINX ];
  230.     miny = gZoneData[ int_zone_id ][ g_GANG_ZONE_MINY ];
  231.     maxx = gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXX ];
  232.     maxy = gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXY ];
  233.     return int_zone_id;
  234. }
  235.  
  236. /*----------------------------------------------------------------------------*\
  237.     Descrição:
  238.         - Esta função mostra uma dynamic gangzone para um jogador.
  239.  
  240.     Params:
  241.         - playerid ----> ID do jogador que verá a gangzone
  242.         - int_zone_id -> ID da gangzone que será mostrada ao jogador
  243.  
  244.     Return:
  245.         - Esta função retorna -1 caso o jogador for inválido.
  246.         - Esta função retorna 0 caso a gangzone for inválida.
  247.         - Esta função retorna 1 caso for mostrada para o jogador.
  248. \*----------------------------------------------------------------------------*/
  249. stock ShowDynamicZoneForPlayer(playerid, int_zone_id)
  250. {
  251.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  252.         return 0;
  253.  
  254.     if(!IsPlayerConnected(playerid) || playerid == INVALID_PLAYER_ID)
  255.         return -1;
  256.  
  257.     GangZoneShowForPlayer(playerid,
  258.         gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  259.         gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ]);
  260.  
  261.     new str_zone_id[14];
  262.     format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  263.     SetPVarInt(playerid, str_zone_id, 1);
  264.  
  265.     return 1;
  266. }
  267.  
  268. /*----------------------------------------------------------------------------*\
  269.     Descrição:
  270.         - Esta função oculta uma dynamic gangzone para um jogador.
  271.  
  272.     Params:
  273.         - playerid ----> ID do jogador que será oculta a gangzone
  274.         - int_zone_id -> ID da gangzone que será ocultada ao jogador
  275.  
  276.     Return:
  277.         - Esta função retorna -1 caso o jogador for inválido.
  278.         - Esta função retorna 0 caso a gangzone for inválida.
  279.         - Esta função retorna 1 caso for ocultada ao jogador.
  280. \*----------------------------------------------------------------------------*/
  281. stock HideDynamicZoneForPlayer(playerid, int_zone_id)
  282. {
  283.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  284.         return 0;
  285.  
  286.     if(!IsPlayerConnected(playerid) || playerid == INVALID_PLAYER_ID)
  287.         return -1;
  288.  
  289.     GangZoneHideForPlayer(playerid,
  290.         gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  291.  
  292.     new str_zone_id[14];
  293.     format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  294.     DeletePVar(playerid, str_zone_id);
  295.  
  296.     return 1;
  297. }
  298.  
  299. /*----------------------------------------------------------------------------*\
  300.     Descrição:
  301.         - Esta função mostra uma dynamic gangzone para todos
  302.  
  303.     Params:
  304.         - int_zone_id -> ID da gangzone que será mostrada
  305.  
  306.     Return:
  307.         - Esta função retorna 0 caso a gangzone for inválida.
  308.         - Esta função retorna 1 caso for mostrada a todos.
  309. \*----------------------------------------------------------------------------*/
  310. stock ShowDynamicZoneForAll(int_zone_id)
  311. {
  312.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  313.         return 0;
  314.  
  315.     new str_zone_id[14];
  316.     for (new i; i < MAX_PLAYERS; i++) {
  317.         if(!IsPlayerConnected(i))
  318.             continue;
  319.  
  320.         GangZoneShowForPlayer(i, gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  321.             gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ]);
  322.  
  323.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  324.         SetPVarInt(i, str_zone_id, 1);
  325.     }
  326.     return 1;
  327. }
  328.  
  329. /*----------------------------------------------------------------------------*\
  330.     Descrição:
  331.         - Esta função oculta uma dynamic gangzone para todos
  332.  
  333.     Params:
  334.         - int_zone_id -> ID da gangzone que será ocultada
  335.  
  336.     Return:
  337.         - Esta função retorna 0 caso a gangzone for inválida.
  338.         - Esta função retorna 1 caso for ocultada a todos.
  339. \*----------------------------------------------------------------------------*/
  340. stock HideDynamicZoneForAll(int_zone_id)
  341. {
  342.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  343.         return 0;
  344.  
  345.     new str_zone_id[14];
  346.     for (new i; i < MAX_PLAYERS; i++) {
  347.         if(!IsPlayerConnected(i))
  348.             continue;
  349.  
  350.         GangZoneHideForPlayer(i, gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  351.  
  352.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  353.         DeletePVar(i, str_zone_id);
  354.     }
  355.     return 1;
  356. }
  357.  
  358. /*----------------------------------------------------------------------------*\
  359.     Descrição:
  360.         - Esta função pisca uma dynamic gangzone para todos
  361.  
  362.     Params:
  363.         - int_zone_id -> ID da gangzone que irá piscar
  364.         - color -------> Segunda cor na qual a gangzone irá piscar.
  365.  
  366.     Return:
  367.         - Esta função retorna 0 caso a gangzone for inválida.
  368.         - Esta função retorna 1 caso for piscada a todos.
  369. \*----------------------------------------------------------------------------*/
  370. stock FlashDynamicZoneForAll(int_zone_id, color)
  371. {
  372.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  373.         return 0;
  374.  
  375.     new str_zone_id[14];
  376.     for (new i; i < MAX_PLAYERS; i++) {
  377.         if(!IsPlayerConnected(i))
  378.             continue;
  379.  
  380.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  381.         if (GetPVarInt(i, str_zone_id) == 1) {
  382.             GangZoneFlashForPlayer(i,
  383.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  384.                 color);
  385.  
  386.             format(str_zone_id, sizeof str_zone_id, "fszone_%i",
  387.                 int_zone_id);
  388.             SetPVarInt(i, str_zone_id, 1);
  389.         }
  390.     }
  391.     return 1;
  392. }
  393.  
  394. /*----------------------------------------------------------------------------*\
  395.     Descrição:
  396.         - Esta função para de piscar uma dynamic gangzone para todos
  397.  
  398.     Params:
  399.         - int_zone_id -> ID da gangzone que parará de piscar
  400.  
  401.     Return:
  402.         - Esta função retorna 0 caso a gangzone for inválida.
  403.         - Esta função retorna 1 caso for piscada a todos.
  404. \*----------------------------------------------------------------------------*/
  405. stock StopFlashDynamicZoneForAll(int_zone_id)
  406. {
  407.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  408.         return 0;
  409.  
  410.     new str_zone_id[14];
  411.     for (new i; i < MAX_PLAYERS; i++) {
  412.         if(!IsPlayerConnected(i))
  413.             continue;
  414.  
  415.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  416.         if (GetPVarInt(i, str_zone_id) == 1) {
  417.             GangZoneStopFlashForPlayer(i,
  418.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  419.  
  420.             format(str_zone_id, sizeof str_zone_id, "fszone_%i",
  421.                 int_zone_id);
  422.             DeletePVar(i, str_zone_id);
  423.         }
  424.     }
  425.     return 1;
  426. }
  427.  
  428. /*----------------------------------------------------------------------------*\
  429.     Descrição:
  430.         - Esta função pisca uma dynamic gangzone para um jogador
  431.  
  432.     Params:
  433.         - playerid ----> ID do jogador que verá a gangzone piscar
  434.         - int_zone_id -> ID da gangzone que irá piscar
  435.         - color -------> Segunda cor na qual a gangzone irá piscar
  436.  
  437.     Return:
  438.         - Esta função retorna -1 caso o jogador for inválido.
  439.         - Esta função retorna 0 caso a gangzone for inválida.
  440.         - Esta função retorna 1 caso for piscada.
  441. \*----------------------------------------------------------------------------*/
  442. stock FlashDynamicZoneForPlayer(playerid, int_zone_id, color)
  443. {
  444.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  445.         return 0;
  446.  
  447.     if(!IsPlayerConnected(playerid) || playerid == INVALID_PLAYER_ID)
  448.         return -1;
  449.  
  450.     new str_zone_id[14];
  451.     format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  452.     if (GetPVarInt(playerid, str_zone_id) == 1) {
  453.         GangZoneFlashForPlayer(playerid,
  454.             gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  455.             color);
  456.         format(str_zone_id, sizeof str_zone_id, "fszone_%i", int_zone_id);
  457.         SetPVarInt(playerid, str_zone_id, 1);
  458.     }
  459.     return 1;
  460. }
  461.  
  462. /*----------------------------------------------------------------------------*\
  463.     Descrição:
  464.         - Esta função para de piscar uma dynamic gangzone para um jogador
  465.  
  466.     Params:
  467.         - playerid ----> ID do jogador que verá a gangzone parar de piscar
  468.         - int_zone_id -> ID da gangzone que irá parar de piscar
  469.  
  470.     Return:
  471.         - Esta função retorna -1 caso o jogador for inválido.
  472.         - Esta função retorna 0 caso a gangzone for inválida.
  473.         - Esta função retorna 1 caso parar de piscar.
  474. \*----------------------------------------------------------------------------*/
  475. stock StopFlashDynamicZoneForPlayer(playerid, int_zone_id)
  476. {
  477.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  478.         return 0;
  479.  
  480.     if(!IsPlayerConnected(playerid) || playerid == INVALID_PLAYER_ID)
  481.         return -1;
  482.  
  483.     new str_zone_id[14];
  484.     format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  485.     if (GetPVarInt(playerid, str_zone_id) == 1) {
  486.         GangZoneStopFlashForPlayer(playerid,
  487.             gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  488.         format(str_zone_id, sizeof str_zone_id, "fszone_%i",
  489.             int_zone_id);
  490.         DeletePVar(playerid, str_zone_id);
  491.     }
  492.     return 1;
  493. }
  494.  
  495. /*----------------------------------------------------------------------------*\
  496.     Descrição:
  497.         - Esta função define a cor de uma gangzone
  498.  
  499.     Params:
  500.         - int_zone_id -> ID da gangzone que irá mudar de cor
  501.         - color -------> Nova cor da gangzone (hexadecimal)
  502.  
  503.     Return:
  504.         - Esta função retorna 0 caso a gangzone for inválida.
  505.         - Esta função retorna 1 caso mudar a cor da gangzone
  506. \*----------------------------------------------------------------------------*/
  507. stock SetDynamicZoneColor(int_zone_id, color)
  508. {
  509.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  510.         return 0;
  511.  
  512.     gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ] = color;
  513.     new str_zone_id[14];
  514.     for (new i; i < MAX_PLAYERS; i++) {
  515.         if(!IsPlayerConnected(i))
  516.             continue;
  517.  
  518.         format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  519.         if (GetPVarInt(i, str_zone_id) == 1) {
  520.             GangZoneHideForPlayer(i,
  521.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]);
  522.             GangZoneShowForPlayer(i,
  523.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ],
  524.                 gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ]);
  525.         }
  526.     }
  527.     return 1;
  528. }
  529.  
  530. /*----------------------------------------------------------------------------*\
  531.     Descrição:
  532.         - Esta função retorna a cor de uma gangzone.
  533.  
  534.     Params:
  535.         - int_zone_id -> ID da gangzone que irá obter a cor
  536.  
  537.     Return:
  538.         - Esta função retorna 0 caso a gangzone for inválida.
  539.         - Esta função retorna a cor da gangzone caso executada com sucesso.
  540. \*----------------------------------------------------------------------------*/
  541. stock GetDynamicZoneColor(int_zone_id)
  542. {
  543.     if (gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  544.         return 0;
  545.  
  546.     return gZoneData[ int_zone_id ][ g_GANG_ZONE_COLOR ];
  547. }
  548.  
  549. /*----------------------------------------------------------------------------*\
  550.     Descrição:
  551.         - Esta função retorna se uma zona é visível para um jogador.
  552.  
  553.     Params:
  554.         - playerid ----> ID do jogador para verificar se pode ver a zona
  555.         - int_zone_id -> ID da gangzone para verificar se o jogador pode ve-la
  556.  
  557.     Return:
  558.         - Esta função retorna 0 se o jogador não puder ver a zona.
  559.         - Esta função retorna 1 se o jogador puder ver a zona.
  560. \*----------------------------------------------------------------------------*/
  561. stock IsDynamicZoneVisibleForPlayer(playerid, int_zone_id)
  562. {
  563.     new str_zone_id[14];
  564.     format(str_zone_id, sizeof str_zone_id, "vszone_%i", int_zone_id);
  565.     return (!GetPVarInt(playerid, str_zone_id)) ? 0 : 1;
  566. }
  567.  
  568. /*----------------------------------------------------------------------------*\
  569.     Descrição:
  570.         - Esta função retorna se uma zona está piscando para um jogador.
  571.  
  572.     Params:
  573.         - playerid ----> ID do jogador para verificar se a zona está piscando
  574.         - int_zone_id -> ID da gangzone para verificar se o jogador ve piscando
  575.  
  576.     Return:
  577.         - Esta função retorna 0 se a zona não estiver picando para o jogador.
  578.         - Esta função retorna 1 se a zona estiver picando para o jogador.
  579. \*----------------------------------------------------------------------------*/
  580. stock IsDynamicZoneFlashingForPlayer(playerid, int_zone_id)
  581. {
  582.     new str_zone_id[14];
  583.     format(str_zone_id, sizeof str_zone_id, "fszone_%i", int_zone_id);
  584.     return (!GetPVarInt(playerid, str_zone_id)) ? 0 : 1;
  585. }
  586.  
  587. /*----------------------------------------------------------------------------*\
  588.     Descrição:
  589.         - Esta função checa se um jogador está em uma dynamic gangzone
  590.  
  591.     Params:
  592.         - playerid ----> ID do jogador para verificar se está na zona
  593.         - int_zone_id -> ID da gangzone para verificar se o jogador está na zona
  594.  
  595.     Return:
  596.         - Esta função retorna 0 se o jogador não estiver na zona.
  597.         - Esta função retorna 1 se o jogador estiver na zona.
  598. \*----------------------------------------------------------------------------*/
  599. stock IsPlayerInDynamicZone(playerid, int_zone_id)
  600. {
  601.     new
  602.         Float:x,
  603.         Float:y,
  604.         Float:z;
  605.  
  606.     GetPlayerPos(playerid, x, y, z);
  607.     if (x > gZoneData[ int_zone_id ][ g_GANG_ZONE_MINX ] &&
  608.         x < gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXX ] &&
  609.         y > gZoneData[ int_zone_id ][ g_GANG_ZONE_MINY ] &&
  610.         y < gZoneData[ int_zone_id ][ g_GANG_ZONE_MAXY ]) return 1;
  611.     return 0;
  612. }
  613.  
  614. /*----------------------------------------------------------------------------*\
  615.     Descrição:
  616.         - Esta função checa se uma dynamic gangzone existe
  617.  
  618.     Params:
  619.         - int_zone_id -> ID da gangzone para verificar se existe
  620.  
  621.     Return:
  622.         - Esta função retorna 0 se a gangzone não existir.
  623.         - Esta função retorna 1 se a gangzone existir.
  624. \*----------------------------------------------------------------------------*/
  625. stock zexist(int_zone_id)
  626. {
  627.     return (!gZoneData[ int_zone_id ][ g_GANG_ZONE_ID ]) ? 0 : 1;
  628. }
  629.  
  630. /*----------------------------------------------------------------------------*\
  631.     Descrição:
  632.         - Esta função procura por gangzones existentes.
  633.  
  634.     Params:
  635.         -
  636.  
  637.     Return:
  638.         - Esta função retorna o primeiro id de dgangzone livre no enum
  639.         - Esta função retorna invalid_gang_zone caso não houver ^
  640. \*----------------------------------------------------------------------------*/
  641. stock SearchZones()
  642. {
  643.     for (new z = 0; z < MAX_GANG_ZONES; z++)
  644.         if (gZoneData[ z ][ g_GANG_ZONE_ID ] == INVALID_GANG_ZONE)
  645.             return z;
  646.     return INVALID_GANG_ZONE;
  647. }
  648.  
  649. /*----------------------------------------------------------------------------*\
  650.     Descrição;
  651.         Esta callback é chamada uma vez a cada segundo
  652.  
  653.     Params:
  654.         -
  655.  
  656.     Return:
  657.         -
  658. \*----------------------------------------------------------------------------*/
  659. public dzones_Check()
  660. {
  661.     new str_zone_id[14];
  662.     for (new i = 0; i < MAX_PLAYERS; i++) {
  663.         if(!IsPlayerConnected(i))
  664.             continue;
  665.  
  666.         for (new z = 0; z < MAX_GANG_ZONES; z++) {
  667.             format(str_zone_id, sizeof str_zone_id, "etzone_%i", z);
  668.             if (IsPlayerInDynamicZone(i, z) &&
  669.             GetPVarInt(i, str_zone_id) == 0) {
  670.                 CallLocalFunction("OnPlayerEnterDynamicZone", "ii",
  671.                     i,
  672.                     z);
  673.                 SetPVarInt(i, str_zone_id, 1);
  674.             }
  675.             else if (!IsPlayerInDynamicZone(i, z) &&
  676.             GetPVarInt(i, str_zone_id) == 1) {
  677.                 CallLocalFunction("OnPlayerExitDynamicZone", "ii",
  678.                     i,
  679.                     z);
  680.                 DeletePVar(i, str_zone_id);
  681.             }
  682.         }
  683.     }
  684.     return 1;
  685. }
  686.  
  687. /*----------------------------------------------------------------------------*\
  688.             Hooking OnGameMode/FilterScriptInit, Obrigado Y_Less.
  689. \*----------------------------------------------------------------------------*/
  690. #if defined FILTERSCRIPT
  691.     public OnFilterScriptInit()
  692.     {
  693.         for (new z = 0; z < MAX_GANG_ZONES; z++) {
  694.             gZoneData[ z ][ g_GANG_ZONE_ID ] = INVALID_GANG_ZONE;
  695.         }
  696.         SetTimer("dzones_Check", 1000, true);
  697.         return CallLocalFunction("dzones_OnFilterScriptInit", "");
  698.     }
  699.     #if defined _ALS_OnFilterScriptInit
  700.         #undef OnFilterScriptInit
  701.     #else
  702.         #define _ALS_OnFilterScriptInit
  703.     #endif
  704.     #define OnFilterScriptInit dzones_OnFilterScriptInit
  705.     forward dzones_OnFilterScriptInit();
  706.     forward OnPlayerEnterDynamicZone(playerid, zoneid);
  707.     forward OnPlayerExitDynamicZone(playerid, zoneid);
  708. #else
  709.     public OnGameModeInit()
  710.     {
  711.         for (new z = 0; z < MAX_GANG_ZONES; z++) {
  712.             gZoneData[ z ][ g_GANG_ZONE_ID ] = INVALID_GANG_ZONE;
  713.         }
  714.         SetTimer("dzones_Check", 1000, true);
  715.         return CallLocalFunction("dzones_OnGameModeInit", "");
  716.     }
  717.     #if defined _ALS_OnGameModeInit
  718.         #undef OnGameModeInit
  719.     #else
  720.         #define _ALS_OnGameModeInit
  721.     #endif
  722.     #define OnGameModeInit dzones_OnGameModeInit
  723.     forward dzones_OnGameModeInit();
  724.     forward OnPlayerEnterDynamicZone(playerid, zoneid);
  725.     forward OnPlayerExitDynamicZone(playerid, zoneid);
  726. #endif
  727.  
  728. #undef swap
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!