[SEGA EMPRESS ERIS]

Left 4 Dead 2

Special Infected Bot Spawner

l4d2_autoIS [modded - template]

Name file l4d2_autoIS or whatever you change the name of AutoExecConfig(true, "l4d2_autoIS"); to within the file after you copy and paste it to a blank file

Hunter will leap away again if "l4d2_ais_fast_response" is 1 or 0

Boomer and Smoker will STILL have a fast reaction time if "l4d2_ais_fast_response" is 1 and difficulty is on Easy or Normal

PHP Code:

/*
--------------------------------------------------------------
L4D2 Auto Infected Spawner 1.0.0
--------------------------------------------------------------
Manages its own system of automatic infected spawning.
--------------------------------------------------------------
*/

/*
TO DO:
- different max infected based on survivor count
- when spawn is full, use death event instead
- hook "mission_lost" event?
- use of queues?
*/
#pragma semicolon 1
#include <sourcemod>
#include <sdktools>

#define PLUGIN_VERSION "1.0"

#define DEBUG_GENERAL 0
#define DEBUG_TIMES 0
#define DEBUG_SPAWNS 0
#define DEBUG_WEIGHTS 0
#define DEBUG_EVENTS 0

// Uncommons Debug
//#define DEBUG 1


#define MAX_INFECTED 14
#define NUM_TYPES_INFECTED 7

#define TEAM_SPECTATOR        1
#define TEAM_SURVIVORS         2
#define TEAM_INFECTED         3

//pz constants (for SI type checking)
#define IS_SMOKER    1
#define IS_BOOMER    2
#define IS_HUNTER    3
#define IS_SPITTER    4
#define IS_JOCKEY    5
#define IS_CHARGER    6
#define IS_TANK        8

//pz constants (for spawning)
#define SI_SMOKER        0
#define SI_BOOMER        1
#define SI_HUNTER        2
#define SI_SPITTER        3
#define SI_JOCKEY        4
#define SI_CHARGER        5
#define SI_TANK            6

//make sure spawn names and ordering match pz constants
new String:Spawns[NUM_TYPES_INFECTED][16] = {"smoker auto","boomer auto","hunter auto","spitter auto","jockey auto","charger auto","tank auto"};

new SICount;
new SILimit;
new SpawnSize;
new SpawnTimeMode;
new GameMode;

new Float:SpawnTimeMin;
new Float:SpawnTimeMax;
new Float:SpawnTimes[MAX_INFECTED+1];

new SpawnWeights[NUM_TYPES_INFECTED];
new SpawnLimits[NUM_TYPES_INFECTED];
new SpawnCounts[NUM_TYPES_INFECTED];
new Handle:hSpawnWeights[NUM_TYPES_INFECTED];
new Handle:hSpawnLimits[NUM_TYPES_INFECTED];
new Float:IntervalEnds[NUM_TYPES_INFECTED];

new bool:Enabled;
new bool:EventsHooked;
new bool:SafeRoomChecking;
new bool:FasterResponse;
new bool:FasterSpawn;
new bool:SafeSpawn;
new bool:ScaleWeights;
new bool:ChangeByConstantTime;
new bool:SpawnTimerStarted;
new bool:WitchTimerStarted;
new bool:WitchWaitTimerStarted;
new bool:WitchCountFull;
new bool:RoundStarted;
new bool:RoundEnded;
new bool:LeftSafeRoom;



new Handle:hEnabled;
new Handle:hDisableInVersus;
new Handle:hFasterResponse;
new Handle:hFasterSpawn;
new Handle:hSafeSpawn;
new Handle:hSILimit;
new Handle:hSILimitMax;
new Handle:hScaleWeights;
new Handle:hSpawnSize;
new Handle:hSpawnTimeMin;
new Handle:hSpawnTimeMax;
new Handle:hSpawnTimer;
new Handle:hSpawnTimeMode;
new Handle:hGameMode;

new WitchCount;
new WitchLimit;
new Float:WitchPeriod;
new bool:VariableWitchPeriod;
new Handle:hWitchLimit;
new Handle:hWitchPeriod;
new Handle:hWitchPeriodMode;
new Handle:hWitchTimer;
new Handle:hWitchWaitTimer;



// Uncommons


public Plugin:myinfo =  
{
    name = "L4D2 Auto Infected Spawner",
    author = "Tordecybombo ,, FuzzOne - miniupdate ,, TacKLER - miniupdate again",
    description = "Custom automatic infected spawner",
    version = PLUGIN_VERSION,
    url = "http://www.sourcemod.net/"
};

public OnPluginStart()
{

    new Handle:surv_l = FindConVar("survivor_limit");
    SetConVarBounds(surv_l , ConVarBound_Upper, true, 8.0);

    new Handle:zombie_player_l = FindConVar("z_max_player_zombies");
    SetConVarBounds(zombie_player_l , ConVarBound_Upper, true, 8.0);
    SetConVarBounds(FindConVar("z_max_player_zombies"), ConVarBound_Upper, false);

    new Handle:zombie_minion_l = FindConVar("z_minion_limit");
    SetConVarBounds(zombie_minion_l , ConVarBound_Upper, true, 8.0);
    
    new Handle:zombie_surv = FindConVar("survival_max_specials");
    SetConVarBounds(zombie_surv , ConVarBound_Upper, true, 8.0);
    

    //l4d2 check
    decl String:mod[32];
    GetGameFolderName(mod, sizeof(mod));
    if(!StrEqual(mod, "left4dead2", false))
        SetFailState("[AIS] This plugin is for Left 4 Dead 2 only.");
    
    //hook events
    HookEvents();
    //witch events should not be unhooked to keep witch count working even when plugin is off
    HookEvent("witch_spawn", evtWitchSpawn);
    HookEvent("witch_killed", evtWitchKilled);
    HookEvent("witch_harasser_set", evtWitchHarasse);
    
    
    
    
    
    //admin commands
    RegAdminCmd("l4d2_ais_reset", ResetSpawns, ADMFLAG_RCON, "Reset by slaying all special infected and restarting the timer");
    RegAdminCmd("l4d2_ais_start", StartSpawnTimerManually, ADMFLAG_RCON, "Manually start the spawn timer");
    RegAdminCmd("l4d2_ais_time", SetConstantSpawnTime, ADMFLAG_CHEATS, "Set a constant spawn time (seconds) by setting l4d2_ais_time_min and l4d2_ais_time_max to the same value.");
    RegAdminCmd("l4d2_ais_preset", PresetWeights, ADMFLAG_CHEATS, "<default|none|boomer|smoker|hunter|tank|charger|jockey|spitter> Set spawn weights to given presets");
    
    //version cvar
    CreateConVar("l4d2_ais_version", PLUGIN_VERSION, "Auto Infected Spawner Version", FCVAR_PLUGIN|FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);
    //console variables and handles
    hEnabled = CreateConVar("l4d2_ais_enabled", "1", "[0=OFF|1=ON] Disable/Enable functionality of the plugin", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hDisableInVersus = CreateConVar("l4d2_ais_disable_in_versus", "1", "[0=OFF|1=ON] Automatically disable plugin in versus mode", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hFasterResponse = CreateConVar("l4d2_ais_fast_response", "1", "[0=OFF|1=ON] Disable/Enable faster special infected response", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hFasterSpawn = CreateConVar("l4d2_ais_fast_spawn", "0", "[0=OFF|1=ON] Disable/Enable faster special infected spawn (Enable when SI spawn rate is high)", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hSafeSpawn = CreateConVar("l4d2_ais_safe_spawn", "0", "[0=OFF|1=ON] Disable/Enable special infected spawning while survivors are in safe room", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hSpawnWeights[SI_BOOMER] = CreateConVar("l4d2_ais_boomer_weight", "100", "The weight for a boomer spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnWeights[SI_HUNTER] = CreateConVar("l4d2_ais_hunter_weight", "100", "The weight for a hunter spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnWeights[SI_SMOKER] = CreateConVar("l4d2_ais_smoker_weight", "100", "The weight for a smoker spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnWeights[SI_TANK] = CreateConVar("l4d2_ais_tank_weight", "10", "[-1 = Director spawns tanks] The weight for a tank spawning", FCVAR_PLUGIN, true, -1.0);
    hSpawnWeights[SI_CHARGER] = CreateConVar("l4d2_ais_charger_weight", "100", "The weight for a charger spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnWeights[SI_JOCKEY] = CreateConVar("l4d2_ais_jockey_weight", "100", "The weight for a jockey spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnWeights[SI_SPITTER] = CreateConVar("l4d2_ais_spitter_weight", "100", "The weight for a spitter spawning", FCVAR_PLUGIN, true, 0.0);
    hSpawnLimits[SI_BOOMER] = CreateConVar("l4d2_ais_boomer_limit", "4", "The max amount of boomers present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_HUNTER] = CreateConVar("l4d2_ais_hunter_limit", "4", "The max amount of hunters present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_SMOKER] = CreateConVar("l4d2_ais_smoker_limit", "4", "The max amount of smokers present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_TANK] = CreateConVar("l4d2_ais_tank_limit", "2", "The max amount of tanks present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_CHARGER] = CreateConVar("l4d2_ais_charger_limit", "4", "The max amount of chargers present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_JOCKEY] = CreateConVar("l4d2_ais_jockey_limit", "4", "The max amount of jockeys present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hSpawnLimits[SI_SPITTER] = CreateConVar("l4d2_ais_spitter_limit", "4", "The max amount of spitters present at once", FCVAR_PLUGIN, true, 0.0, true, 14.0);
    hScaleWeights = CreateConVar("l4d2_ais_scale_weights", "0", "[0=OFF|1=ON] Scale spawn weights with the limits of corresponding SI", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hWitchLimit = CreateConVar("l4d2_ais_witch_limit", "6", "[-1 = Director spawns witches] The max amount of witches present at once (independant of l4d2_ais_limit).", FCVAR_PLUGIN, true, -1.0, true, 100.0);
    hWitchPeriod = CreateConVar("l4d2_ais_witch_period", "180.0", "The time (seconds) interval in which exactly one witch will spawn", FCVAR_PLUGIN, true, 1.0);
    hWitchPeriodMode = CreateConVar("l4d2_ais_witch_period_mode", "1", "The witch spawn rate consistency [0=CONSTANT|1=VARIABLE]", FCVAR_PLUGIN, true, 0.0, true, 1.0);
    hSILimit = CreateConVar("l4d2_ais_limit", "3", "The max amount of special infected at once", FCVAR_PLUGIN, true, 1.0, true, float(MAX_INFECTED));
    hSILimitMax = FindConVar("z_max_player_zombies");
    hSpawnSize = CreateConVar("l4d2_ais_spawn_size", "3", "The amount of special infected spawned at each spawn interval", FCVAR_PLUGIN, true, 1.0, true, float(MAX_INFECTED));
    hSpawnTimeMode = CreateConVar("l4d2_ais_time_mode", "0", "The spawn time mode [0=RANDOMIZED|1=INCREMENTAL|2=DECREMENTAL]", FCVAR_PLUGIN, true, 0.0, true, 2.0);
    //hSpawnTimeFunction = CreateConVar("l4d2_ais_time_function", "0", "The spawn time function [0=LINEAR|1=EXPONENTIAL|2=LOGARITHMIC]", FCVAR_PLUGIN, true, 0.0, true 2.0);
    hSpawnTimeMin = CreateConVar("l4d2_ais_time_min", "30.0", "The minimum auto spawn time (seconds) for infected", FCVAR_PLUGIN, true, 0.0);
    hSpawnTimeMax = CreateConVar("l4d2_ais_time_max", "30.0", "The maximum auto spawn time (seconds) for infected", FCVAR_PLUGIN, true, 1.0);
    hGameMode = FindConVar("mp_gamemode");
    
    //hook cvar changes to variables
    HookConVarChange(hEnabled, ConVarEnabled);
    HookConVarChange(hFasterResponse, ConVarFasterResponse);
    HookConVarChange(hFasterSpawn, ConVarFasterSpawn);
    HookConVarChange(hSafeSpawn, ConVarSafeSpawn);
    HookConVarChange(hScaleWeights, ConVarScaleWeights);
    HookConVarChange(hSILimit, ConVarSILimit);
    HookConVarChange(hSpawnSize, ConVarSpawnSize);
    HookConVarChange(hSpawnTimeMode, ConVarSpawnTimeMode);
    HookConVarChange(hSpawnTimeMin, ConVarSpawnTime);
    HookConVarChange(hSpawnTimeMax, ConVarSpawnTime);
    HookConVarChangeSpawnWeights(); //hooks all SI weights
    HookConVarChangeSpawnLimits();
    HookConVarChange(hGameMode, ConVarGameMode);
    HookConVarChange(hWitchLimit, ConVarWitchLimit);
    HookConVarChange(hWitchPeriod, ConVarWitchPeriod);
    HookConVarChange(hWitchPeriodMode, ConVarWitchPeriodMode);

    //set console variables
    EnabledCheck(); //sets Enabled, FasterResponse, FasterSpawn, and cvars
    SafeSpawn = GetConVarBool(hSafeSpawn);
    SILimit = GetConVarInt(hSILimit);
    SpawnSize = GetConVarInt(hSpawnSize);
    SpawnTimeMode = GetConVarInt(hSpawnTimeMode);
    SetSpawnTimes(); //sets SpawnTimeMin, SpawnTimeMax, and SpawnTimes[]
    SetSpawnWeights(); //sets SpawnWeights[]
    SetSpawnLimits(); //sets SpawnLimits[]
    WitchLimit = GetConVarInt(hWitchLimit);
    WitchPeriod = GetConVarFloat(hWitchPeriod);
    VariableWitchPeriod = GetConVarBool(hWitchPeriodMode);
    
    //set other variables
    ChangeByConstantTime = false;
    RoundStarted = false;
    RoundEnded = false;
    LeftSafeRoom = false;
    
    //autoconfig executed on every map change
    AutoExecConfig(true, "l4d2_autoIS");
}

public OnConfigsExecuted()
{
    SetCvars(); //refresh cvar settings in case they change
    GameModeCheck();
    
    if (GameMode == 2 && GetConVarBool(hDisableInVersus)) //disable in versus
        SetConVarBool(hEnabled, false);
}

HookEvents()
{
    if (!EventsHooked)
    {
        EventsHooked = true;
        //MI 5, We hook the round_start (and round_end) event on plugin start, since it occurs before map_start
        HookEvent("round_start", evtRoundStart, EventHookMode_Post);
        HookEvent("round_end", evtRoundEnd, EventHookMode_Pre);
        //hook other events
        HookEvent("map_transition", evtRoundEnd, EventHookMode_Pre); //also stop spawn timers upon map transition
        HookEvent("create_panic_event", evtSurvivalStart);
        HookEvent("player_death", evtInfectedDeath);
        #if DEBUG_EVENTS
        LogMessage("[AIS] Events Hooked");
        #endif
    }
}
UnhookEvents()
{
    if (EventsHooked)
    {
        EventsHooked = false;
        UnhookEvent("round_start", evtRoundStart, EventHookMode_Post);
        UnhookEvent("round_end", evtRoundEnd, EventHookMode_Pre);
        UnhookEvent("map_transition", evtRoundEnd, EventHookMode_Pre);
        UnhookEvent("create_panic_event", evtSurvivalStart);
        UnhookEvent("player_death", evtInfectedDeath);
        #if DEBUG_EVENTS
        LogMessage("[AIS] Events Unhooked");
        #endif
    }
}

HookConVarChangeSpawnWeights()
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        HookConVarChange(hSpawnWeights[i], ConVarSpawnWeights);
}

HookConVarChangeSpawnLimits()
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        HookConVarChange(hSpawnLimits[i], ConVarSpawnLimits);
}

SetSpawnLimits()
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        SpawnLimits[i] = GetConVarInt(hSpawnLimits[i]);
}

public ConVarEnabled(Handle:convar, const String:oldValue[], const String:newValue[])
{
    EnabledCheck();
}
public ConVarFasterResponse(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SetAIDelayCvars();
}
public ConVarFasterSpawn(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SetAISpawnCvars();
}
public ConVarSafeSpawn(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SafeSpawn = GetConVarBool(hSafeSpawn);
}
public ConVarScaleWeights(Handle:convar, const String:oldValue[], const String:newValue[])
{
    ScaleWeights = GetConVarBool(hScaleWeights);
}
public ConVarSILimit(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SILimit = GetConVarInt(hSILimit); 
    CalculateSpawnTimes(); //must recalculate spawn time table to compensate for limit change
    if (LeftSafeRoom)
        StartSpawnTimer(); //restart timer after times change
}
public ConVarSpawnSize(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SpawnSize = GetConVarInt(hSpawnSize); 
}
public ConVarSpawnTimeMode(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SpawnTimeMode = GetConVarInt(hSpawnTimeMode);
    CalculateSpawnTimes(); //must recalculate spawn time table to compensate for mode change
    if (LeftSafeRoom)
        StartSpawnTimer(); //restart timer after times change
}
public ConVarSpawnTime(Handle:convar, const String:oldValue[], const String:newValue[])
{
    if (!ChangeByConstantTime)
        SetSpawnTimes();
}
public ConVarSpawnWeights(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SetSpawnWeights();
    if (WitchLimit < 0 && SpawnWeights[SI_TANK] >= 0)
    {
        SetConVarInt(FindConVar("director_no_bosses"), 1);
        SetConVarInt(hWitchLimit, 0); 
    }
    else if (WitchLimit >= 0 && SpawnWeights[SI_TANK] < 0)
    {
        SetConVarInt(FindConVar("director_no_bosses"), 0);
        SetConVarInt(hWitchLimit, -1);
    }
}
public ConVarSpawnLimits(Handle:convar, const String:oldValue[], const String:newValue[])
{
    SetSpawnLimits();
}
public ConVarWitchLimit(Handle:convar, const String:oldValue[], const String:newValue[])
{
    WitchLimit = GetConVarInt(hWitchLimit);
    if (WitchLimit < 0 && SpawnWeights[SI_TANK] >= 0)
    {
        SetConVarInt(FindConVar("director_no_bosses"), 0);
        SetConVarInt(hSpawnWeights[SI_TANK], -1);
    }
    else if (WitchLimit >= 0 && SpawnWeights[SI_TANK] < 0)
    {
        SetConVarInt(FindConVar("director_no_bosses"), 1);
        SetConVarInt(hSpawnWeights[SI_TANK], 0);
    }
    if (LeftSafeRoom && WitchLimit > 0)
        RestartWitchTimer(0.0); //restart timer after times change
}
public ConVarWitchPeriod(Handle:convar, const String:oldValue[], const String:newValue[])
{
    WitchPeriod = GetConVarFloat(hWitchPeriod);
    if (LeftSafeRoom && WitchLimit > 0)
        RestartWitchTimer(0.0); //restart timer after times change
}
public ConVarWitchPeriodMode(Handle:convar, const String:oldValue[], const String:newValue[])
{
    VariableWitchPeriod = GetConVarBool(hWitchPeriodMode);
    if (LeftSafeRoom && WitchLimit > 0)
        RestartWitchTimer(0.0); //restart timer after times change
}
public ConVarGameMode(Handle:convar, const String:oldValue[], const String:newValue[])
{
    GameModeCheck();
}

EnabledCheck()
{
    Enabled = GetConVarBool(hEnabled);
    SetCvars();
    if (Enabled)
    {
        HookEvents();
        InitTimers();
    }
    else
        UnhookEvents();
    #if DEBUG_GENERAL
    LogMessage("[AIS] Plugin Enabled?: %b", Enabled);
    #endif
}

InitTimers()
{
    if (LeftSafeRoom)
        StartTimers();
    else if (GameMode != 3 && !SafeRoomChecking) //start safe room check in non-survival mode
    {
        SafeRoomChecking = true;
        CreateTimer(1.0, PlayerLeftStart);
    }
}

SetCvars()
{
    if (Enabled)
    {
        SetConVarBounds(hSILimitMax, ConVarBound_Upper, true, float(MAX_INFECTED));
        SetConVarFloat(hSILimitMax, float(MAX_INFECTED));
        SetConVarInt(FindConVar("z_boomer_limit"), 0);
        SetConVarInt(FindConVar("z_hunter_limit"), 0);
        SetConVarInt(FindConVar("z_smoker_limit"), 0);
        SetConVarInt(FindConVar("z_charger_limit"), 0);
        SetConVarInt(FindConVar("z_spitter_limit"), 0);
        SetConVarInt(FindConVar("z_jockey_limit"), 0);
        SetConVarInt(FindConVar("survival_max_boomers"), 0);
        SetConVarInt(FindConVar("survival_max_hunters"), 0);
        SetConVarInt(FindConVar("survival_max_smokers"), 0);
        SetConVarInt(FindConVar("survival_max_chargers"), 0);
        SetConVarInt(FindConVar("survival_max_spitters"), 0);
        SetConVarInt(FindConVar("survival_max_jockeys"), 0);    
        SetConVarInt(FindConVar("survival_max_specials"), SILimit);
        SetBossesCvar();
        SetConVarInt(FindConVar("director_spectate_specials"), 1);
    }
    else
    {
        ResetConVar(FindConVar("z_max_player_zombies"));
        ResetConVar(FindConVar("z_boomer_limit"));
        ResetConVar(FindConVar("z_hunter_limit"));
        ResetConVar(FindConVar("z_smoker_limit"));
        ResetConVar(FindConVar("z_charger_limit"));
        ResetConVar(FindConVar("z_spitter_limit"));
        ResetConVar(FindConVar("z_jockey_limit"));
        ResetConVar(FindConVar("survival_max_boomers"));
        ResetConVar(FindConVar("survival_max_hunters"));
        ResetConVar(FindConVar("survival_max_smokers"));
        ResetConVar(FindConVar("survival_max_chargers"));
        ResetConVar(FindConVar("survival_max_spitters"));
        ResetConVar(FindConVar("survival_max_jockeys"));
        ResetConVar(FindConVar("survival_max_specials"));
        ResetConVar(FindConVar("director_no_bosses"));    
        ResetConVar(FindConVar("director_spectate_specials"));
    }
    
    SetAIDelayCvars();
    SetAISpawnCvars();
}

SetBossesCvar() //both tank and witch must be handled by director or not
{
    if (WitchLimit < 0 || SpawnWeights[SI_TANK] < 0)
        SetConVarInt(FindConVar("director_no_bosses"), 0);
    else
        SetConVarInt(FindConVar("director_no_bosses"), 1);        
}

SetAIDelayCvars()
{
    FasterResponse = GetConVarBool(hFasterResponse);
    if (FasterResponse)
    {            
        SetConVarInt(FindConVar("boomer_vomit_delay"), 0);
        SetConVarInt(FindConVar("smoker_tongue_delay"), 0);
    }
    else
    {
        ResetConVar(FindConVar("boomer_vomit_delay"));
        ResetConVar(FindConVar("smoker_tongue_delay"));    
    }
}

SetAISpawnCvars()
{
    FasterSpawn = GetConVarBool(hFasterSpawn);
    if (FasterSpawn)
        SetConVarInt(FindConVar("z_spawn_safety_range"), 0);
    else
        ResetConVar(FindConVar("z_spawn_safety_range"));
}

//MI 5
GameModeCheck()
{
    //We determine what the gamemode is
    decl String:GameName[16];
    GetConVarString(FindConVar("mp_gamemode"), GameName, sizeof(GameName));
    if (StrContains(GameName, "survival", false) != -1)
        GameMode = 1; //3
    else if (StrContains(GameName, "versus", false) != -1)
        GameMode = 1; //2
    else if (StrContains(GameName, "coop", false) != -1)
        GameMode = 1; //1
    else 
        GameMode = 1; //0
}

public Action:SetConstantSpawnTime(client, args)
{
    ChangeByConstantTime = true; //prevent conflict with hooked event change
    if (args > 0)
    {
        new Float:time = 1.0;
        decl String:arg[8];
        GetCmdArg(1, arg, sizeof(arg));
        time = StringToFloat(arg);
        if (time < 0.0)
            time = 1.0;
        SetConVarFloat(hSpawnTimeMin, time);
        SetConVarFloat(hSpawnTimeMax, time);
        SetSpawnTimes(); //refresh times since hooked event from SetConVarFloat is temporarily disabled
        ReplyToCommand(client, "[AIS] Minimum and maximum spawn time set to %.3f seconds.", time);
    }
    else
        ReplyToCommand(client, "l4d2_ais_time <# of seconds>");
    ChangeByConstantTime = false;
}

SetSpawnTimes()
{
    SpawnTimeMin = GetConVarFloat(hSpawnTimeMin);
    SpawnTimeMax = GetConVarFloat(hSpawnTimeMax);
    if (SpawnTimeMin > SpawnTimeMax) //SpawnTimeMin cannot be greater than SpawnTimeMax
        SetConVarFloat(hSpawnTimeMin, SpawnTimeMax); //set back to appropriate limit
    else if (SpawnTimeMax < SpawnTimeMin) //SpawnTimeMax cannot be less than SpawnTimeMin
        SetConVarFloat(hSpawnTimeMax, SpawnTimeMin); //set back to appropriate limit
    else
    {
        CalculateSpawnTimes(); //must recalculate spawn time table to compensate for min change
        if (LeftSafeRoom)
            StartSpawnTimer(); //restart timer after times change    
    }
}

CalculateSpawnTimes()
{
    new i;
    if (SILimit > 1 && SpawnTimeMode > 0)
    {
        new Float:unit = (SpawnTimeMax-SpawnTimeMin)/(SILimit-1);
        switch (SpawnTimeMode)
        {
            case 1: //incremental spawn time mode
            {
                SpawnTimes[0] = SpawnTimeMin;
                for (i = 1; i <= MAX_INFECTED; i++)
                {
                    if (i < SILimit)
                        SpawnTimes[i] = SpawnTimes[i-1] + unit;
                    else
                        SpawnTimes[i] = SpawnTimeMax;
                }
            }
            case 2: //decremental spawn time mode
            {
                SpawnTimes[0] = SpawnTimeMax;
                for (i = 1; i <= MAX_INFECTED; i++)
                {
                    if (i < SILimit)
                        SpawnTimes[i] = SpawnTimes[i-1] - unit;
                    else
                        SpawnTimes[i] = SpawnTimeMax;
                }
            }
            //randomized spawn time mode does not use time tables
        }    
    }
    else //constant spawn time for if SILimit is 1
        SpawnTimes[0] = SpawnTimeMax;
    #if DEBUG_TIMES
    for (i = 0; i <= MAX_INFECTED; i++)
        LogMessage("[AIS] %d : %.5f s", i, SpawnTimes[i]);
    #endif
}

SetSpawnWeights()
{
    new i, weight, TotalWeight;
    //set and sum spawn weights
    for (i = 0; i < NUM_TYPES_INFECTED; i++)
    {
        weight = GetConVarInt(hSpawnWeights[i]);
        SpawnWeights[i] = weight;
        if (weight >= 0)
            TotalWeight += weight;
    }
    #if DEBUG_WEIGHTS
    for (i = 0; i < NUM_TYPES_INFECTED; i++)
        LogMessage("[AIS] %s weight: %d (%.5f)", Spawns[i], SpawnWeights[i]);
    #endif
}

public Action:PresetWeights(client, args)
{
    decl String:arg[16];
    GetCmdArg(1, arg, sizeof(arg));
    
    if (strcmp(arg, "default") == 0)
        ResetWeights();
    else if (strcmp(arg, "none") == 0)
        ZeroWeights();
    else //presets for spawning special infected i only
    {
        for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        {
            if (strcmp(arg, Spawns[i]) == 0)
            {
                ZeroWeightsExcept(i);
                return Plugin_Handled;
            }
        }    
    }
    ReplyToCommand(client, "l4d2_ais_preset <default|none|smoker|boomer|hunter|spitter|jockey|charger|tank>");
    return Plugin_Handled;
}

ResetWeights()
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        ResetConVar(hSpawnWeights[i]);
}
ZeroWeights()
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        SetConVarInt(hSpawnWeights[i], 0);
}
ZeroWeightsExcept(index)
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
    {
        if (i == index)
            SetConVarInt(hSpawnWeights[i], 100);
        else
            SetConVarInt(hSpawnWeights[i], 0);
    }
    if (index != SI_TANK) //include director spawning of tank for non-tank SI presets
        ResetConVar(hSpawnWeights[SI_TANK]);
}

GenerateSpawn(client)
{
    CountSpecialInfected(); //refresh infected count
    if (SICount < SILimit) //spawn when infected count hasn't reached limit
    {
        new size;
        if (SpawnSize > SILimit - SICount) //prevent amount of special infected from exceeding SILimit
            size = SILimit - SICount;
        else
            size = SpawnSize;
        
        new index;
        new SpawnQueue[MAX_INFECTED] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
        
        //refresh current SI counts
        SITypeCount();
        
        //generate the spawn queue
        for (new i = 0; i < size; i++)
        {
            index = GenerateIndex();
            if (index == -1)
                break;
            SpawnQueue[i]= index;
            SpawnCounts[index] += 1;
        }
        
        for (new i = 0; i < MAX_INFECTED; i++)
        {
            if(SpawnQueue[i] < 0) //stops if the current array index is out of bound
                break;
            new bot = CreateFakeClient("Infected Bot");
            if (bot != 0)
            {
                ChangeClientTeam(bot,TEAM_INFECTED);
                CreateTimer(0.1,kickbot,bot);
            }    
            CheatCommand(client, "z_spawn_old", Spawns[SpawnQueue[i]]); 
            
            #if DEBUG_SPAWNS
                LogMessage("[AIS] Spawned %s", Spawns[SpawnQueue[i]]);
            #endif
        }
    }
}

//MI
SITypeCount() //Count the number of each SI ingame
{
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
        SpawnCounts[i] = 0;

    for (new i = 1; i <= MaxClients; i++)
    {
        //If player is not connected ...
        if (!IsClientConnected(i)) continue;
        
        //We check if player is in game
        if (!IsClientInGame(i)) continue;
        
        //Check if client is infected ...
        if (GetClientTeam(i)==3)
        {
            switch (GetEntProp(i,Prop_Send,"m_zombieClass")) //detect SI type
            {
                case IS_SMOKER:
                    SpawnCounts[SI_SMOKER]++;
                
                case IS_BOOMER:
                    SpawnCounts[SI_BOOMER]++;
                
                case IS_HUNTER:
                    SpawnCounts[SI_HUNTER]++;
                
                case IS_SPITTER:
                    SpawnCounts[SI_SPITTER]++;
                
                case IS_JOCKEY:
                    SpawnCounts[SI_JOCKEY]++;
                
                case IS_CHARGER:
                    SpawnCounts[SI_CHARGER]++;
                
                case IS_TANK:
                    SpawnCounts[SI_TANK]++;
            }
        }
    }
}

public Action:kickbot(Handle:timer, any:client)
{
    if (IsClientInGame(client) && (!IsClientInKickQueue(client)))
    {
        if (IsFakeClient(client)) KickClient(client);
    }
}

stock CheatCommand(client, String:command[], String:arguments[] = "")
{
    if (!client || !IsClientInGame(client))
    {
        for (new target = 1; target <= MaxClients; target++)
        {
            client = target;
            break;
        }
        
        return; // case no valid Client found
    }
    
    new userFlags = GetUserFlagBits(client);
    SetUserFlagBits(client, ADMFLAG_ROOT);
    new flags = GetCommandFlags(command);
    SetCommandFlags(command, flags & ~FCVAR_CHEAT);
    FakeClientCommand(client, "%s %s", command, arguments);
    SetCommandFlags(command, flags);
    SetUserFlagBits(client, userFlags);
}

GenerateIndex()
{
    new TotalSpawnWeight, StandardizedSpawnWeight;
    
    //temporary spawn weights factoring in SI spawn limits
    decl TempSpawnWeights[NUM_TYPES_INFECTED];
    for(new i = 0; i < NUM_TYPES_INFECTED; i++)
    {
        if(SpawnCounts[i] < SpawnLimits[i])
        {
            if(ScaleWeights)
                TempSpawnWeights[i] = (SpawnLimits[i] - SpawnCounts[i]) * SpawnWeights[i];
            else
                TempSpawnWeights[i] = SpawnWeights[i];
        }
        else
            TempSpawnWeights[i] = 0;
        
        TotalSpawnWeight += TempSpawnWeights[i];
    }
    
    //calculate end intervals for each spawn
    new Float:unit = 1.0/TotalSpawnWeight;
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
    {
        if (TempSpawnWeights[i] >= 0)
        {
            StandardizedSpawnWeight += TempSpawnWeights[i];
            IntervalEnds[i] = StandardizedSpawnWeight * unit;
        }
    }
    
    new Float:r = GetRandomFloat(0.0, 1.0); //selector r must be within the ith interval for i to be selected
    for (new i = 0; i < NUM_TYPES_INFECTED; i++)
    {
        //negative and 0 weights are ignored
        if (TempSpawnWeights[i] <= 0) continue;
        //r is not within the ith interval
        if (IntervalEnds[i] < r) continue;
        //selected index i because r is within ith interval
        return i;
    }
    return -1; //no selection because all weights were negative or 0
}

//special infected spawn timer based on time modes
StartSpawnTimer()
{
    //prevent multiple timer instances
    EndSpawnTimer();
    //only start spawn timer if plugin is enabled
    if (Enabled)
    {
        new Float:time;
        CountSpecialInfected();
        
        if (SpawnTimeMode > 0) //NOT randomization spawn time mode
            time = SpawnTimes[SICount]; //a spawn time based on the current amount of special infected
        else //randomization spawn time mode
            time = GetRandomFloat(SpawnTimeMin, SpawnTimeMax); //a random spawn time between min and max inclusive

        SpawnTimerStarted = true;
        hSpawnTimer = CreateTimer(time, SpawnInfectedAuto);
        #if DEBUG_TIMES
        LogMessage("[AIS] Mode: %d | SI: %d | Next: %.3f s", SpawnTimeMode, SICount, time);
        #endif
    }
}

//never directly set hSpawnTimer, use this function for custom spawn times
StartCustomSpawnTimer(Float:time)
{
    //prevent multiple timer instances
    EndSpawnTimer();
    //only start spawn timer if plugin is enabled
    if (Enabled)
    {
        SpawnTimerStarted = true;
        hSpawnTimer = CreateTimer(time, SpawnInfectedAuto);
    }
}
EndSpawnTimer()
{
    if (SpawnTimerStarted)
    {
        CloseHandle(hSpawnTimer);
        SpawnTimerStarted = false;
    }
}

StartWitchWaitTimer(Float:time)
{
    EndWitchWaitTimer();
    if (Enabled && WitchLimit > 0)
    {
        if (WitchCount < WitchLimit)
        {
            WitchWaitTimerStarted = true;
            hWitchWaitTimer = CreateTimer(time, StartWitchTimer);
            #if DEBUG_TIMES
            LogMessage("[AIS] Mode: %b | Witches: %d | Next(WitchWait): %.3f s", VariableWitchPeriod, WitchCount, time);
            #endif
        }
        else //if witch count reached limit, wait until a witch killed event to start witch timer
        {
            WitchCountFull = true;
            #if DEBUG_TIMES
            LogMessage("[AIS] Witch Limit reached. Waiting for witch death.");
            #endif        
        }
    }
}
public Action:StartWitchTimer(Handle:timer)
{
    WitchWaitTimerStarted = false;
    EndWitchTimer();
    if (Enabled && WitchLimit > 0)
    {
        new Float:time;
        if (VariableWitchPeriod)
            time = GetRandomFloat(0.0, WitchPeriod);
        else
            time = WitchPeriod;
        
        WitchTimerStarted = true;
        hWitchTimer = CreateTimer(time, SpawnWitchAuto, WitchPeriod-time);
        #if DEBUG_TIMES
        LogMessage("[AIS] Mode: %b | Witches: %d | Next(Witch): %.3f s", VariableWitchPeriod, WitchCount, time);
        #endif
    }
    return Plugin_Handled;
}
EndWitchWaitTimer()
{
    if (WitchWaitTimerStarted)
    {
        CloseHandle(hWitchWaitTimer);
        WitchWaitTimerStarted = false;
    }
}
EndWitchTimer()
{
    if (WitchTimerStarted)
    {
        CloseHandle(hWitchTimer);
        WitchTimerStarted = false;
    }
}
//take account of both witch timers when restarting overall witch timer
RestartWitchTimer(Float:time)
{
    EndWitchTimer();
    StartWitchWaitTimer(time);
}

StartTimers()
{
    StartSpawnTimer();
    RestartWitchTimer(0.0);
}
EndTimers()
{
    EndSpawnTimer();
    EndWitchWaitTimer();
    EndWitchTimer();
}

public Action:StartSpawnTimerManually(client, args)
{
    if (Enabled)
    {
        if (args < 1)
        {
            StartSpawnTimer();
            ReplyToCommand(client, "[AIS] Spawn timer started manually.");
        }
        else
        {
            new Float:time = 1.0;
            decl String:arg[8];
            GetCmdArg(1, arg, sizeof(arg));
            time = StringToFloat(arg);
            
            if (time < 0.0)
                time = 1.0;
            
            StartCustomSpawnTimer(time);
            ReplyToCommand(client, "[AIS] Spawn timer started manually. Next potential spawn in %.3f seconds.", time);
        }
    }
    else
        ReplyToCommand(client, "[AIS] Plugin is disabled. Enable plugin before manually starting timer.");

    return Plugin_Handled;
}
 
public Action:SpawnInfectedAuto(Handle:timer)
{
    SpawnTimerStarted = false; //spawn timer always stops here (the non-repeated spawn timer calls this function)
    if (LeftSafeRoom) //only spawn infected and repeat spawn timer when survivors have left safe room
    {
        new client = GetAnyClient();
        if (client) //make sure client is in-game
        {
            GenerateSpawn(client);
            StartSpawnTimer();
        }
        else //longer timer for when invalid client was returned (prevent a potential infinite loop when there are 0 SI)
            StartCustomSpawnTimer(SpawnTimeMax);
    }

    return Plugin_Handled;
}

public Action:SpawnWitchAuto(Handle:timer, any:waitTime)
{
    WitchTimerStarted = false;
    if (LeftSafeRoom)
    {
        new client = GetAnyClient();
        if (client)
        {
            if (WitchCount < WitchLimit)
                ExecuteCheatCommand(client, "z_spawn_old", "witch", "auto");
            StartWitchWaitTimer(waitTime);
        }
        else
            StartWitchWaitTimer(waitTime+1.0);
    }
    return Plugin_Handled;
}

ExecuteCheatCommand(client, const String:command[], String:param1[], String:param2[]) {
    //Hold original user flag for restoration, temporarily give user root admin flag (prevent conflict with admincheats)
    new admindata = GetUserFlagBits(client);
    SetUserFlagBits(client, ADMFLAG_ROOT);
    
    //Removes sv_cheat flag from command
    new flags = GetCommandFlags(command);
    SetCommandFlags(command, flags & ~FCVAR_CHEAT);

    FakeClientCommand(client, "%s %s %s", command, param1, param2);
    
    //Restore command flag and user flag
    SetCommandFlags(command, flags);
    SetUserFlagBits(client, admindata);
}

public Action:ResetSpawns(client, args)
{    
    KillSpecialInfected();
    if (Enabled)
    {
        StartCustomSpawnTimer(SpawnTimes[0]);
        RestartWitchTimer(0.0);
        ReplyToCommand(client, "[AIS] Slayed all special infected. Spawn timer restarted. Next potential spawn in %.3f seconds.", SpawnTimeMin);
    }
    else
        ReplyToCommand(client, "[AIS] Slayed all special infected.");
    return Plugin_Handled;
}

CountSpecialInfected()
{
    //reset counter
    SICount = 0;
    
    //First we count the amount of infected players
    for (new i = 1; i <= MaxClients; i++)
    {
        //If player is not connected ...
        if (!IsClientConnected(i)) continue;
        
        //We check if player is in game
        if (!IsClientInGame(i)) continue;
        
        //Check if client is infected ...
        if (GetClientTeam(i)==3)
            SICount++;
    }
}

KillSpecialInfected()
{
    for (new i = 1; i <= MaxClients; i++)
    {
        if (!IsClientConnected(i)) continue;
        
        if (!IsClientInGame(i)) continue;
        
        if (GetClientTeam(i)==3)
            ForcePlayerSuicide(i);
    }
    
    //reset counter after all special infected have been killed
    SICount = 0;
}

public GetAnyClient ()
{
    for (new  i = 1; i <= MaxClients; i++)
    {
        if (IsClientConnected(i) && IsClientInGame(i) && (!IsFakeClient(i)))
            return i;
    }
    return 0;
}

//MI 5
public Action:evtRoundStart(Handle:event, const String:name[], bool:dontBroadcast)
{    
    //If round haven't started
    if (!RoundStarted)
    {
        //and we reset some variables
        RoundEnded = false;
        RoundStarted = true;
        LeftSafeRoom = SafeSpawn; //depends on whether special infected should spawn while survivors are in starting safe room
        WitchCount = 0;
        SpawnTimerStarted = false;
        WitchTimerStarted = false;
        WitchWaitTimerStarted = false;
        WitchCountFull = false;

        InitTimers();
    }
}

//MI 5
public Action:evtRoundEnd (Handle:event, const String:name[], bool:dontBroadcast)
{    
    //If round has not been reported as ended ..
    if (!RoundEnded)
    {
        //we mark the round as ended
        EndTimers();
        RoundEnded = true;
        RoundStarted = false;
        LeftSafeRoom = false;
    }
}

//MI 5
public Action:PlayerLeftStart(Handle:Timer)
{
    if (LeftStartArea())
    {
        // We don't care who left, just that at least one did
        if (!LeftSafeRoom)
        {
            LeftSafeRoom = true;
            StartTimers();        
        }
        SafeRoomChecking = false;
    }
    else
        CreateTimer(1.0, PlayerLeftStart);
    
    return Plugin_Continue;
}

//MI 5
bool:LeftStartArea()
{
    new ent = -1, maxents = GetMaxEntities();
    for (new i = MaxClients+1; i <= maxents; i++)
    {
        if (IsValidEntity(i))
        {
            decl String:netclass[64];
            GetEntityNetClass(i, netclass, sizeof(netclass));
            
            if (StrEqual(netclass, "CTerrorPlayerResource"))
            {
                ent = i;
                break;
            }
        }
    }
    
    if (ent > -1)
    {
        new offset = FindSendPropInfo("CTerrorPlayerResource", "m_hasAnySurvivorLeftSafeArea");
        if (offset > 0)
        {
            if (GetEntData(ent, offset))
            {
                if (GetEntData(ent, offset) == 1) return true;
            }
        }
    }
    return false;
}

//MI 5
//This is hooked to the panic event, but only starts if its survival. This is what starts up the bots in survival.
public Action:evtSurvivalStart(Handle:event, const String:name[], bool:dontBroadcast)
{
    if (GameMode == 3)
    {  
        if (!LeftSafeRoom)
        {
            LeftSafeRoom = true;
            StartTimers();
        }
    }
    return Plugin_Continue;
}

//Kick infected bots immediately after they die to allow quicker infected respawn
public Action:evtInfectedDeath(Handle:event, const String:name[], bool:dontBroadcast)
{
    if (FasterSpawn)
    {
        new client = GetClientOfUserId(GetEventInt(event, "userid"));
        
        if (client) {
            if (GetClientTeam(client) == 3 && IsFakeClient(client))
                KickClient(client, "");
        }
    }
}

public Action:evtWitchSpawn(Handle:event, const String:name[], bool:dontBroadcast)
{
    WitchCount++;
}

public Action:evtWitchHarasse(Handle:event, const String:name[], bool:dontBroadcast)
{
    decl String:names[32];
    new killer = GetClientOfUserId(GetEventInt(event, "userid"));
    
    if (GetClientTeam(killer) == 2) //only show message if player is in survivor team
    {
        GetClientName(killer, names, sizeof(names));
    }
}

public Action:evtWitchKilled(Handle:event, const String:name[], bool:dontBroadcast)
{
    WitchCount--;
    if (WitchCountFull)
    {
        WitchCountFull = false;
        StartWitchWaitTimer(0.0);
    }
}

public OnMapEnd()
{
    RoundStarted = false;
    RoundEnded = true;
    LeftSafeRoom = false;
    //KillTimer(timer);

} 


[SEGA EMPRESS ERIS]

Left 4 Dead 2

Item Drop System | Chance / Roll

Special Infected drop items

Steam-SteamApps-common-left 4 dead 2-left4dead2-addons-sourcemod-scripting+

copy paste into a template|Blank "SP File" (make a copy|backup)

copy paste - drag and drop into "spcomp" file

it compiles the code then it becomes .SMX extension which is then read if in plugins folder.

where?
addons-sourcemod-plugins |drop|

all weapons

 
/*
New ConVars:
l4d_loot_witch_max 3   // max witches alive/any time.
l4d_loot_witch_map_max 10  // max witches/spawned per round.
l4d_loot_tank_max 1   // max tanks alive/any time.
l4d_loot_tank_map_max 5  // max tanks/spawned per round.
l4d_loot_panic_map_max 15 // max panic events per round.
l4d_loot_hunter_military_min 26
l4d_loot_hunter_military_max 30
l4d_loot_hunter_ak47_min 27
l4d_loot_hunter_ak47_max 32
l4d_loot_hunter_defibrillator_min 31
l4d_loot_hunter_defibrillator_max 35
l4d_loot_hunter_magnum_min 34
l4d_loot_hunter_magnum_max 40
l4d_loot_hunter_spas_min 37
l4d_loot_hunter_spas_max 43
l4d_loot_hunter_crowbar_min 40
l4d_loot_hunter_crowbar_max 46
l4d_loot_hunter_desert_min 43
l4d_loot_hunter_desert_max 47
l4d_loot_hunter_chainsaw_min 0
l4d_loot_hunter_chainsaw_max 0
l4d_loot_hunter_explosive_min 43
l4d_loot_hunter_explosive_max 49
l4d_loot_hunter_incendiary_min 45
l4d_loot_hunter_incendiary_max 50
l4d_loot_hunter_adrenaline_min 40
l4d_loot_hunter_adrenaline_max 50
l4d_loot_hunter_vomitjar_min 49
l4d_loot_hunter_vomitjar_max 50
(Repeat for all 8 classes)
(hunter,smoker,boomer,spitter,charger,jockey,witch,tank)
(Default Values)
1.4.1
Added Support for Left 4 Dead 2 items
and guns from North American release.
*/

#include <sourcemod>
#define CVAR_FLAGS FCVAR_PLUGIN
#define PLUGIN_VERSION "1.4"
#define ZOMBIECLASS_SMOKER 1
#define ZOMBIECLASS_BOOMER 2
#define ZOMBIECLASS_HUNTER 3
#define ZOMBIECLASS_SPITTER 4
#define ZOMBIECLASS_JOCKEY 5
#define ZOMBIECLASS_CHARGER 6
#define ZOMBIECLASS_WITCH 7
#define ZOMBIECLASS_TANK 8
#define LOOT_DIENUMBER  0
#define LOOT_DIECOUNT 1
#define LOOT_ITEM_COUNT 2
#define LOOT_KIT_MIN 3
#define LOOT_KIT_MAX 4
#define LOOT_PILLS_MIN 5
#define LOOT_PILLS_MAX 6
#define LOOT_MOLLY_MIN 7
#define LOOT_MOLLY_MAX 8
#define LOOT_PIPE_MIN 9
#define LOOT_PIPE_MAX 10
#define LOOT_PANIC_MIN 11
#define LOOT_PANIC_MAX 12
#define LOOT_TANK_MIN 13
#define LOOT_TANK_MAX 14
#define LOOT_WITCH_MIN 15
#define LOOT_WITCH_MAX 16
#define LOOT_COMMON_MIN 17
#define LOOT_COMMON_MAX 18
#define LOOT_PISTOL_MIN 19
#define LOOT_PISTOL_MAX 20
#define LOOT_SMG_MIN 21
#define LOOT_SMG_MAX 22
#define LOOT_SHOT_MIN 23
#define LOOT_SHOT_MAX 24
#define LOOT_RIFLE_MIN 25
#define LOOT_RIFLE_MAX 26
#define LOOT_AUTOSHOT_MIN 27
#define LOOT_AUTOSHOT_MAX 28
#define LOOT_SNIPER_MIN 29
#define LOOT_SNIPER_MAX 30
#define LOOT_MILITARY_MIN 31
#define LOOT_MILITARY_MAX 32
#define LOOT_AK47_MIN 33
#define LOOT_AK47_MAX 34
#define LOOT_DEFIBRILLATOR_MIN 35
#define LOOT_DEFIBRILLATOR_MAX 36
#define LOOT_MAGNUM_MIN 37
#define LOOT_MAGNUM_MAX 38
#define LOOT_SPAS_MIN 39
#define LOOT_SPAS_MAX 40
#define LOOT_CROWBAR_MIN 41
#define LOOT_CROWBAR_MAX 42
#define LOOT_DESERT_MIN 43
#define LOOT_DESERT_MAX 44
#define LOOT_CHAINSAW_MIN 45
#define LOOT_CHAINSAW_MAX 46
#define LOOT_EXPLOSIVE_MIN 47
#define LOOT_EXPLOSIVE_MAX 48
#define LOOT_INCENDIARY_MIN 49
#define LOOT_INCENDIARY_MAX 50
#define LOOT_ADRENALINE_MIN 51
#define LOOT_ADRENALINE_MAX 52
#define LOOT_VOMITJAR_MIN 53
#define LOOT_VOMITJAR_MAX 54
#define LOOT_AXE_MIN 55
#define LOOT_AXE_MAX 56
#define LOOT_TONFA_MIN 57
#define LOOT_TONFA_MAX 58
#define LOOT_FRYINGPAN_MIN 59
#define LOOT_FRYINGPAN_MAX 60
#define LOOT_GUITAR_MIN 61
#define LOOT_GUITAR_MAX 62
#define LOOT_BAT_MIN 63
#define LOOT_BAT_MAX 64
#define LOOT_KATANA_MIN 65
#define LOOT_KATANA_MAX 66
#define LOOT_MACHETE_MIN 67
#define LOOT_MACHETE_MAX 68
#define LOOT_CRICKETBAT_MIN 69
#define LOOT_CRICKETBAT_MAX 70
#define LOOT_GRENADELAUNCHER_MIN 71
#define LOOT_GRENADELAUNCHER_MAX 72
#define LOOT_M60_MIN 73
#define LOOT_M60_MAX 74
#define LOOT_GOLF_MIN 75
#define LOOT_GOLF_MAX 76
#define LOOT_SMGS_MIN 77
#define LOOT_SMGS_MAX 78
#define LOOT_CHROME_MIN 79
#define LOOT_CHROME_MAX 80
public Plugin:myinfo = 
{
 name = "[L4D2] Infected Loot",
 author = "Sourcemod Community",
 description = "L4D2 Random Infected Loot Drop System",
 version = PLUGIN_VERSION,
 url = "http://steamcommunity.com/groups/skyservers"
}
new Handle:CVarIsEnabled;
new Handle:CVarDieSides[4];
new Handle:CVarHunterLoot[100];
new Handle:CVarBoomerLoot[100];
new Handle:CVarSmokerLoot[100];
new Handle:CVarTankLoot[100];
new Handle:CVarSpitterLoot[100];
new Handle:CVarChargerLoot[100];
new Handle:CVarJockeyLoot[100];
new Handle:CVarWitchLoot[100];
new Handle: tankMax;
new Handle: witchMax;
new Handle: witchMapMax;
new Handle: tankMapMax;
new Handle: panicMax;
new numTank;
new numTankMax;
new tankSpawn;
new numWitch;
new numWitchMax;
new witchSpawn;
new numPanic;
new HunterLoot[100];
new BoomerLoot[100];
new SmokerLoot[100];
new SpitterLoot[100];
new ChargerLoot[100];
new JockeyLoot[100];
new TankLoot[100];
new WitchLoot[100];
new Dice[4];
 
public OnPluginStart()
{
 SetRandomSeed(GetSysTickCount());
 
 CreateConVar("l4d2_loot_ver", PLUGIN_VERSION, "Version of the infected loot drops plugins.", FCVAR_PLUGIN|FCVAR_SPONLY|FCVAR_NOTIFY);
 
 CVarIsEnabled = CreateConVar("l4d_loot_enabled", "1", "Is the plugin enabled.", FCVAR_PLUGIN);
 HookConVarChange(CVarIsEnabled, Loot_EnableDisable);
 HookEvent("round_start", Event_RoundStart); // Allow tank, witch, panic limit/round.
 
 tankMax = CreateConVar("l4d_loot_tank_max","0","Number of tanks allowed to spawn/live at a time/round.",CVAR_FLAGS,true,0.0);
 witchMax = CreateConVar("l4d_loot_witch_max","0","Number of witches allowed to spawn/live at a time/round.",CVAR_FLAGS,true,0.0);
 tankMapMax = CreateConVar("l4d_loot_tank_map_max","0","Total Number of Tanks plugin can spawn per map.",CVAR_FLAGS,true,0.0);
 witchMapMax = CreateConVar("l4d_loot_witch_map_max","0","Total Number of Witches plugin can spawn per map.",CVAR_FLAGS,true,0.0);
 panicMax = CreateConVar("l4d_loot_panic_map_max","0","Total Number of Witches plugin can spawn per map.",CVAR_FLAGS,true,0.0);
 CVarDieSides[0] = CreateConVar("l4d_loot_dice1_sides", "50", "How many sides die 1 has.", FCVAR_PLUGIN);
 CVarDieSides[1] = CreateConVar("l4d_loot_dice2_sides", "50", "How many sides die 2 has.", FCVAR_PLUGIN);
 CVarDieSides[2] = CreateConVar("l4d_loot_dice3_sides", "40", "How many sides die 3 has.", FCVAR_PLUGIN);
 CVarDieSides[3] = CreateConVar("l4d_loot_dice4_sides", "100", "How many sides die 4 has.", FCVAR_PLUGIN);
  
 CVarHunterLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_hunter_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarHunterLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_hunter_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarHunterLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_hunter_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarHunterLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_hunter_kit_min", "1", "Min die number for a hunter to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_hunter_kit_max", "11", "Max die number for a hunter to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_hunter_pills_min", "90", "Min die number for a hunter to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_hunter_pills_max", "100", "Max die number for a hunter to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_hunter_molly_min", "12", "Min die number for a hunter to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_hunter_molly_max", "17", "Max die number for a hunter to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_hunter_pipe_min", "84", "Min die number for a hunter to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_hunter_pipe_max", "89", "Max die number for a hunter to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarHunterLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_hunter_panic_min", "0", "Min die number for a hunter to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_hunter_panic_max", "0", "Max die number for a hunter to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_hunter_tankspawn_min", "0", "Min die number for a hunter to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_hunter_tankspawn_max", "0", "Max die number for a hunter to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_hunter_witchspawn_min", "0", "Min die number for a hunter to cause a hunter to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_hunter_witchspawn_max", "0", "Max die number for a hunter to cause a hunter to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_hunter_common_min", "0", "Min die number for a hunter to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_hunter_common_max", "0", "Max die number for a hunter to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarHunterLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_hunter_pistol_min", "22",  "Min die number for a hunter to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_hunter_pistol_max", "22",  "Max die number for a hunter to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_hunter_smg_min", "23", "Min die number for a hunter to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_hunter_smg_max", "23", "Max die number for a hunter to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_hunter_shotgun_min", "26", "Min die number for a hunter to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_hunter_shotgun_max", "26", "Max die number for a hunter to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_hunter_rifle_min", "29", "Min die number for a hunter to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_hunter_rifle_max", "29", "Max die number for a hunter to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_hunter_autoshot_min", "31", "Min die number for a hunter to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_hunter_autoshot_max", "31", "Max die number for a hunter to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_hunter_sniper_min", "32", "Min die number for a hunter to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_hunter_sniper_max", "32", "Max die number for a hunter to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarHunterLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_hunter_military_min", "83", "Min die number for a hunter to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_hunter_military_max", "83", "Max die number for a hunter to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_hunter_ak47_min", "82", "Min die number for a hunter to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_hunter_ak47_max", "82", "Max die number for a hunter to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_hunter_defibrillator_min", "63", "Min die number for a hunter to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_hunter_defibrillator_max", "67", "Max die number for a hunter to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_hunter_magnum_min", "81", "Min die number for a hunter to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_hunter_magnum_max", "81", "Max die number for a hunter to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_hunter_spas_min", "80", "Min die number for a hunter to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_hunter_spas_max", "80", "Max die number for a hunter to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_hunter_crowbar_min", "70", "Min die number for a hunter to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_hunter_crowbar_max", "70", "Max die number for a hunter to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_hunter_desert_min", "62", "Min die number for a hunter to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_hunter_desert_max", "62", "Max die number for a hunter to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_hunter_chainsaw_min", "71", "Min die number for a hunter to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_hunter_chainsaw_max", "71", "Max die number for a hunter to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_hunter_explosive_min", "61", "Min die number for a hunter to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_hunter_explosive_max", "61", "Max die number for a hunter to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_hunter_incendiary_min", "60", "Min die number for a hunter to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_hunter_incendiary_max", "60", "Max die number for a hunter to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_hunter_adrenaline_min", "49", "Min die number for a hunter to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_hunter_adrenaline_max", "59", "Max die number for a hunter to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_hunter_vomitjar_min", "35", "Min die number for a hunter to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_hunter_vomitjar_max", "35", "Max die number for a hunter to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_hunter_axe_min", "72", "Min die number for a hunter to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_hunter_axe_max", "72", "Max die number for a hunter to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_hunter_tonfa_min", "73", "Min die number for a hunter to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_hunter_tonfa_max", "73", "Max die number for a hunter to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_hunter_fryingpan_min", "74", "Min die number for a hunter to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_hunter_fryingpan_max", "74", "Max die number for a hunter to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_hunter_guitar_min", "75", "Min die number for a hunter to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_hunter_guitar_max", "75", "Max die number for a hunter to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_hunter_bat_min", "76", "Min die number for a hunter to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_hunter_bat_max", "76", "Max die number for a hunter to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_hunter_katana_min", "77", "Min die number for a hunter to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_hunter_katana_max", "77", "Max die number for a hunter to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_hunter_machete_min", "78", "Min die number for a hunter to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_hunter_machete_max", "78", "Max die number for a hunter to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_hunter_cricketbat_min", "79", "Min die number for a hunter to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_hunter_cricketbat_max", "79", "Max die number for a hunter to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_hunter_grenadelauncher_min", "68", "Min die number for a hunter to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_hunter_grenadelauncher_max", "68", "Max die number for a hunter to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_hunter_m60_min", "69", "Min die number for a hunter to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_hunter_m60_max", "69", "Max die number for a hunter to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_hunter_golf_min", "18", "Min die number for a hunter to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_hunter_golf_max", "18", "Max die number for a hunter to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_hunter_smgs_min", "19", "Min die number for a hunter to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_hunter_smgs_max", "19", "Max die number for a hunter to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_hunter_chrome_min", "20", "Min die number for a hunter to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarHunterLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_hunter_chrome_max", "20", "Max die number for a hunter to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 
 CVarBoomerLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_boomer_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarBoomerLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_boomer_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarBoomerLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_boomer_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarBoomerLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_boomer_kit_min", "90", "Min die number for a boomer to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_boomer_kit_max", "100", "Max die number for a boomer to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_boomer_pills_min", "79", "Min die number for a boomer to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_boomer_pills_max", "89", "Max die number for a boomer to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_boomer_molly_min", "1", "Min die number for a boomer to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_boomer_molly_max", "11", "Max die number for a boomer to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_boomer_pipe_min", "12", "Min die number for a boomer to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_boomer_pipe_max", "22", "Max die number for a boomer to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarBoomerLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_boomer_panic_min", "0", "Min die number for a boomer to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_boomer_panic_max", "0", "Max die number for a boomer to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_boomer_tankspawn_min", "0", "Min die number for a boomer to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_boomer_tankspawn_max", "0", "Max die number for a boomer to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_boomer_witchspawn_min", "0", "Min die number for a boomer to cause a boomer to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_boomer_witchspawn_max", "0", "Max die number for a boomer to cause a boomer to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_boomer_common_min", "0", "Min die number for a boomer to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_boomer_common_max", "0", "Max die number for a boomer to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarBoomerLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_boomer_pistol_min", "23",  "Min die number for a boomer to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_boomer_pistol_max", "23",  "Max die number for a boomer to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_boomer_smg_min", "0", "Min die number for a boomer to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_boomer_smg_max", "0", "Max die number for a boomer to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_boomer_shotgun_min", "0", "Min die number for a boomer to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_boomer_shotgun_max", "0", "Max die number for a boomer to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_boomer_rifle_min", "0", "Min die number for a boomer to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_boomer_rifle_max", "0", "Max die number for a boomer to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_boomer_autoshot_min", "0", "Min die number for a boomer to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_boomer_autoshot_max", "0", "Max die number for a boomer to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_boomer_sniper_min", "0", "Min die number for a boomer to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_boomer_sniper_max", "0", "Max die number for a boomer to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarBoomerLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_boomer_military_min", "0", "Min die number for a boomer to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_boomer_military_max", "0", "Max die number for a boomer to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_boomer_ak47_min", "0", "Min die number for a boomer to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_boomer_ak47_max", "0", "Max die number for a boomer to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_boomer_defibrillator_min", "30", "Min die number for a boomer to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_boomer_defibrillator_max", "35", "Max die number for a boomer to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_boomer_magnum_min", "36", "Min die number for a boomer to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_boomer_magnum_max", "41", "Max die number for a boomer to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_boomer_spas_min", "0", "Min die number for a boomer to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_boomer_spas_max", "0", "Max die number for a boomer to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_boomer_crowbar_min", "42", "Min die number for a boomer to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_boomer_crowbar_max", "42", "Max die number for a boomer to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_boomer_desert_min", "0", "Min die number for a boomer to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_boomer_desert_max", "0", "Max die number for a boomer to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_boomer_chainsaw_min", "51", "Min die number for a boomer to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_boomer_chainsaw_max", "52", "Max die number for a boomer to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_boomer_explosive_min", "53", "Min die number for a boomer to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_boomer_explosive_max", "53", "Max die number for a boomer to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_boomer_incendiary_min", "54", "Min die number for a boomer to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_boomer_incendiary_max", "54", "Max die number for a boomer to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_boomer_adrenaline_min", "60", "Min die number for a boomer to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_boomer_adrenaline_max", "70", "Max die number for a boomer to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_boomer_vomitjar_min", "55", "Min die number for a boomer to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_boomer_vomitjar_max", "55", "Max die number for a boomer to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_boomer_axe_min", "43", "Min die number for a boomer to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_boomer_axe_max", "43", "Max die number for a boomer to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_boomer_tonfa_min", "44", "Min die number for a boomer to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_boomer_tonfa_max", "44", "Max die number for a boomer to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_boomer_fryingpan_min", "45", "Min die number for a boomer to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_boomer_fryingpan_max", "45", "Max die number for a boomer to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_boomer_guitar_min", "46", "Min die number for a boomer to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_boomer_guitar_max", "46", "Max die number for a boomer to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_boomer_bat_min", "47", "Min die number for a boomer to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_boomer_bat_max", "47", "Max die number for a boomer to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_boomer_katana_min", "48", "Min die number for a boomer to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_boomer_katana_max", "48", "Max die number for a boomer to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_boomer_machete_min", "49", "Min die number for a boomer to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_boomer_machete_max", "49", "Max die number for a boomer to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_boomer_cricketbat_min", "50", "Min die number for a boomer to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_boomer_cricketbat_max", "50", "Max die number for a boomer to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_boomer_grenadelauncher_min", "0", "Min die number for a boomer to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_boomer_grenadelauncher_max", "0", "Max die number for a boomer to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_boomer_m60_min", "0", "Min die number for a boomer to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_boomer_m60_max", "0", "Max die number for a boomer to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_boomer_golf_min", "26", "Min die number for a boomer to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_boomer_golf_max", "26", "Max die number for a boomer to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_boomer_smgs_min", "27", "Min die number for a boomer to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_boomer_smgs_max", "27", "Max die number for a boomer to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_boomer_chrome_min", "28", "Min die number for a boomer to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarBoomerLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_boomer_chrome_max", "28", "Max die number for a boomer to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 

 CVarSmokerLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_smoker_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarSmokerLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_smoker_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarSmokerLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_smoker_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarSmokerLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_smoker_kit_min", "50", "Min die number for a smoker to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_smoker_kit_max", "60", "Max die number for a smoker to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_smoker_pills_min", "61", "Min die number for a smoker to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_smoker_pills_max", "71", "Max die number for a smoker to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_smoker_molly_min", "5", "Min die number for a smoker to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_smoker_molly_max", "11", "Max die number for a smoker to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_smoker_pipe_min", "7", "Min die number for a smoker to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_smoker_pipe_max", "12", "Max die number for a smoker to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarSmokerLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_smoker_panic_min", "0", "Min die number for a smoker to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_smoker_panic_max", "0", "Max die number for a smoker to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_smoker_tankspawn_min", "0", "Min die number for a smoker to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_smoker_tankspawn_max", "0", "Max die number for a smoker to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_smoker_witchspawn_min", "0", "Min die number for a smoker to cause a smoker to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_smoker_witchspawn_max", "0", "Max die number for a smoker to cause a smoker to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_smoker_common_min", "0", "Min die number for a smoker to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_smoker_common_max", "0", "Max die number for a smoker to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarSmokerLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_smoker_pistol_min", "20",  "Min die number for a smoker to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_smoker_pistol_max", "25",  "Max die number for a smoker to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_smoker_smg_min", "26", "Min die number for a smoker to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_smoker_smg_max", "26", "Max die number for a smoker to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_smoker_shotgun_min", "27", "Min die number for a smoker to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_smoker_shotgun_max", "27", "Max die number for a smoker to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_smoker_rifle_min", "28", "Min die number for a smoker to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_smoker_rifle_max", "28", "Max die number for a smoker to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_smoker_autoshot_min", "30", "Min die number for a smoker to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_smoker_autoshot_max", "30", "Max die number for a smoker to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_smoker_sniper_min", "31", "Min die number for a smoker to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_smoker_sniper_max", "31", "Max die number for a smoker to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarSmokerLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_smoker_military_min", "32", "Min die number for a smoker to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_smoker_military_max", "32", "Max die number for a smoker to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_smoker_ak47_min", "42", "Min die number for a smoker to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_smoker_ak47_max", "42", "Max die number for a smoker to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_smoker_defibrillator_min", "90", "Min die number for a smoker to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_smoker_defibrillator_max", "95", "Max die number for a smoker to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_smoker_magnum_min", "33", "Min die number for a smoker to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_smoker_magnum_max", "37", "Max die number for a smoker to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_smoker_spas_min", "43", "Min die number for a smoker to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_smoker_spas_max", "43", "Max die number for a smoker to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_smoker_crowbar_min", "49", "Min die number for a smoker to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_smoker_crowbar_max", "49", "Max die number for a smoker to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_smoker_desert_min", "1", "Min die number for a smoker to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_smoker_desert_max", "1", "Max die number for a smoker to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_smoker_chainsaw_min", "98", "Min die number for a smoker to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_smoker_chainsaw_max", "98", "Max die number for a smoker to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_smoker_explosive_min", "2", "Min die number for a smoker to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_smoker_explosive_max", "2", "Max die number for a smoker to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_smoker_incendiary_min", "3", "Min die number for a smoker to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_smoker_incendiary_max", "3", "Max die number for a smoker to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_smoker_adrenaline_min", "79", "Min die number for a smoker to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_smoker_adrenaline_max", "89", "Max die number for a smoker to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_smoker_vomitjar_min", "4", "Min die number for a smoker to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_smoker_vomitjar_max", "4", "Max die number for a smoker to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_smoker_axe_min", "96", "Min die number for a smoker to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_smoker_axe_max", "96", "Max die number for a smoker to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_smoker_tonfa_min", "47", "Min die number for a smoker to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_smoker_tonfa_max", "47", "Max die number for a smoker to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_smoker_fryingpan_min", "48", "Min die number for a smoker to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_smoker_fryingpan_max", "48", "Max die number for a smoker to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_smoker_guitar_min", "46", "Min die number for a smoker to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_smoker_guitar_max", "46", "Max die number for a smoker to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_smoker_bat_min", "45", "Min die number for a smoker to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_smoker_bat_max", "45", "Max die number for a smoker to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_smoker_katana_min", "38", "Min die number for a smoker to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_smoker_katana_max", "38", "Max die number for a smoker to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_smoker_machete_min", "44", "Min die number for a smoker to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_smoker_machete_max", "44", "Max die number for a smoker to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_smoker_cricketbat_min", "97", "Min die number for a smoker to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_smoker_cricketbat_max", "97", "Max die number for a smoker to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_smoker_grenadelauncher_min", "99", "Min die number for a smoker to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_smoker_grenadelauncher_max", "99", "Max die number for a smoker to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_smoker_m60_min", "100", "Min die number for a smoker to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_smoker_m60_max", "100", "Max die number for a smoker to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_smoker_golf_min", "13", "Min die number for a smoker to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_smoker_golf_max", "14", "Max die number for a smoker to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_smoker_smgs_min", "17", "Min die number for a smoker to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_smoker_smgs_max", "19", "Max die number for a smoker to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_smoker_chrome_min", "15", "Min die number for a smoker to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarSmokerLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_smoker_chrome_max", "16", "Max die number for a smoker to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 
 CVarSpitterLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_spitter_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarSpitterLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_spitter_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarSpitterLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_spitter_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarSpitterLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_spitter_kit_min", "1", "Min die number for a spitter to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_spitter_kit_max", "11", "Max die number for a spitter to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_spitter_pills_min", "90", "Min die number for a spitter to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_spitter_pills_max", "100", "Max die number for a spitter to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_spitter_molly_min", "71", "Min die number for a spitter to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_spitter_molly_max", "79", "Max die number for a spitter to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_spitter_pipe_min", "14", "Min die number for a spitter to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_spitter_pipe_max", "19", "Max die number for a spitter to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarSpitterLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_spitter_panic_min", "0", "Min die number for a spitter to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_spitter_panic_max", "0", "Max die number for a spitter to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_spitter_tankspawn_min", "0", "Min die number for a spitter to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_spitter_tankspawn_max", "0", "Max die number for a spitter to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_spitter_witchspawn_min", "0", "Min die number for a spitter to cause a spitter to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_spitter_witchspawn_max", "0", "Max die number for a spitter to cause a spitter to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_spitter_common_min", "0", "Min die number for a spitter to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_spitter_common_max", "0", "Max die number for a spitter to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarSpitterLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_spitter_pistol_min", "20",  "Min die number for a spitter to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_spitter_pistol_max", "20",  "Max die number for a spitter to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_spitter_smg_min", "22", "Min die number for a spitter to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_spitter_smg_max", "22", "Max die number for a spitter to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_spitter_shotgun_min", "24", "Min die number for a spitter to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_spitter_shotgun_max", "24", "Max die number for a spitter to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_spitter_rifle_min", "80", "Min die number for a spitter to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_spitter_rifle_max", "80", "Max die number for a spitter to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_spitter_autoshot_min", "81", "Min die number for a spitter to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_spitter_autoshot_max", "81", "Max die number for a spitter to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_spitter_sniper_min", "82", "Min die number for a spitter to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_spitter_sniper_max", "82", "Max die number for a spitter to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarSpitterLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_spitter_military_min", "84", "Min die number for a spitter to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_spitter_military_max", "84", "Max die number for a spitter to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_spitter_ak47_min", "85", "Min die number for a spitter to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_spitter_ak47_max", "85", "Max die number for a spitter to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_spitter_defibrillator_min", "30", "Min die number for a spitter to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_spitter_defibrillator_max", "35", "Max die number for a spitter to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_spitter_magnum_min", "28", "Min die number for a spitter to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_spitter_magnum_max", "28", "Max die number for a spitter to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_spitter_spas_min", "83", "Min die number for a spitter to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_spitter_spas_max", "83", "Max die number for a spitter to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_spitter_crowbar_min", "12", "Min die number for a spitter to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_spitter_crowbar_max", "12", "Max die number for a spitter to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_spitter_desert_min", "41", "Min die number for a spitter to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_spitter_desert_max", "41", "Max die number for a spitter to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_spitter_chainsaw_min", "0", "Min die number for a spitter to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_spitter_chainsaw_max", "0", "Max die number for a spitter to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_spitter_explosive_min", "42", "Min die number for a spitter to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_spitter_explosive_max", "42", "Max die number for a spitter to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_spitter_incendiary_min", "43", "Min die number for a spitter to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_spitter_incendiary_max", "43", "Max die number for a spitter to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_spitter_adrenaline_min", "60", "Min die number for a spitter to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_spitter_adrenaline_max", "70", "Max die number for a spitter to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_spitter_vomitjar_min", "44", "Min die number for a spitter to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_spitter_vomitjar_max", "44", "Max die number for a spitter to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_spitter_axe_min", "45", "Min die number for a spitter to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_spitter_axe_max", "45", "Max die number for a spitter to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_spitter_tonfa_min", "46", "Min die number for a spitter to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_spitter_tonfa_max", "46", "Max die number for a spitter to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_spitter_fryingpan_min", "47", "Min die number for a spitter to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_spitter_fryingpan_max", "47", "Max die number for a spitter to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_spitter_guitar_min", "48", "Min die number for a spitter to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_spitter_guitar_max", "48", "Max die number for a spitter to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_spitter_bat_min", "49", "Min die number for a spitter to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_spitter_bat_max", "49", "Max die number for a spitter to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_spitter_katana_min", "50", "Min die number for a spitter to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_spitter_katana_max", "50", "Max die number for a spitter to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_spitter_machete_min", "51", "Min die number for a spitter to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_spitter_machete_max", "51", "Max die number for a spitter to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_spitter_cricketbat_min", "52", "Min die number for a spitter to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_spitter_cricketbat_max", "52", "Max die number for a spitter to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_spitter_grenadelauncher_min", "53", "Min die number for a spitter to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_spitter_grenadelauncher_max", "53", "Max die number for a spitter to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_spitter_m60_min", "54", "Min die number for a spitter to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_spitter_m60_max", "54", "Max die number for a spitter to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_spitter_golf_min", "55", "Min die number for a spitter to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_spitter_golf_max", "55", "Max die number for a spitter to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_spitter_smgs_min", "56", "Min die number for a spitter to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_spitter_smgs_max", "56", "Max die number for a spitter to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_spitter_chrome_min", "57", "Min die number for a spitter to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarSpitterLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_spitter_chrome_max", "57", "Max die number for a spitter to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 
 CVarChargerLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_charger_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarChargerLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_charger_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarChargerLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_charger_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarChargerLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_charger_kit_min", "12", "Min die number for a charger to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_charger_kit_max", "22", "Max die number for a charger to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_charger_pills_min", "1", "Min die number for a charger to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_charger_pills_max", "11", "Max die number for a charger to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_charger_molly_min", "90", "Min die number for a charger to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_charger_molly_max", "99", "Max die number for a charger to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_charger_pipe_min", "54", "Min die number for a charger to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_charger_pipe_max", "59", "Max die number for a charger to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarChargerLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_charger_panic_min", "0", "Min die number for a charger to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_charger_panic_max", "0", "Max die number for a charger to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_charger_tankspawn_min", "0", "Min die number for a charger to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_charger_tankspawn_max", "0", "Max die number for a charger to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_charger_witchspawn_min", "0", "Min die number for a charger to cause a charger to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_charger_witchspawn_max", "0", "Max die number for a charger to cause a charger to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_charger_common_min", "0", "Min die number for a charger to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_charger_common_max", "0", "Max die number for a charger to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarChargerLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_charger_pistol_min", "25",  "Min die number for a charger to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_charger_pistol_max", "25",  "Max die number for a charger to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_charger_smg_min", "31", "Min die number for a charger to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_charger_smg_max", "31", "Max die number for a charger to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_charger_shotgun_min", "33", "Min die number for a charger to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_charger_shotgun_max", "33", "Max die number for a charger to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_charger_rifle_min", "36", "Min die number for a charger to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_charger_rifle_max", "36", "Max die number for a charger to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_charger_autoshot_min", "37", "Min die number for a charger to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_charger_autoshot_max", "37", "Max die number for a charger to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_charger_sniper_min", "38", "Min die number for a charger to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_charger_sniper_max", "38", "Max die number for a charger to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarChargerLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_charger_military_min", "39", "Min die number for a charger to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_charger_military_max", "39", "Max die number for a charger to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_charger_ak47_min", "51", "Min die number for a charger to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_charger_ak47_max", "51", "Max die number for a charger to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_charger_defibrillator_min", "79", "Min die number for a charger to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_charger_defibrillator_max", "83", "Max die number for a charger to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_charger_magnum_min", "52", "Min die number for a charger to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_charger_magnum_max", "52", "Max die number for a charger to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_charger_spas_min", "53", "Min die number for a charger to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_charger_spas_max", "53", "Max die number for a charger to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_charger_crowbar_min", "24", "Min die number for a charger to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_charger_crowbar_max", "24", "Max die number for a charger to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_charger_desert_min", "65", "Min die number for a charger to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_charger_desert_max", "65", "Max die number for a charger to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_charger_chainsaw_min", "23", "Min die number for a charger to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_charger_chainsaw_max", "23", "Max die number for a charger to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_charger_explosive_min", "66", "Min die number for a charger to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_charger_explosive_max", "66", "Max die number for a charger to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_charger_incendiary_min", "67", "Min die number for a charger to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_charger_incendiary_max", "67", "Max die number for a charger to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_charger_adrenaline_min", "40", "Min die number for a charger to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_charger_adrenaline_max", "50", "Max die number for a charger to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_charger_vomitjar_min", "68", "Min die number for a charger to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_charger_vomitjar_max", "68", "Max die number for a charger to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_charger_axe_min", "35", "Min die number for a charger to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_charger_axe_max", "35", "Max die number for a charger to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_charger_tonfa_min", "99", "Min die number for a charger to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_charger_tonfa_max", "99", "Max die number for a charger to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_charger_fryingpan_min", "64", "Min die number for a charger to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_charger_fryingpan_max", "64", "Max die number for a charger to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_charger_guitar_min", "32", "Min die number for a charger to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_charger_guitar_max", "32", "Max die number for a charger to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_charger_bat_min", "30", "Min die number for a charger to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_charger_bat_max", "30", "Max die number for a charger to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_charger_katana_min", "29", "Min die number for a charger to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_charger_katana_max", "29", "Max die number for a charger to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_charger_machete_min", "28", "Min die number for a charger to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_charger_machete_max", "28", "Max die number for a charger to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_charger_cricketbat_min", "27", "Min die number for a charger to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_charger_cricketbat_max", "27", "Max die number for a charger to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_charger_grenadelauncher_min", "26", "Min die number for a charger to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_charger_grenadelauncher_max", "26", "Max die number for a charger to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_charger_m60_min", "84", "Min die number for a charger to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_charger_m60_max", "84", "Max die number for a charger to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_charger_golf_min", "60", "Min die number for a charger to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_charger_golf_max", "60", "Max die number for a charger to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_charger_smgs_min", "61", "Min die number for a charger to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_charger_smgs_max", "61", "Max die number for a charger to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_charger_chrome_min", "62", "Min die number for a charger to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarChargerLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_charger_chrome_max", "62", "Max die number for a charger to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 
 CVarJockeyLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_jockey_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarJockeyLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_jockey_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarJockeyLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_jockey_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarJockeyLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_jockey_kit_min", "70", "Min die number for a jockey to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_jockey_kit_max", "80", "Max die number for a jockey to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_jockey_pills_min", "20", "Min die number for a jockey to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_jockey_pills_max", "30", "Max die number for a jockey to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_jockey_molly_min", "1", "Min die number for a jockey to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_jockey_molly_max", "10", "Max die number for a jockey to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_jockey_pipe_min", "90", "Min die number for a jockey to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_jockey_pipe_max", "100", "Max die number for a jockey to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarJockeyLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_jockey_panic_min", "0", "Min die number for a jockey to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_jockey_panic_max", "0", "Max die number for a jockey to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_jockey_tankspawn_min", "0", "Min die number for a jockey to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_jockey_tankspawn_max", "0", "Max die number for a jockey to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_jockey_witchspawn_min", "0", "Min die number for a jockey to cause a jockey to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_jockey_witchspawn_max", "0", "Max die number for a jockey to cause a jockey to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_jockey_common_min", "0", "Min die number for a jockey to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_jockey_common_max", "0", "Max die number for a jockey to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarJockeyLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_jockey_pistol_min", "21",  "Min die number for a jockey to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_jockey_pistol_max", "29",  "Max die number for a jockey to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_jockey_smg_min", "30", "Min die number for a jockey to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_jockey_smg_max", "35", "Max die number for a jockey to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_jockey_shotgun_min", "0", "Min die number for a jockey to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_jockey_shotgun_max", "0", "Max die number for a jockey to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_jockey_rifle_min", "0", "Min die number for a jockey to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_jockey_rifle_max", "0", "Max die number for a jockey to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_jockey_autoshot_min", "0", "Min die number for a jockey to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_jockey_autoshot_max", "0", "Max die number for a jockey to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_jockey_sniper_min", "0", "Min die number for a jockey to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_jockey_sniper_max", "0", "Max die number for a jockey to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarJockeyLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_jockey_military_min", "0", "Min die number for a jockey to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_jockey_military_max", "0", "Max die number for a jockey to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_jockey_ak47_min", "0", "Min die number for a jockey to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_jockey_ak47_max", "0", "Max die number for a jockey to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_jockey_defibrillator_min", "12", "Min die number for a jockey to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_jockey_defibrillator_max", "16", "Max die number for a jockey to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_jockey_magnum_min", "36", "Min die number for a jockey to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_jockey_magnum_max", "41", "Max die number for a jockey to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_jockey_spas_min", "0", "Min die number for a jockey to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_jockey_spas_max", "0", "Max die number for a jockey to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_jockey_crowbar_min", "42", "Min die number for a jockey to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_jockey_crowbar_max", "42", "Max die number for a jockey to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_jockey_desert_min", "0", "Min die number for a jockey to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_jockey_desert_max", "0", "Max die number for a jockey to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_jockey_chainsaw_min", "0", "Min die number for a jockey to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_jockey_chainsaw_max", "0", "Max die number for a jockey to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_jockey_explosive_min", "65", "Min die number for a jockey to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_jockey_explosive_max", "67", "Max die number for a jockey to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_jockey_incendiary_min", "62", "Min die number for a jockey to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_jockey_incendiary_max", "64", "Max die number for a jockey to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_jockey_adrenaline_min", "50", "Min die number for a jockey to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_jockey_adrenaline_max", "60", "Max die number for a jockey to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_jockey_vomitjar_min", "61", "Min die number for a jockey to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_jockey_vomitjar_max", "61", "Max die number for a jockey to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_jockey_axe_min", "43", "Min die number for a jockey to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_jockey_axe_max", "43", "Max die number for a jockey to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_jockey_tonfa_min", "44", "Min die number for a jockey to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_jockey_tonfa_max", "44", "Max die number for a jockey to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_jockey_fryingpan_min", "45", "Min die number for a jockey to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_jockey_fryingpan_max", "45", "Max die number for a jockey to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_jockey_guitar_min", "46", "Min die number for a jockey to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_jockey_guitar_max", "46", "Max die number for a jockey to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_jockey_bat_min", "47", "Min die number for a jockey to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_jockey_bat_max", "47", "Max die number for a jockey to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_jockey_katana_min", "48", "Min die number for a jockey to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_jockey_katana_max", "48", "Max die number for a jockey to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_jockey_machete_min", "49", "Min die number for a jockey to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_jockey_machete_max", "49", "Max die number for a jockey to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_jockey_cricketbat_min", "11", "Min die number for a jockey to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_jockey_cricketbat_max", "11", "Max die number for a jockey to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_jockey_grenadelauncher_min", "0", "Min die number for a jockey to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_jockey_grenadelauncher_max", "0", "Max die number for a jockey to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_jockey_m60_min", "0", "Min die number for a jockey to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_jockey_m60_max", "0", "Max die number for a jockey to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_jockey_golf_min", "67", "Min die number for a jockey to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_jockey_golf_max", "67", "Max die number for a jockey to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_jockey_smgs_min", "68", "Min die number for a jockey to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_jockey_smgs_max", "68", "Max die number for a jockey to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_jockey_chrome_min", "69", "Min die number for a jockey to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarJockeyLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_jockey_chrome_max", "69", "Max die number for a jockey to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 
 CVarTankLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_tank_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarTankLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_tank_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarTankLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_tank_item_count", "2", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarTankLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_tank_kit_min", "1", "Min die number for a tank to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_tank_kit_max", "11", "Max die number for a tank to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_tank_pills_min", "12", "Min die number for a tank to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_tank_pills_max", "22", "Max die number for a tank to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_tank_molly_min", "61", "Min die number for a tank to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_tank_molly_max", "70", "Max die number for a tank to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_tank_pipe_min", "72", "Min die number for a tank to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_tank_pipe_max", "80", "Max die number for a tank to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarTankLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_tank_panic_min", "0", "Min die number for a tank to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_tank_panic_max", "0", "Max die number for a tank to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_tank_tankspawn_min", "0", "Min die number for a tank to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_tank_tankspawn_max", "0", "Max die number for a tank to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_tank_witchspawn_min", "0", "Min die number for a tank to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_tank_witchspawn_max", "0", "Max die number for a tank to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_tank_common_min", "0", "Min die number for a tank to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_tank_common_max", "0", "Max die number for a tank to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarTankLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_tank_pistol_min", "45",  "Min die number for a tank to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_tank_pistol_max", "45",  "Max die number for a tank to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_tank_smg_min", "46", "Min die number for a tank to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_tank_smg_max", "46", "Max die number for a tank to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_tank_shotgun_min", "47", "Min die number for a tank to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_tank_shotgun_max", "47", "Max die number for a tank to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_tank_rifle_min", "48", "Min die number for a tank to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_tank_rifle_max", "48", "Max die number for a tank to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_tank_autoshot_min", "49", "Min die number for a tank to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_tank_autoshot_max", "49", "Max die number for a tank to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_tank_sniper_min", "71", "Min die number for a tank to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_tank_sniper_max", "71", "Max die number for a tank to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarTankLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_tank_military_min", "81", "Min die number for a tank to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_tank_military_max", "81", "Max die number for a tank to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_tank_ak47_min", "82", "Min die number for a tank to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_tank_ak47_max", "82", "Max die number for a tank to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_tank_defibrillator_min", "23", "Min die number for a tank to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_tank_defibrillator_max", "27", "Max die number for a tank to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_tank_magnum_min", "83", "Min die number for a tank to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_tank_magnum_max", "83", "Max die number for a tank to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_tank_spas_min", "84", "Min die number for a tank to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_tank_spas_max", "84", "Max die number for a tank to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_tank_crowbar_min", "50", "Min die number for a tank to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_tank_crowbar_max", "50", "Max die number for a tank to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_tank_desert_min", "86", "Min die number for a tank to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_tank_desert_max", "86", "Max die number for a tank to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_tank_chainsaw_min", "100", "Min die number for a tank to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_tank_chainsaw_max", "100", "Max die number for a tank to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_tank_explosive_min", "87", "Min die number for a tank to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_tank_explosive_max", "87", "Max die number for a tank to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_tank_incendiary_min", "88", "Min die number for a tank to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_tank_incendiary_max", "88", "Max die number for a tank to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_tank_adrenaline_min", "34", "Min die number for a tank to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_tank_adrenaline_max", "44", "Max die number for a tank to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_tank_vomitjar_min", "89", "Min die number for a tank to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_tank_vomitjar_max", "89", "Max die number for a tank to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AXE_MIN] = CreateConVar("l4d_loot_tank_axe_min", "51", "Min die number for a tank to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_AXE_MAX] = CreateConVar("l4d_loot_tank_axe_max", "51", "Max die number for a tank to drop a fireaxe.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_TONFA_MIN] = CreateConVar("l4d_loot_tank_tonfa_min", "52", "Min die number for a tank to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_TONFA_MAX] = CreateConVar("l4d_loot_tank_tonfa_max", "52", "Max die number for a tank to drop a tonfa.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_FRYINGPAN_MIN] = CreateConVar("l4d_loot_tank_fryingpan_min", "53", "Min die number for a tank to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_FRYINGPAN_MAX] = CreateConVar("l4d_loot_tank_fryingpan_max", "53", "Max die number for a tank to drop a frying pan.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GUITAR_MIN] = CreateConVar("l4d_loot_tank_guitar_min", "54", "Min die number for a tank to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GUITAR_MAX] = CreateConVar("l4d_loot_tank_guitar_max", "54", "Max die number for a tank to drop a guitar.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_BAT_MIN] = CreateConVar("l4d_loot_tank_bat_min", "55", "Min die number for a tank to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_BAT_MAX] = CreateConVar("l4d_loot_tank_bat_max", "55", "Max die number for a tank to drop a baseball bat.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_KATANA_MIN] = CreateConVar("l4d_loot_tank_katana_min", "56", "Min die number for a tank to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_KATANA_MAX] = CreateConVar("l4d_loot_tank_katana_max", "56", "Max die number for a tank to drop a katana.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MACHETE_MIN] = CreateConVar("l4d_loot_tank_machete_min", "57", "Min die number for a tank to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_MACHETE_MAX] = CreateConVar("l4d_loot_tank_machete_max", "57", "Max die number for a tank to drop a machete.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CRICKETBAT_MIN] = CreateConVar("l4d_loot_tank_cricketbat_min", "58", "Min die number for a tank to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CRICKETBAT_MAX] = CreateConVar("l4d_loot_tank_cricketbat_max", "58", "Max die number for a tank to drop a cricket bat.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GRENADELAUNCHER_MIN] = CreateConVar("l4d_loot_tank_grenadelauncher_min", "29", "Min die number for a tank to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GRENADELAUNCHER_MAX] = CreateConVar("l4d_loot_tank_grenadelauncher_max", "29", "Max die number for a tank to drop a grenade launcher.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_M60_MIN] = CreateConVar("l4d_loot_tank_m60_min", "33", "Min die number for a tank to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_M60_MAX] = CreateConVar("l4d_loot_tank_m60_max", "33", "Max die number for a tank to drop a M60.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GOLF_MIN] = CreateConVar("l4d_loot_tank_golf_min", "59", "Min die number for a tank to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_GOLF_MAX] = CreateConVar("l4d_loot_tank_golf_max", "59", "Max die number for a tank to drop a golfclub.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SMGS_MIN] = CreateConVar("l4d_loot_tank_smgs_min", "60", "Min die number for a tank to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_SMGS_MAX] = CreateConVar("l4d_loot_tank_smgs_max", "60", "Max die number for a tank to drop a silencedsmg.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CHROME_MIN] = CreateConVar("l4d_loot_tank_chrome_min", "61", "Min die number for a tank to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 CVarTankLoot[LOOT_CHROME_MAX] = CreateConVar("l4d_loot_tank_chrome_max", "61", "Max die number for a tank to drop a chrome.", FCVAR_PLUGIN, true, 0.0);
 
 

 CVarWitchLoot[LOOT_DIENUMBER] = CreateConVar("l4d_loot_witch_dienumber", "4", "Which die (1, 2, 4, or 4) is used when rolling for the witch", FCVAR_PLUGIN, true, 1.0, true, 4.0);
 CVarWitchLoot[LOOT_DIECOUNT] = CreateConVar("l4d_loot_witch_diecount", "1", "How many dice can roll. Each die is added to a total. (If a die rolls 0 it is not thrown)", FCVAR_PLUGIN, true, 1.0, true, 3.0);
 CVarWitchLoot[LOOT_ITEM_COUNT] = CreateConVar("l4d_loot_witch_item_count", "1", "How many items are rolled for when the witch dies.", FCVAR_PLUGIN, true, 0.0); 
 
 CVarWitchLoot[LOOT_KIT_MIN] = CreateConVar("l4d_loot_witch_kit_min", "0", "Min die number for a witch to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_KIT_MAX] = CreateConVar("l4d_loot_witch_kit_max", "0", "Max die number for a witch to drop a kit.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PILLS_MIN] = CreateConVar("l4d_loot_witch_pills_min", "0", "Min die number for a witch to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PILLS_MAX] = CreateConVar("l4d_loot_witch_pills_max", "0", "Max die number for a witch to drop pills.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_MOLLY_MIN] = CreateConVar("l4d_loot_witch_molly_min", "0", "Min die number for a witch to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_MOLLY_MAX] = CreateConVar("l4d_loot_witch_molly_max", "0", "Max die number for a witch to drop a molitov.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PIPE_MIN] = CreateConVar("l4d_loot_witch_pipe_min", "0", "Min die number for a witch to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PIPE_MAX] = CreateConVar("l4d_loot_witch_pipe_max", "0", "Max die number for a witch to drop a pipe bomb.", FCVAR_PLUGIN, true, 0.0);
 
 CVarWitchLoot[LOOT_PANIC_MIN] = CreateConVar("l4d_loot_witch_panic_min", "0", "Min die number for a witch to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PANIC_MAX] = CreateConVar("l4d_loot_witch_panic_max", "0", "Max die number for a witch to cause a zombie panic event.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_TANK_MIN] = CreateConVar("l4d_loot_witch_tankspawn_min", "0", "Min die number for a witch to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_TANK_MAX] = CreateConVar("l4d_loot_witch_tankspawn_max", "0", "Max die number for a witch to cause a tank to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_WITCH_MIN] = CreateConVar("l4d_loot_witch_witchspawn_min", "0", "Min die number for a witch to cause a witch to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_WITCH_MAX] = CreateConVar("l4d_loot_witch_witchspawn_max", "0", "Max die number for a witch to cause a witch to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_COMMON_MIN] = CreateConVar("l4d_loot_witch_common_min", "0", "Min die number for a witch to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_COMMON_MAX] = CreateConVar("l4d_loot_witch_common_max", "0", "Max die number for a witch to cause common infected to spawn nearby.", FCVAR_PLUGIN, true, 0.0);
 
 CVarWitchLoot[LOOT_PISTOL_MIN] = CreateConVar("l4d_loot_witch_pistol_min", "0",  "Min die number for a witch to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_PISTOL_MAX] = CreateConVar("l4d_loot_witch_pistol_max", "0",  "Max die number for a witch to drop a pistol.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SMG_MIN] = CreateConVar("l4d_loot_witch_smg_min", "0", "Min die number for a witch to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SMG_MAX] = CreateConVar("l4d_loot_witch_smg_max", "0", "Max die number for a witch to drop a small machine gun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SHOT_MIN] = CreateConVar("l4d_loot_witch_shotgun_min", "0", "Min die number for a witch to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SHOT_MAX] = CreateConVar("l4d_loot_witch_shotgun_max", "0", "Max die number for a witch to drop a shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_RIFLE_MIN] = CreateConVar("l4d_loot_witch_rifle_min", "0", "Min die number for a witch to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_RIFLE_MAX] = CreateConVar("l4d_loot_witch_rifle_max", "0", "Max die number for a witch to drop an auto rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_AUTOSHOT_MIN] = CreateConVar("l4d_loot_witch_autoshot_min", "0", "Min die number for a witch to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_AUTOSHOT_MAX] = CreateConVar("l4d_loot_witch_autoshot_max", "0", "Max die number for a witch to drop an auto shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SNIPER_MIN] = CreateConVar("l4d_loot_witch_sniper_min", "0", "Min die number for a witch to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SNIPER_MAX] = CreateConVar("l4d_loot_witch_sniper_max", "0", "Max die number for a witch to drop a sniper rifle.", FCVAR_PLUGIN, true, 0.0); 
 CVarWitchLoot[LOOT_MILITARY_MIN] = CreateConVar("l4d_loot_witch_military_min", "0", "Min die number for a witch to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_MILITARY_MAX] = CreateConVar("l4d_loot_witch_military_max", "0", "Max die number for a witch to drop a military rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_AK47_MIN] = CreateConVar("l4d_loot_witch_ak47_min", "0", "Min die number for a witch to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_AK47_MAX] = CreateConVar("l4d_loot_witch_ak47_max", "0", "Max die number for a witch to drop a ak47 rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_DEFIBRILLATOR_MIN] = CreateConVar("l4d_loot_witch_defibrillator_min", "0", "Min die number for a witch to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_DEFIBRILLATOR_MAX] = CreateConVar("l4d_loot_witch_defibrillator_max", "0", "Max die number for a witch to drop a defibrillator.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_MAGNUM_MIN] = CreateConVar("l4d_loot_witch_magnum_min", "0", "Min die number for a witch to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_MAGNUM_MAX] = CreateConVar("l4d_loot_witch_magnum_max", "0", "Max die number for a witch to drop a magnum.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SPAS_MIN] = CreateConVar("l4d_loot_witch_spas_min", "0", "Min die number for a witch to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_SPAS_MAX] = CreateConVar("l4d_loot_witch_spas_max", "0", "Max die number for a witch to drop a spas shotgun.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_CROWBAR_MIN] = CreateConVar("l4d_loot_witch_crowbar_min", "0", "Min die number for a witch to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_CROWBAR_MAX] = CreateConVar("l4d_loot_witch_crowbar_max", "0", "Max die number for a witch to drop a crowbar.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_DESERT_MIN] = CreateConVar("l4d_loot_witch_desert_min", "0", "Min die number for a witch to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_DESERT_MAX] = CreateConVar("l4d_loot_witch_desert_max", "0", "Max die number for a witch to drop a desert rifle.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_CHAINSAW_MIN] = CreateConVar("l4d_loot_witch_chainsaw_min", "0", "Min die number for a witch to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_CHAINSAW_MAX] = CreateConVar("l4d_loot_witch_chainsaw_max", "0", "Max die number for a witch to drop a chainsaw.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_EXPLOSIVE_MIN] = CreateConVar("l4d_loot_witch_explosive_min", "0", "Min die number for a witch to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_EXPLOSIVE_MAX] = CreateConVar("l4d_loot_witch_explosive_max", "0", "Max die number for a witch to drop a explosive ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_INCENDIARY_MIN] = CreateConVar("l4d_loot_witch_incendiary_min", "0", "Min die number for a witch to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_INCENDIARY_MAX] = CreateConVar("l4d_loot_witch_incendiary_max", "0", "Max die number for a witch to drop a incendiary ammo.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_ADRENALINE_MIN] = CreateConVar("l4d_loot_witch_adrenaline_min", "0", "Min die number for a witch to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_ADRENALINE_MAX] = CreateConVar("l4d_loot_witch_adrenaline_max", "0", "Max die number for a witch to drop a adrenaline.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_VOMITJAR_MIN] = CreateConVar("l4d_loot_witch_vomitjar_min", "0", "Min die number for a witch to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 CVarWitchLoot[LOOT_VOMITJAR_MAX] = CreateConVar("l4d_loot_witch_vomitjar_max", "0", "Max die number for a witch to drop a vomitjar.", FCVAR_PLUGIN, true, 0.0);
 

 
 RegConsoleCmd("sm_loot_sim_infected", Command_SimInfected);
 RegConsoleCmd("sm_loot_print_settings", Command_PrintSettings);
 RegConsoleCmd("sm_loot_load", Command_LoadSettings);
 
 PrintToServer("[DICE] Loading config.");
 AutoExecConfig(true, "l4d2_lootdrop");
 
 // Change the enabled flag to the one the convar holds.
 if (GetConVarInt(CVarIsEnabled) == 1) 
 {
  HookEvent("player_death", Event_PlayerDeath);
  PullCVarValues();
 }
 else
 {
  UnhookEvent("player_death", Event_PlayerDeath);
 }
}
public OnMapStart()
{
 PrintToServer("[DICE] Starting map, refreshing settings.");
 PullCVarValues();
 numTank = 0;
 numWitch = 0;
 tankSpawn = 0;
 witchSpawn = 0;
 numTankMax = 0;
 numWitchMax = 0;
}
//HookEvent("round_end", Event_RoundEnd);
// Debugging purposes (above)
public Action:Event_RoundStart(Handle:event, const String:name[], bool:dontBroadcast)
{
 numTank = 0;
 numWitch = 0;
 tankSpawn = 0;
 witchSpawn = 0;
 numTankMax = 0;
 numWitchMax = 0;
 numPanic = 0;
 TellAll("Tank Allowances Reset.");
}
// At round end, reset tank/witch count.
public Action:Command_LoadSettings(client, args)
{
 PrintToServer("[DICE] Refreshing settings.");
 AutoExecConfig(false, "l4d_loot_drop");
 PullCVarValues();
}
public Action:Command_PrintSettings(client, args)
{
 new String:arg[128]
 
 GetCmdArg(1, arg, sizeof(arg))
 
 if (StrEqual(arg, "hunter", false))
 {
  PrintToServer("[DICE SETTINGS] Hunter");
  PrintSettings(HunterLoot);
 }
 else if (StrEqual(arg, "hmoker", false))
 {
  PrintToServer("[DICE SETTINGS] Smoker");
  PrintSettings(SmokerLoot);
 }
 else if (StrEqual(arg, "boomer", false))
 {
  PrintToServer("[DICE SETTINGS] Boomer");
  PrintSettings(BoomerLoot);
 }
 else if (StrEqual(arg, "tank", false))
 {
  PrintToServer("[DICE SETTINGS] Tank");
  PrintSettings(TankLoot);
 }
 else if (StrEqual(arg, "witch", false))
 {
  PrintToServer("[DICE SETTINGS] Witch");
  PrintSettings(WitchLoot);
 }
 else if (StrEqual(arg, "spitter", false))
 {
  PrintToServer("[DICE SETTINGS] Spitter");
  PrintSettings(SpitterLoot);
 }
 else if (StrEqual(arg, "charger", false))
 {
  PrintToServer("[DICE SETTINGS] Charger");
  PrintSettings(ChargerLoot);
 }
 else if (StrEqual(arg, "jockey", false))
 {
  PrintToServer("[DICE SETTINGS] Jockey");
  PrintSettings(JockeyLoot);
 }
 else if (StrEqual(arg, "dice", false))
 {
  PrintToServer("[DICE SETTINGS] Dice");
  PrintToServer("Die 1: %i", Dice[0]);
  PrintToServer("Die 2: %i", Dice[1]);
  PrintToServer("Die 3: %i", Dice[2]);
  PrintToServer("Die 4: %i", Dice[3]);
 }
 
 return Plugin_Handled;
}
PrintSettings(diceSettings[100])
{
 PrintToServer("Die Number: id = %i, of %i sides", diceSettings[LOOT_DIENUMBER], Dice[ diceSettings[LOOT_DIENUMBER] - 1]);
 PrintToServer("Dice To Roll: %i", diceSettings[LOOT_DIECOUNT]);
 PrintToServer("Item Count: %i", diceSettings[LOOT_ITEM_COUNT]);
 PrintToServer("First Aid Kit Min-Max: %i-%i", diceSettings[LOOT_KIT_MIN], diceSettings[LOOT_KIT_MAX]);
 PrintToServer("Pain Pills Min-Max: %i-%i", diceSettings[LOOT_PILLS_MIN], diceSettings[LOOT_PILLS_MAX]);
 PrintToServer("Molotov Min-Max: %i-%i", diceSettings[LOOT_MOLLY_MIN], diceSettings[LOOT_MOLLY_MAX]);
 PrintToServer("Pipe Bomb Min-Max: %i-%i", diceSettings[LOOT_PIPE_MIN], diceSettings[LOOT_PIPE_MAX]);
 PrintToServer("Pistol Min-Max: %i-%i", diceSettings[LOOT_PISTOL_MIN], diceSettings[LOOT_PISTOL_MAX]);
 PrintToServer("SMG Min-Max: %i-%i", diceSettings[LOOT_SMG_MIN], diceSettings[LOOT_SMG_MAX]);
 PrintToServer("Shotgun Min-Max: %i-%i", diceSettings[LOOT_SHOT_MIN], diceSettings[LOOT_SHOT_MAX]);
 PrintToServer("Rifle Min-Max: %i-%i", diceSettings[LOOT_RIFLE_MIN], diceSettings[LOOT_RIFLE_MAX]);
 PrintToServer("Auto Shotgun Min-Max: %i-%i", diceSettings[LOOT_AUTOSHOT_MIN], diceSettings[LOOT_AUTOSHOT_MAX]);
 PrintToServer("Sniper Rifle Min-Max: %i-%i", diceSettings[LOOT_SNIPER_MIN], diceSettings[LOOT_SNIPER_MAX]);
 PrintToServer("Panic Event Min-Max: %i-%i", diceSettings[LOOT_PANIC_MIN], diceSettings[LOOT_PANIC_MAX]);
 PrintToServer("Tank Spawn Min-Max: %i-%i", diceSettings[LOOT_TANK_MIN], diceSettings[LOOT_TANK_MAX]);
 PrintToServer("Witch Spawn Min-Max: %i-%i", diceSettings[LOOT_WITCH_MIN], diceSettings[LOOT_WITCH_MAX]);
 PrintToServer("Common Infected Spawn Min-Max: %i-%i", diceSettings[LOOT_COMMON_MIN], diceSettings[LOOT_COMMON_MAX]); 
 PrintToServer("AK47 Spawn Min-Max: %i-%i", diceSettings[LOOT_AK47_MIN], diceSettings[LOOT_AK47_MAX]);
 PrintToServer("Defibrillator Spawn Min-Max: %i-%i", diceSettings[LOOT_DEFIBRILLATOR_MIN], diceSettings[LOOT_DEFIBRILLATOR_MAX]);
 PrintToServer("Military Rifle Spawn Min-Max: %i-%i", diceSettings[LOOT_MILITARY_MIN], diceSettings[LOOT_MILITARY_MAX]);
 PrintToServer("Magnum Pistol Spawn Min-Max: %i-%i", diceSettings[LOOT_MAGNUM_MIN], diceSettings[LOOT_MAGNUM_MAX]);
 PrintToServer("SPAS Shotgun Spawn Min-Max: %i-%i", diceSettings[LOOT_SPAS_MIN], diceSettings[LOOT_SPAS_MAX]);
 PrintToServer("Crowbar Spawn Min-Max: %i-%i", diceSettings[LOOT_CROWBAR_MIN], diceSettings[LOOT_CROWBAR_MAX]);
 PrintToServer("Desert Rifle Spawn Min-Max: %i-%i", diceSettings[LOOT_DESERT_MIN], diceSettings[LOOT_DESERT_MAX]);
 PrintToServer("Chainsaw Spawn Min-Max: %i-%i", diceSettings[LOOT_CHAINSAW_MIN], diceSettings[LOOT_CHAINSAW_MAX]);
 PrintToServer("Explosive Ammo Spawn Min-Max: %i-%i", diceSettings[LOOT_EXPLOSIVE_MIN], diceSettings[LOOT_EXPLOSIVE_MAX]);
 PrintToServer("Incendiary Ammo Spawn Min-Max: %i-%i", diceSettings[LOOT_INCENDIARY_MIN], diceSettings[LOOT_INCENDIARY_MAX]);
 PrintToServer("Adrenaline Shot Spawn Min-Max: %i-%i", diceSettings[LOOT_ADRENALINE_MIN], diceSettings[LOOT_ADRENALINE_MAX]);
 PrintToServer("Vomitjar Spawn Min-Max: %i-%i", diceSettings[LOOT_VOMITJAR_MIN], diceSettings[LOOT_VOMITJAR_MAX]);
 PrintToServer("Fireaxe Spawn Min-Max: %i-%i", diceSettings[LOOT_AXE_MIN], diceSettings[LOOT_AXE_MAX]);
 PrintToServer("Tonfa Spawn Min-Max: %i-%i", diceSettings[LOOT_TONFA_MIN], diceSettings[LOOT_TONFA_MAX]);
 PrintToServer("Frying Pan Spawn Min-Max: %i-%i", diceSettings[LOOT_FRYINGPAN_MIN], diceSettings[LOOT_FRYINGPAN_MAX]);
 PrintToServer("Electric Guitar Spawn Min-Max: %i-%i", diceSettings[LOOT_GUITAR_MIN], diceSettings[LOOT_GUITAR_MAX]);
 PrintToServer("Baseball Bat Spawn Min-Max: %i-%i", diceSettings[LOOT_BAT_MIN], diceSettings[LOOT_BAT_MAX]);
 PrintToServer("Katana Spawn Min-Max: %i-%i", diceSettings[LOOT_KATANA_MIN], diceSettings[LOOT_KATANA_MAX]);
 PrintToServer("Machete Spawn Min-Max: %i-%i", diceSettings[LOOT_MACHETE_MIN], diceSettings[LOOT_MACHETE_MAX]);
 PrintToServer("Cricket Bat Spawn Min-Max: %i-%i", diceSettings[LOOT_CRICKETBAT_MIN], diceSettings[LOOT_CRICKETBAT_MAX]);
 PrintToServer("Grenade Launcher Spawn Min-Max: %i-%i", diceSettings[LOOT_GRENADELAUNCHER_MIN], diceSettings[LOOT_GRENADELAUNCHER_MAX]);
 PrintToServer("M60 Spawn Min-Max: %i-%i", diceSettings[LOOT_M60_MIN], diceSettings[LOOT_M60_MAX]);
 PrintToServer("Golfclub Spawn Min-Max: %i-%i", diceSettings[LOOT_GOLF_MIN], diceSettings[LOOT_GOLF_MAX]);
 PrintToServer("SMG_Silenced Spawn Min-Max: %i-%i", diceSettings[LOOT_SMGS_MIN], diceSettings[LOOT_SMGS_MAX]);
 PrintToServer("Chrome_Shotgun Spawn Min-Max: %i-%i", diceSettings[LOOT_CHROME_MIN], diceSettings[LOOT_CHROME_MAX]);
}
public Action:Command_SimInfected(client, args)
{
 new String:arg[128]
 
 /*
 if (!IsClientConnected(client) && !IsClientInGame(client))
  return Plugin_Handled;
 if (IsClientBot(client))
  return Plugin_Handled;
 */
 
 GetCmdArg(1, arg, sizeof(arg))
 
 if (StrEqual(arg, "hunter", false))
 {
  PrintToServer("[DICE SIM] Hunter killed: Rolling for %i items.", HunterLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < HunterLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[HunterLoot[LOOT_DIENUMBER] - 1], HunterLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(client, 
           HunterLoot,
           RollDice(HunterLoot[LOOT_DIECOUNT], HunterLoot[LOOT_DIENUMBER], true), true);
  }       
 }
 else if (StrEqual(arg, "smoker", false))
 {
  PrintToServer("[DICE SIM] Smoker killed: Rolling for %i items.", SmokerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < SmokerLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[SmokerLoot[LOOT_DIENUMBER] - 1], SmokerLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(client, 
           SmokerLoot,
           RollDice(SmokerLoot[LOOT_DIECOUNT], SmokerLoot[LOOT_DIENUMBER], true), true);
  }
 }
 else if (StrEqual(arg, "boomer", false))
 {
  PrintToServer("[DICE SIM] Boomer killed: Rolling for %i items.", BoomerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < BoomerLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[BoomerLoot[LOOT_DIENUMBER] - 1], BoomerLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(client, 
           BoomerLoot,
           RollDice(BoomerLoot[LOOT_DIECOUNT], BoomerLoot[LOOT_DIENUMBER], true), true);
  }
  
 }
 else if (StrEqual(arg, "tank", false))
 {
  PrintToServer("[DICE SIM] Tank killed: Rolling for %i items.", TankLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < TankLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[TankLoot[LOOT_DIENUMBER] - 1], TankLoot[LOOT_DIECOUNT]);
   SpawnItemFromDieResult(client, 
           TankLoot,
           RollDice(TankLoot[LOOT_DIECOUNT], TankLoot[LOOT_DIENUMBER], true), true);
  }
 }
 else if (StrEqual(arg, "witch", false))
 {
  PrintToServer("[DICE SIM] Witch killed: Rolling for %i items.", WitchLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < WitchLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[WitchLoot[LOOT_DIENUMBER] - 1], WitchLoot[LOOT_DIECOUNT]);
   
   SpawnItemFromDieResult(client, 
           WitchLoot,
           RollDice(WitchLoot[LOOT_DIECOUNT], WitchLoot[LOOT_DIENUMBER], true), true);
  }
 }
 else if (StrEqual(arg, "spitter", false))
 {
  PrintToServer("[DICE SIM] Spitter killed: Rolling for %i items.", SpitterLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < SpitterLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[SpitterLoot[LOOT_DIENUMBER] - 1], SpitterLoot[LOOT_DIECOUNT]);
   
   SpawnItemFromDieResult(client, 
           SpitterLoot,
           RollDice(SpitterLoot[LOOT_DIECOUNT], SpitterLoot[LOOT_DIENUMBER], true), true);
  }
 }
 else if (StrEqual(arg, "charger", false))
 {
  PrintToServer("[DICE SIM] Charger killed: Rolling for %i items.", ChargerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < ChargerLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[ChargerLoot[LOOT_DIENUMBER] - 1], ChargerLoot[LOOT_DIECOUNT]);
   
   SpawnItemFromDieResult(client, 
           ChargerLoot,
           RollDice(ChargerLoot[LOOT_DIECOUNT], ChargerLoot[LOOT_DIENUMBER], true), true);
  }
 }
 else if (StrEqual(arg, "jockey", false))
 {
  PrintToServer("[DICE SIM] Jockey killed: Rolling for %i items.", JockeyLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < JockeyLoot[LOOT_ITEM_COUNT]; i++)
  {
   PrintToServer("[DICE SIM] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[JockeyLoot[LOOT_DIENUMBER] - 1], JockeyLoot[LOOT_DIECOUNT]);
   
   SpawnItemFromDieResult(client, 
           JockeyLoot,
           RollDice(JockeyLoot[LOOT_DIECOUNT], JockeyLoot[LOOT_DIENUMBER], true), true);
  }
 }
 
 return Plugin_Handled;
}
public Loot_EnableDisable(Handle:hVariable, const String:strOldValue[], const String:strNewValue[])
{
    // Change the enabled flag to the one the convar holds.
    if (GetConVarInt(CVarIsEnabled) == 1) 
 {
  HookEvent("player_death", Event_PlayerDeath);
 }
    else
 {
  UnhookEvent("player_death", Event_PlayerDeath);
 }
}
PullCVarValues()
{
 Dice[0] = GetConVarInt(CVarDieSides[0]);
 Dice[1] = GetConVarInt(CVarDieSides[1]);
 Dice[2] = GetConVarInt(CVarDieSides[2]);
 Dice[3] = GetConVarInt(CVarDieSides[3]);
 
 HunterLoot[LOOT_DIENUMBER] = GetConVarInt(CVarHunterLoot[LOOT_DIENUMBER])
 HunterLoot[LOOT_DIECOUNT] = GetConVarInt(CVarHunterLoot[LOOT_DIECOUNT])
 HunterLoot[LOOT_KIT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_KIT_MIN])
 HunterLoot[LOOT_KIT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_KIT_MAX])
 HunterLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarHunterLoot[LOOT_PILLS_MIN])
 HunterLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarHunterLoot[LOOT_PILLS_MAX])
 HunterLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarHunterLoot[LOOT_MOLLY_MIN])
 HunterLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarHunterLoot[LOOT_MOLLY_MAX])
 HunterLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_PIPE_MIN])
 HunterLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_PIPE_MAX])
 HunterLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarHunterLoot[LOOT_ITEM_COUNT])
 HunterLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarHunterLoot[LOOT_PANIC_MIN])
 HunterLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarHunterLoot[LOOT_PANIC_MAX])
 HunterLoot[LOOT_TANK_MIN] = GetConVarInt(CVarHunterLoot[LOOT_TANK_MIN])
 HunterLoot[LOOT_TANK_MAX] = GetConVarInt(CVarHunterLoot[LOOT_TANK_MAX])
 HunterLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarHunterLoot[LOOT_WITCH_MIN])
 HunterLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarHunterLoot[LOOT_WITCH_MAX])
 HunterLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarHunterLoot[LOOT_COMMON_MIN])
 HunterLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarHunterLoot[LOOT_COMMON_MAX])
 
 HunterLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarHunterLoot[LOOT_PISTOL_MIN])
 HunterLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarHunterLoot[LOOT_PISTOL_MAX])
 HunterLoot[LOOT_SMG_MIN] = GetConVarInt(CVarHunterLoot[LOOT_SMG_MIN])
 HunterLoot[LOOT_SMG_MAX] = GetConVarInt(CVarHunterLoot[LOOT_SMG_MAX])
 HunterLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_SHOT_MIN])
 HunterLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_SHOT_MAX])
 HunterLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_RIFLE_MIN])
 HunterLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_RIFLE_MAX])
 HunterLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_AUTOSHOT_MIN])
 HunterLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_AUTOSHOT_MAX])
 HunterLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarHunterLoot[LOOT_SNIPER_MIN])
 HunterLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarHunterLoot[LOOT_SNIPER_MAX])
 HunterLoot[LOOT_AK47_MIN] = GetConVarInt(CVarHunterLoot[LOOT_AK47_MIN])
 HunterLoot[LOOT_AK47_MAX] = GetConVarInt(CVarHunterLoot[LOOT_AK47_MAX])
 HunterLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarHunterLoot[LOOT_DEFIBRILLATOR_MIN])
 HunterLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarHunterLoot[LOOT_DEFIBRILLATOR_MAX])
 HunterLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarHunterLoot[LOOT_MILITARY_MIN])
 HunterLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarHunterLoot[LOOT_MILITARY_MAX])
 HunterLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarHunterLoot[LOOT_MAGNUM_MIN])
 HunterLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarHunterLoot[LOOT_MAGNUM_MAX])
 HunterLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarHunterLoot[LOOT_SPAS_MIN])
 HunterLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarHunterLoot[LOOT_SPAS_MAX])
 HunterLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarHunterLoot[LOOT_CROWBAR_MIN])
 HunterLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarHunterLoot[LOOT_CROWBAR_MAX])
 HunterLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_DESERT_MIN])
 HunterLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_DESERT_MAX])
 HunterLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarHunterLoot[LOOT_CHAINSAW_MIN])
 HunterLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarHunterLoot[LOOT_CHAINSAW_MAX])
 HunterLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_EXPLOSIVE_MIN])
 HunterLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_EXPLOSIVE_MAX])
 HunterLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarHunterLoot[LOOT_INCENDIARY_MIN])
 HunterLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarHunterLoot[LOOT_INCENDIARY_MAX])
 HunterLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_ADRENALINE_MIN])
 HunterLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_ADRENALINE_MAX])
 HunterLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarHunterLoot[LOOT_VOMITJAR_MIN])
 HunterLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarHunterLoot[LOOT_VOMITJAR_MAX])
 HunterLoot[LOOT_AXE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_AXE_MIN])
 HunterLoot[LOOT_AXE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_AXE_MAX])
 HunterLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarHunterLoot[LOOT_TONFA_MIN])
 HunterLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarHunterLoot[LOOT_TONFA_MAX])
 HunterLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarHunterLoot[LOOT_FRYINGPAN_MIN])
 HunterLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarHunterLoot[LOOT_FRYINGPAN_MAX])
 HunterLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarHunterLoot[LOOT_GUITAR_MIN])
 HunterLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarHunterLoot[LOOT_GUITAR_MAX])
 HunterLoot[LOOT_BAT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_BAT_MIN])
 HunterLoot[LOOT_BAT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_BAT_MAX])
 HunterLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarHunterLoot[LOOT_KATANA_MIN])
 HunterLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarHunterLoot[LOOT_KATANA_MAX])
 HunterLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarHunterLoot[LOOT_MACHETE_MIN])
 HunterLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarHunterLoot[LOOT_MACHETE_MAX])
 HunterLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarHunterLoot[LOOT_CRICKETBAT_MIN])
 HunterLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarHunterLoot[LOOT_CRICKETBAT_MAX])
 HunterLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarHunterLoot[LOOT_GRENADELAUNCHER_MIN])
 HunterLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarHunterLoot[LOOT_GRENADELAUNCHER_MAX])
 HunterLoot[LOOT_M60_MIN] = GetConVarInt(CVarHunterLoot[LOOT_M60_MIN])
 HunterLoot[LOOT_M60_MAX] = GetConVarInt(CVarHunterLoot[LOOT_M60_MAX])
 HunterLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarHunterLoot[LOOT_GOLF_MIN])
 HunterLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarHunterLoot[LOOT_GOLF_MAX])
 HunterLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarHunterLoot[LOOT_SMGS_MIN])
 HunterLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarHunterLoot[LOOT_SMGS_MAX])
 HunterLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarHunterLoot[LOOT_CHROME_MIN])
 HunterLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarHunterLoot[LOOT_CHROME_MAX])
 
 
 
 BoomerLoot[LOOT_DIENUMBER] = GetConVarInt(CVarBoomerLoot[LOOT_DIENUMBER])
 BoomerLoot[LOOT_DIECOUNT] = GetConVarInt(CVarBoomerLoot[LOOT_DIECOUNT])
 BoomerLoot[LOOT_KIT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_KIT_MIN])
 BoomerLoot[LOOT_KIT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_KIT_MAX])
 BoomerLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_PILLS_MIN])
 BoomerLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_PILLS_MAX])
 BoomerLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_MOLLY_MIN])
 BoomerLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_MOLLY_MAX])
 BoomerLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_PIPE_MIN])
 BoomerLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_PIPE_MAX])
 BoomerLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarBoomerLoot[LOOT_ITEM_COUNT])
 
 BoomerLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_PANIC_MIN])
 BoomerLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_PANIC_MAX])
 BoomerLoot[LOOT_TANK_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_TANK_MIN])
 BoomerLoot[LOOT_TANK_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_TANK_MAX])
 BoomerLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_WITCH_MIN])
 BoomerLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_WITCH_MAX])
 BoomerLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_COMMON_MIN])
 BoomerLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_COMMON_MAX])
 
 BoomerLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_PISTOL_MIN])
 BoomerLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_PISTOL_MAX])
 BoomerLoot[LOOT_SMG_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_SMG_MIN])
 BoomerLoot[LOOT_SMG_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_SMG_MAX])
 BoomerLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_SHOT_MIN])
 BoomerLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_SHOT_MAX])
 BoomerLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_RIFLE_MIN])
 BoomerLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_RIFLE_MAX])
 BoomerLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_AUTOSHOT_MIN])
 BoomerLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_AUTOSHOT_MAX])
 BoomerLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_SNIPER_MIN])
 BoomerLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_SNIPER_MAX])
 BoomerLoot[LOOT_AK47_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_AK47_MIN])
 BoomerLoot[LOOT_AK47_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_AK47_MAX])
 BoomerLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_DEFIBRILLATOR_MIN])
 BoomerLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_DEFIBRILLATOR_MAX])
 BoomerLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_MILITARY_MIN])
 BoomerLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_MILITARY_MAX])
 BoomerLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_MAGNUM_MIN])
 BoomerLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_MAGNUM_MAX])
 BoomerLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_SPAS_MIN])
 BoomerLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_SPAS_MAX])
 BoomerLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_CROWBAR_MIN])
 BoomerLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_CROWBAR_MAX])
 BoomerLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_DESERT_MIN])
 BoomerLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_DESERT_MAX])
 BoomerLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_CHAINSAW_MIN])
 BoomerLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_CHAINSAW_MAX])
 BoomerLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_EXPLOSIVE_MIN])
 BoomerLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_EXPLOSIVE_MAX])
 BoomerLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_INCENDIARY_MIN])
 BoomerLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_INCENDIARY_MAX])
 BoomerLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_ADRENALINE_MIN])
 BoomerLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_ADRENALINE_MAX])
 BoomerLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_VOMITJAR_MIN])
 BoomerLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_VOMITJAR_MAX])
 BoomerLoot[LOOT_AXE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_AXE_MIN])
 BoomerLoot[LOOT_AXE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_AXE_MAX])
 BoomerLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_TONFA_MIN])
 BoomerLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_TONFA_MAX])
 BoomerLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_FRYINGPAN_MIN])
 BoomerLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_FRYINGPAN_MAX])
 BoomerLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_GUITAR_MIN])
 BoomerLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_GUITAR_MAX])
 BoomerLoot[LOOT_BAT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_BAT_MIN])
 BoomerLoot[LOOT_BAT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_BAT_MAX])
 BoomerLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_KATANA_MIN])
 BoomerLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_KATANA_MAX])
 BoomerLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_MACHETE_MIN])
 BoomerLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_MACHETE_MAX])
 BoomerLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_CRICKETBAT_MIN])
 BoomerLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_CRICKETBAT_MAX])
 BoomerLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_GRENADELAUNCHER_MIN])
 BoomerLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_GRENADELAUNCHER_MAX])
 BoomerLoot[LOOT_M60_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_M60_MIN])
 BoomerLoot[LOOT_M60_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_M60_MAX])
 BoomerLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_GOLF_MIN])
 BoomerLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_GOLF_MAX])
 BoomerLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_SMGS_MIN])
 BoomerLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_SMGS_MAX])
 BoomerLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarBoomerLoot[LOOT_CHROME_MIN])
 BoomerLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarBoomerLoot[LOOT_CHROME_MAX])
 
 
 SmokerLoot[LOOT_DIENUMBER] = GetConVarInt(CVarSmokerLoot[LOOT_DIENUMBER])
 SmokerLoot[LOOT_DIECOUNT] = GetConVarInt(CVarSmokerLoot[LOOT_DIECOUNT])
 SmokerLoot[LOOT_KIT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_KIT_MIN])
 SmokerLoot[LOOT_KIT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_KIT_MAX])
 SmokerLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_PILLS_MIN])
 SmokerLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_PILLS_MAX])
 SmokerLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_MOLLY_MIN])
 SmokerLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_MOLLY_MAX])
 SmokerLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_PIPE_MIN])
 SmokerLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_PIPE_MAX])
 SmokerLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarSmokerLoot[LOOT_ITEM_COUNT])
 SmokerLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_PANIC_MIN])
 SmokerLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_PANIC_MAX])
 SmokerLoot[LOOT_TANK_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_TANK_MIN])
 SmokerLoot[LOOT_TANK_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_TANK_MAX])
 SmokerLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_WITCH_MIN])
 SmokerLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_WITCH_MAX])
 SmokerLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_COMMON_MIN])
 SmokerLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_COMMON_MAX])
 
 SmokerLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_PISTOL_MIN])
 SmokerLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_PISTOL_MAX])
 SmokerLoot[LOOT_SMG_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_SMG_MIN])
 SmokerLoot[LOOT_SMG_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_SMG_MAX])
 SmokerLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_SHOT_MIN])
 SmokerLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_SHOT_MAX])
 SmokerLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_RIFLE_MIN])
 SmokerLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_RIFLE_MAX])
 SmokerLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_AUTOSHOT_MIN])
 SmokerLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_AUTOSHOT_MAX])
 SmokerLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_SNIPER_MIN])
 SmokerLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_SNIPER_MAX])
 SmokerLoot[LOOT_AK47_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_AK47_MIN])
 SmokerLoot[LOOT_AK47_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_AK47_MAX])
 SmokerLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_DEFIBRILLATOR_MIN])
 SmokerLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_DEFIBRILLATOR_MAX])
 SmokerLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_MILITARY_MIN])
 SmokerLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_MILITARY_MAX])
 SmokerLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_MAGNUM_MIN])
 SmokerLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_MAGNUM_MAX])
 SmokerLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_SPAS_MIN])
 SmokerLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_SPAS_MAX])
 SmokerLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_CROWBAR_MIN])
 SmokerLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_CROWBAR_MAX])
 SmokerLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_DESERT_MIN])
 SmokerLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_DESERT_MAX])
 SmokerLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_CHAINSAW_MIN])
 SmokerLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_CHAINSAW_MAX])
 SmokerLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_EXPLOSIVE_MIN])
 SmokerLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_EXPLOSIVE_MAX])
 SmokerLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_INCENDIARY_MIN])
 SmokerLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_INCENDIARY_MAX])
 SmokerLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_ADRENALINE_MIN])
 SmokerLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_ADRENALINE_MAX])
 SmokerLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_VOMITJAR_MIN])
 SmokerLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_VOMITJAR_MAX])
 SmokerLoot[LOOT_AXE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_AXE_MIN])
 SmokerLoot[LOOT_AXE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_AXE_MAX])
 SmokerLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_TONFA_MIN])
 SmokerLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_TONFA_MAX])
 SmokerLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_FRYINGPAN_MIN])
 SmokerLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_FRYINGPAN_MAX])
 SmokerLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_GUITAR_MIN])
 SmokerLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_GUITAR_MAX])
 SmokerLoot[LOOT_BAT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_BAT_MIN])
 SmokerLoot[LOOT_BAT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_BAT_MAX])
 SmokerLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_KATANA_MIN])
 SmokerLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_KATANA_MAX])
 SmokerLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_MACHETE_MIN])
 SmokerLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_MACHETE_MAX])
 SmokerLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_CRICKETBAT_MIN])
 SmokerLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_CRICKETBAT_MAX])
 SmokerLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_GRENADELAUNCHER_MIN])
 SmokerLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_GRENADELAUNCHER_MAX])
 SmokerLoot[LOOT_M60_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_M60_MIN])
 SmokerLoot[LOOT_M60_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_M60_MAX])
 SmokerLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_GOLF_MIN])
 SmokerLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_GOLF_MAX])
 SmokerLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_SMGS_MIN])
 SmokerLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_SMGS_MAX])
 SmokerLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarSmokerLoot[LOOT_CHROME_MIN])
 SmokerLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarSmokerLoot[LOOT_CHROME_MAX])
 
 
 TankLoot[LOOT_DIENUMBER] = GetConVarInt(CVarTankLoot[LOOT_DIENUMBER])
 TankLoot[LOOT_DIECOUNT] = GetConVarInt(CVarTankLoot[LOOT_DIECOUNT])
 TankLoot[LOOT_KIT_MIN] = GetConVarInt(CVarTankLoot[LOOT_KIT_MIN])
 TankLoot[LOOT_KIT_MAX] = GetConVarInt(CVarTankLoot[LOOT_KIT_MAX])
 TankLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarTankLoot[LOOT_PILLS_MIN])
 TankLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarTankLoot[LOOT_PILLS_MAX])
 TankLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarTankLoot[LOOT_MOLLY_MIN])
 TankLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarTankLoot[LOOT_MOLLY_MAX])
 TankLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarTankLoot[LOOT_PIPE_MIN])
 TankLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarTankLoot[LOOT_PIPE_MAX])
 TankLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarTankLoot[LOOT_ITEM_COUNT])
 
 TankLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarTankLoot[LOOT_PANIC_MIN])
 TankLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarTankLoot[LOOT_PANIC_MAX])
 TankLoot[LOOT_TANK_MIN] = GetConVarInt(CVarTankLoot[LOOT_TANK_MIN])
 TankLoot[LOOT_TANK_MAX] = GetConVarInt(CVarTankLoot[LOOT_TANK_MAX])
 TankLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarTankLoot[LOOT_WITCH_MIN])
 TankLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarTankLoot[LOOT_WITCH_MAX])
 TankLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarTankLoot[LOOT_COMMON_MIN])
 TankLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarTankLoot[LOOT_COMMON_MAX])
 
 TankLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarTankLoot[LOOT_PISTOL_MIN])
 TankLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarTankLoot[LOOT_PISTOL_MAX])
 TankLoot[LOOT_SMG_MIN] = GetConVarInt(CVarTankLoot[LOOT_SMG_MIN])
 TankLoot[LOOT_SMG_MAX] = GetConVarInt(CVarTankLoot[LOOT_SMG_MAX])
 TankLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarTankLoot[LOOT_SHOT_MIN])
 TankLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarTankLoot[LOOT_SHOT_MAX])
 TankLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarTankLoot[LOOT_RIFLE_MIN])
 TankLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarTankLoot[LOOT_RIFLE_MAX])
 TankLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarTankLoot[LOOT_AUTOSHOT_MIN])
 TankLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarTankLoot[LOOT_AUTOSHOT_MAX])
 TankLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarTankLoot[LOOT_SNIPER_MIN])
 TankLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarTankLoot[LOOT_SNIPER_MAX])
 TankLoot[LOOT_AK47_MIN] = GetConVarInt(CVarTankLoot[LOOT_AK47_MIN])
 TankLoot[LOOT_AK47_MAX] = GetConVarInt(CVarTankLoot[LOOT_AK47_MAX])
 TankLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarTankLoot[LOOT_DEFIBRILLATOR_MIN])
 TankLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarTankLoot[LOOT_DEFIBRILLATOR_MAX])
 TankLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarTankLoot[LOOT_MILITARY_MIN])
 TankLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarTankLoot[LOOT_MILITARY_MAX])
 TankLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarTankLoot[LOOT_MAGNUM_MIN])
 TankLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarTankLoot[LOOT_MAGNUM_MAX])
 TankLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarTankLoot[LOOT_SPAS_MIN])
 TankLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarTankLoot[LOOT_SPAS_MAX])
 TankLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarTankLoot[LOOT_CROWBAR_MIN])
 TankLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarTankLoot[LOOT_CROWBAR_MAX])
 TankLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarTankLoot[LOOT_DESERT_MIN])
 TankLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarTankLoot[LOOT_DESERT_MAX])
 TankLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarTankLoot[LOOT_CHAINSAW_MIN])
 TankLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarTankLoot[LOOT_CHAINSAW_MAX])
 TankLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarTankLoot[LOOT_EXPLOSIVE_MIN])
 TankLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarTankLoot[LOOT_EXPLOSIVE_MAX])
 TankLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarTankLoot[LOOT_INCENDIARY_MIN])
 TankLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarTankLoot[LOOT_INCENDIARY_MAX])
 TankLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarTankLoot[LOOT_ADRENALINE_MIN])
 TankLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarTankLoot[LOOT_ADRENALINE_MAX])
 TankLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarTankLoot[LOOT_VOMITJAR_MIN])
 TankLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarTankLoot[LOOT_VOMITJAR_MAX])
 TankLoot[LOOT_AXE_MIN] = GetConVarInt(CVarTankLoot[LOOT_AXE_MIN])
 TankLoot[LOOT_AXE_MAX] = GetConVarInt(CVarTankLoot[LOOT_AXE_MAX])
 TankLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarTankLoot[LOOT_TONFA_MIN])
 TankLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarTankLoot[LOOT_TONFA_MAX])
 TankLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarTankLoot[LOOT_FRYINGPAN_MIN])
 TankLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarTankLoot[LOOT_FRYINGPAN_MAX])
 TankLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarTankLoot[LOOT_GUITAR_MIN])
 TankLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarTankLoot[LOOT_GUITAR_MAX])
 TankLoot[LOOT_BAT_MIN] = GetConVarInt(CVarTankLoot[LOOT_BAT_MIN])
 TankLoot[LOOT_BAT_MAX] = GetConVarInt(CVarTankLoot[LOOT_BAT_MAX])
 TankLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarTankLoot[LOOT_KATANA_MIN])
 TankLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarTankLoot[LOOT_KATANA_MAX])
 TankLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarTankLoot[LOOT_MACHETE_MIN])
 TankLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarTankLoot[LOOT_MACHETE_MAX])
 TankLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarTankLoot[LOOT_CRICKETBAT_MIN])
 TankLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarTankLoot[LOOT_CRICKETBAT_MAX])
 TankLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarTankLoot[LOOT_GRENADELAUNCHER_MIN])
 TankLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarTankLoot[LOOT_GRENADELAUNCHER_MAX])
 TankLoot[LOOT_M60_MIN] = GetConVarInt(CVarTankLoot[LOOT_M60_MIN])
 TankLoot[LOOT_M60_MAX] = GetConVarInt(CVarTankLoot[LOOT_M60_MAX])
 TankLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarTankLoot[LOOT_GOLF_MIN])
 TankLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarTankLoot[LOOT_GOLF_MAX])
 TankLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarTankLoot[LOOT_SMGS_MIN])
 TankLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarTankLoot[LOOT_SMGS_MAX])
 TankLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarTankLoot[LOOT_CHROME_MIN])
 TankLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarTankLoot[LOOT_CHROME_MAX])
 
 WitchLoot[LOOT_DIENUMBER] = GetConVarInt(CVarWitchLoot[LOOT_DIENUMBER])
 WitchLoot[LOOT_DIECOUNT] = GetConVarInt(CVarWitchLoot[LOOT_DIECOUNT])
 WitchLoot[LOOT_KIT_MIN] = GetConVarInt(CVarWitchLoot[LOOT_KIT_MIN])
 WitchLoot[LOOT_KIT_MAX] = GetConVarInt(CVarWitchLoot[LOOT_KIT_MAX])
 WitchLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarWitchLoot[LOOT_PILLS_MIN])
 WitchLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarWitchLoot[LOOT_PILLS_MAX])
 WitchLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarWitchLoot[LOOT_MOLLY_MIN])
 WitchLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarWitchLoot[LOOT_MOLLY_MAX])
 WitchLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarWitchLoot[LOOT_PIPE_MIN])
 WitchLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarWitchLoot[LOOT_PIPE_MAX])
 WitchLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarWitchLoot[LOOT_ITEM_COUNT])
 
 WitchLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarWitchLoot[LOOT_PANIC_MIN])
 WitchLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarWitchLoot[LOOT_PANIC_MAX])
 WitchLoot[LOOT_TANK_MIN] = GetConVarInt(CVarWitchLoot[LOOT_TANK_MIN])
 WitchLoot[LOOT_TANK_MAX] = GetConVarInt(CVarWitchLoot[LOOT_TANK_MAX])
 WitchLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarWitchLoot[LOOT_WITCH_MIN])
 WitchLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarWitchLoot[LOOT_WITCH_MAX])
 WitchLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarWitchLoot[LOOT_COMMON_MIN])
 WitchLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarWitchLoot[LOOT_COMMON_MAX])
 
 WitchLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarWitchLoot[LOOT_PISTOL_MIN])
 WitchLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarWitchLoot[LOOT_PISTOL_MAX])
 WitchLoot[LOOT_SMG_MIN] = GetConVarInt(CVarWitchLoot[LOOT_SMG_MIN])
 WitchLoot[LOOT_SMG_MAX] = GetConVarInt(CVarWitchLoot[LOOT_SMG_MAX])
 WitchLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarWitchLoot[LOOT_SHOT_MIN])
 WitchLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarWitchLoot[LOOT_SHOT_MAX])
 WitchLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarWitchLoot[LOOT_RIFLE_MIN])
 WitchLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarWitchLoot[LOOT_RIFLE_MAX])
 WitchLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarWitchLoot[LOOT_AUTOSHOT_MIN])
 WitchLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarWitchLoot[LOOT_AUTOSHOT_MAX])
 WitchLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarWitchLoot[LOOT_SNIPER_MIN])
 WitchLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarWitchLoot[LOOT_SNIPER_MAX])
 WitchLoot[LOOT_AK47_MIN] = GetConVarInt(CVarWitchLoot[LOOT_AK47_MIN])
 WitchLoot[LOOT_AK47_MAX] = GetConVarInt(CVarWitchLoot[LOOT_AK47_MAX])
 WitchLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarWitchLoot[LOOT_DEFIBRILLATOR_MIN])
 WitchLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarWitchLoot[LOOT_DEFIBRILLATOR_MAX])
 WitchLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarWitchLoot[LOOT_MILITARY_MIN])
 WitchLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarWitchLoot[LOOT_MILITARY_MAX])
 WitchLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarWitchLoot[LOOT_MAGNUM_MIN])
 WitchLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarWitchLoot[LOOT_MAGNUM_MAX])
 WitchLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarWitchLoot[LOOT_SPAS_MIN])
 WitchLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarWitchLoot[LOOT_SPAS_MAX])
 WitchLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarWitchLoot[LOOT_CROWBAR_MIN])
 WitchLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarWitchLoot[LOOT_CROWBAR_MAX])
 WitchLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarWitchLoot[LOOT_DESERT_MIN])
 WitchLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarWitchLoot[LOOT_DESERT_MAX])
 WitchLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarWitchLoot[LOOT_CHAINSAW_MIN])
 WitchLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarWitchLoot[LOOT_CHAINSAW_MAX])
 WitchLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarWitchLoot[LOOT_EXPLOSIVE_MIN])
 WitchLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarWitchLoot[LOOT_EXPLOSIVE_MAX])
 WitchLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarWitchLoot[LOOT_INCENDIARY_MIN])
 WitchLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarWitchLoot[LOOT_INCENDIARY_MAX])
 WitchLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarWitchLoot[LOOT_ADRENALINE_MIN])
 WitchLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarWitchLoot[LOOT_ADRENALINE_MAX])
 WitchLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarWitchLoot[LOOT_VOMITJAR_MIN])
 WitchLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarWitchLoot[LOOT_VOMITJAR_MAX])
 
 SpitterLoot[LOOT_DIENUMBER] = GetConVarInt(CVarSpitterLoot[LOOT_DIENUMBER])
 SpitterLoot[LOOT_DIECOUNT] = GetConVarInt(CVarSpitterLoot[LOOT_DIECOUNT])
 SpitterLoot[LOOT_KIT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_KIT_MIN])
 SpitterLoot[LOOT_KIT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_KIT_MAX])
 SpitterLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_PILLS_MIN])
 SpitterLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_PILLS_MAX])
 SpitterLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_MOLLY_MIN])
 SpitterLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_MOLLY_MAX])
 SpitterLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_PIPE_MIN])
 SpitterLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_PIPE_MAX])
 SpitterLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarSpitterLoot[LOOT_ITEM_COUNT])
 
 SpitterLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_PANIC_MIN])
 SpitterLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_PANIC_MAX])
 SpitterLoot[LOOT_TANK_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_TANK_MIN])
 SpitterLoot[LOOT_TANK_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_TANK_MAX])
 SpitterLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_WITCH_MIN])
 SpitterLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_WITCH_MAX])
 SpitterLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_COMMON_MIN])
 SpitterLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_COMMON_MAX])
 
 SpitterLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_PISTOL_MIN])
 SpitterLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_PISTOL_MAX])
 SpitterLoot[LOOT_SMG_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_SMG_MIN])
 SpitterLoot[LOOT_SMG_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_SMG_MAX])
 SpitterLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_SHOT_MIN])
 SpitterLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_SHOT_MAX])
 SpitterLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_RIFLE_MIN])
 SpitterLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_RIFLE_MAX])
 SpitterLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_AUTOSHOT_MIN])
 SpitterLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_AUTOSHOT_MAX])
 SpitterLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_SNIPER_MIN])
 SpitterLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_SNIPER_MAX])
 SpitterLoot[LOOT_AK47_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_AK47_MIN])
 SpitterLoot[LOOT_AK47_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_AK47_MAX])
 SpitterLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_DEFIBRILLATOR_MIN])
 SpitterLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_DEFIBRILLATOR_MAX])
 SpitterLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_MILITARY_MIN])
 SpitterLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_MILITARY_MAX])
 SpitterLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_MAGNUM_MIN])
 SpitterLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_MAGNUM_MAX])
 SpitterLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_SPAS_MIN])
 SpitterLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_SPAS_MAX])
 SpitterLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_CROWBAR_MIN])
 SpitterLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_CROWBAR_MAX])
 SpitterLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_DESERT_MIN])
 SpitterLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_DESERT_MAX])
 SpitterLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_CHAINSAW_MIN])
 SpitterLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_CHAINSAW_MAX])
 SpitterLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_EXPLOSIVE_MIN])
 SpitterLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_EXPLOSIVE_MAX])
 SpitterLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_INCENDIARY_MIN])
 SpitterLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_INCENDIARY_MAX])
 SpitterLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_ADRENALINE_MIN])
 SpitterLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_ADRENALINE_MAX])
 SpitterLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_VOMITJAR_MIN])
 SpitterLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_VOMITJAR_MAX])
 SpitterLoot[LOOT_AXE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_AXE_MIN])
 SpitterLoot[LOOT_AXE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_AXE_MAX])
 SpitterLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_TONFA_MIN])
 SpitterLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_TONFA_MAX])
 SpitterLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_FRYINGPAN_MIN])
 SpitterLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_FRYINGPAN_MAX])
 SpitterLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_GUITAR_MIN])
 SpitterLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_GUITAR_MAX])
 SpitterLoot[LOOT_BAT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_BAT_MIN])
 SpitterLoot[LOOT_BAT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_BAT_MAX])
 SpitterLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_KATANA_MIN])
 SpitterLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_KATANA_MAX])
 SpitterLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_MACHETE_MIN])
 SpitterLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_MACHETE_MAX])
 SpitterLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_CRICKETBAT_MIN])
 SpitterLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_CRICKETBAT_MAX])
 SpitterLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_GRENADELAUNCHER_MIN])
 SpitterLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_GRENADELAUNCHER_MAX])
 SpitterLoot[LOOT_M60_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_M60_MIN])
 SpitterLoot[LOOT_M60_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_M60_MAX])
 SpitterLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_GOLF_MIN])
 SpitterLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_GOLF_MAX])
 SpitterLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_SMGS_MIN])
 SpitterLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_SMGS_MAX])
 SpitterLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarSpitterLoot[LOOT_CHROME_MIN])
 SpitterLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarSpitterLoot[LOOT_CHROME_MAX])
 
 ChargerLoot[LOOT_DIENUMBER] = GetConVarInt(CVarChargerLoot[LOOT_DIENUMBER])
 ChargerLoot[LOOT_DIECOUNT] = GetConVarInt(CVarChargerLoot[LOOT_DIECOUNT])
 ChargerLoot[LOOT_KIT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_KIT_MIN])
 ChargerLoot[LOOT_KIT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_KIT_MAX])
 ChargerLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarChargerLoot[LOOT_PILLS_MIN])
 ChargerLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarChargerLoot[LOOT_PILLS_MAX])
 ChargerLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarChargerLoot[LOOT_MOLLY_MIN])
 ChargerLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarChargerLoot[LOOT_MOLLY_MAX])
 ChargerLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_PIPE_MIN])
 ChargerLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_PIPE_MAX])
 ChargerLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarChargerLoot[LOOT_ITEM_COUNT])
 
 ChargerLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarChargerLoot[LOOT_PANIC_MIN])
 ChargerLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarChargerLoot[LOOT_PANIC_MAX])
 ChargerLoot[LOOT_TANK_MIN] = GetConVarInt(CVarChargerLoot[LOOT_TANK_MIN])
 ChargerLoot[LOOT_TANK_MAX] = GetConVarInt(CVarChargerLoot[LOOT_TANK_MAX])
 ChargerLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarChargerLoot[LOOT_WITCH_MIN])
 ChargerLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarChargerLoot[LOOT_WITCH_MAX])
 ChargerLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarChargerLoot[LOOT_COMMON_MIN])
 ChargerLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarChargerLoot[LOOT_COMMON_MAX])
 
 ChargerLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarChargerLoot[LOOT_PISTOL_MIN])
 ChargerLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarChargerLoot[LOOT_PISTOL_MAX])
 ChargerLoot[LOOT_SMG_MIN] = GetConVarInt(CVarChargerLoot[LOOT_SMG_MIN])
 ChargerLoot[LOOT_SMG_MAX] = GetConVarInt(CVarChargerLoot[LOOT_SMG_MAX])
 ChargerLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_SHOT_MIN])
 ChargerLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_SHOT_MAX])
 ChargerLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_RIFLE_MIN])
 ChargerLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_RIFLE_MAX])
 ChargerLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_AUTOSHOT_MIN])
 ChargerLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_AUTOSHOT_MAX])
 ChargerLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarChargerLoot[LOOT_SNIPER_MIN])
 ChargerLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarChargerLoot[LOOT_SNIPER_MAX])
 ChargerLoot[LOOT_AK47_MIN] = GetConVarInt(CVarChargerLoot[LOOT_AK47_MIN])
 ChargerLoot[LOOT_AK47_MAX] = GetConVarInt(CVarChargerLoot[LOOT_AK47_MAX])
 ChargerLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarChargerLoot[LOOT_DEFIBRILLATOR_MIN])
 ChargerLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarChargerLoot[LOOT_DEFIBRILLATOR_MAX])
 ChargerLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarChargerLoot[LOOT_MILITARY_MIN])
 ChargerLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarChargerLoot[LOOT_MILITARY_MAX])
 ChargerLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarChargerLoot[LOOT_MAGNUM_MIN])
 ChargerLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarChargerLoot[LOOT_MAGNUM_MAX])
 ChargerLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarChargerLoot[LOOT_SPAS_MIN])
 ChargerLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarChargerLoot[LOOT_SPAS_MAX])
 ChargerLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarChargerLoot[LOOT_CROWBAR_MIN])
 ChargerLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarChargerLoot[LOOT_CROWBAR_MAX])
 ChargerLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_DESERT_MIN])
 ChargerLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_DESERT_MAX])
 ChargerLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarChargerLoot[LOOT_CHAINSAW_MIN])
 ChargerLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarChargerLoot[LOOT_CHAINSAW_MAX])
 ChargerLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_EXPLOSIVE_MIN])
 ChargerLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_EXPLOSIVE_MAX])
 ChargerLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarChargerLoot[LOOT_INCENDIARY_MIN])
 ChargerLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarChargerLoot[LOOT_INCENDIARY_MAX])
 ChargerLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_ADRENALINE_MIN])
 ChargerLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_ADRENALINE_MAX])
 ChargerLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarChargerLoot[LOOT_VOMITJAR_MIN])
 ChargerLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarChargerLoot[LOOT_VOMITJAR_MAX])
 ChargerLoot[LOOT_AXE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_AXE_MIN])
 ChargerLoot[LOOT_AXE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_AXE_MAX])
 ChargerLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarChargerLoot[LOOT_TONFA_MIN])
 ChargerLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarChargerLoot[LOOT_TONFA_MAX])
 ChargerLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarChargerLoot[LOOT_FRYINGPAN_MIN])
 ChargerLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarChargerLoot[LOOT_FRYINGPAN_MAX])
 ChargerLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarChargerLoot[LOOT_GUITAR_MIN])
 ChargerLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarChargerLoot[LOOT_GUITAR_MAX])
 ChargerLoot[LOOT_BAT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_BAT_MIN])
 ChargerLoot[LOOT_BAT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_BAT_MAX])
 ChargerLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarChargerLoot[LOOT_KATANA_MIN])
 ChargerLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarChargerLoot[LOOT_KATANA_MAX])
 ChargerLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarChargerLoot[LOOT_MACHETE_MIN])
 ChargerLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarChargerLoot[LOOT_MACHETE_MAX])
 ChargerLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarChargerLoot[LOOT_CRICKETBAT_MIN])
 ChargerLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarChargerLoot[LOOT_CRICKETBAT_MAX])
 ChargerLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarChargerLoot[LOOT_GRENADELAUNCHER_MIN])
 ChargerLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarChargerLoot[LOOT_GRENADELAUNCHER_MAX])
 ChargerLoot[LOOT_M60_MIN] = GetConVarInt(CVarChargerLoot[LOOT_M60_MIN])
 ChargerLoot[LOOT_M60_MAX] = GetConVarInt(CVarChargerLoot[LOOT_M60_MAX])
 ChargerLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarChargerLoot[LOOT_GOLF_MIN])
 ChargerLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarChargerLoot[LOOT_GOLF_MAX])
 ChargerLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarChargerLoot[LOOT_SMGS_MIN])
 ChargerLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarChargerLoot[LOOT_SMGS_MAX])
 ChargerLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarChargerLoot[LOOT_CHROME_MIN])
 ChargerLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarChargerLoot[LOOT_CHROME_MAX])

 JockeyLoot[LOOT_DIENUMBER] = GetConVarInt(CVarJockeyLoot[LOOT_DIENUMBER])
 JockeyLoot[LOOT_DIECOUNT] = GetConVarInt(CVarJockeyLoot[LOOT_DIECOUNT])
 JockeyLoot[LOOT_KIT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_KIT_MIN])
 JockeyLoot[LOOT_KIT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_KIT_MAX])
 JockeyLoot[LOOT_PILLS_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_PILLS_MIN])
 JockeyLoot[LOOT_PILLS_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_PILLS_MAX])
 JockeyLoot[LOOT_MOLLY_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_MOLLY_MIN])
 JockeyLoot[LOOT_MOLLY_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_MOLLY_MAX])
 JockeyLoot[LOOT_PIPE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_PIPE_MIN])
 JockeyLoot[LOOT_PIPE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_PIPE_MAX])
 JockeyLoot[LOOT_ITEM_COUNT] = GetConVarInt(CVarJockeyLoot[LOOT_ITEM_COUNT])
 
 JockeyLoot[LOOT_PANIC_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_PANIC_MIN])
 JockeyLoot[LOOT_PANIC_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_PANIC_MAX])
 JockeyLoot[LOOT_TANK_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_TANK_MIN])
 JockeyLoot[LOOT_TANK_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_TANK_MAX])
 JockeyLoot[LOOT_WITCH_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_WITCH_MIN])
 JockeyLoot[LOOT_WITCH_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_WITCH_MAX])
 JockeyLoot[LOOT_COMMON_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_COMMON_MIN])
 JockeyLoot[LOOT_COMMON_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_COMMON_MAX])
 
 JockeyLoot[LOOT_PISTOL_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_PISTOL_MIN])
 JockeyLoot[LOOT_PISTOL_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_PISTOL_MAX])
 JockeyLoot[LOOT_SMG_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_SMG_MIN])
 JockeyLoot[LOOT_SMG_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_SMG_MAX])
 JockeyLoot[LOOT_SHOT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_SHOT_MIN])
 JockeyLoot[LOOT_SHOT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_SHOT_MAX])
 JockeyLoot[LOOT_RIFLE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_RIFLE_MIN])
 JockeyLoot[LOOT_RIFLE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_RIFLE_MAX])
 JockeyLoot[LOOT_AUTOSHOT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_AUTOSHOT_MIN])
 JockeyLoot[LOOT_AUTOSHOT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_AUTOSHOT_MAX])
 JockeyLoot[LOOT_SNIPER_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_SNIPER_MIN])
 JockeyLoot[LOOT_SNIPER_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_SNIPER_MAX])
 JockeyLoot[LOOT_AK47_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_AK47_MIN])
 JockeyLoot[LOOT_AK47_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_AK47_MAX])
 JockeyLoot[LOOT_DEFIBRILLATOR_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_DEFIBRILLATOR_MIN])
 JockeyLoot[LOOT_DEFIBRILLATOR_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_DEFIBRILLATOR_MAX])
 JockeyLoot[LOOT_MILITARY_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_MILITARY_MIN])
 JockeyLoot[LOOT_MILITARY_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_MILITARY_MAX])
 JockeyLoot[LOOT_MAGNUM_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_MAGNUM_MIN])
 JockeyLoot[LOOT_MAGNUM_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_MAGNUM_MAX])
 JockeyLoot[LOOT_SPAS_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_SPAS_MIN])
 JockeyLoot[LOOT_SPAS_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_SPAS_MAX])
 JockeyLoot[LOOT_CROWBAR_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_CROWBAR_MIN])
 JockeyLoot[LOOT_CROWBAR_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_CROWBAR_MAX])
 JockeyLoot[LOOT_DESERT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_DESERT_MIN])
 JockeyLoot[LOOT_DESERT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_DESERT_MAX])
 JockeyLoot[LOOT_CHAINSAW_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_CHAINSAW_MIN])
 JockeyLoot[LOOT_CHAINSAW_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_CHAINSAW_MAX])
 JockeyLoot[LOOT_EXPLOSIVE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_EXPLOSIVE_MIN])
 JockeyLoot[LOOT_EXPLOSIVE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_EXPLOSIVE_MAX])
 JockeyLoot[LOOT_INCENDIARY_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_INCENDIARY_MIN])
 JockeyLoot[LOOT_INCENDIARY_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_INCENDIARY_MAX])
 JockeyLoot[LOOT_ADRENALINE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_ADRENALINE_MIN])
 JockeyLoot[LOOT_ADRENALINE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_ADRENALINE_MAX])
 JockeyLoot[LOOT_VOMITJAR_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_VOMITJAR_MIN])
 JockeyLoot[LOOT_VOMITJAR_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_VOMITJAR_MAX])
 JockeyLoot[LOOT_AXE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_AXE_MIN])
 JockeyLoot[LOOT_AXE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_AXE_MAX])
 JockeyLoot[LOOT_TONFA_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_TONFA_MIN])
 JockeyLoot[LOOT_TONFA_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_TONFA_MAX])
 JockeyLoot[LOOT_FRYINGPAN_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_FRYINGPAN_MIN])
 JockeyLoot[LOOT_FRYINGPAN_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_FRYINGPAN_MAX])
 JockeyLoot[LOOT_GUITAR_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_GUITAR_MIN])
 JockeyLoot[LOOT_GUITAR_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_GUITAR_MAX])
 JockeyLoot[LOOT_BAT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_BAT_MIN])
 JockeyLoot[LOOT_BAT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_BAT_MAX])
 JockeyLoot[LOOT_KATANA_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_KATANA_MIN])
 JockeyLoot[LOOT_KATANA_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_KATANA_MAX])
 JockeyLoot[LOOT_MACHETE_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_MACHETE_MIN])
 JockeyLoot[LOOT_MACHETE_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_MACHETE_MAX])
 JockeyLoot[LOOT_CRICKETBAT_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_CRICKETBAT_MIN])
 JockeyLoot[LOOT_CRICKETBAT_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_CRICKETBAT_MAX])
 JockeyLoot[LOOT_GRENADELAUNCHER_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_GRENADELAUNCHER_MIN])
 JockeyLoot[LOOT_GRENADELAUNCHER_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_GRENADELAUNCHER_MAX])
 JockeyLoot[LOOT_M60_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_M60_MIN])
 JockeyLoot[LOOT_M60_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_M60_MAX])
 JockeyLoot[LOOT_GOLF_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_GOLF_MIN])
 JockeyLoot[LOOT_GOLF_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_GOLF_MAX])
 JockeyLoot[LOOT_SMGS_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_SMGS_MIN])
 JockeyLoot[LOOT_SMGS_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_SMGS_MAX])
 JockeyLoot[LOOT_CHROME_MIN] = GetConVarInt(CVarJockeyLoot[LOOT_CHROME_MIN])
 JockeyLoot[LOOT_CHROME_MAX] = GetConVarInt(CVarJockeyLoot[LOOT_CHROME_MAX])
}
public Action:Event_PlayerDeath(Handle:hEvent, const String:strName[], bool:DontBroadcast)
{
 decl String:strBuffer[100];
 //qwerty search key
 new ClientId    = 0;
 
 ClientId = GetClientOfUserId(GetEventInt(hEvent, "userid"));
 
 if (ClientId == 0) 
 {
  // We had 0 so it MAY be a witch, check.
  GetEntityNetClass(GetEventInt(hEvent, "entityid"), strBuffer, sizeof(strBuffer));
  if (StrEqual(strBuffer, "Witch", false))
  {
   /*
   // TODO: Add witch functionallity
   // Witch Functionality Added Below,
   // This segment left in for error testing.
   //TellAll("entityid check");
   // Visual Check
   //LogMessage("entityid check");
   // Log Check
   */
  }
  return Plugin_Continue;
 }
 
 new class = GetEntProp(ClientId, Prop_Send, "m_zombieClass");
   
 if (class == ZOMBIECLASS_HUNTER)
 {
  LogMessage("[DICE] Hunter killed: Rolling for %i items.", HunterLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < HunterLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[HunterLoot[LOOT_DIENUMBER] - 1], HunterLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           HunterLoot,
           RollDice(HunterLoot[LOOT_DIECOUNT], HunterLoot[LOOT_DIENUMBER]));
  }       
 }
 else if (class == ZOMBIECLASS_SMOKER)
 {
  LogMessage("[DICE] Smoker killed: Rolling for %i items.", SmokerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < SmokerLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[SmokerLoot[LOOT_DIENUMBER] - 1], SmokerLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           SmokerLoot,
           RollDice(SmokerLoot[LOOT_DIECOUNT], SmokerLoot[LOOT_DIENUMBER]));
  }
 }
 else if (class == ZOMBIECLASS_BOOMER)
 {
  LogMessage("[DICE] Boomer killed: Rolling for %i items.", BoomerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < BoomerLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[BoomerLoot[LOOT_DIENUMBER] - 1], BoomerLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           BoomerLoot,
           RollDice(BoomerLoot[LOOT_DIECOUNT], BoomerLoot[LOOT_DIENUMBER]));
  }
  
 }
 else if (class == ZOMBIECLASS_SPITTER)
 {
  LogMessage("[DICE] Spitter killed: Rolling for %i items.", SpitterLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < SpitterLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[SpitterLoot[LOOT_DIENUMBER] - 1], SpitterLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           SpitterLoot,
           RollDice(SpitterLoot[LOOT_DIECOUNT], SpitterLoot[LOOT_DIENUMBER]));
  }
  
 }
 else if (class == ZOMBIECLASS_CHARGER)
 {
  LogMessage("[DICE] Charger killed: Rolling for %i items.", ChargerLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < ChargerLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[ChargerLoot[LOOT_DIENUMBER] - 1], ChargerLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           ChargerLoot,
           RollDice(ChargerLoot[LOOT_DIECOUNT], ChargerLoot[LOOT_DIENUMBER]));
  }
  
 }
 else if (class == ZOMBIECLASS_JOCKEY)
 {
  LogMessage("[DICE] Jockey killed: Rolling for %i items.", JockeyLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < JockeyLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[JockeyLoot[LOOT_DIENUMBER] - 1], JockeyLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           JockeyLoot,
           RollDice(JockeyLoot[LOOT_DIECOUNT], JockeyLoot[LOOT_DIENUMBER]));
  }
  
 }
 else if (class == ZOMBIECLASS_WITCH)
 {
  if (witchSpawn != 0)
  {
   numWitch -= 1;
   witchSpawn -= 1;
   if (witchSpawn < 0)
   {
    witchSpawn = 0;
   }
   LogMessage("Witch Lottery Enabled!");
  }
  else
  {
   LogMessage("Didn't Kill My Witch...");
  }
  LogMessage("[DICE] Witch killed: Rolling for %i items.", WitchLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < WitchLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[WitchLoot[LOOT_DIENUMBER] - 1], WitchLoot[LOOT_DIECOUNT]);
  
   SpawnItemFromDieResult(ClientId, 
           WitchLoot,
           RollDice(WitchLoot[LOOT_DIECOUNT], WitchLoot[LOOT_DIENUMBER]));
  }
  
 }
 else if (class == ZOMBIECLASS_TANK)
 {
  if (tankSpawn != 0)
  {
   numTank -= 1;
   tankSpawn -= 1;
   if (tankSpawn < 0)
   {
    tankSpawn = 0;
   }
   LogMessage("Tank Lottery Enabled!");
  }
  else
  {
   LogMessage("Didn't Kill My Tank...");
  }
  LogMessage("[DICE] Tank killed: Rolling for %i items.", TankLoot[LOOT_ITEM_COUNT]);
 
  for (new i = 0; i < TankLoot[LOOT_ITEM_COUNT]; i++)
  {
   LogMessage("[DICE] Rolling item %i, die has %i sides, %i dice will be rolled.", i + 1, Dice[TankLoot[LOOT_DIENUMBER] - 1], TankLoot[LOOT_DIECOUNT]);
   
   SpawnItemFromDieResult(ClientId, 
           TankLoot,
           RollDice(TankLoot[LOOT_DIECOUNT], TankLoot[LOOT_DIENUMBER]));
  }
 }
 
 return Plugin_Continue;
}
ExecuteCommand(Client, String:strCommand[], String:strParam1[])
{
 new flags = GetCommandFlags(strCommand);
    
 SetCommandFlags(strCommand, flags & ~FCVAR_CHEAT);
 FakeClientCommand(Client, "%s %s", strCommand, strParam1);
 SetCommandFlags(strCommand, flags);
}
ForcePanicEvent(client)
{
 new String:command[] = "director_force_panic_event";
 new flags = GetCommandFlags(command);
 
 SetCommandFlags(command, flags & ~FCVAR_CHEAT);
 FakeClientCommand(client, command);
 SetCommandFlags(command, flags);
}
TellHumans(String:msg[])
{
 for (new i = 1; i <= MaxClients; i++)
 {
  if (!IsClientInGame(i))
   continue;
  
  if (GetClientTeam(i) == 2)
   PrintHintText(i, msg);
 } 
 
}
TellInfected(String:msg[])
{
 for (new i = 1; i <= MaxClients; i++)
 {
  if (!IsClientInGame(i))
   continue;
  
  if (GetClientTeam(i) == 3)
   PrintHintText(i, msg);
 } 
 
}
TellAll(String:msg[])
{
 for (new i = 1; i <= MaxClients; i++)
 {
  if (!IsClientInGame(i))
   continue;
  
  if (GetClientTeam(i) > 1)
   PrintHintText(i, msg);
 } 
 
}
Give(Client, String:itemId[], String:playerMsg[], bool:sim = false)
{
 if (sim == false)
 {
  ExecuteCommand(Client, "give", itemId);
  
  LogMessage("[DICE] Spawned %s.", itemId);
  
  if (!StrEqual(playerMsg, ""))
   TellHumans(playerMsg);
 }
 else
  PrintToServer("[DICE SIM] Spawned %s.", itemId);
 
}
RollDice(dieCount, dieId, bool:sim = false)
{
 
 if (dieId == 0)
  return 0;
 
 new dieSides = Dice[dieId - 1];
 new result = 0;
 
 for (new i = 0; i < dieCount; i++)
 {
  new tempResult = GetRandomInt(0, dieSides);
  
  if (tempResult != 0)
   result += tempResult;
  
  if (sim == false)
   LogMessage("[DICE] Die %i, Result: %i, Total: %i", i + 1, tempResult, result);
  else
   PrintToServer("[DICE SIM] Die %i, Result: %i, Total: %i", i + 1, tempResult, result);
 }
 
 return result;
}
SpawnItemFromDieResult(client, diceSettings[100], dieResult, bool:sim = false)
{
 if (dieResult != 0)
 {
  PrintSettings(diceSettings);
  
  if (dieResult >= diceSettings[LOOT_KIT_MIN] && dieResult <= diceSettings[LOOT_KIT_MAX])
   Give(client, "first_aid_kit", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_MOLLY_MIN] && dieResult <= diceSettings[LOOT_MOLLY_MAX])
   Give(client, "molotov", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_PIPE_MIN] && dieResult <= diceSettings[LOOT_PIPE_MAX])
   Give(client, "pipe_bomb", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_PILLS_MIN] && dieResult <= diceSettings[LOOT_PILLS_MAX])
   Give(client, "pain_pills", "", sim);
  else if (dieResult >= diceSettings[LOOT_DEFIBRILLATOR_MIN] && dieResult <= diceSettings[LOOT_DEFIBRILLATOR_MAX])
   Give(client, "defibrillator", "", sim);
  else if (dieResult >= diceSettings[LOOT_EXPLOSIVE_MIN] && dieResult <= diceSettings[LOOT_EXPLOSIVE_MAX])
   Give(client, "upgradepack_explosive", "", sim);
  else if (dieResult >= diceSettings[LOOT_INCENDIARY_MIN] && dieResult <= diceSettings[LOOT_INCENDIARY_MAX])
   Give(client, "upgradepack_incendiary", "", sim);
  else if (dieResult >= diceSettings[LOOT_ADRENALINE_MIN] && dieResult <= diceSettings[LOOT_ADRENALINE_MAX])
   Give(client, "adrenaline", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_VOMITJAR_MIN] && dieResult <= diceSettings[LOOT_VOMITJAR_MAX])
   Give(client, "vomitjar", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_PANIC_MIN] && dieResult <= diceSettings[LOOT_PANIC_MAX])
  {
   if (!sim)
   {
    if (numPanic < GetConVarInt(panicMax) + 1)
    {
     numPanic += 1;
     ForcePanicEvent(client);
     LogMessage("Incoming Panic Event...");
     LogMessage("[DICE] Spawned Panic Event.");
    }
    else
    {
     TellAll("Panic Event Round Lottery Limit Reached...");
    }
   }
   else
   {
    PrintToServer("[DICE SIM] Spawned Panic Event");
   }
  }
  
  else if (dieResult >= diceSettings[LOOT_TANK_MIN] && dieResult <= diceSettings[LOOT_TANK_MAX])
  {
   if (!sim)
   {
    //Check to see if tank map limit reached.
    if (numTankMax < GetConVarInt(tankMapMax))
    {
     //Increase numTankMax to force tank map spawn restriction.
     numTankMax += 1;
     //Check to see if tank alive limit reached.
     //If not, spawn a tank.
     if (numTank < GetConVarInt(tankMax))
     // was (tankMax) +1 )
     {
     tankSpawn += 1;
     numTank += 1;
     ExecuteCommand(client, "z_spawn", "tank auto");
     LogMessage("A Tank Is Coming...");
     TellInfected("Tank...");
     LogMessage("[DICE] Spawned Tank.");
     }
     else
     {
     TellAll("Tank Lottery Allowance Detected...");     }
    }
    else
    {
    TellAll("Tank Round Lottery Limit Reached...");
    }
   }
   else
    PrintToServer("[DICE SIM] Spawned Tank");
  }
  else if (dieResult >= diceSettings[LOOT_WITCH_MIN] && dieResult <= diceSettings[LOOT_WITCH_MAX])
  {
   if (!sim)
   {
    //Check to see if witch map limit reached.
    if (numWitchMax < GetConVarInt(witchMapMax))
    {
     //Increase numWitchMax to force witch map spawn restriction.
     numWitchMax += 1;
     //Check to see if witch alive limit reached.
     //If not, spawn a witch.
     if (numWitch < GetConVarInt(witchMax))
     {
     // was (witchMax) + 1)
     witchSpawn += 1;
     numWitch += 1;
     ExecuteCommand(client, "z_spawn", "witch auto");
     LogMessage("A Witch Has Appeared...");
     TellInfected("Witch...");
     LogMessage("[DICE] Spawned Witch.");
     }
     else
     {
     TellAll("Witch Lottery Allowance Detected...");
     }
    }
    else
    {
    TellAll("Witch Round Lottery Limit Reached...");
    }
   }
   else
    PrintToServer("[DICE SIM] Spawned Witch");
  }
  else if (dieResult >= diceSettings[LOOT_COMMON_MIN] && dieResult <= diceSettings[LOOT_COMMON_MAX])
  {
   if (!sim)
   {
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common auto");
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common auto");
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common");
    ExecuteCommand(client, "z_spawn", "common auto");
    ExecuteCommand(client, "z_spawn", "common");
    
    LogMessage("[DICE] Spawned Commons.");
   }
   else
    PrintToServer("[DICE SIM] Spawned Commons");
  }
  else if (dieResult >= diceSettings[LOOT_PISTOL_MIN] && dieResult <= diceSettings[LOOT_PISTOL_MAX])
   Give(client, "pistol", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_SMG_MIN] && dieResult <= diceSettings[LOOT_SMG_MAX])
   Give(client, "smg", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_SHOT_MIN] && dieResult <= diceSettings[LOOT_SHOT_MAX])
   Give(client, "pumpshotgun", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_RIFLE_MIN] && dieResult <= diceSettings[LOOT_RIFLE_MAX])
   Give(client, "rifle", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_AUTOSHOT_MIN] && dieResult <= diceSettings[LOOT_AUTOSHOT_MAX])
   Give(client, "autoshotgun", "", sim);
  
  else if (dieResult >= diceSettings[LOOT_SNIPER_MIN] && dieResult <= diceSettings[LOOT_SNIPER_MAX])
   Give(client, "hunting_rifle", "", sim);
  else if (dieResult >= diceSettings[LOOT_AK47_MIN] && dieResult <= diceSettings[LOOT_AK47_MAX])
   Give(client, "rifle_ak47", "", sim);
  else if (dieResult >= diceSettings[LOOT_MILITARY_MIN] && dieResult <= diceSettings[LOOT_MILITARY_MAX])
   Give(client, "sniper_military", "", sim);
  else if (dieResult >= diceSettings[LOOT_SPAS_MIN] && dieResult <= diceSettings[LOOT_SPAS_MAX])
   Give(client, "shotgun_spas", "", sim);
  else if (dieResult >= diceSettings[LOOT_MAGNUM_MIN] && dieResult <= diceSettings[LOOT_MAGNUM_MAX])
   Give(client, "pistol_magnum", "", sim);
  else if (dieResult >= diceSettings[LOOT_CROWBAR_MIN] && dieResult <= diceSettings[LOOT_CROWBAR_MAX])
   Give(client, "crowbar", "", sim);
  else if (dieResult >= diceSettings[LOOT_DESERT_MIN] && dieResult <= diceSettings[LOOT_DESERT_MAX])
   Give(client, "rifle_desert", "", sim);
  else if (dieResult >= diceSettings[LOOT_CHAINSAW_MIN] && dieResult <= diceSettings[LOOT_CHAINSAW_MAX])
   Give(client, "chainsaw", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_AXE_MIN] && dieResult <= diceSettings[LOOT_AXE_MAX])
   Give(client, "fireaxe", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_TONFA_MIN] && dieResult <= diceSettings[LOOT_TONFA_MAX])
   Give(client, "tonfa", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_FRYINGPAN_MIN] && dieResult <= diceSettings[LOOT_FRYINGPAN_MAX])
   Give(client, "frying_pan", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_GUITAR_MIN] && dieResult <= diceSettings[LOOT_GUITAR_MAX])
   Give(client, "electric_guitar", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_BAT_MIN] && dieResult <= diceSettings[LOOT_BAT_MAX])
   Give(client, "baseball_bat", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_KATANA_MIN] && dieResult <= diceSettings[LOOT_KATANA_MAX])
   Give(client, "katana", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_MACHETE_MIN] && dieResult <= diceSettings[LOOT_MACHETE_MAX])
   Give(client, "machete", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_CRICKETBAT_MIN] && dieResult <= diceSettings[LOOT_CRICKETBAT_MAX])
   Give(client, "cricket_bat", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_GRENADELAUNCHER_MIN] && dieResult <= diceSettings[LOOT_GRENADELAUNCHER_MAX])
   Give(client, "grenade_launcher", "", sim);
   
  else if (dieResult >= diceSettings[LOOT_M60_MIN] && dieResult <= diceSettings[LOOT_M60_MAX])
   Give(client, "rifle_m60", "", sim);
  else if (dieResult >= diceSettings[LOOT_CHROME_MIN] && dieResult <= diceSettings[LOOT_CHROME_MAX])
   Give(client, "shotgun_chrome", "", sim);
  else if (dieResult >= diceSettings[LOOT_SMGS_MIN] && dieResult <= diceSettings[LOOT_SMGS_MAX])
   Give(client, "smg_silenced", "", sim);
  else if (dieResult >= diceSettings[LOOT_GOLF_MIN] && dieResult <= diceSettings[LOOT_GOLF_MAX])
   Give(client, "golfclub", "", sim);
 }
}

[Marcus101RR]

I wish I knew which cvars of l4d1 control the frequency of special infected spawning and timing. I want Expert SI spawning to be the same on all difficulties.