Raised This Month: $248 Target: $400
 62% 

to rotate the sprite of fire


Post New Thread Reply   
 
Thread Tools Display Modes
Author Message
anakonda001
Member
Join Date: Jul 2020
Old 09-13-2020 , 16:05   to rotate the sprite of fire
Reply With Quote #1

hi, where to turn the fire sprite? horizontally

Code:
#pragma semicolon 1
#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <cstrike>
#include <csx>
#include <fun>
#include <fakemeta_util>
 
// Uncomment the following line to enable debug logging.
//#define MOLOTOV_DEBUG
 
#define AUTHORS "DynamicBits"
 
#define ADMIN_ACCESS ADMIN_IMMUNITY
 
#define ANTI_LAGG 7.0   // Defines max calculations before a flame is spawned without check if onground
// This is to prevent lagg at really narrow ents where you could end up with 400 calculations per flame
// Suggested: <= 10
 
#define MOLOTOV_HARD_LIMIT 10   // Maximum molotov cocktails this code is capable of handling without bugs
            // Also how many cocktails people get with molotov_give command
 
#define MOLOTOV_MENU_KEYS MENU_KEY_0|MENU_KEY_1|MENU_KEY_2   // Choices to look for with optional menu
 
#define MOLOTOV_TASKID_BASE 1000            // What is the lowest task ID?
#define MOLOTOV_TASKID_OFFSET MOLOTOV_HARD_LIMIT
#define MOLOTOV_TASKID_BASE1 MOLOTOV_TASKID_BASE             // By default, with 32 players, task ids
#define MOLOTOV_TASKID_BASE2 MOLOTOV_TASKID_BASE1 + (MOLOTOV_TASKID_OFFSET * 32) // from 1000 to 1959 can
#define MOLOTOV_TASKID_BASE3 MOLOTOV_TASKID_BASE2 + (MOLOTOV_TASKID_OFFSET * 32) // potentially be used used.
 
#define TEAM_UNASSIGNED 0
#define TEAM_ONE   1
#define TEAM_TWO   2
#define TEAM_SPECTATOR   3
 
new pEnabled, pPrice, pMlDamage, pMlRadius, pFireTime, pOverride;
new pFriendlyFire, pFireDmg, pMaxMolotovs, pBuyMenu, pBuyZone, pMolotovMenu;
 
new gmsgScoreInfo, gmsgDeathMsg;
 
new g_pAllocModel, g_vAllocModel;
 
new g_frags[33];
new g_hasMolotov[33];
new g_restarted;
new g_MaxPlayers;
new g_bomb_map;
 
new firespr, smokespr[2];
 
new last_Molotov_ent;
new g_Molotov_offset[33];
 
new g_g;
 
public plugin_init() {
 
   register_plugin("Molotov Cocktail", "3.20", AUTHORS);
 
   register_menucmd(register_menuid("Buy Molotov Coctail"), MOLOTOV_MENU_KEYS, "giveMolotov");
#if defined MOLOTOV_DEBUG
   register_clcmd("molotov_menutest", "show_molotov_menu");
#endif
 
   register_clcmd("say /molotov", "buy_molotov");
   register_clcmd("say molotov", "buy_molotov");
 
   register_concmd("molotov_give", "cmd_MolotovGive", ADMIN_ACCESS, "<player|@all|@t|@ct|@al|@ax> - Gives free molotov cocktails (default=10)");
   register_concmd("molotov_override", "cmd_Override", ADMIN_ACCESS, "[0|1] - Enable/disable the HE grenade override (If no arguments, show the status)");
   register_concmd("molotov_cocktail", "cmd_PluginStatus", ADMIN_ACCESS, "[0|1] - Enable/disable the plugin (If no arguments, show the status)");
 
   pEnabled = register_cvar("molotov_enabled", "1", FCVAR_SPONLY);
   pOverride = register_cvar("molotov_override_he", "0", FCVAR_SPONLY);
   pPrice = register_cvar("molotov_price", "800", FCVAR_SPONLY);
   pMlDamage = register_cvar("molotov_damage", "60.0", FCVAR_SPONLY);
   pMlRadius = register_cvar("molotov_radius", "200.0", FCVAR_SPONLY);
   pFireTime = register_cvar("molotov_firetime", "12", FCVAR_SPONLY);
   pFireDmg = register_cvar("molotov_firedamage", "3", FCVAR_SPONLY);
   pFriendlyFire = register_cvar("molotov_ff", "1", FCVAR_SPONLY);
   pMaxMolotovs = register_cvar("molotov_max", "2", FCVAR_SPONLY);
   pBuyMenu = register_cvar("molotov_inmenu", "0", FCVAR_SPONLY);
   pBuyZone = register_cvar("molotov_buyzone", "1", FCVAR_SPONLY);
   pMolotovMenu = register_cvar("molotov_menu", "0", FCVAR_SPONLY);
 
   register_event("CurWeapon", "Event_CurWeapon", "be", "1=1");
   register_event("HLTV", "event_new_round", "a", "1=0", "2=0");
   register_event("TextMsg", "Event_GameRestart", "a", "2=#Game_Commencing", "2=#Game_will_restart_in");
   register_event("DeathMsg", "event_DeathMsg", "a");
 
   register_event("ShowMenu", "event_BuyMenuT", "b", "4=#T_BuyItem", "1=575");
   register_event("ShowMenu", "event_BuyMenuCT", "b", "4=#CT_BuyItem", "1=703");
   register_event("ShowMenu", "event_BuyMenuT", "b", "4=#DT_BuyItem", "1=575");
   register_event("ShowMenu", "event_BuyMenuCT", "b", "4=#DCT_BuyItem", "1=767");
 
   register_logevent("logevent_Round_End", 2, "1=Round_End");
 
   register_menucmd(register_menuid("#CT_BuyItem"), 1023, "handle_BuyMenuCT");
   register_menucmd(register_menuid("#T_BuyItem"), 1023, "handle_BuyMenuT");
 
   register_forward(FM_EmitSound, "fw_EmitSound");
 
   g_MaxPlayers = get_maxplayers();
 
   gmsgScoreInfo = get_user_msgid("ScoreInfo");
   gmsgDeathMsg = get_user_msgid("DeathMsg");
 
   g_pAllocModel = engfunc(EngFunc_AllocString, "models/molotov/p_molotov.mdl");
   g_vAllocModel = engfunc(EngFunc_AllocString, "models/molotov/v_molotov.mdl");
 
   g_bomb_map = engfunc(EngFunc_FindEntityByString, g_MaxPlayers, "classname", "info_bomb_target") ? 1 : 0;
}
 
public plugin_precache() {
 
   firespr = precache_model("sprites/flame.spr");
 
   smokespr[0] = precache_model("sprites/black_smoke3.spr");
   smokespr[1] = precache_model("sprites/steam1.spr");
 
   precache_sound("molotov/molotov_fire.wav");
 
   precache_model("models/molotov/p_molotov.mdl");
   precache_model("models/molotov/v_molotov.mdl");
   precache_model("models/molotov/w_molotov.mdl");
   precache_model("models/molotov/w_broke_molotov.mdl");
 
}
 
public client_disconnected(id) {
   g_hasMolotov[id] = 0;
}
 
public fw_EmitSound(ent, channel, sample[]) {
 
   if (equal(sample[8], "he_bounce", 9)) {
 
      new model[32];
      pev(ent, pev_model, model, 31);
 
      if (equal(model[9], "lotov/w_molotov.mdl")) {
         if (last_Molotov_ent != ent) {
            new Float:fFriction, Float:fVelocity[3];
 
            pev(ent, pev_friction, fFriction);
            pev(ent, pev_velocity, fVelocity);
 
            fFriction *= 1.3;   // Increase friction to make it look more realistic
            set_pev(ent, pev_friction, fFriction);
#if defined MOLOTOV_DEBUG
            log_amx("[MC] ent:%d Friction:%f Velocity:%f/%f/%f ====================", ent, fFriction, fVelocity[0], fVelocity[1], fVelocity[2]);
#endif
            last_Molotov_ent = ent;
            grenade_explode(ent);
 
            return FMRES_SUPERCEDE;
#if defined MOLOTOV_DEBUG
         } else {
            log_amx("[MC] last_Molotov_ent(%d) ent(%d)", last_Molotov_ent, ent);
#endif
         }
      }
   }
   return FMRES_IGNORED;
}
 
public Event_CurWeapon(id) {
 
   if (!get_pcvar_num(pEnabled) || !is_user_alive(id)) {
      return PLUGIN_CONTINUE;
   }
 
   if (!g_hasMolotov[id] && !get_pcvar_num(pOverride)) {
      return PLUGIN_CONTINUE;
   }
 
   new WeaponID = get_user_weapon(id, WeaponID, WeaponID);
 
   if (WeaponID != CSW_HEGRENADE) {
      return PLUGIN_CONTINUE;
   }
 
   set_pev(id, pev_viewmodel, g_vAllocModel);
   set_pev(id, pev_weaponmodel, g_pAllocModel);
   set_pev(id, pev_weaponanim, 9);
 
   return PLUGIN_CONTINUE;
}
 
public Event_GameRestart() {
   g_restarted = 1;
}
 
public event_DeathMsg() {
   g_hasMolotov[read_data(2)] = 0;
}
 
public logevent_Round_End() {
#if defined MOLOTOV_DEBUG
   log_amx("[MC] ========== Round_End ==========");
#endif
   reset_tasks();
}
 
stock reset_tasks() {
#if defined MOLOTOV_DEBUG
   new tmpdbgid;
#endif
   for (new i; i < g_MaxPlayers; i++) {
      for (new o; o < MOLOTOV_TASKID_OFFSET; o++) {   //TODO DEBUG: Verify this fixes the tasks not reset at new round issue
         if (task_exists(MOLOTOV_TASKID_BASE1 + (MOLOTOV_TASKID_OFFSET * i) + o)) {
            remove_task(MOLOTOV_TASKID_BASE1 + (MOLOTOV_TASKID_OFFSET * i) + o);
#if defined MOLOTOV_DEBUG
            tmpdbgid = MOLOTOV_TASKID_BASE1 + (MOLOTOV_TASKID_OFFSET * i) + o;
            log_amx("[MC] %d exists. ----------==========----------", tmpdbgid);
#endif
         }
 
         if (task_exists(MOLOTOV_TASKID_BASE2 + (MOLOTOV_TASKID_OFFSET * i) + o)) {
            remove_task(MOLOTOV_TASKID_BASE2 + (MOLOTOV_TASKID_OFFSET * i) + o);
#if defined MOLOTOV_DEBUG
            tmpdbgid = MOLOTOV_TASKID_BASE2 + (MOLOTOV_TASKID_OFFSET * i) + o;
            log_amx("[MC] %d exists. ----------==========----------", tmpdbgid);
#endif
         }
 
         if (task_exists(MOLOTOV_TASKID_BASE3 + (MOLOTOV_TASKID_OFFSET * i) + o)) {
            remove_task(MOLOTOV_TASKID_BASE3 + (MOLOTOV_TASKID_OFFSET * i) + o);
#if defined MOLOTOV_DEBUG
            tmpdbgid = MOLOTOV_TASKID_BASE3 + (MOLOTOV_TASKID_OFFSET * i) + o;
            log_amx("[MC] %d exists. ----------==========----------", tmpdbgid);
#endif
         }
      }
   }
}
 
public event_new_round(id) {
#if defined MOLOTOV_DEBUG
   log_amx("[MC] ========== event_new_round ==========");
#endif
   if (!get_pcvar_num(pEnabled)) {
      return PLUGIN_CONTINUE;
   }
 
   reset_tasks();   // DEBUG
 
   if (get_pcvar_num(pMolotovMenu)) {
      show_molotov_menu(id);
   }
 
   for (new i; i < g_MaxPlayers; i++) {
      if (g_frags[i] && is_user_connected(i)) {
         set_user_frags(i, get_user_frags(i) + g_frags[i]);
      }
      g_frags[i] = 0;
   }
 
   if (g_restarted) {
      for (new i; i < g_MaxPlayers; i++) {
         g_hasMolotov[i] = 0;
      }
      g_restarted = 0;
   }
 
   if (get_pcvar_num(pOverride)) {
      set_molotovs();
   } else {
      reset_molotovs();
   }
 
   return PLUGIN_CONTINUE;
}
 
public cmd_Override(id, level, cid) {   
 
   if (!cmd_access(id, level, cid, 1)) {      // First argument (passed to molotov_override) is optional
      return PLUGIN_HANDLED;
   }
 
   if (!get_pcvar_num(pEnabled)) {
      return PLUGIN_HANDLED;
   }
 
   if (read_argc() == 1) {            // No arguments; Display status
      client_print(id, print_console, "Override is currently %s.", get_pcvar_num(pOverride) ? "enabled" : "disabled");
      return PLUGIN_HANDLED;
   }
 
   new arg[2];
   read_argv(1, arg, 1);
 
   new num = str_to_num(arg);
 
   if ((num < 0) || (num > 1) || (!isdigit(arg[0]))) {   // If less than 0 or greater than 1 or not a digit
      if (id) {
         client_print(id, print_console, "Invalid argument(%s). Valid arguments are ^"0^" and ^"1^".", arg);
      } else {
         server_print("Invalid argument(%s). Valid arguments are ^"0^" and ^"1^".", arg);
      }
      return PLUGIN_HANDLED;
   }
 
   if (num == get_pcvar_num(pOverride)) {
      if (id) {
         client_print(id, print_console, "Override is already %s.", num ? "enabled" : "disabled");
      } else {
         server_print("Override is already %s.", num ? "enabled" : "disabled");
      }
      return PLUGIN_HANDLED;
   }
 
   set_pcvar_num(pOverride, num);
 
   if (id) {
      client_print(id, print_console, "Override was %s.", num ? "enabled" : "disabled");
   } else {
      server_print("Override was %s.", num ? "enabled" : "disabled");
   }
 
   if (num) {
      set_molotovs();
   } else {
      reset_molotovs();
   }
 
   return PLUGIN_HANDLED;
}
 
public cmd_PluginStatus(id, level, cid) {
   if (!cmd_access(id, level, cid, 1)) {      // First argument (passed to molotov_cocktail) is optional
      return PLUGIN_HANDLED;
   }
 
   if (read_argc() == 1) {            // No arguments; Display status
      client_print(id, print_console, "Plugin is currently %s.", get_pcvar_num(pEnabled) ? "enabled" : "disabled");
      return PLUGIN_HANDLED;
   }
 
   new arg[2];
   read_argv(1, arg, 1);
 
   new num = str_to_num(arg);
 
   if ((num < 0) || (num > 1) || (!isdigit(arg[0]))) {   // If less than 0 or greater than 1 or not a digit
      if (id) {
         client_print(id, print_console, "Invalid argument(%s). Valid arguments are ^"0^" and ^"1^".", arg);
      } else {
         server_print("Invalid argument(%s). Valid arguments are ^"0^" and ^"1^".", arg);
      }
      return PLUGIN_HANDLED;
   }
 
   if (num == get_pcvar_num(pEnabled)) {
      if (id) {
         client_print(id, print_console, "Plugin is already %s.", num ? "enabled" : "disabled");
      } else {
         server_print("Plugin is already %s.", num ? "enabled" : "disabled");
      }
      return PLUGIN_HANDLED;
   }
 
   set_pcvar_num(pEnabled, num);
 
   if (id) {
      client_print(id, print_console, "Plugin was %s.", num ? "enabled" : "disabled");
   } else {
      server_print("Plugin was %s.", num ? "enabled" : "disabled");
   }
 
   if (num && get_pcvar_num(pOverride)) {
      set_molotovs();
   } else {
      reset_molotovs();
   }
   return PLUGIN_HANDLED;
}
 
public cmd_MolotovGive(id, level, cid) {
 
#if defined MOLOTOV_DEBUG
   log_amx("[MC] cmd_MolotovGive");
#endif
   if (!cmd_access(id, level, cid, 2)) {
      return PLUGIN_HANDLED;
   }
 
   new Arg1[64], target;
   read_argv(1, Arg1, 63);
 
   new adminName[32];
   get_user_name(id, adminName, 31);
 
   new targetTeam, targetTeamName[32];
   new Players[32], iNum;
#if defined MOLOTOV_DEBUG
   log_amx("[MC] cmd_MolotovGive Arg1[0](%s) Arg1[1](%s)", Arg1[0], Arg1[1]);
#endif
   if (Arg1[0] == '@') {
 
      if (equali(Arg1[1], "all")) {
         targetTeam = 0;
      } else if (equali(Arg1[1], "t") || equali(Arg1[1], "al")) {   // CS_TEAM_T or ALLIES
         targetTeam = TEAM_ONE;
      } else if (equali(Arg1[1], "ct") || equali(Arg1[1], "ax")) {   // CS_TEAM_CT or AXIS
         targetTeam = TEAM_TWO;
      }
 
      get_players(Players, iNum, "ac");   // Bots don't understand molotov cocktails
 
      for (new i = 0; i < iNum; ++i) {
         target = Players[i];
 
         if ((targetTeam == 0) || (get_user_team(target) == targetTeam)) {
            g_hasMolotov[target] = MOLOTOV_HARD_LIMIT;
 
            give_item(target, "weapon_hegrenade");
            cs_set_user_bpammo(target, CSW_HEGRENADE, MOLOTOV_HARD_LIMIT);
            emit_sound(target, CHAN_WEAPON, "items/gunpickup2.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
         }
      }
 
      switch(targetTeam) {
         case 0: {
            targetTeamName = "everyone";
         }
         case 1: {
            if (cstrike_running()) {
               targetTeamName = "all terrorists";
            } else if (is_running("dod")) {
               targetTeamName = "all allies";
            } else {
               targetTeamName = "team 1";
            }
         }
         case 2: {
            if (cstrike_running()) {
               targetTeamName = "all ct's";
            } else if (is_running("dod")) {
               targetTeamName = "all axis";
            } else {
               targetTeamName = "team 2";
            }
         }
      }
      client_print(0, print_chat, "ADMIN %s: has given %s %d Molotov Cocktails!", adminName, targetTeamName, MOLOTOV_HARD_LIMIT);
 
   } else {
 
      target = cmd_target(id, Arg1, 0);
 
      if (!is_user_connected(target) || !is_user_alive(target)) {
         return PLUGIN_HANDLED;
      }
 
      new targetName[32];
      get_user_name(target, targetName, 31);
 
      g_hasMolotov[target] = MOLOTOV_HARD_LIMIT;
 
      give_item(target, "weapon_hegrenade");
      cs_set_user_bpammo(target, CSW_HEGRENADE, MOLOTOV_HARD_LIMIT);
 
      emit_sound(target, CHAN_WEAPON, "items/gunpickup2.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
 
      client_print(target, print_chat, "ADMIN %s: has given you %d Molotov Cocktails!", adminName, MOLOTOV_HARD_LIMIT);
 
   }
   return PLUGIN_HANDLED;
}
 
public buy_molotov(id) {
 
   if (!get_pcvar_num(pEnabled)) {
      return PLUGIN_HANDLED;
   }
 
   if (get_pcvar_num(pOverride)) {
      if (get_pcvar_num(pBuyMenu)) {
         client_print(id, print_center, "Buy them in the buy equipment menu.");
      } else {
         client_print(id, print_center, "Just buy a HE grenade and get molotov automatically!");
      }
      return PLUGIN_HANDLED;
   }
 
   if (!is_user_alive(id)) {
      client_print(id, print_center, "Вы не можете приобрести Molotov Cocktails пока убиты.");
      return PLUGIN_HANDLED;
   }
 
   if (!cs_get_user_buyzone(id) && get_pcvar_num(pBuyZone)) {
      client_print(id, print_center, "Вы находитесь не в зоне покупки.");
      return PLUGIN_HANDLED;
   }
 
   new money = cs_get_user_money(id);
 
   if (money < get_pcvar_num(pPrice)) {
      client_print(id, print_center, "У Вас не достаточно денег для приобретения Molotov Cocktail!");
      return PLUGIN_HANDLED;
   }
 
   if (g_hasMolotov[id] == get_pcvar_num(pMaxMolotovs)) {
      if (g_hasMolotov[id] == 1) {
         client_print(id, print_center, "Вы уже приобрели Molotov Cocktail.");
      } else {
         client_print(id, print_center, "Вы уже приобрели %d Molotov Cocktails.", g_hasMolotov[id]);
      }
      return PLUGIN_HANDLED;
   }
 
   if (!g_hasMolotov[id] && user_has_weapon(id, CSW_HEGRENADE)) {
      client_print(id, print_center, "You already have a HE Grenade.");
      return PLUGIN_HANDLED;
   }
 
   cs_set_user_money(id, money - get_pcvar_num(pPrice));
   give_item(id, "weapon_hegrenade");
   cs_set_user_bpammo(id, CSW_HEGRENADE, ++g_hasMolotov[id]);
   client_print(id, print_chat, "Вы приобрели Molotov Cocktail!");
 
   return PLUGIN_HANDLED;
}
 
public event_BuyMenuCT(id) {
 
   if (!get_pcvar_num(pEnabled) || !get_pcvar_num(pBuyMenu)) {
      return PLUGIN_CONTINUE;
   }
 
   new Override = get_pcvar_num(pOverride);
 
   new menu[1024];
   new len = formatex(menu, 1023, "\yBuy Equipment\R$ Cost");
 
   len += formatex(menu[len], 1023-len, "^n^n\w1. Kevlar Vest\R\y650");
   len += formatex(menu[len], 1023-len, "^n\w2. Kevlar Vest & Helmet\R\y1000");
   len += formatex(menu[len], 1023-len, "^n\w3. Flashbang\R\y200");
 
   if (Override) {
      len += formatex(menu[len], 1023-len, "^n\w4. Molotov Cocktail\R\y%d", get_pcvar_num(pPrice));
   } else {
      len += formatex(menu[len], 1023-len, "^n\w4. HE Grenade\R\y300");
   }
 
   len += formatex(menu[len], 1023-len, "^n\w5. Smoke Grenade\R\y300");
   len += formatex(menu[len], 1023-len, "^n\w6. NightVision Goggles\R\y1250");
   len += formatex(menu[len], 1023-len, "^n\%c7. Defuse Kit\R\y200 ", g_bomb_map ? 'w' : 'd');
   len += formatex(menu[len], 1023-len, "^n\w8. Tactical Shield\R\y2200");
 
   if (!Override) {
      len += formatex(menu[len], 1023-len, "^n\w9. Molotov Cocktail\R\y%d", get_pcvar_num(pPrice));
   }
 
   len += formatex(menu[len], 1023-len, "^n^n\w0. Exit");
 
   show_menu(id, read_data(1)|MENU_KEY_9, menu, -1, "#CT_BuyItem");
 
   return PLUGIN_HANDLED;
}
 
public event_BuyMenuT(id) {
 
   if (!get_pcvar_num(pEnabled) || !get_pcvar_num(pBuyMenu)) {
      return PLUGIN_CONTINUE;
   }
 
   new Override = get_pcvar_num(pOverride);
 
   new menu[1024];
   new len = formatex(menu, 1023, "\yBuy Equipment\R$ Cost");
   len += formatex(menu[len], 1023-len, "^n^n\w1. Kevlar Vest\R\y650");
   len += formatex(menu[len], 1023-len, "^n\w2. Kevlar Vest & Helmet\R\y1000");
   len += formatex(menu[len], 1023-len, "^n\w3. Flashbang\R\y200");
 
   if (Override) {
      len += formatex(menu[len], 1023-len, "^n\w4. Molotov Cocktail\R\y%d", get_pcvar_num(pPrice));
   } else {
      len += formatex(menu[len], 1023-len, "^n\w4. HE Grenade\R\y300");
   }
 
   len += formatex(menu[len], 1023-len, "^n\w5. Smoke Grenade\R\y300");
   len += formatex(menu[len], 1023-len, "^n\w6. NightVision Goggles\R\y1250");
 
   if (!Override) {
      len += formatex(menu[len], 1023-len, "^n\w7. Molotov Cocktail\R\y%d", get_pcvar_num(pPrice));
   }
 
   len += formatex(menu[len], 1023-len, "^n^n\w0. Exit");
 
   show_menu(id, read_data(1)|MENU_KEY_7, menu, -1, "#T_BuyItem");
 
   return PLUGIN_HANDLED;
}
 
public handle_BuyMenuCT(id, key) {
 
   if (key == (get_pcvar_num(pOverride) ? 3 : 8)) {
      handle_BuyMenu(id);
      return PLUGIN_HANDLED;
   }
 
   return PLUGIN_CONTINUE;
}
 
public handle_BuyMenuT(id, key) {
 
   if (key == (get_pcvar_num(pOverride) ? 3 : 6)) {
      handle_BuyMenu(id);
      return PLUGIN_HANDLED;
   }
 
   return PLUGIN_CONTINUE;
}
 
stock handle_BuyMenu(id) {
 
   new money = cs_get_user_money(id);
 
   if (money < get_pcvar_num(pPrice)) {
      client_print(id, print_center, "You don't have enough $ to buy a Molotov Cocktail.");
      return PLUGIN_HANDLED;
   }
 
   if (g_hasMolotov[id] == get_pcvar_num(pMaxMolotovs)) {
      if (g_hasMolotov[id] == 1) {
         client_print(id, print_center, "You already have a Molotov Cocktail.");
      } else {
         client_print(id, print_center, "You already have %d Molotov Cocktails.", g_hasMolotov[id]);
      }
      return PLUGIN_HANDLED;
   } else if (!g_hasMolotov[id] && user_has_weapon(id, CSW_HEGRENADE)) {
      client_print(id, print_center, "You already have a HE Grenade.");
      return PLUGIN_HANDLED;
   }
 
   cs_set_user_money(id, money - get_pcvar_num(pPrice));
   give_item(id, "weapon_hegrenade");
   cs_set_user_bpammo(id, CSW_HEGRENADE, ++g_hasMolotov[id]);
   client_print(id, print_chat, "You got a Molotov Cocktail!");
 
   return PLUGIN_HANDLED;
}
 
public grenade_throw(id, ent, wid) {
 
   if (!get_pcvar_num(pEnabled) || !is_user_connected(id) || wid != CSW_HEGRENADE) {
      return PLUGIN_CONTINUE;
   }
 
   if (!g_hasMolotov[id] && !get_pcvar_num(pOverride)) {
      return PLUGIN_CONTINUE;
   }
 
   g_hasMolotov[id]--;
   engfunc(EngFunc_SetModel, ent, "models/molotov/w_molotov.mdl");
   set_pev(ent, pev_nextthink, 99999.0);
 
   return PLUGIN_CONTINUE;
}
 
public grenade_explode(ent) {
 
   new param[6], iOrigin[3];
   new Float:fOrigin[3];
   new owner = pev(ent, pev_owner);
   new ent2 = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
 
   pev(ent, pev_origin, fOrigin);
 
#if defined MOLOTOV_DEBUG
   new iOwnerAlive = is_user_alive(owner);
   new iOwnerConnected = is_user_connected(owner);
   new iEnt2Valid = pev_valid(ent2);
   log_amx("[MC] grenade_explode ent(%d) owner(%d) ent2(%d) iOwnerAlive(%d) iOwnerConnected(%d) iEnt2Valid(%d)", ent, owner, ent2, iOwnerAlive, iOwnerConnected, iEnt2Valid);
#endif
 
   param[0] = ent;
   param[1] = ent2;
   param[2] = owner;
   param[3] = iOrigin[0] = floatround(fOrigin[0]);
   param[4] = iOrigin[1] = floatround(fOrigin[1]);
   param[5] = iOrigin[2] = floatround(fOrigin[2]);
 
   emit_sound(ent, CHAN_AUTO, "molotov/molotov_fire.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
 
   engfunc(EngFunc_SetModel, ent, "models/molotov/w_broke_molotov.mdl");
 
   random_fire(iOrigin, ent2);
   radius_damage(owner, fOrigin, get_pcvar_float(pMlDamage), get_pcvar_float(pMlRadius), DMG_BLAST);
 
   new Float:FireTime = get_pcvar_float(pFireTime);
 
   if (++g_Molotov_offset[owner] == MOLOTOV_HARD_LIMIT) {
      g_Molotov_offset[owner] = 0;
   }
 
   set_task(0.2, "fire_damage", MOLOTOV_TASKID_BASE1 + (MOLOTOV_TASKID_OFFSET * (owner - 1)) + g_Molotov_offset[owner], param, 6, "a", floatround(FireTime / 0.2, floatround_floor));
   set_task(1.0, "fire_sound", MOLOTOV_TASKID_BASE2 + (MOLOTOV_TASKID_OFFSET * (owner - 1)) + g_Molotov_offset[owner], param, 6, "a", floatround(FireTime) - 1);
   set_task(FireTime, "fire_stop", MOLOTOV_TASKID_BASE3 + (MOLOTOV_TASKID_OFFSET * (owner - 1)) + g_Molotov_offset[owner], param, 6);
 
   return PLUGIN_CONTINUE;
}
 
public fire_sound(param[]) {
   emit_sound(param[1], CHAN_AUTO, "molotov/molotov_fire.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
 
public fire_stop(param[]) {
   g_g = 0;
 
   if (pev_valid(param[0])) { engfunc(EngFunc_RemoveEntity, param[0]); }
   if (pev_valid(param[1])) { engfunc(EngFunc_RemoveEntity, param[1]); }
 
   if ((last_Molotov_ent = (param[0]))) {
      last_Molotov_ent = 0;
   }
}
 
public fire_damage(param[]) {
 
   new iOrigin[3], Float:fOrigin[3];
   iOrigin[0] = param[3];
   iOrigin[1] = param[4];
   iOrigin[2] = param[5];
 
   random_fire(iOrigin, param[1]);
 
   IVecFVec(iOrigin, fOrigin);
   radius_damage(param[2], fOrigin, get_pcvar_float(pFireDmg), get_pcvar_float(pMlRadius), DMG_BURN, 0);
}
 
stock radius_damage(attacker, Float:origin[3], Float:damage, Float:range, dmgtype, calc = 1) {
 
   new Float:pOrigin[3], Float:dist, Float:tmpdmg;
   new i, ateam = get_user_team(attacker), iFF = get_pcvar_num(pFriendlyFire);
 
   while (i++ < g_MaxPlayers) {
      if (!is_user_alive(i)) {
         continue;
      }
 
      if (!iFF && ateam == get_user_team(i)) {
         continue;
      }
 
      pev(i, pev_origin, pOrigin);
      dist = get_distance_f(origin, pOrigin);
 
      if (dist > range) {
         continue;
      }
 
      if (calc) {
         tmpdmg = damage - (damage / range) * dist;
      } else {
         tmpdmg = damage;
      }
 
      if (pev(i, pev_health) < tmpdmg) {
         kill(attacker, i);
      } else {
         fm_fakedamage(i, "molotov", tmpdmg, dmgtype);
      }
   }
 
   while ((i = engfunc(EngFunc_FindEntityInSphere, i, origin, range))) {   // warning 211: possibly unintended assignment
      if (pev(i, pev_takedamage)) {
         if (calc) {
            pev(i, pev_origin, pOrigin);
            tmpdmg = damage - (damage / range) * get_distance_f(origin, pOrigin);
         } else {
            tmpdmg = damage;
         }
         fm_fakedamage(i, "molotov", tmpdmg, dmgtype);
      }
   }
}
 
stock random_fire(Origin[3], ent) {
 
   new range = get_pcvar_num(pMlRadius);
   new iOrigin[3];
 
   for (new i = 1; i <= 5; i++) {
 
      g_g = 1;
 
      iOrigin[0] = Origin[0] + random_num(-range, range);
      iOrigin[1] = Origin[1] + random_num(-range, range);
      iOrigin[2] = Origin[2];
      iOrigin[2] = ground_z(iOrigin, ent);
 
      while (get_distance(iOrigin, Origin) > range) {
         g_g++;
#if defined MOLOTOV_DEBUG
         //log_amx("[MC] random_fire ent(%d) i(%d) g_g(%d)", ent, i, g_g);
#endif
         iOrigin[0] = Origin[0] + random_num(-range, range);
         iOrigin[1] = Origin[1] + random_num(-range, range);
         iOrigin[2] = Origin[2];
 
         if (g_g >= ANTI_LAGG) {
            iOrigin[2] = ground_z(iOrigin, ent, 1);
         } else {
            iOrigin[2] = ground_z(iOrigin, ent);
         }
      }
 
      new rand = random_num(5, 15);
 
      message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
      write_byte(TE_SPRITE);
      write_coord(iOrigin[0]);
      write_coord(iOrigin[1]);
      write_coord(iOrigin[2] + rand * 5);
      write_short(firespr);
      write_byte(rand);
      write_byte(100);
      message_end();
 
      if (!(i % 4)) {   // Smoke every 4th flame
         message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
         write_byte(TE_SMOKE);
         write_coord(iOrigin[0]);
         write_coord(iOrigin[1]);
         write_coord(iOrigin[2] + 120);
         write_short(smokespr[random_num(0, 1)]);
         write_byte(random_num(10, 30));
         write_byte(random_num(10, 20));
         message_end();
      }
   }
}
 
stock kill(k, v) {
 
   user_silentkill(v);
 
   new kteam = get_user_team(k);
   new vteam = get_user_team(v);
 
   new kfrags = get_user_frags(k) + 1;
   new kdeaths = get_user_deaths(k);
   if (kteam == vteam) {
      kfrags = get_user_frags(k) - 2;
   }
 
   new vfrags = get_user_frags(v);
   new vdeaths = get_user_deaths(v);
 
   message_begin(MSG_ALL, gmsgScoreInfo);
   write_byte(k);
   write_short(kfrags);
   write_short(kdeaths);
   write_short(0);
   write_short(kteam);
   message_end();
 
   message_begin(MSG_ALL, gmsgScoreInfo);
   write_byte(v);
   write_short(vfrags + 1);
   write_short(vdeaths);
   write_short(0);
   write_short(vteam);
   message_end();
 
   message_begin(MSG_ALL, gmsgDeathMsg, {0,0,0}, 0);
   write_byte(k);
   write_byte(v);
   write_byte(0);
   write_string("molotov");
   message_end();
 
   g_frags[k]++;
 
   if (kteam != vteam) {
      cs_set_user_money(k, cs_get_user_money(k) + 300);
   } else {
      cs_set_user_money(k, cs_get_user_money(k) - 300);
   }
}
 
stock ground_z(iOrigin[3], ent, skip = 0, iRecursion = 0) {
 
#if defined MOLOTOV_DEBUG
   new iEntValid = pev_valid(ent);
   if (iRecursion > 0) {
      log_amx("[MC] ground_z ent(%d) iEntValid(%d) skip(%d) iRecursion(%d)", ent, iEntValid, skip, iRecursion);
   }
#endif
   iOrigin[2] += random_num(5, 80);
 
   if (!pev_valid(ent)) {   // Fix for: Run time error 10: native error (native "set_pev")
      return iOrigin[2];
   }
 
   new Float:fOrigin[3];
 
   IVecFVec(iOrigin, fOrigin);
 
   set_pev(ent, pev_origin, fOrigin);
 
   engfunc(EngFunc_DropToFloor, ent);
 
   if (!skip && !engfunc(EngFunc_EntIsOnFloor, ent)) {
      if (iRecursion >= ANTI_LAGG) {
         skip = 1;
      }
#if defined MOLOTOV_DEBUG
      log_amx("[MC] ground_z ++iRecursion(%d)", ++iRecursion);
      return ground_z(iOrigin, ent, skip, iRecursion);
#else
      return ground_z(iOrigin, ent, skip, ++iRecursion);
#endif
   }
 
   pev(ent, pev_origin, fOrigin);
 
   return floatround(fOrigin[2]);
}
 
stock reset_molotovs() {
   new ent = g_MaxPlayers;
   while ((ent = engfunc(EngFunc_FindEntityByString, ent, "model", "models/molotov/w_molotov.mdl"))) {
      engfunc(EngFunc_SetModel, ent, "models/w_hegrenade.mdl");
   }
}
 
stock set_molotovs() {
   new ent = g_MaxPlayers;
   while ((ent = engfunc(EngFunc_FindEntityByString, ent, "model", "models/w_hegrenade.mdl"))) {
      engfunc(EngFunc_SetModel, ent, "models/molotov/w_molotov.mdl");
   }
}
 
// This will run at event New Round if enabled
public show_molotov_menu(id) {
   new menu[192];
 
   // Get a custom menu title with the price
   // When done it should look something like this:
   // Buy Molotov Cocktail ($1200)...
   new menu_title_text[120], the_molotov_price[7];
   get_cvar_string("molotov_price", the_molotov_price, 6);
   strcat(menu_title_text, "Buy Molotov Cocktail ($", 40);
   strcat(menu_title_text, the_molotov_price, 40);
   strcat(menu_title_text, ")?^n^n1. Yes, I will burn them all...^n2. No, I will kill in some other way...^n^n0. EXIT MENU", 119);
 
   format(menu, 191, menu_title_text);
 
   // This shows the menu for 30 seconds, I tried first with get_cvar_num("mp_buytime")*60 , but it didn't work well
   // when using 0.5 as mp_buytime. If you like, just change the time below
   show_menu(id, MOLOTOV_MENU_KEYS, menu, 30);
 
   return PLUGIN_HANDLED;
}
 
//Our menu function will get the player id and the key they pressed
public giveMolotov(id, key) {
 
   //key will start at zero
   if (key == 0) {
      buy_molotov(id);
   } else if (key == 1) {
      client_print(id, print_center, ">You have chosen not to buy a Molotov Coctail<");
   } else {
      client_print(id, print_center, ">You have choosen to exit the molotov menu...<");
   }
}

Last edited by anakonda001; 09-13-2020 at 16:06.
anakonda001 is offline
Reply


Thread Tools
Display Modes

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 08:11.


Powered by vBulletin®
Copyright ©2000 - 2020, vBulletin Solutions, Inc.
Theme made by Freecode