JS-скрипт Northwood self-leak [OTV4]

Забаненный
Статус
Оффлайн
Регистрация
8 Июл 2021
Сообщения
45
Реакции[?]
26
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
credits : wish, yagodnick

JavaScript:
const p = {
    exploits: ["Rage", "Exploits", "General"],
    rage: ["Rage", "General", "General"],
    rage_keys: ["Rage", "General", "General", "Key assignment"],
    antiaim: ["Rage", "Anti Aim", "Directions"],
    antiaim_fake: ["Rage", "Anti Aim", "Fake"],
    antiaim_keys: ["Rage", "Anti Aim", "General", "Key assignment"],
    visuals: ["Visuals", "ESP", "Enemy"],
    radar: ["Visuals", "Extra", "Radar"],
    cheat: ["Config", "Cheat", "General"],
    script_ui: ["Misc.", "Helpers", "General"],
    indicators: ["Misc.", "Helpers", "Client"],
    general: ["Config", "Scripts", "Scripts"]
}

var GUI = {
    GetPath: function(path, name) {
        if (path.length == 3)
            return [path[0], path[1], path[2], name];
        else
            return [path[0], path[1], path[2], path[3], name];
    },
    GetValue: function(path, name) {
        return UI.GetValue(GUI.GetPath(path, name));
    },
    GetColor: function(path, name) {
        return UI.GetColor(GUI.GetPath(path, name));
    },
    GetString: function(path, name) {
        return UI.GetString(GUI.GetPath(path, name));
    },
    SetValue: function(path, name, value) {
        UI.SetValue(GUI.GetPath(path, name), value);
    },
    SetEnabled: function(path, name, value) {
        UI.SetEnabled(GUI.GetPath(path, name), value);
    },
    RegisterCallback: function(path, name, func) {
        UI.RegisterCallback(GUI.GetPath(path, name), func);
    },
}

UI.AddDropdown(p.script_ui, "[NW] UI style", ["Flat", "Fade", "Dynamic fade"], 0);
UI.AddColorPicker(p.script_ui, "[NW] UI color");
if (GUI.GetColor(p.script_ui, "[NW] UI color") == [255, 255, 255, 255]);
    UI.SetColor(GUI.GetPath(p.script_ui, "[NW] UI color"), [89, 119, 239, 125]);
UI.AddSliderFloat(p.script_ui, "[NW] Fade offset", 0, 3.99)
UI.AddSliderFloat(p.script_ui, "[NW] Fade animation speed", 0.01, 10)
UI.AddSliderFloat(p.script_ui, "[NW] Fade split ratio", 0, 1)
UI.AddSliderFloat(p.script_ui, "[NW] Background split ratio", 0, 1)


// First, checks if it isn't implemented yet.
if (!String.format) {
    String.format = function(format) {
      var args = Array.prototype.slice.call(arguments, 1);
      return format.replace(/{(\d+)}/g, function(match, number) {
        return typeof args[number] != 'undefined'
          ? args[number]
          : match
        ;
      });
    };
}

var Northwood = {
    LatestLoad: 0,
    I_Offset: 0,
    Utils: {
        StatusColor: function(num, max, decl) {
            var Colors = [[255, 0, 0], [237, 27, 3], [235, 63, 6], [229, 104, 8],
            [228, 126, 10], [220, 169, 16], [213, 201, 19], [176, 205, 10], [124, 195, 13]];

            var int = (num > max ? max : num);
            var tmp = max / int;

            var declspec = Colors.length - 1;
            var i = declspec / tmp;
            if (decl)
                i += decl;
            i = (i >= 0 ? Math.floor(i + 0.5) : 0)
            i = Math.min(i, declspec);
            //Cheat.Print(String.format("i: {0}\n", i))
            return Colors[i];
        }
    },
    Get: function(dbname) {
        return DataFile.GetKey("northwood", dbname)
    },
    Write: function(dbname, dbvalue) {
        DataFile.SetKey("northwood", dbname, dbvalue)
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    Erase: function(dbname) {
        DataFile.EraseKey("northwood", dbname)
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    OnLoad: function() {
        DataFile.Load("northwood")
        Northwood.LatestLoad = DataFile.GetKey("northwood", "latest_load")
        var today = new Date()
        DataFile.SetKey("northwood", "latest_load", today.toString().substring(0, 16))
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    OnUnload: function() {
        DataFile.Save("northwood")
    },
    OnDraw: function() {
        Northwood.I_Offset = 0;

        if (GUI.GetValue(p.script_ui, "[NW] UI style") == 2)
            GUI.SetEnabled(p.script_ui, "[NW] Fade animation speed", 1)
        else
            GUI.SetEnabled(p.script_ui, "[NW] Fade animation speed", 0)
    },
    IsBeta: function() {
        return true;
    },
    GetColor: function() {
        return GUI.GetColor(p.script_ui, "[NW] UI color")
    },
    GetStyle: function() {
        switch (GUI.GetValue(p.script_ui, "[NW] UI style")) {
            case 0:
                return 0;
            case 1:
            case 2:
                return 1;
        }
    },
    GetFade: function() {
        if (GUI.GetValue(p.script_ui, "[NW] UI style") == 2)
            var value = (Globals.Curtime() * GUI.GetValue(p.script_ui, "[NW] Fade animation speed")) % 4
        else
            var value = GUI.GetValue(p.script_ui, "[NW] Fade offset")
        var alpha = GUI.GetValue(p.script_ui, "[NW] Fade split ratio")
        var maxv = 255 * (value % 1)
        var midv = 200 * (value % 1)
        var minv = 180 * (value % 1)
        var mminv = 55 * (value % 1)
        var mmminv = 75 * (value % 1)
        var r, g, b;
        if (value < 1) {
            r = [0 + maxv, 0, 255 - mmminv, 255 * alpha];
            g = [255 - mmminv, 0 + maxv, 0, 255 * alpha];
            b = [0, 255 - mmminv, 0 + maxv, 255 * alpha];
        }
        else if (value < 2) {
            r = [255 - mminv, 0 + maxv, 180 - minv, 255 * alpha];
            g = [180 - minv, 255, 0 + midv, 255 * alpha];
            b = [0 + maxv, 180 - minv, 255 - mminv, 255 * alpha];
        }
        else if (value < 3) {
            r = [200 - midv, 255, 0 + maxv, 255 * alpha];
            g = [0 + maxv, 255 - maxv, 200 + mminv, 255 * alpha];
            b = [255, 0 + maxv, 200 - midv, 255 * alpha];
        }
        else {
            r = [0, 255 - maxv, 255, 255 * alpha];
            g = [255, 0, 255 - maxv, 255 * alpha];
            b = [255 - maxv, 255, 0, 255 * alpha];
        }
        return [r, g, b]
    },
    GetBackground: function() {
        var value = GUI.GetValue(p.script_ui, "[NW] Background split ratio")
        var first = [17, 17, 17, Northwood.GetColor()[3] * value]
        var second = [17, 17, 17, Northwood.GetColor()[3]]
        return [first, second]
    }
}
Northwood.OnLoad();
Cheat.RegisterCallback("Unload", "Northwood.OnUnload")
Cheat.RegisterCallback("Draw", "Northwood.OnDraw")

var size = Render.GetScreenSize();
size = [size[0], size[1] - 60];
var nlogs = new Array();
var speed = 0;

function draw_arc1(a,n,o,r,t,h,M,c){M=360/M;for(var e=t;e<t+h;e+=M){var s=e*Math.PI/180,P=(e+M)*Math.PI/180,d=Math.cos(s),i=Math.sin(s),f=Math.cos(P),g=Math.sin(P),l=a+d*r,v=n+i*r,y=a+d*o,I=n+i*o,R=a+f*r,u=n+g*r,w=a+f*o,_=n+g*o;Render.Polygon([[y,I],[w,_],[l,v]],c),Render.Polygon([[l,v],[w,_],[R,u]],c)}};
function notify(e, i, r) {
    var n = Render.GetFont("Verdana.ttf", 11, true);
        d = Render.TextSize(e, n)[0],
        s = Math.floor(size[0] / 2) - 4 - Math.floor(d / 2);
        draw_arc1(s-1, size[1] - 60 - i, 15, 0, 90, 180, 60, [56, 56, 57, 150 * r])
        draw_arc1(s+d, size[1] - 60 - i, 15, 0, 270, 180, 60, [56, 56, 57, 150 * r])
        Render.FilledRect(s, size[1] - 60 - i - 15, d, 31, [56, 56, 57, 150 * r]);
        Render.FilledRect(s-1, size[1] - 60 - i - 15, 1, 31, [56, 56, 57, 100 * r]);
        Render.FilledRect(s+d, size[1] - 60 - i - 15, 1, 31, [56, 56, 57, 100 * r]);
        Render.String(s, size[1] - 60 - i - 8, 0, e, [255, 255, 255, 255 * r], n)
};

//GUI.SetEnabled(P.exploits, "Double tap", 0);
//GUI.RegisterCallback(P.exploits, "Double tap", "TestLog");

/*
Section: Tickbase
*/

UI.AddMultiDropdown(p.exploits, "Double tap options", ["Decrease recharge delay", "WIP: Tickbase correction"]);

var Tickbase = {
    LastShot: 0,
    MaxShift: function() {
        return Convar.GetInt("sv_maxusrcmdprocessticks");
    },
    CanShift: function(Ticks) {
        var me = Entity.GetLocalPlayer();
        var wpn = Entity.GetWeapon(me);
    
        if (me == null || wpn == null)
            return false;
    
        var tickbase = Entity.GetProp(me, "CCSPlayer", "m_nTickBase");
        //var tickbase = Globals.Tickcount();
        var curtime = Globals.TickInterval() * (tickbase-Ticks)
    
        if (curtime < Entity.GetProp(me, "CCSPlayer", "m_flNextAttack"))
            return false;
    
        if (curtime < Entity.GetProp(wpn, "CBaseCombatWeapon", "m_flNextPrimaryAttack"))
            return false;

        /*if ((Globals.Tickcount() - Ticks - (Globals.Latency() * Globals.TickInterval())) > Tickbase.LastShot)
            return true;*/
    
        return true;
    },
    CreateMove: function() {
        var Options = GUI.GetValue(p.exploits, "Double tap options");
        var Charge = Exploit.GetCharge();

        //Exploit.OverrideTolerance(0);
        //Exploit.OverrideShift(Tickbase.MaxShift())

        if (Options & 1 << 0) {
            Exploit[(Charge != 1 ? "Enable" : "Disable") + "Recharge"]()
            if (Tickbase.CanShift(1) && Charge != 1) {
                Exploit.DisableRecharge();
                if (Ragebot.GetTargets().length == 0)
                    Exploit.Recharge();
            }
        }
        else {
            Exploit.EnableRecharge()
        }
        if (Options & 1 << 1) {
            if (Charge == 1) {
                Exploit.OverrideMaxProcessTicks(Tickbase.MaxShift() + 1);
                Exploit.OverrideShift(Tickbase.MaxShift());
                GUI.SetValue(p.exploits, "Options", GUI.GetValue(p.exploits, "Options") & ~(1 << 5));
            }
            else {
                Exploit.OverrideMaxProcessTicks(Tickbase.MaxShift());
            }
        }
    }
}

Cheat.RegisterCallback("CreateMove", "Tickbase.CreateMove");



/*
Section: Anti-aim
*/

var aa_active = UI.AddCheckbox(p.antiaim, "Extended anti-aimbot angles");

UI.AddDropdown(p.antiaim, "Anti-aimbot mode", ["Standing", "Walking", "Moving"], 0);

//STANDING
UI.AddDropdown(p.antiaim, "[S] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[S] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[S] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[S] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[S] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[S] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[S] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[S] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[S] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[S] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[S] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//WALKING
UI.AddDropdown(p.antiaim, "[W] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[W] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[W] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[W] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[W] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[W] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[W] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[W] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[W] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[W] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[W] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//MOVING
UI.AddDropdown(p.antiaim, "[M] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[M] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[M] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[M] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[M] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[M] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[M] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[M] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[M] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[M] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[M] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//UTILS
UI.AddCheckbox(["Rage", "Anti Aim", "General"], "Manual direction")
UI.AddColorPicker(["Rage", "Anti Aim", "General"], "Direction color")
UI.AddHotkey(p.antiaim_keys, "Freestanding", "Freestanding")
UI.AddDropdown(p.antiaim_fake, "Lower body yaw", ["Opposite", "Eye yaw"], 0);

function RandomInt(min, max) {
    return Math.floor(Math.random() * (max - min)) + min;
}

function Clamp(num, min, max) {
    return num <= min ? min : num >= max ? max : num;
}

function deg2rad( degress ) {
    return degress * Math.PI / 180.0;
}

function angle_to_vec( pitch, yaw ) {
    var p = deg2rad( pitch );
    var y = deg2rad( yaw )
    var sin_p = Math.sin( p );
    var cos_p = Math.cos( p );
    var sin_y = Math.sin( y );
    var cos_y = Math.cos( y );
    return [ cos_p * cos_y, cos_p * sin_y, -sin_p ];
}

function trace( entity_id, entity_angles ) {
    var entity_vec = angle_to_vec( entity_angles[0], entity_angles[1] );
    var entity_pos = Entity.GetRenderOrigin( entity_id );
    entity_pos[2] += 50;
    var stop = [ entity_pos[ 0 ] + entity_vec[0] * 8192, entity_pos[1] + entity_vec[1] * 8192, ( entity_pos[2] )  + entity_vec[2] * 8192 ];
    var traceResult = Trace.Line( entity_id, entity_pos, stop );
    if( traceResult[1] == 1.0 )
        return;
    stop = [ entity_pos[ 0 ] + entity_vec[0] * traceResult[1] * 8192, entity_pos[1] + entity_vec[1] * traceResult[1] * 8192, entity_pos[2] + entity_vec[2] * traceResult[1] * 8192 ];
    var distance = Math.sqrt( ( entity_pos[0] - stop[0] ) * ( entity_pos[0] - stop[0] ) + ( entity_pos[1] - stop[1] ) * ( entity_pos[1] - stop[1] ) + ( entity_pos[2] - stop[2] ) * ( entity_pos[2] - stop[2] ) );
    entity_pos = Render.WorldToScreen( entity_pos );
    stop = Render.WorldToScreen( stop );
    if( stop[2] != 1 || entity_pos[2] != 1 )
        return;

    return distance;
}

var lastHitTime = 0.0;
var lastImpactTimes =
[
    0.0
];
var lastImpacts =
[
    [0.0, 0.0, 0.0]
];

function radian(degree)
{
    return degree * Math.PI / 180.0;
}

function ExtendVector(vector, angle, extension)
{
    var radianAngle = radian(angle);
    return [extension * Math.cos(radianAngle) + vector[0], extension * Math.sin(radianAngle) + vector[1], vector[2]];
}

function VectorAdd(a, b)
{
    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
}

function VectorSubtract(a, b)
{
    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
}

function VectorMultiply(a, b)
{
    return [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
}

function VectorLength(x, y, z)
{
    return Math.sqrt(x * x + y * y + z * z);
}

function VectorNormalize(vec)
{
    var length = VectorLength(vec[0], vec[1], vec[2]);
    return [vec[0] / length, vec[1] / length, vec[2] / length];
}

function VectorDot(a, b)
{
    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

function VectorDistance(a, b)
{
    return VectorLength(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
}

function ClosestPointOnRay(target, rayStart, rayEnd)
{
    var to = VectorSubtract(target, rayStart);
    var dir = VectorSubtract(rayEnd, rayStart);
    var length = VectorLength(dir[0], dir[1], dir[2]);
    dir = VectorNormalize(dir);

    var rangeAlong = VectorDot(dir, to);
    if (rangeAlong < 0.0)
    {
        return rayStart;
    }
    if (rangeAlong > length)
    {
        return rayEnd;
    }
    return VectorAdd(rayStart, VectorMultiply(dir, [rangeAlong, rangeAlong, rangeAlong]));
}
var latest_impact = 0;
var Antiaim = {
    Counter: 0,
    Real: 0,
    Fake: 0,
    Lby: 0,
    Inverse: false,
    Enabled: false,
    ManualKey: "none",
    ManualLeft: false,
    ManualRight: false,
    ManualBack: false,
    GetMode: function() {
        var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
        var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
        var mode = 0;
        if (GUI.GetValue(p.antiaim_keys, "Slow walk"))
            mode = 1;
        else if (speed > 30)
            mode = 2;

        return mode;
    },
    HideGroups: function(standing, walking, moving) {
        //STANDING
        GUI.SetEnabled(p.antiaim, "[S] Yaw base", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw offset", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw jitter", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw jitter offset", standing);
        GUI.SetEnabled(p.antiaim, "[S] Edge yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw offset", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw limit", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Freestand fake yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Bullet evasion", standing);

        //WALKING
        GUI.SetEnabled(p.antiaim, "[W] Yaw base", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw offset", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw jitter", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw jitter offset", walking);
        GUI.SetEnabled(p.antiaim, "[W] Edge yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw offset", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw limit", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Freestand fake yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Bullet evasion", walking);

        //MOVING
        GUI.SetEnabled(p.antiaim, "[M] Yaw base",  moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw offset", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw jitter", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw jitter offset", moving);
        GUI.SetEnabled(p.antiaim, "[M] Edge yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw offset", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw limit", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Freestand fake yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Bullet evasion", moving);
    },
    HideElements: function(bool) {
        if (bool) {
            GUI.SetEnabled(p.antiaim, "At targets", 0);
            GUI.SetEnabled(p.antiaim, "Yaw offset", 0);
            GUI.SetEnabled(p.antiaim, "Jitter offset", 0);
            GUI.SetEnabled(p.antiaim, "Auto direction", 0);
            GUI.SetEnabled(p.antiaim, "Manual direction", 0);
            GUI.SetEnabled(p.antiaim, "Mouse direction", 0);
            GUI.SetEnabled(p.antiaim, "In Air mode", 0);
            GUI.SetEnabled(p.antiaim_fake, "Fake angles", 0);
            GUI.SetEnabled(p.antiaim_fake, "Jitter move", 0);
            GUI.SetEnabled(p.antiaim_fake, "On-shot desync", 0);
            GUI.SetEnabled(p.antiaim_fake, "Hide real angle", 0);
            GUI.SetEnabled(p.antiaim_fake, "Avoid overlap", 0);
            GUI.SetEnabled(p.antiaim_fake, "Fake desync", 0);
            GUI.SetEnabled(p.antiaim_fake, "Lower body yaw mode", 0);
            GUI.SetEnabled(p.antiaim_fake, "Inverter flip conditions", 0);
        }
        else {
            GUI.SetEnabled(p.antiaim, "At targets", 1);
            GUI.SetEnabled(p.antiaim, "Yaw offset", 1);
            GUI.SetEnabled(p.antiaim, "Jitter offset", 1);
            GUI.SetEnabled(p.antiaim, "Auto direction", 1);
            GUI.SetEnabled(p.antiaim, "Manual direction", 1);
            GUI.SetEnabled(p.antiaim, "Mouse direction", 1);
            GUI.SetEnabled(p.antiaim, "In Air mode", 1);
            GUI.SetEnabled(p.antiaim_fake, "Fake angles", 1);
            GUI.SetEnabled(p.antiaim_fake, "Jitter move", 1);
            GUI.SetEnabled(p.antiaim_fake, "On-shot desync", 1);
            GUI.SetEnabled(p.antiaim_fake, "Hide real angle", 1);
            GUI.SetEnabled(p.antiaim_fake, "Avoid overlap", 1);
            GUI.SetEnabled(p.antiaim_fake, "Fake desync", 1);
            GUI.SetEnabled(p.antiaim_fake, "Lower body yaw mode", 1);
            GUI.SetEnabled(p.antiaim_fake, "Inverter flip conditions", 1);
        }
    },
    Callback: function() {
        if (GUI.GetValue(p.antiaim, "Extended anti-aimbot angles")) {
            Antiaim.HideElements(true);
            AntiAim.SetOverride(1);
        }
        else {
            Antiaim.HideElements(false);
            AntiAim.SetOverride(0);
            Antiaim.HideGroups(0, 0, 0)
        }
    },
    Unload: function() {
        Antiaim.HideElements(false);
        AntiAim.SetOverride(0);
    },
    CreateMove: function() {
        if (UI.GetValue(aa_active)) {
            AntiAim.SetOverride(1);
        }
        else {
            AntiAim.SetOverride(0);
            return
        }

        GUI.SetValue(p.antiaim, "Manual direction", 0)
        UI.SetHotkeyState(p.antiaim_keys.concat("Left direction"), "Hold")
        UI.SetHotkeyState(p.antiaim_keys.concat("Back direction"), "Hold")
        UI.SetHotkeyState(p.antiaim_keys.concat("Right direction"), "Hold")
        

        if (GUI.GetValue(["Rage", "Anti Aim", "General"], "Manual direction")) {
            if (GUI.GetValue(p.antiaim_keys, "Left direction")) {
                if (!Antiaim.ManualLeft) {
                    Antiaim.ManualLeft = true;
                    if (Antiaim.ManualKey == "left")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "left"
                }
            }
            else
                Antiaim.ManualLeft = false

            if (GUI.GetValue(p.antiaim_keys, "Back direction")) {
                if (!Antiaim.ManualBack) {
                    Antiaim.ManualBack = true;
                    if (Antiaim.ManualKey == "back")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "back"
                }
            }
            else
                Antiaim.ManualBack = false
            
            if (GUI.GetValue(p.antiaim_keys, "Right direction")) {
                if (!Antiaim.ManualRight) {
                    Antiaim.ManualRight = true;
                    if (Antiaim.ManualKey == "right")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "right"
                }
            }
            else
                Antiaim.ManualRight = false
        }
        if (Globals.ChokedCommands() > 0)
            return;

        Antiaim.Counter++;
        var local = Entity.GetLocalPlayer();

        /*
        * Anti-aimbot: Real yaw
        */

        GUI.SetValue(p.antiaim, "Auto direction", GUI.GetValue(p.antiaim_keys, "Freestanding"))

        switch (Antiaim.GetMode()) {
            case 0:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[S] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[S] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[S] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[S] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[S] Yaw jitter offset"));
                        break;
                }
                if (GUI.GetValue(p.antiaim, "[S] Edge yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var forward_distance = trace(local, [0, eye_angles[1]]);
                    /*var left_distance = trace(local, [0, eye_angles[1] - 90]);
                    var right_distance = trace(local, [0, eye_angles[1] + 90]);
                    var back_distance = trace(local, [0, eye_angles[1] + 180]);*/

                    if (forward_distance < 30)
                        Antiaim.Real = 90;
                }
                break;
            case 1:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[W] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[W] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[W] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[W] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[W] Yaw jitter offset"));
                        break;
                }
                break;
            case 2:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[M] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[M] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[M] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[M] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[M] Yaw jitter offset"));
                        break;
                }
                break;
        }
            

        /*
        * Anti-aimbot: Fake yaw
        */

        switch (Antiaim.GetMode()) {
            case 0:
                switch (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw())) < 1) {
                            Antiaim.Real *= -1;
                        } 
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[S] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
            case 1:
                switch (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(Math.abs(Local.GetRealYaw()) - Math.abs(Local.GetFakeYaw()) < 1)) {
                            Antiaim.Real *= -1;
                        }
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[W] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
            case 2:
                switch (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(Math.abs(Local.GetRealYaw()) - Math.abs(Local.GetFakeYaw()) < 1)) {
                            Antiaim.Real *= -1;
                        } 
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[M] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
        }

        /*
        * Anti-aimbot: Setting values
        */

        if (Antiaim.Inverse) {
            switch (Antiaim.GetMode()) {
                case 0:
                    switch (GUI.GetValue(p.antiaim_fake, "[S] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
                case 1:
                    switch (GUI.GetValue(p.antiaim_fake, "[W] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
                case 2:
                    switch (GUI.GetValue(p.antiaim_fake, "[M] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
            }
        }

        if (GUI.GetValue(p.antiaim_keys, "AA Direction inverter"))
            Antiaim.Fake *= -1;
        
        if (Antiaim.ManualKey == "left") {
            GUI.SetValue(p.antiaim, "At targets", 0)
            Antiaim.Real = -45;
        }
        else if (Antiaim.ManualKey == "right") {
            GUI.SetValue(p.antiaim, "At targets", 0)
            Antiaim.Real = 45;
        }

        switch (GUI.GetValue(p.antiaim_fake, "Lower body yaw")) {
            case 0:
                GUI.SetValue(p.antiaim, "Yaw offset", Antiaim.Real);
                AntiAim.SetFakeOffset(Antiaim.Real)
                AntiAim.SetRealOffset(Antiaim.Fake != 0 ? Antiaim.Fake * 2 + (Antiaim.Fake > 0 ? -60 : 60) : 60)
                AntiAim.SetLBYOffset(Antiaim.Fake > 0 ? -120 : 120);
                break;
            case 1:
                GUI.SetValue(p.antiaim, "Yaw offset", Antiaim.Real - Antiaim.Fake / 4);
                AntiAim.SetFakeOffset(Antiaim.Real)
                AntiAim.SetRealOffset(Antiaim.Real + Antiaim.Fake)
                AntiAim.SetLBYOffset(0);
                break;
        } 
    },
    ArrowsAlpha: 0,
    ArrowsText: "",
    AlphaShouldSwitch: false,
    MenuUpdate: Globals.Curtime(),
    Draw: function() {
        if (Antiaim.MenuUpdate + 0.16 < Globals.Curtime()) {
            Antiaim.MenuUpdate = Globals.Curtime()
            switch (GUI.GetValue(p.antiaim, "Anti-aimbot mode")) {
                case 0:
                    Antiaim.HideGroups(1, 0, 0);
                    break;
                case 1:
                    Antiaim.HideGroups(0, 1, 0);
                    break;
                case 2:
                    Antiaim.HideGroups(0, 0, 1);
                    break;
            }
            Antiaim.Callback()
        }
        
        // Arrows
        if (World.GetServerString() && Entity.IsAlive(Entity.GetLocalPlayer())) {
            var t = Globals.Frametime() * 1.5 * 255;
            if (GUI.GetValue(["Rage", "Anti Aim", "General"], "Manual direction")) {
                var color = GUI.GetColor(["Rage", "Anti Aim", "General"], "Direction color")
                color[3] = Antiaim.ArrowsAlpha
                var y = center_screen[1]
                if (Antiaim.ManualKey == "left") {
                    Antiaim.ArrowsText = "left"
                    if (Antiaim.ArrowsAlpha == 255) AlphaShouldSwitch = true;
                    else if (Antiaim.ArrowsAlpha == 0) AlphaShouldSwitch = false;
                    Antiaim.ArrowsAlpha += (AlphaShouldSwitch ? -t : t);
                }
                else if (Antiaim.ManualKey == "right") {
                    Antiaim.ArrowsText = "right"
                    if (Antiaim.ArrowsAlpha == 255) AlphaShouldSwitch = true;
                    else if (Antiaim.ArrowsAlpha == 0) AlphaShouldSwitch = false;
                    Antiaim.ArrowsAlpha += (AlphaShouldSwitch ? -t : t);
                }
                else {
                    Antiaim.ArrowsAlpha -= t * 2;
                } 
                Antiaim.ArrowsAlpha = Clamp(Antiaim.ArrowsAlpha, 0, 255)
                if (Antiaim.ArrowsText == "left") {
                    var x = center_screen[0] - 50
                    Render.Polygon( [[x, y], [x+15, y-8], [x+12, y]], color);
                    Render.Polygon( [[x+12, y], [x+15, y+8], [x, y]], color);
                    Render.Polygon( [[x, y], [x+15, y-8], [x+12, y]], [255, 255, 255, 25 * (Antiaim.ArrowsAlpha / 255)]);
                    Render.Polygon( [[x+12, y], [x+15, y+8], [x, y]], [0, 0, 0, 50 * (Antiaim.ArrowsAlpha / 255)]);
                }
                else if (Antiaim.ArrowsText == "right") {
                    var x = center_screen[0] + 50
                    Render.Polygon( [[x-12, y], [x-15, y-8], [x, y]], color);
                    Render.Polygon( [[x-15, y+8], [x-12, y], [x, y]], color);
                    Render.Polygon( [[x-12, y], [x-15, y-8], [x, y]], [255, 255, 255, 25 * (Antiaim.ArrowsAlpha / 255)]);
                    Render.Polygon( [[x-15, y+8], [x-12, y], [x, y]], [0, 0, 0, 50 * (Antiaim.ArrowsAlpha / 255)]);
                }
                
                //Visuals.Text(center_screen[0] + (Antiaim.ArrowsText == "<" ? -50 : 50), center_screen[1] - 10, "+", Antiaim.ArrowsText, color)
              
            }
        }
        
        
    },
    BulletImpact: function() {
        var curtime = Global.Curtime();

        if (Entity.GetEntityFromUserID(Event.GetInt("userid")) == Entity.GetLocalPlayer())
            latest_impact = Globals.Tickcount();

        if (Math.abs(lastHitTime - curtime) < 0.5) return;

        var entity = Entity.GetEntityFromUserID(Event.GetInt("userid"));
        var impact = [Event.GetFloat("x"), Event.GetFloat("y"), Event.GetFloat("z"), curtime];
        var source;
        if (Entity.IsValid(entity) && Entity.IsEnemy(entity))
        {
            if (!Entity.IsDormant(entity))
            {
                source = Entity.GetEyePosition(entity);
            }
            else if (Math.abs(lastImpactTimes[entity] - curtime) < 0.1)
            {
                source = lastImpacts[entity];
            }
            else
            {
                lastImpacts[entity] = impact;
                lastImpactTimes[entity] = curtime;
                return;
            }
            var local = Entity.GetLocalPlayer();
            var localEye = Entity.GetEyePosition(local);
            var localOrigin = Entity.GetProp(local, "CBaseEntity", "m_vecOrigin");
            var localBody = VectorMultiply(VectorAdd(localEye, localOrigin), [0.5, 0.5, 0.5]);

            var bodyVec = ClosestPointOnRay(localBody, source, impact);
            var bodyDist = VectorDistance(localBody, bodyVec);
        
            if (bodyDist < 150)       //he clearly shot at us!
            {
                var realAngle = Local.GetRealYaw();
                var fakeAngle = Local.GetFakeYaw();

                var headVec = ClosestPointOnRay(localEye, source, impact);
                var headDist = VectorDistance(localEye, headVec);
                var feetVec = ClosestPointOnRay(localOrigin, source, impact);
                var feetDist = VectorDistance(localOrigin, feetVec);

                var closestRayPoint;
                var realPos;
                var fakePos;

                if (bodyDist < headDist && bodyDist < feetDist)     //that's a pelvis
                {                                                   //pelvis direction = goalfeetyaw + 180   
                    closestRayPoint = bodyVec;
                    realPos = ExtendVector(bodyVec, realAngle + 180.0, 10.0);
                    fakePos = ExtendVector(bodyVec, fakeAngle + 180.0, 10.0);
                }
                else if (feetDist < headDist)                       //ow my toe
                {                                                   //toe direction = goalfeetyaw -30 +- 90
                    closestRayPoint = feetVec;
                    var realPos1 = ExtendVector(bodyVec, realAngle - 30.0 + 60.0, 10.0);
                    var realPos2 = ExtendVector(bodyVec, realAngle - 30.0 - 60.0, 10.0);
                    var fakePos1 = ExtendVector(bodyVec, fakeAngle - 30.0 + 60.0, 10.0);
                    var fakePos2 = ExtendVector(bodyVec, fakeAngle - 30.0 - 60.0, 10.0);
                    if (VectorDistance(feetVec, realPos1) < VectorDistance(feetVec, realPos2))
                    {
                        realPos = realPos1;
                    }
                    else
                    {
                        realPos = realPos2;
                    }
                    if (VectorDistance(feetVec, fakePos1) < VectorDistance(feetVec, fakePos2))
                    {
                        fakePos = fakePos1;
                    }
                    else
                    {
                        fakePos = fakePos2;
                    }
                }
                else                                                //ow my head i feel like i slept for 2 days
                {
                    closestRayPoint = headVec;
                    realPos = ExtendVector(bodyVec, realAngle, 10.0);
                    fakePos = ExtendVector(bodyVec, fakeAngle, 10.0);
                }

                if (VectorDistance(closestRayPoint, fakePos) < VectorDistance(closestRayPoint, realPos))        //they shot at our fake. they will probably not gonna shoot it again.
                {
                    lastHitTime = curtime;
                    Antiaim.Inverse = !Antiaim.Inverse
                }
            }

            lastImpacts[entity] = impact;
            lastImpactTimes[entity] = curtime;
        }
    },
}

Antiaim.HideElements(GUI.GetValue(p.antiaim, "Extended anti-aimbot angles"));
Antiaim.HideGroups(0, 0, 0);
Antiaim.Callback();
GUI.RegisterCallback(p.antiaim, "Extended anti-aimbot angles", "Antiaim.Callback");
Cheat.RegisterCallback("CreateMove", "Antiaim.CreateMove");
Cheat.RegisterCallback("bullet_impact", "Antiaim.BulletImpact")
Cheat.RegisterCallback("Unload", "Antiaim.Unload");
Cheat.RegisterCallback("Draw", "Antiaim.Draw");

/*
* Section: Materials
*/

var mats = []
var subtab = ["Visuals", "Chams", "Global"]
var editor_array = []

function makemat(name) {
    Material.Create(name)
    editor_array.push(name)
    mats.push({
        mat_name: name,
        ui_color: subtab.concat(name + " color"),
        update: true,
        update_color: true,
        first: true
    })
}
function lerp(a, b, c) {
    return (b - a) * c + a
}
function HSVtoRGB(h, s, v) {
    var r, g, b, i, f, p, q, t;
    if (arguments.length === 1) {
        s = h.s, v = h.v, h = h.h;
    }
    i = Math.floor(h * 6);
    f = h * 6 - i;
    p = v * (1 - s);
    q = v * (1 - f * s);
    t = v * (1 - (1 - f) * s);
    switch (i % 6) {
        case 0: r = v, g = t, b = p; break;
        case 1: r = q, g = v, b = p; break;
        case 2: r = p, g = v, b = t; break;
        case 3: r = p, g = q, b = v; break;
        case 4: r = t, g = p, b = v; break;
        case 5: r = v, g = p, b = q; break;
    }
    return [
        Math.round(r * 255),
        Math.round(g * 255),
        Math.round(b * 255),
        255
    ]
}
function Glow_Material() {
    for (i in mats) {
        var mat = Material.Get(mats[i].mat_name)
        var refresh = false
        if (mats[i].first) {
            mats[i].first = false
            Material.SetKeyValue(mat, "$basetexture", "vgui/white")
            Material.SetKeyValue(mat, "$envmap", "models/effects/cube_white")
            Material.SetKeyValue(mat, "$envmapfresnel", "1")
            refresh = true
        }
        if (mats[i].update) {
            mats[i].update = false
            refresh = true
        }
        if (mats[i].update_color) {
            mats[i].update_color = false
            var uicol = UI.GetColor(mats[i].ui_color)
            Material.SetKeyValue(mat, "$envmaptint", "[" + uicol[0] / 255 + " " + uicol[1] / 255 + " " + uicol[2] / 255 + "]")
            var alpha_fraction = uicol[3] / 255
            if (alpha_fraction > 1)
                alpha_fraction = 1
            var first = lerp(12, 1, alpha_fraction)
            var second = lerp(24, 2, alpha_fraction)
            Material.SetKeyValue(mat, "$envmapfresnelminmaxexp", "[0 " + first + " " + second + "]")
            refresh = true
        }
        if (refresh)
            Material.Refresh(mat)
    }
}
function Glow_Unload() {
    for (i in mats)
        Material.Destroy(mats[i].mat_name)
}
var lasttime = 0
var last_ui_values = {}
var last_ui_colors = {}
var last_editor_value = -1
var last_current_mat_settings = []
function Glow_Draw() {
    // update every 16.6666667 ms to save some fps :)
    var time = Globals.Realtime()
    if (time - lasttime > (16.6666667) / 1000) {
        for (i in mats) {
            var ui_col = UI.GetColor(mats[i].ui_color)
                
            if (last_ui_colors[mats[i].mat_name] == null)
                last_ui_colors[mats[i].mat_name] = ui_col
                
            if (last_ui_colors[mats[i].mat_name][0] != ui_col[0] ||
                last_ui_colors[mats[i].mat_name][1] != ui_col[1] ||
                last_ui_colors[mats[i].mat_name][2] != ui_col[2] ||
                last_ui_colors[mats[i].mat_name][3] != ui_col[3]) {
                last_ui_colors = ui_col
                mats[i].update_color = true
            }
        }
        var editor_value = UI.GetValue(subtab.concat("Editor"))
      
        if (editor_value != last_editor_value) {
            last_editor_value = editor_value
            var mat = mats[editor_value]
            UI.SetEnabled(subtab.concat(mat.mat_name + " color"), 1)
            for (i in mats) {
                if (mats[i].mat_name == mat.mat_name)
                    continue
                UI.SetEnabled(subtab.concat(mats[i].mat_name + " color"), 0)
            }
        }
    }
}

makemat("Glow (1)")
makemat("Glow (2)")
makemat("Glow (3)")
UI.AddDropdown(subtab, "Editor", editor_array, 0)
for (i in mats) {
    var name = mats[i].mat_name
    UI.AddColorPicker(subtab, name + " color")
}
for (i in mats) {
    mats[i].first = true
}

Cheat.RegisterCallback("Draw", "Glow_Draw")
Cheat.RegisterCallback("Unload", "Glow_Unload")
Cheat.RegisterCallback("Material", "Glow_Material")

/*
* Section: Visuals
*/

UI.AddCheckbox(p.visuals, "[NW] HP Bar")
UI.AddCheckbox(p.visuals, "[NW] Weapon name")
UI.AddCheckbox(p.visuals, "[NW] Zeus warning")
UI.AddCheckbox(p.visuals, "[NW] Ping warning")
UI.AddCheckbox(p.visuals, "Show difference between delays");

UI.AddCheckbox(p.radar, "[NW] Hostages")
UI.AddCheckbox(p.radar, "[NW] Bomb")
UI.AddCheckbox(p.radar, "[NW] FOV Arrows")
UI.AddCheckbox(p.radar, "[NW] Dormant arrows")

var screen_size = Render.GetScreenSize();
var center_screen = [screen_size[0]/2, screen_size[1]/2 ]
var lp = Entity.GetLocalPlayer;
function rad( deg )
{
    return deg * Math.PI / 180
}

function normalize_yaw(angle) {
    angle = (angle % 360 + 360) % 360;
    return angle > 180 ? angle - 360 : angle;
}

function calculate_yaw(src, to) {
    var delta = [src[0] - to[0], src[1] - to[1]]
    var yaw = Math.atan(delta[1]/delta[0])
    yaw = normalize_yaw(yaw * 180 / Math.PI)

    if (delta[0] >= 0)
        yaw = normalize_yaw(yaw + 180)

    return yaw
}
function rotate_angle(cx, cy, deg, distance)
{

    var viewAngles = Local.GetViewAngles()

    deg = rad( deg - viewAngles[1] )

    var x = Math.sin( deg ) * distance
    var y = Math.cos( deg ) * distance

    x = cx - x
    y = cy - y

    return [ x, y ]
}
function calculate_angles(x, y) {
    var _0x1a38f0 = [y[0x0] - x[0x0], y[0x1] - x[0x1], y[0x2] - x[0x2]];
    var _0x53da66 = -radian_to_degree(Math.atan2(_0x1a38f0[0x2], Math.hypot(_0x1a38f0[0x0], _0x1a38f0[0x1])));
    var _0x136715 = radian_to_degree(Math.atan2(_0x1a38f0[0x1], _0x1a38f0[0x0]));
    return [_0x53da66, _0x136715, 0x0];
}
/*function drawArrow(angle) {
    const pulse = Clamp(Math.floor(Math.sin(Globals.Realtime() * 4) * 127 + 128), 0, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance")
    var size = Math.pow(GUI.GetValue(p.radar, "Arrow size"), 5)
    var color = GUI.GetColor(p.radar, "FOV arrows")

    /*
    var radius = 50 + ((screen_size[0] / 4) * distance)

    var pos = [center_screen[0] + radius * Math.cos(angle), center_screen[1] + radius * Math.sin(angle)]
    var line = [pos[0] - center_screen[0], pos[1] - center_screen[1]]
    var arrowBase = [pos[0] - line[0] * (size / (2 * (Math.tan(rad(45)) / 2) * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), pos[1] - line[1] * (size / (2 * (Math.tan(rad(45)) / 2) * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    var arrowNormal = [-line[1], line[0]]
    var arrowLeft = [arrowBase[0] + arrowNormal[0] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), arrowBase[1] + arrowNormal[1] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    var arrowRight = [arrowBase[0] + arrowNormal[0] * (-size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), arrowBase[1] + arrowNormal[1] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    
    var new_point = rotate_angle(center_screen[0], center_screen[1], angle, distance, 1, 1.2)

    var top = rotate_angle(new_point[0], new_point[1], angle, 50, 1, 1)
    var left = rotate_angle( new_point[0], new_point[1], angle + (50/2),  50/2, 1.2, 1)
    var right = rotate_angle( new_point[0], new_point[1], angle - (50/2), 50/2, 1.2, 1)


    Render.Polygon( [top, left, right], [color[0], color[1], color[2],pulse] );
 
}*/

function drawArrow(angle) {
    const pulse = Clamp((Math.floor(Math.sin(Globals.Realtime() * 5) * 127) + 128) + 20, 20, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance") * 600
    var size = GUI.GetValue(p.radar, "Arrow size") * 30
    var color = GUI.GetColor(p.radar, "FOV arrows")

    var new_point = rotate_angle(center_screen[0], center_screen[1], angle, distance)

    var top = rotate_angle(new_point[0], new_point[1], angle, size)
    var left = rotate_angle( new_point[0], new_point[1], angle + (size/2),  size/2)
    var right = rotate_angle( new_point[0], new_point[1], angle - (size/2), size/2)

    Render.Polygon([top, right, left], [color[0], color[1], color[2], pulse]);     
}

/*function drawArrow(angle) {
    const pulse = Clamp((Math.floor(Math.sin(Globals.Realtime() * 5) * 127) + 128) + 20, 20, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance") * 600
    var size = GUI.GetValue(p.radar, "Arrow size") * 30
    var color = GUI.GetColor(p.radar, "FOV arrows")

    angle = Local.GetCameraAngles()[1] - angle - 90;

    const _0x55b844 = deg2rad(angle)
    var x = center_screen[0] + Math.cos(_0x55b844) * distance;
    var y = center_screen[1] + Math.sin(_0x55b844) * distance;


}*/

function world_point_visible(origin) {
    var w2s = Render.WorldToScreen(origin)
    if (w2s[0] < 0 || w2s[0] > screen_size[0] || w2s[1] < 0 || w2s[1] > screen_size[1])
        return false
    else
        return true
}

function paint() {
    if (!GUI.GetValue(p.radar, "[NW] FOV Arrows") || Entity.IsAlive(lp()) == false)
        return

    var players = Entity.GetEnemies();

    var local_origin = Local.GetCameraPosition();

    for (var i in players) {
        var player = players[i]
        if (Entity.IsValid(player) && Entity.IsAlive(player)) {
            var player_origin = Entity.GetRenderOrigin(player);
            var angles = calculate_yaw(local_origin, player_origin);

            var do_draw = world_point_visible(player_origin)
            if (!do_draw && ((GUI.GetValue(p.radar, "[NW] Dormant arrows") && Visuals.LastSeen[player] + 10 > Globals.Curtime()) || !Entity.IsDormant(player)))
                drawArrow(angles)
        }
    }
}

Cheat.RegisterCallback("Draw", "paint");

function get_icon_name(a) {
    var letter = ""
    switch (a) {
        case "desert eagle":
            letter = "A"
            break
        case "dual berettas":
            letter = "B"
            break
        case "five seven":
            letter = "C"
            break
        case "glock 18":
            letter = "D"
            break
        case "ak 47":
            letter = "W"
            break
        case "aug":
            letter = "U"
            break
        case "awp":
            letter = "Z"
            break
        case "famas":
            letter = "R"
            break
        case "m249":
            letter = "g"
            break
        case "g3sg1":
            letter = "X"
            break
        case "galil ar":
            letter = "Q"
            break
        case "m4a4":
            letter = "S"
            break
        case "m4a1 s":
            letter = "T"
            break
        case "mac 10":
            letter = "K"
            break
        case "p2000":
            letter = "E"
            break
        case "ump 45":
            letter = "L"
            break
        case "xm1014":
            letter = "b"
            break
        case "pp bizon":
            letter = "M"
            break
        case "mag 7":
            letter = "d"
            break
        case "negev":
            letter = "f"
            break
        case "sawed off":
            letter = "c"
            break
        case "tec 9":
            letter = "w"
            break
        case "zeus x27":
            letter = "h"
            break
        case "p250":
            letter = "F"
            break
        case "mp7":
            letter = "N"
            break
        case "mp9":
            letter = "O"
            break
        case "nova":
            letter = "e"
            break
        case "p90":
            letter = "P"
            break
        case "scar 20":
            letter = "Y"
            break
        case "sg 553":
            letter = "V"
            break
        case "ssg 08":
            letter = "a"
            break
        case "knife":
            letter = "["
            break
        case "flashbang":
            letter = "i"
            break
        case "high explosive grenade":
            letter = "j"
            break
        case "smoke grenade":
            letter = "k"
            break
        case "molotov":
            letter = "l"
            break
        case "decoy grenade":
            letter = "m"
            break
        case "incendiary grenade":
            letter = "n"
            break
        case "c4 explosive":
            letter = "o"
            break
        case "usp s":
            letter = "G"
            break
        case "cz75 auto":
            letter = "I"
            break
        case "r8 revolver":
            letter = "J"
            break
        case "bayonet":
            letter = "1"
            break
        case "flip knife":
            letter = "2"
            break
        case "gut knife":
            letter = "3"
            break
        case "karambit":
            letter = "4"
            break
        case "m9 bayonet":
            letter = "5"
            break
        case "falchion knife":
            letter = "0"
            break
        case "bowie knife":
            letter = "7"
            break
        case "butterfly knife":
            letter = "8"
            break
        case "shadow daggers":
            letter = "9"
            break
        case "ursus knife":
            letter = "6"
            break
        case "navaja knife":
            letter = "0"
            break
        case "stiletto knife":
            letter = "1"
            break
        case "skeleton knife":
            letter = "8"
            break
        case "huntsman knife":
            letter = "6"
            break
        case "talon knife":
            letter = "4"
            break
        case "classic knife":
            letter = "7"
            break
        case "paracord knife":
            letter = "1"
            break
        case "survival knife":
            letter = "2"
            break
        case "nomad knife":
            letter = "6"
            break
        default:
            letter = ""
            break
    }
    return letter
}

Entity.IsFakeDucking = function(player) {
    const DuckSpeed = Entity.GetProp(player, "CBasePlayer", "m_flDuckSpeed");
    const DuckAmount = Entity.GetProp(player, "CBasePlayer", "m_flDuckAmount");
    const Flags = Entity.GetProp(player, "CBasePlayer", "m_fFlags");
    
    if (DuckSpeed == 8 && DuckAmount > 0 && !(Flags & (1 << 1)))
        return true;
    
    return false;
}

var Visuals = {
    LastSeen: new Array(64),
    PFlags: new Object(),
    Hittables: new Array(),
    Fonts: function() {
        var sfont = Render.GetFont("font.ttf", 16, false)
        var nfont = Render.GetFont("Verdana.ttf", 10, true)
        var bfont = Render.GetFont("Calibrib.ttf", Indicators.Size, true)
        if (Northwood.Get("visuals:weapon_icon") == "true")
            var ifont = Render.GetFont("undefeated.ttf", 14, true)
        return [sfont, nfont, bfont, ifont]
    },
    Text: function(x, y, flags, text, color) {
        var sfont = Render.GetFont("font.ttf", 16, false)
        var nfont = Render.GetFont("Verdana.ttf", 10, true)
        var bfont = Render.GetFont("Calibrib.ttf", Indicators.Size, true)
        if (Northwood.Get("visuals:weapon_icon") == "true")
            var ifont = Render.GetFont("undefeated.ttf", 14, true)
        if (flags.includes("-")) {
            Render.String(x-1, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x-1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x-1, y, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, sfont)
        }
        else if (flags.includes("+")) {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], bfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, bfont)
        }
        else if (flags.includes("i")) {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], ifont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, ifont)
        }
        else {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], nfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, nfont)
        }
    },
    WeaponName: function(ply) {
        var weaponname = Entity.GetName(Entity.GetWeapon(ply)).toUpperCase()
        switch (weaponname) {
            case "SCAR 20":
                weaponname = "SCAR-20"
                break;
        }
        return weaponname;
    },
    CreateMove: function() {
        Visuals.Hittables = new Array();
        var enem = Entity.GetEnemies();
        var lp = Entity.GetLocalPlayer();
        for (var i = 0; i < enem.length; i++) {
            var ply = enem[i];

            if (!Entity.IsAlive(ply) || Entity.GetName(Entity.GetWeapon(ply)).includes("knife"))
                continue;

            var target_body = Entity.GetHitboxPosition(ply, 2);
            var target_head = Entity.GetHitboxPosition(ply, 0);
            var local_eye = Entity.GetEyePosition(lp);

            var trace = Trace.Bullet(lp, ply, local_eye, target_body);

            if (trace !== undefined && trace[1] > 0)
                Visuals.Hittables.push(ply);
            else {
                trace = Trace.Bullet(lp, ply, local_eye, target_head);
                if (trace !== undefined && trace[1] > 0)
                    Visuals.Hittables.push(ply);
            }
        }
    },
    Draw: function() {
        var enem = Entity.GetEnemies();
        for (var i = 0; i < enem.length; i++) {
            var ply = enem[i];

            if (!Entity.IsAlive(ply))
                continue;

            var b = Entity.GetRenderBox(ply);
            var w = b[3] - b[1];
            var h = b[4] - b[2];
            var dcolor = GUI.GetColor(["Visuals", "Extra", "General"], "Dormant ESP");
            var dalpha = 1;
            if (!Entity.IsDormant(ply))
                Visuals.LastSeen[i] = Globals.Curtime();
            else { dalpha = 0.7 }
            if (Visuals.LastSeen[i] + 11 > Globals.Curtime() && Visuals.LastSeen[i] + 10 < Globals.Curtime()) {
                dalpha = Math.max(0.7 + (Visuals.LastSeen[i] + 10 - Globals.Curtime()), 0)
            }
            dcolor = [dcolor[0], dcolor[1], dcolor[2], dcolor[3] * dalpha]

            if (Visuals.LastSeen[i] + 11 < Globals.Curtime() || Visuals.LastSeen[i] == undefined)
                continue;

            Visuals.PFlags[ply] = new Array();

            Visuals.PFlags[ply].push(["$"+Entity.GetProp(ply, "CCSPlayer", "m_iAccount").toString(), [140, 200, 40, 175]]);

            if (Entity.GetProp(ply, "CCSPlayerResource", "m_iArmor") > 0)
                Visuals.PFlags[ply].push([(Entity.GetProp(ply, "CCSPlayer", "m_bHasHelmet") ? "HK" : "K"), [255, 255, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_bIsScoped") > 0)   
                Visuals.PFlags[ply].push(["ZOOM", [87, 175, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_flFlashDuration") > 0)   
                Visuals.PFlags[ply].push(["BLIND", [87, 175, 255, 175]]);

            var weapons = Entity.GetWeapons(ply);
            var hasc4 = false;

            for (var wn in weapons) {
                if (Entity.GetName(weapons[wn]) == "c4 explosive")
                hasc4 = true;
            }

            if (hasc4)
                Visuals.PFlags[ply].push(["B", [255, 0, 0, 175]]);

            if (Entity.IsFakeDucking(ply))
                Visuals.PFlags[ply].push(["FD", [255, 255, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_hCarriedHostage").toString() != "m_hCarriedHostage")
                Visuals.PFlags[ply].push(["VIP", [255, 0, 0, 175]]);

            if (Entity.GetProp(Entity.GetWeapon(ply), "CBaseCSGrenade", "m_bPinPulled"))
                Visuals.PFlags[ply].push(["PIN", [255, 0, 0, 175]]);

            if (Visuals.Hittables.indexOf(ply) !== -1)
                Visuals.PFlags[ply].push(["HIT", [255, 255, 255, 175]]);

            if (Northwood.Get("visuals:weapon_icon") && b[0]) {
                var flags = Visuals.PFlags[ply];
                for (var f in flags) {
                    var ft = flags[f][0];
                    var fc = !Entity.IsDormant(ply) ? flags[f][1] : dcolor;
                    if (Entity.IsDormant(ply))
                        fc[3] *= 1.2;

                    Visuals.Text(b[3] + 3, Math.floor(b[2] - 5 + (10 * f)), "-", ft, fc)
                }
            }

            if (GUI.GetValue(p.visuals, "[NW] HP Bar")) {
                    /*
                    * HP BAR
                    */
                    if (b[0]) {
                        var hp = Entity.GetProp(ply, "CCSPlayer", "m_iHealth")
                        var maxhp = 100;
                        var hpheight = Math.ceil(h / maxhp * Math.min(hp, 100))
                        
                        var color = GUI.GetColor(p.visuals, "Health color override")

                        if (Northwood.Get("visuals:weapon_icon") == "true") {
                            if (hp <= 30)
                                color = [200, 100, 90, 255];
                            else if (hp <= 50)
                                color = [200, 200, 90, 255];
                            else
                                color = [90, 200, 100, 255];
                        }
                        /*if (hp <= 30)
                            color = [90, 50, 150, 255];
                        else if (hp <= 50)
                            color = [50, 90, 150, 255];*/
                        
                        Render.FilledRect(b[1] - 6, b[2] - 1, 4, h + 2, [0, 0, 0, 125 * dalpha]);
                        Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, !Entity.IsDormant(ply) ? color : dcolor);
                        if (!Entity.IsDormant(ply) && Northwood.Get("visuals:weapon_icon") != "true") {
                            if (hp <= 30)
                                Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, [0, 0, 0, 150]);
                            else if (hp <= 50)
                                Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, [0, 0, 0, 80]);
                        }
                        if (hp < 95 || hp > 100)
                            Visuals.Text(b[1] - 4, b[2] + (h / maxhp * (maxhp - hp)) - 6, "c-", hp.toString(), [255, 255, 255, 200 * dalpha])
                    }
            }
            if (GUI.GetValue(p.visuals, "[NW] Weapon name")) {
                /*
                * WEAPON NAME
                */
                if (b[0] && Visuals.WeaponName(ply) != Entity.GetName(ply).toUpperCase())
                    Visuals.Text(b[1] + w/2, b[4] + (!Entity.IsDormant(ply) ? 4 : 0), "c-", Visuals.WeaponName(ply), [255, 255, 255, 220 * dalpha])
            }


            
            if (Northwood.Get("visuals:weapon_icon") == "true" && b[0] && Visuals.WeaponName(ply) != Entity.GetName(ply).toUpperCase())
                Visuals.Text(b[1] + w/2, b[4] + (!Entity.IsDormant(ply) && !Entity.GetName(Entity.GetWeapon(ply)).includes("knife") ? 6 : 2), "ci", get_icon_name(Entity.GetName(Entity.GetWeapon(ply))), [255, 255, 255, 220 * dalpha])

            if (GUI.GetValue(p.visuals, "[NW] Zeus warning")) {
                if (b[0] && !Entity.IsDormant(ply)) {
                    var flag = false;
                    for (var wpn in Entity.GetWeapons(ply)) {
                        if (Entity.GetName(Entity.GetWeapons(ply)[wpn]) == "zeus x27")
                            flag = true;
                    }
    
                    if (flag) {
                        var x = b[1] - 14;
                        var y = b[2];
                        Render.Polygon([[x, y], [x, y+7], [x-6, y+7]], [255, 255, 0, 255])
                        Render.Polygon([[x, y], [x+4, y], [x-2, y+7]], [255, 255, 0, 255])
                        Render.Polygon([[x-1, y+5], [x+6, y+5], [x-3, y+12]], [255, 255, 0, 255])
                    }   
                }
            }

            if (GUI.GetValue(p.visuals, "[NW] Ping warning")) {
                if (b[0]) {
                    var localping = Math.floor(Entity.GetProp(Entity.GetLocalPlayer(), "CPlayerResource", "m_iPing"));
                    var ping = Math.floor(Entity.GetProp(ply, "CPlayerResource", "m_iPing"));
                    if (GUI.GetValue(p.visuals, "Show difference between delays")) {
                        if (localping - ping > 0) {
                            var color = Northwood.Utils.StatusColor(Math.max(0, 100 - (localping - ping)), 100);
                            Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("+{0} MS", localping - ping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                        }
                        else {
                            var color = Northwood.Utils.StatusColor(Math.max(0, ping - localping), 100, 5);
                            Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("-{0} MS", ping - localping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                        }
                        
                    }
                    else {
                        var color = Northwood.Utils.StatusColor(Math.max(0, 150 - ping), 150);
                        Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("{0} MS", ping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                    }
                }
            }
        }
    },
    DrawEntities: function() {
        if (GUI.GetValue(p.radar, "[NW] Hostages")) {
            var ents = Entity.GetEntitiesByClassID(97);
            for(i=0; i < ents.length; i++) {
                var ent = ents[i];
                var origin = Entity.GetRenderOrigin(ent);
                var scr = Render.WorldToScreen(origin)
                
                if (scr[2] && calcDist(Entity.GetRenderOrigin(lp()), origin) < 1200)
                    Visuals.Text(scr[0] - 20, Math.max(scr[1] - 20, 0), "-", "HOSTAGE", [56, 159, 252, 201])
            }
        }
        
        if (GUI.GetValue(p.radar, "[NW] Bomb")) {
            var ents = Entity.GetEntitiesByClassID(34);
            for(i=0; i < ents.length; i++) {
                var ent = ents[i];
                var origin = Entity.GetRenderOrigin(ent);
                var scr = Render.WorldToScreen(origin)
                
                if (scr[2] && Entity.GetProp(ent, "CBaseEntity", "m_hOwnerEntity").toString() == "m_hOwnerEntity")
                    Visuals.Text(scr[0] - 10, scr[1] - 10, "-", "BOMB", [150, 200, 60, 255])
            }
        }
    }
}

Cheat.RegisterCallback("Draw", "Visuals.Draw")
Cheat.RegisterCallback("CreateMove", "Visuals.CreateMove")
Cheat.RegisterCallback("Draw", "Visuals.DrawEntities")

UI.AddCheckbox(p.radar, "[NW] Grenade proximity warning")
/*UI.AddCheckbox(p.radar, "[NW] Predict grenade path")
UI.AddSliderInt(p.radar, "[NW] Re-predict grenade", 0, 126)
if (GUI.GetValue(p.radar, "[NW] Re-predict grenade") == 0)
    GUI.SetValue(p.radar, "[NW] Re-predict grenade", 126)*/

function GrenadeWarning()
{
    if (!Entity.IsAlive(lp()) || !GUI.GetValue(p.radar, "[NW] Grenade proximity warning"))
        return;

    var font1 = Render.GetFont("Calibrib.ttf", 25, true);
    var font2 = Render.GetFont("Verdanab.ttf", 10, true);
    var DistanceInFeet = function(origin, destination) {
            var sub = [destination[0] - origin[0], destination[1] - origin[1], destination[2] - origin[2]];
            return Math.round(Math.sqrt(sub[0] ** 2 + sub[1] ** 2 + sub[2] ** 2) / 12);
    }

    GrenadePrediction.Run();

    var origin = Entity.GetRenderOrigin(lp());
    var grenades = GrenadePrediction.GetLiveGrenades();

    /*for (var i in grenades)
    {
        var g = grenades[i];
        var destination = g.Position;
        var distance = DistanceInFeet(origin, destination);
        var screen = Render.WorldToScreen(destination);

        if (distance > 50)
        {
            continue;
        }

        if (!g.IsLive)
            continue;

        Render.FilledCircle(screen[0], screen[1] -50, 30, [Math.max(0, 255 - Math.pow(distance, 1.7)), 0, 0, 255])
        draw_arc1(screen[0]-1, screen[1] - 50, 31, 29, 270, 360, 30, [10, 10, 10, 255]);
        Render.String(screen[0], screen[1] - 68, 1, "!", [255, 250, 20, 200], font1);
        Render.String(screen[0], screen[1] - 45, 1, distance + " ft", [232, 232, 232, 200], font2);
        if (g.Type == "Molotov") {
            time = Entity.GetProp(g.EntityIndex, "CInferno", "m_nFireEffectTickBegin") * Globals.TickInterval();
            factor = Clamp(((time + 7) - Globals.Curtime()) / 7, 0, 7);
            draw_arc1(screen[0]-1, screen[1] - 50, 31, 29, 270, 360 * factor, 150, [232, 232, 232, 200]);
        }
    }*/

    for (var i in grenades) {
        var g = grenades[i];

        if (g.Type != "Molotov" && g.Type != "Grenade")
            return;

        var destination = g.Position;
        var distance = DistanceInFeet(origin, destination)
        var Hit = true;
        var screen = Render.WorldToScreen(destination)
        screen[1] += 30;

        if (g.Type == "Grenade") {
            Hit = false;
            for (var d in g.Hits) {
                var hit = g.Hits[d];
                if (hit.EntityIndex == Entity.GetLocalPlayer()) {
                    distance = hit.Damage;
                    Hit = true;
                    break;
                }
            }
        }

        if ((g.Type == "Grenade" && !Hit) || (g.Type == "Molotov" && distance > 25))
            continue;

        if (!g.IsLive)
            continue;
        
        /*if (screen[2]) {
            Render.FilledCircle(screen[0], screen[1] -50, Math.max(30, 40 - distance), [Math.max(0, 255 - Math.pow(distance, 1.8)), 0, 0, 220])
            Render.Circle(screen[0], screen[1] -50, Math.max(30, 40 - distance), [10, 10, 10, 255])
            Render.Circle(screen[0], screen[1] -50, Math.max(30, 40 - distance) - 1, [10, 10, 10, 255])
            //draw_arc1(screen[0]-1, screen[1] - 50, Math.max(30, 40 - distance) + 1, Math.max(30, 40 - distance) - 1, 270, 360, 30, [10, 10, 10, 255]);
            Render.String(screen[0], screen[1] - 68, 1, "!", [255, 250, 20, 200], font1);
            Render.String(screen[0], screen[1] - 45, 1, distance + (g.Type == "Grenade" ? " hp" : " ft"), [232, 232, 232, 200], font2);
        }*/

        else {
            var yaw = calculate_yaw(origin, destination);
            var new_point = rotate_angle(center_screen[0], center_screen[1], yaw, center_screen[1] / 1.15)
            new_point = rotate_angle(new_point[0], new_point[1], yaw, 50 / Math.tan(rad(45)))
            Render.FilledCircle(new_point[0], new_point[1] -50, 30, [Math.max(17, 255 - Math.pow(distance, 1.8)), 17, 17, 220])
            Render.Circle(new_point[0], new_point[1] -50, 30, [10, 10, 10, 255])
            Render.Circle(new_point[0], new_point[1] -50, 30 - 1, [10, 10, 10, 255])
            //draw_arc1(new_point[0]-1, new_point[1] - 50, 30 + 1, 29, 270, 360, 30, [0, 0, 0, 200]);
            Render.String(new_point[0], new_point[1] - 68, 1, "!", [255, 250, 20, 200], font1);
            Render.String(new_point[0], new_point[1] - 45, 1, distance + (g.Type == "Grenade" ? " hp" : " ft"), [232, 232, 232, 200], font2);
        }         
    }
}

Cheat.RegisterCallback("Draw", "GrenadeWarning");

/*
* Section: Logs
*/

UI.AddCheckbox(p.cheat, "Override event logs")
UI.AddDropdown(p.cheat, "Event logs output", ["Console", "Console + Screen"], 0)
UI.AddMultiDropdown(p.cheat, "Event logs triggers", ["Item purchase", "Aimbot fire", "Player hurt", "Missed shots"])
var logs = new Array();
function event_log(text) {
    if (!GUI.GetValue(p.cheat, "Override event logs"))
        return;

    if (!GUI.GetValue(p.cheat, "Event logs output")) {
        Cheat["PrintColor"](GUI.GetColor(p.cheat, "Log color"), "[onetap] "+text+"\n");
    }
    else {
        //Cheat["PrintLog"](text, GUI.GetColor(p.cheat, "Log color"));
        Cheat["PrintColor"](GUI.GetColor(p.cheat, "Log color"), "[onetap] "+text+"\n");
        logs.push({text: text, time: Globals.Curtime(), color: [255, 255, 255], alpha: 255, y: 0});
    }
}

function draw_logs() {
    while (logs.length > 6) {
        logs.shift();
    }
    
    for (var l in logs) {
        if (logs[l].time + 6 < Globals.Curtime()) {
            logs[l].alpha -= Globals.Frametime() * 1.5 * 255;
            if (logs[l].alpha <= 80) {
                logs[l].y += Globals.Frametime() * 180;
            }
            if (logs[l].alpha <= 0)
                logs.shift();
        }
    }

    var cfont = Render.GetFont("lucidaconsolenoa3.ttf", 16, false);
    for (var l in logs) {
        log = logs[l];
        Render.String(9, (3 + 12 * l) - Math.floor(log.y), 0, log.text, [0, 0, 0, log.alpha], cfont);
        Render.String(8, (2 + 12 * l) - Math.floor(log.y), 0, log.text, log.color.concat(log.alpha), cfont);
    }
}

//Cheat.RegisterCallback("Draw", "draw_logs")

function eventlog_handle_ui() {
    if (!GUI.GetValue(p.cheat, "Override event logs")) {
        GUI.SetEnabled(p.cheat, "Event logs output", 0)
        GUI.SetEnabled(p.cheat, "Event logs triggers", 0)
        GUI.SetEnabled(p.cheat, "Log output", 1)
        GUI.SetEnabled(p.cheat, "Log events", 1)
    }
    else {
        GUI.SetEnabled(p.cheat, "Event logs output", 1)
        GUI.SetEnabled(p.cheat, "Event logs triggers", 1)
        GUI.SetEnabled(p.cheat, "Log output", 0)
        GUI.SetEnabled(p.cheat, "Log events", 0)
        GUI.SetValue(p.cheat, "Log output", 0)
    }
}

var hitgroups = ["generic", "head", "chest", "stomach", "left arm", "right arm", "left leg", "right leg", "unknown"];
var hitboxes = ["head", "head", "stomach", "stomach", "chest", "chest", "chest", "left leg", "right leg", "left leg", "right leg", "left leg", "right leg", "left arm", "right arm", "left arm", "left arm", "right arm", "generic"];

var choked = 0;
var choked_prev = 0;
var choked_max = 0;
var choked_prev_cmd = 0;
var tickcount = 0;
var tickcount_prev = 0;
function fakelag_handler() {
    choked_prev = choked;
    choked = Globals.ChokedCommands();
    if (choked > choked_max)
        choked_max = choked;
    else if (choked == 0 && choked_prev != 0)
        choked_max = choked_prev;
    else if (choked == 0 && choked_prev_cmd == 0)
        choked_max = 0;
    
    tickcount = Globals.Tickcount();
    if (tickcount != tickcount_prev) {
        choked_prev_cmd = choked_prev_cmd;
        tickcount_prev = tickcount;
    }
}

Global.RegisterCallback("CreateMove", "fakelag_handler");

function on_player_hurt() {
    if (!(GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 2) || Entity.GetEntityFromUserID(Event.GetInt("attacker")) != Entity.GetLocalPlayer())
        return;

    var hit_type = "Hit"
    switch (Event.GetString("weapon")) {
        case "hegrenade":
            hit_type = "Naded"
            break;
        case "inferno":
            hit_type = "Burned"
            break;
        default:
            hit_type = "Hit"
            break;
    }

    if (Event.GetString("weapon").includes("knife"))
        hit_type = "Knifed"

    var ply = Entity.GetEntityFromUserID(Event.GetInt("userid"))

    if (hit_type == "Hit") {
        ragebot_hit++;   
        event_log(String.format("Hit {0} in the {1} for {2} damage ({3} health remaining)", Entity.GetName(ply), hitgroups[Event.GetInt("hitgroup")], Event.GetInt("dmg_health").toString(), Event.GetInt("health").toString()))
    }
        
    else
        event_log(String.format("{0} {1} for {2} damage ({3} health remaining)", hit_type, Entity.GetName(ply), Event.GetInt("dmg_health").toString(), Event.GetInt("health").toString()))
}

var entities = {}

var cl_data = {
    tick_shifted: false,
    extrapolated: false,
}

var tickbase_prev = 0;
var tickbase = 0;
var ragebot_shots = 0;
var ragebot_hit = 0;
var latest_shot = {
    name: "",
    hitchance: 0,
    safety: 0,
    hitbox: 0,
};
function anglevector(a) {
    var sy = Math.sin(a[1] / 180 * Math.PI)
    var cy = Math.cos(a[1] / 180 * Math.PI)
    var sp = Math.sin(a[0] / 180 * Math.PI)
    var cp = Math.cos(a[0] / 180 * Math.PI)
    return [cp * cy, cp * sy, -sp]
}
function vecmulfl(a, b) {
    return [a[0] * b, a[1] * b, a[2] * b]
}
function vecadd(a, b) {
    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
}

function flags_handler() {
    for (var i in Entity.GetEnemies()) {
        var ply = Entity.GetEnemies()[i]
        entities[ply] = {
            shots: Entity.GetProp(ply, "CCSPlayer", "m_iShotsFired"),
        }
    }
    //tickbase = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_nTickBase")
    tickbase = Exploit.GetPredictedTickbase();
    if (tickbase_prev + 2 < tickbase)
        cl_data.tick_shifted = true;
    else
        cl_data.tick_shifted = false;

    cl_data.extrapolated = Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) > 40960;
    tickbase_prev = tickbase;

    if (GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 3) {
        if (latest_impact == Globals.Tickcount()) {
            if (ragebot_shots > ragebot_hit) {
                var reason = "unknown"
                if (latest_shot.safety > 0 && latest_shot.hitchance <= 95)
                    reason = "spread";
                else if (latest_shot.safety > 0 && latest_shot.hitchance > 95)
                    reason = "prediction error";
                else if (latest_shot.safety == 0) {
                    if (latest_shot.hitchance > 35)
                        reason = "correction";
                    else
                        reason = "spread";
                }
                event_log(String.format("Missed shot at {0}'s {1} due to {4} (hc={2}; safe={3})", latest_shot.name, hitboxes[latest_shot.hitbox], latest_shot.hitchance, latest_shot.safety, reason))
                latest_impact = 0;
            }
            ragebot_hit = ragebot_shots;
        }
    }
}

function on_weapon_fire() {
    if (Event.GetInt("exploit") == 0)
        ragebot_shots++;
      
    var ply = Event.GetInt("target_index")
    var hitbox = hitboxes[Event.GetInt("hitbox")]
    var flags = "";
    if (Event.GetInt("exploit") > 0)
        flags += "S";
    if (Event.GetInt("hitchance") == 0)
        flags += "T";
    if (entities[ply].shots > 0 || Entity.GetProp(ply, "CCSPlayer", "m_iShotsFired") > 0)
        flags += "H";
    if (GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 1)
        event_log(String.format("Fired at {0}'s {1} (hc={2}; safe={3}; fl={4}"+(flags != "" ? "; flags={5}" : "")+")", Entity.GetName(ply), hitbox, Event.GetInt("hitchance"), Event.GetInt("safepoint"), choked_max, flags))
    latest_shot = {
        name: Entity.GetName(ply),
        hitchance: Event.GetInt("hitchance"),
        safety: Event.GetInt("safepoint"),
        hitbox: Event.GetInt("hitbox"),
    }
}

function on_item_purchase() {
    if (!(GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 0))
        return;

    if (Event.GetString("weapon") == "weapon_unknown")
        return;

    var ply = Entity.GetEntityFromUserID(Event.GetInt("userid"))
    if (ply != Entity.GetLocalPlayer())
        event_log(String.format("{0} bought {1}", Entity.GetName(ply), Event.GetString("weapon")))
}

function weapon_fire() {
    Tickbase.LastShot = Globals.Tickcount();
}

Cheat.RegisterCallback("FRAME_NET_UPDATE_END", "flags_handler")
Cheat.RegisterCallback("ragebot_fire", "on_weapon_fire")
Cheat.RegisterCallback("weapon_fire", "weapon_fire")
Cheat.RegisterCallback("player_hurt", "on_player_hurt")
Cheat.RegisterCallback("item_purchase", "on_item_purchase")
Cheat.RegisterCallback("Draw", "eventlog_handle_ui")

/*
* Section: Indicators
*/



UI.AddCheckbox(p.indicators, "[NW] Indicators")
UI.AddCheckbox(p.indicators, "Fake indicator")
UI.AddCheckbox(p.indicators, "Fake lag indicator")
UI.AddCheckbox(p.indicators, "Damage override indicator")
UI.AddMultiDropdown(p.indicators, "On-screen indicators", ["Double tap", "Hide shots", "Damage override", "Fake duck", "Inverter", "Safe points", "Body aim", "Freestanding", "Slow walk", "Auto peek", "Edge jump", "Fake angles"])
UI.AddDropdown(p.indicators, "On-screen indicators font", ["Normal", "Small"], 0)
UI.AddCheckbox(p.indicators, "On-screen indicators short text")

function calcDist(local, target) {
    var lx = local[0];
    var ly = local[1];
    var lz = local[2];
    var tx = target[0];
    var ty = target[1];
    var tz = target[2];
    var dx = lx - tx;
    var dy = ly - ty;
    var dz = lz - tz;

    return Math.sqrt(dx * dx + dy * dy + dz * dz);
}

var lc = false;

var Indicators = {
    Size: (Northwood.Get("indicators:size") == "" ? 24 : parseInt(Northwood.Get("indicators:size"))),
    last_origin: [0, 0, 0],
    last_origin_sqr: 0,
    origin_sqr: 0,
    Offset: 0,
    Air_tickcount: Globals.Tickcount(),
    Planting: false,
    Defusing: false,
    PlantingTimer: Globals.Curtime(),
    DefusingTimer: Globals.Curtime(),
    APlants: [454, 372, 102, 276, 174, 121, 301, 142, 408, 97, 213, 216],
    PlantIndex: 0,
    Damage: 0,
    Alpha: {
        ['Double tap']: 0,
        ['Hide shots']: 0,
        ['Damage override']: 0,
        ['Fake duck']: 0,
        ['Inverter']: 0,
        ['Safe points']: 0,
        ['Body aim']: 0,
        ['Freestanding']: 0,
        ['Slow walk']: 0,
        ['Auto peek']: 0,
        ['Edge jump']: 0,
    },
    OnPlanting: function() {
        Indicators.Planting = true;
        Indicators.PlantingTimer = Globals.Curtime() + 3;
        Indicators.PlantIndex = Event.GetInt("site");
        //Cheat.Print(Event.GetInt("site").toString())
    },
    OnAbortPlanting: function() {
        Indicators.Planting = false;
    },
    OnDefusing: function() {
        Indicators.Defusing = true;
        Indicators.DefusingTimer = Globals.Curtime() + (Event.GetInt("haskit") ? 5 : 10)
    },
    OnAbortDefusing: function() {
        Indicators.Defusing = false;
    },
    Circle: function(x, y, radius, thickness, color) {
        var inner = radius - thickness;

        for(; radius > inner; --radius)
        {
            Render.Circle(x, y, radius, color);
        }
    },
    Arc: function(x, y, radius, radius_inner, start_angle, end_angle, segments, color) {
        segments = 360 / segments;

    for (var i = start_angle; i < start_angle + end_angle; i = i + segments)
    {

        var rad = i * Math.PI / 180;
        var rad2 = (i + segments) * Math.PI / 180;

        var rad_cos = Math.cos(rad);
        var rad_sin = Math.sin(rad);

        var rad2_cos = Math.cos(rad2);
        var rad2_sin = Math.sin(rad2);

        var x1_inner = x + rad_cos * radius_inner;
        var y1_inner = y + rad_sin * radius_inner;

        var x1_outer = x + rad_cos * radius;
        var y1_outer = y + rad_sin * radius;

        var x2_inner = x + rad2_cos * radius_inner;
        var y2_inner = y + rad2_sin * radius_inner;

        var x2_outer = x + rad2_cos * radius;
        var y2_outer = y + rad2_sin * radius;

        Render.Polygon( [
            [ x1_outer, y1_outer ],
            [ x2_outer, y2_outer ],
            [ x1_inner, y1_inner ] ],
            color
        );

        Render.Polygon( [
            [ x1_inner, y1_inner ],
            [ x2_outer, y2_outer ],
            [ x2_inner, y2_inner ] ],
            color
        );
    }
    },
    Add: function(text, color) {
        var tw = Render.TextSize(text, Visuals.Fonts()[2])[0]
        Render.GradientRect(11, screen_size[1] - 340 - 37 * this.Offset - 6, Math.floor(tw/2), 33 * (Indicators.Size / 24), 1, [0, 0, 0, 5], [0, 0, 0, 60])
        Render.GradientRect(11 + Math.floor(tw/2), screen_size[1] - 340 - 37 * this.Offset - 6, Math.floor(tw/2), 33 * (Indicators.Size / 24), 1, [0, 0, 0, 60], [0, 0, 0, 5])
        Visuals.Text(20, screen_size[1] - 340 - 37 * this.Offset, "+", text, color)
        this.Offset++;
        return (screen_size[1] - 340 - 37 * (this.Offset - 1))
    },
    Draw: function() {
        if (GUI.GetValue(p.indicators, "[NW] Indicators")) {

            Indicators.Offset = 0;
            var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
            var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
            var flags = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer" ,"m_fFlags")
            var fake = Math.abs(normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw()))
            if (GUI.GetValue(p.indicators, "Fake indicator") && Entity.IsAlive(Entity.GetLocalPlayer())) {
                //[255 - Math.min(57, fake)*2.3682, Math.min(57, fake)*3.4210, Math.min(57, fake)*0.22807, 255]
                var y = Indicators.Add("FAKE", Northwood.Utils.StatusColor(fake, 60).concat(255));
                Indicators.Arc(90, y+11*(Indicators.Size / 24), 10, 5, 0, 360, 15, [0, 0, 0, 180]);
                Indicators.Arc(90, y+11*(Indicators.Size / 24), 9, 6, 0, fake * 6, 60, Northwood.Utils.StatusColor(fake, 60).concat(255));
            }

            if (GUI.GetValue(p.indicators, "Fake lag indicator") && Entity.IsAlive(Entity.GetLocalPlayer())) {
                var c = Northwood.GetColor();
                c[3] = 255;
                var y = Indicators.Add("FL", c);
                Indicators.Arc(60, y+11*(Indicators.Size / 24), 10, 5, 0, 360, 15, [0, 0, 0, 180])
                Indicators.Arc(60, y+11*(Indicators.Size / 24), 9, 6, 0, Math.min(360, Globals.ChokedCommands() * (360 / 14)), 56, c)
            }
            if (GUI.GetValue(p.indicators, "Damage override indicator") && GUI.GetValue(p.rage, "Minimum damage override") && Indicators.Damage >= 0) {
                Indicators.Add("DMG: "+Indicators.Damage.toString(), [150, 160, 170, 255]);
            }
            if (Indicators.Planting) {
                var y = Indicators.Add("Bombsite " + (Indicators.APlants.indexOf(Indicators.PlantIndex) === -1 ? "B" : "A"), [255, 240, 100, 255]);
                //Indicators.Circle(150, y+12, 10, 7, [0, 0, 0, 180])
                Indicators.Arc(155, y+10, 10, 5, 0, 360, 15, [0, 0, 0, 180])
                Indicators.Arc(155, y+10, 9, 6, 0, Math.min(360 - (Indicators.PlantingTimer - Globals.Curtime()) * 120, 360), 60, [255, 255, 255, 255])
            }

            if (GUI.GetValue(p.antiaim_keys, "Fake duck") && Entity.IsAlive(Entity.GetLocalPlayer()))
                Indicators.Add("DUCK", [255, 255, 255, 255]);

            if (!(flags & 1))
                Indicators.Air_tickcount = Globals.Tickcount()

            if (speed > 180 && (!(flags & 1) || Globals.Tickcount() < Indicators.Air_tickcount + 2) && Entity.IsAlive(Entity.GetLocalPlayer())) {
                lc = true;
            }

            if (lc)
                Indicators.Add("LC",  Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) > 40960 ? [123, 195, 21, 255] : [255, 0, 0, 255]);

            if (speed > 230 && (!(flags & 1) || Globals.Tickcount() < Indicators.Air_tickcount + 2) && Entity.IsAlive(Entity.GetLocalPlayer())) {
                lc = true;
            }
            else {
                lc = false;
            }

            

            var C4 = Entity.GetEntitiesByClassID(129)[0];
            
            if (C4 !== undefined) {
                var local = lp()
                if (!Entity.IsAlive(Entity.GetLocalPlayer()))
                    local = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_hObserverTarget")

                if (local == "m_hObserverTarget")
                    return;

                if (Entity.GetProp(C4, "CPlantedC4", "m_bBombDefused") == 1)
                    return;

                var eLoc = Entity.GetRenderOrigin(C4);
                var lLoc = Entity.GetRenderOrigin(local)
                var distance = calcDist(eLoc, lLoc);
                var dmg = 0;
                var armor = Entity.GetProp(local, "CCSPlayerResource", "m_iArmor");
                var health = Entity.GetProp(local, "CBasePlayer", "m_iHealth");
                var timer = Entity.GetProp(C4, "CPlantedC4", "m_flC4Blow") - Globals.Curtime();
                var bombsite = Entity.GetProp(C4, "CPlantedC4", "m_nBombSite");
                bombsite = (bombsite == 0 ? "A" : "B")

                const a = 450.7;
                const b = 75.68;
                const c = 789.2;

                const d = (distance - b) / c;

                var damage = a * Math.exp(-d * d);

                if (armor > 0) {
                    var newDmg = damage * 0.5;
                    var armorDmg = (damage - newDmg) * 0.5;

                    if (armorDmg > armor) {
                        armor = armor * (1 / .5);
                        newDmg = damage - armorDmg;
                    }
                    damage = newDmg;
                }
                dmg = Math.ceil(damage);

                if (timer > 0)
                    Indicators.Add(String.format("{0} - {1}s", bombsite, timer.toFixed(1)), [255, 255, 255, 255]);

                if (dmg > 1 && timer > 0)
                    Indicators.Add(dmg >= health ? "FATAL" : String.format("-{0} HP", dmg), dmg >= health ? [255, 0, 0, 255] : [255, 240, 100, 255]);
            }

            if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap") && Entity.IsAlive(Entity.GetLocalPlayer()))
                Indicators.Add("DT", Exploit.GetCharge() > 0.8 ? [210, 210, 210, 255] : [255, 0, 0, 255]);

            if (Indicators.Defusing) {
                Render.FilledRect(0, 0, 20, screen_size[1], [0, 0, 0, 150]);
                Render.FilledRect(0, screen_size[1] - (screen_size[1] / 10) *  (Indicators.DefusingTimer - Globals.Curtime()), 19, (screen_size[1] / 10) *  (Indicators.DefusingTimer - Globals.Curtime()), (Indicators.DefusingTimer - Globals.Curtime() > timer ? [180, 0, 0, 120] : [0, 180, 50, 120]));
            }
        }
        if (GUI.GetValue(p.indicators, "On-screen indicators") != 0) {
            if (!Entity.IsAlive(Entity.GetLocalPlayer()))
                    return;
            var t = Globals.Frametime() * 255 * 8;
            var options = GUI.GetValue(p.indicators, "On-screen indicators")
            var flags = "c";
            var offset = 1;
            var offset_size = GUI.GetValue(p.indicators, "On-screen indicators font") == 1 ? 10 : 13;
            if (options & (1 << 11))
                offset += 2;
            var short = GUI.GetValue(p.indicators, "On-screen indicators short text")
            switch (GUI.GetValue(p.indicators, "On-screen indicators font")) {
                case 1:
                    flags += "-";
                    break;
            }
            if (options & (1 << 0)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "DT" : "DOUBLE TAP", Exploit.GetCharge() == 1 || (Indicators.Alpha['Double tap'] < 220 && !GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap")) ? [140, 200, 0, Indicators.Alpha['Double tap']] : [255, 60, 30, Indicators.Alpha['Double tap']])
                if (Indicators.Alpha['Double tap'] !== 0)
                    offset++;
                if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap")) {
                    Indicators.Alpha['Double tap'] = Math.min(220, Indicators.Alpha["Double tap"] + t);
                }
                else {
                    Indicators.Alpha['Double tap'] = Math.max(0, Indicators.Alpha["Double tap"] - t);
                }
            }
            if (options & (1 << 1)) {
                Visuals.Text(center_screen[0] + (short ? 0 : -1), center_screen[1] + offset * offset_size, flags, short ? "HS" : "HIDESHOTS", [80, 130, 230, Indicators.Alpha["Hide shots"]])
                if (Indicators.Alpha["Hide shots"] !== 0)
                    offset++;
                if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Hide shots")) {
                    Indicators.Alpha["Hide shots"] = Math.min(220, Indicators.Alpha["Hide shots"] + t);
                }
                else {
                    Indicators.Alpha["Hide shots"] = Math.max(0, Indicators.Alpha["Hide shots"] - t);
                }
            }
            if (options & (1 << 2)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "DMG" : "DAMAGE OVERRIDE", [80, 80, 230, Indicators.Alpha['Damage override']])
                if (Indicators.Alpha['Damage override'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Minimum damage override")) {
                    Indicators.Alpha['Damage override'] = Math.min(220, Indicators.Alpha['Damage override'] + t);
                }
                else {
                    Indicators.Alpha['Damage override'] = Math.max(0, Indicators.Alpha['Damage override'] - t);
                }
            }
            if (options & (1 << 3)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "FD" : "FAKE DUCK", [130, 80, 230, Indicators.Alpha['Fake duck']])
                if (Indicators.Alpha['Fake duck'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Fake duck")) {
                    Indicators.Alpha['Fake duck'] = Math.min(220, Indicators.Alpha['Fake duck'] + t);
                }
                else {
                    Indicators.Alpha['Fake duck'] = Math.max(0, Indicators.Alpha['Fake duck'] - t);
                }
            }
            if (options & (1 << 4)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "INV" : "INVERTER", [230, 230, 230, Indicators.Alpha['Inverter']])
                if (Indicators.Alpha['Inverter'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "AA Direction inverter")) {
                    Indicators.Alpha['Inverter'] = Math.min(220, Indicators.Alpha['Inverter'] + t);
                }
                else {
                    Indicators.Alpha['Inverter'] = Math.max(0, Indicators.Alpha['Inverter'] - t);
                }
            }
            if (options & (1 << 5)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "SP" : "SAFE POINTS", [80, 230, 180, Indicators.Alpha['Safe points']])
                if (Indicators.Alpha['Safe points'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Force safe point")) {
                    Indicators.Alpha['Safe points'] = Math.min(220, Indicators.Alpha['Safe points'] + t);
                }
                else {
                    Indicators.Alpha['Safe points'] = Math.max(0, Indicators.Alpha['Safe points'] - t);
                }
            }
            if (options & (1 << 6)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "BAIM" : "BODY AIM", [230, 80, 60, Indicators.Alpha['Body aim']])
                if (Indicators.Alpha['Body aim'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Force body aim")) {
                    Indicators.Alpha['Body aim'] = Math.min(220, Indicators.Alpha['Body aim'] + t);
                }
                else {
                    Indicators.Alpha['Body aim'] = Math.max(0, Indicators.Alpha['Body aim'] - t);
                }
            }
            if (options & (1 << 7)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "FS" : "FREESTAND", [0, 230, 230, Indicators.Alpha['Freestanding']])
                if (Indicators.Alpha['Freestanding'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Freestanding")) {
                    Indicators.Alpha['Freestanding'] = Math.min(220, Indicators.Alpha['Freestanding'] + t);
                }
                else {
                    Indicators.Alpha['Freestanding'] = Math.max(0, Indicators.Alpha['Freestanding'] - t);
                }
            }
            if (options & (1 << 8)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "SM" : "SLOWMOTION", [230, 100, 180, Indicators.Alpha['Slow walk']])
                if (Indicators.Alpha['Slow walk'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Slow walk")) {
                    Indicators.Alpha['Slow walk'] = Math.min(220, Indicators.Alpha['Slow walk'] + t);
                }
                else {
                    Indicators.Alpha['Slow walk'] = Math.max(0, Indicators.Alpha['Slow walk'] - t);
                }
            }
            if (options & (1 << 9)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "AP" : "AUTO PEEK", [230, 180, 130, Indicators.Alpha['Auto peek']])
                if (Indicators.Alpha['Auto peek'] !== 0)
                    offset++;
                if (GUI.GetValue(["Misc.", "Keys", "Keys", "Key assignment"], "Auto peek")) {
                    Indicators.Alpha['Auto peek'] = Math.min(220, Indicators.Alpha['Auto peek'] + t);
                }
                else {
                    Indicators.Alpha['Auto peek'] = Math.max(0, Indicators.Alpha['Auto peek'] - t);
                }
            }
            if (options & (1 << 10)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "EJ" : "EDGE JUMP", [230, 180, 60, Indicators.Alpha['Edge jump']])
                if (Indicators.Alpha['Edge jump'] !== 0)
                    offset++;
                if (GUI.GetValue(["Misc.", "Keys", "Keys", "Key assignment"], "Edge jump")) {
                    Indicators.Alpha['Edge jump'] = Math.min(220, Indicators.Alpha['Edge jump'] + t);
                }
                else {
                    Indicators.Alpha['Edge jump'] = Math.max(0, Indicators.Alpha['Edge jump'] - t);
                }
            }

            if (options & (1 << 11)) {
                var c = Northwood.GetColor();
                c[3] = 255;
                Visuals.Text(center_screen[0], center_screen[1] + 13, flags, "FAKE YAW", c)
                var w = Math.ceil(Math.min(60, Math.abs(Fakepanel.Delta)) / 1.3);
                Render.GradientRect(center_screen[0] - w, center_screen[1] + 29, w, 3, 1, [c[0], c[1], c[2], 0], c);
                Render.GradientRect(center_screen[0], center_screen[1] + 29, w, 3, 1, c, [c[0], c[1], c[2], 0]);
            }
        }
    },
    CreateMove: function() {
        if (Globals.ChokedCommands() == 0) {
            if (Indicators.last_origin != Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")) {
                Indicators.last_origin_sqr = Indicators.last_origin[0] * Indicators.last_origin[0] + Indicators.last_origin[1] * Indicators.last_origin[1];
                Indicators.origin_sqr = Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[0] * Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[0] + Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[1] * Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[1];
                Indicators.last_origin = Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin");
            }
        }
    }
}
Cheat.RegisterCallback("bomb_beginplant", "Indicators.OnPlanting")
Cheat.RegisterCallback("bomb_abortplant", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("bomb_planted", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("round_prestart", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("client_disconnect", "Indicators.OnAbortPlanting")

Cheat.RegisterCallback("bomb_begindefuse", "Indicators.OnDefusing")
Cheat.RegisterCallback("round_prestart", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_abortdefuse", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_exploded", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_defused", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("client_disconnect", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("Draw", "Indicators.Draw")
Cheat.RegisterCallback("CreateMove", "Indicators.CreateMove")

/*
* Section: Utilities
*/

var Watermark = {
    Load: function() {
        GUI.SetEnabled(p.script_ui, "Watermark", 0);
        GUI.SetValue(p.script_ui, "Watermark", 0);
        UI.AddCheckbox(p.script_ui, "[NW] Watermark");
        UI.AddDropdown(p.script_ui, "Watermark style", ["northwood", "onetap", "onetap.com"], 0);
        UI.AddTextbox(p.script_ui, "Watermark username");
        if (Northwood.Get("watermark:unlock_prefix") == "true")
            UI.AddTextbox(p.script_ui, "Watermark prefix")
        if (Northwood.Get("watermark:unlock_suffix") == "true")
            UI.AddTextbox(p.script_ui, "Watermark suffix")
        UI.AddCheckbox(p.script_ui, "Fade at top");
    },
    GradientBar: function() {
        if (!GUI.GetValue(p.script_ui, "Fade at top"))
            return;

        var c = Northwood.GetFade();
        Render.GradientRect(0, 0, screen_size[0] / 2, 3, 1, c[0], c[1]);
        Render.GradientRect(screen_size[0] / 2, 0, screen_size[0] / 2, 3, 1, c[1], c[2]);
        Render.FilledRect(0, 1, screen_size[0], 1, [0, 0, 0, 20]);
        Render.FilledRect(0, 2, screen_size[0], 1, [0, 0, 0, 40]);
    },
    Draw: function() {
        if (!GUI.GetValue(p.script_ui, "[NW] Watermark"))
            return;

        var prefix;
        switch (GUI.GetValue(p.script_ui, "Watermark style")) {
            case 0:
                prefix = "northwood"
                break;
            case 1:
                prefix = "onetap"
                break;
            case 2:
                prefix = "onetap.com"
                break;
        }
        if (Northwood.Get("watermark:unlock_prefix") == "true" && GUI.GetString(p.script_ui, "Watermark prefix") != "")
            prefix = GUI.GetString(p.script_ui, "Watermark prefix");
        if (Northwood.Get("watermark:unlock_suffix") == "true" && GUI.GetString(p.script_ui, "Watermark suffix") != "")
            prefix += " ["+GUI.GetString(p.script_ui, "Watermark suffix")+"]"

        var username = GUI.GetString(p.script_ui, "Watermark username") == "" ? Cheat.GetUsername() : GUI.GetString(p.script_ui, "Watermark username")

        var today = new Date()
        today = today.toTimeString().substring(0, 8)

        if (typeof prefix == "Symbol") {
            prefix = prefix.toString();
            prefix = prefix.replace("Symbol(")
            prefix = prefix.replace(")")
        }

        if (typeof username == "Symbol") {
            username = username.toString();
            username = username.replace("Symbol(")
            username = username.replace(")")
        }

        if (!World.GetServerString())
            var text = String.format("{0} | {1} | {2}", prefix, username, today)
        else
            var text = String.format("{0} | {1} | delay: {2}ms | {3}tick | {4}", prefix, username, Math.floor(Entity.GetProp(Entity.GetLocalPlayer(), "CPlayerResource", "m_iPing")), Globals.Tickrate(), today)

        var off = Northwood.I_Offset;
        var c = Northwood.GetColor()
        var w = Math.floor(Render.TextSize(text, Visuals.Fonts()[1])[0])
        var x = size[0] - w - 14
        switch (Northwood.GetStyle()) {
            case 0:
                Render.GradientRect(x - 4, 8 + 22 * off, Math.floor((w + 8) / 2), 2, 1, [c[0], c[1], c[2], 255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio")], [c[0], c[1], c[2], 255])
                Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), 8 + 22 * off, Math.floor((w + 8) / 2) + 1, 2, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio")])
                break;
            case 1:
                var fc = Northwood.GetFade();
                Render.FilledRect(x - 4, 8 + 22 * off, w + 8, 2, [0,0,0,255])
                Render.GradientRect(x - 4, 8 + 22 * off, Math.ceil((w + 8) / 2), 2, 1, fc[0], fc[1])
                Render.GradientRect(x - 4 + Math.ceil((w + 8) / 2), 8 + 22 * off, Math.floor((w + 8) / 2), 2, 1, fc[1], fc[2])
                Render.FilledRect(x - 4, 9 + 22 * off, w + 8, 1, [0,0,0,40])
                break;
        }

        Render.GradientRect(x - 4, 10 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), 10 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])

        Visuals.Text(x, 11 + 22 * off, "", text, [255, 255, 255, 255]);
        Northwood.I_Offset++;
    }
}

Watermark.Load();
Cheat.RegisterCallback("Draw", "Watermark.Draw")
Cheat.RegisterCallback("Draw", "Watermark.GradientBar")

/*
* Section: Fakepanel
*/

var Fakepanel = {
    Load: function() {
        UI.AddCheckbox(p.script_ui, "[NW] Fake yaw panel");
        UI.AddCheckbox(p.script_ui, "[NW] Fake lag panel");
    },
    SetPrev: false,
    Delta: 0,
    CreateMove: function() {
        if (Globals.ChokedCommands() != 0)
            return;


        var Delto = normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw())
        if (Math.abs(Delto - Fakepanel.Delta) > 3 && !Fakepanel.SetPrev) {
            Fakepanel.SetPrev = true
        }
        else {
            Fakepanel.SetPrev = false
            Fakepanel.Delta = Delto
        }

        //Cheat.Print(String.format("Delto: {0} SetPrev: {1} Delta: {2}\n", Delto, Fakepanel.SetPrev, Fakepanel.Delta))
    },
    Color: function(delta) {
        return [255 - Math.min(58, delta)*2.3682, Math.min(58, delta)*3.4210, Math.min(58, delta)*0.22807, 255]
    },
    Draw: function() {
        if (!World.GetServerString() || !Entity.IsAlive(Entity.GetLocalPlayer()) || (!GUI.GetValue(p.script_ui, "[NW] Fake yaw panel") && !GUI.GetValue(p.script_ui, "[NW] Fake lag panel")))
            return;
        if (!GUI.GetValue(p.script_ui, "[NW] Fake lag panel")) {
            var side = "-";

            if ((Fakepanel.Delta > 1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) > 60)))
                side = "<"
            else if ((Fakepanel.Delta < -1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) < 60)))
                side = "<"
            else if ((Fakepanel.Delta < -1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) > 60)))
                side = ">"
            else if ((Fakepanel.Delta > 1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) < 60)))
                side = ">"

            var text = String.format("FAKE ({0} ) | safety: {1}% | side: {2}", Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1), Math.abs(Math.floor(Math.min(Math.abs(Fakepanel.Delta), 116) / 116 * 100)), side)
        }
        else {
            var text = String.format("FAKE ({0} )",  Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1))
            if (Globals.Tickcount() < Indicators.Air_tickcount + 3 || Exploit.GetCharge() == 1)
                var text_fl = String.format("FL: {0} | {1}", choked_max, (Exploit.GetCharge() == 1 ? "SHIFTING " : "dst:        "))
            else
                var text_fl = String.format("FL: {0}", choked_max)
        }
        var off = Northwood.I_Offset;
        var w = Render.TextSize(text, Visuals.Fonts()[1])[0] + 5
        var x = screen_size[0] - 10 - w - (GUI.GetValue(p.script_ui, "[NW] Fake lag panel") ? Render.TextSize(text_fl, Visuals.Fonts()[1])[0] + 15 : 0)
        var a = Northwood.GetColor()[3]
        if (GUI.GetValue(p.script_ui, "[NW] Fake yaw panel")) {
            Render.GradientRect(x - 6, 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
            Render.GradientRect(x - 6 + Math.floor((w + 8) / 2), 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
            var color = Northwood.Utils.StatusColor(Math.abs(Fakepanel.Delta), 60);
            Render.GradientRect(x-8, 13 + 22 * off, 2, 8, 0, color.concat(50), color.concat(255));
            Render.GradientRect(x-8, 21 + 22 * off, 2, 9, 0, color.concat(255), color.concat(50));
            Visuals.Text(x-2, 14 + 22 * off, "", text, [255, 255, 255, 255])
            Render.Circle(x + Render.TextSize(String.format("FAKE ({0}",  Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1)), Visuals.Fonts()[1])[0], 18 + 22 * off, 1, [255, 255, 255, 255])
        }
        Northwood.I_Offset++;
        if (GUI.GetValue(p.script_ui, "[NW] Fake lag panel")) {
            w = Render.TextSize(text_fl, Visuals.Fonts()[1])[0] + 5
            x = screen_size[0] - 10 - w
            a = Northwood.GetColor()[3]
            var c = [180, 190, 190]
            if (Exploit.GetCharge() == 1)
                c = [255, 150, 0]
            Render.GradientRect(x - 5, 13 + 22 * off, Math.floor((w) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
            Render.GradientRect(x - 5 + Math.floor((w) / 2), 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
            Render.GradientRect(x - 5, 30 + 22 * off, Math.floor((w) / 2), 1, 1, [c[0], c[1], c[2], 0], [c[0], c[1], c[2], 255])
            Render.GradientRect(x - 5 + Math.floor((w) / 2), 30 + 22 * off, Math.floor((w + 8) / 2), 1, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 0])
            //Cheat.Print(Indicators.Air_tickcount.toString())
            if (Exploit.GetCharge() != 1 && Globals.Tickcount() < Indicators.Air_tickcount + 2) {
                c = Northwood.GetColor()
                var add_w = Render.TextSize(String.format("FL: {0} | {1}", choked_max, "dst: "), Visuals.Fonts()[1])[0];
                Render.GradientRect(x - 1 + add_w, 19 + 22 * off, Math.min(25, (Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) / 10) / 1024), 6, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 0])
            }
            Visuals.Text(x - 1, 14 + 22 * off, "", text_fl, [255, 255, 255, 255])
        }
    },
}

Fakepanel.Load()
Cheat.RegisterCallback("Draw", "Fakepanel.Draw")
Cheat.RegisterCallback("CreateMove", "Fakepanel.CreateMove")

var Performance = {
    Freq: (Northwood.Get("performance:freq") == "" ? 60 : parseInt(Northwood.Get("performance:freq"))),
    RequestTime: Globals.Curtime(),
    Frametime: Globals.Frametime(),
    Frametimes: [],
    Load: function() {
        UI.AddCheckbox(p.script_ui, "[NW] Performance panel");
    },
    Draw: function() {
        if (!World.GetServerString() || !GUI.GetValue(p.script_ui, "[NW] Performance panel"))
            return;

        if (Performance.RequestTime + 1 < Globals.Curtime()) {
            Performance.Frametime = Globals.Frametime()
            Performance.RequestTime = Globals.Curtime()
            Performance.Frametimes.unshift(Performance.Frametime)
            if (Performance.Frametimes.length > 4)
                Performance.Frametimes.pop()
        } 
        var off = Northwood.I_Offset;
        var text_ie = "IO | ";
        var text_freq = String.format("{0}ms / {1}hz", Math.abs((Performance.Frametime * 1000).toFixed(1)), Performance.Freq)
        var y = 8
        var w = Render.TextSize(text_ie, Visuals.Fonts()[1])[0] + 24
        var x = screen_size[0] - 24 - w - Render.TextSize(text_freq, Visuals.Fonts()[1])[0]
        Render.GradientRect(x - 4, y + 28 * off, Math.floor((w + 4) /2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 4) /2), y + 28 * off, Math.floor((w + 4) /2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
        //Render.FilledRect(x - 4, y + 28 * off, w + 4, 17, [17, 17, 17, Northwood.GetColor()[3]])
        Visuals.Text(x, y+1 + 28 * off, "", text_ie, [255, 255, 255, 255])

        for (var i in Performance.Frametimes) {
            var ft = Performance.Frametimes[i]
            var c = Northwood.GetColor()
            Render.GradientRect(x + w - 9 - (5 * i), y + 28 * off + 14 - Math.floor(Math.min(12, ft / 1 * 1000)), 5, Math.floor(Math.min(12, ft / 1 * 1000)), 0, [c[0], c[1], c[2], 0], [c[0], c[1], c[2], 255])
        }

        w = Render.TextSize(text_freq, Visuals.Fonts()[1])[0]
        x = screen_size[0] - 10 - w - 4
        var c = [0, 255, 0]
        var ft = Performance.Frametime * 1000
        if (ft > 15)
            c = [255, 0, 0]
        else if (ft > 12)
            c = [255, 170, 0]
        else if (ft > 10)
            c = [255, 255, 0]
        else if (ft > 7.5)
            c = [150, 255, 0]
        else if (ft > 5)
            c = [70, 255, 0]

        Render.GradientRect(x - 4, y+ 28 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), y + 28 * off, Math.floor((w + 8) / 2), 17, 1,  Northwood.GetBackground()[1], Northwood.GetBackground()[0])
        //Render.FilledRect(x - 4, y+ 28 * off, w + 8, 17, [17, 17, 17, Northwood.GetColor()[3]])
        Visuals.Text(x, y+1+ 28 * off, "", text_freq, [255, 255, 255, 255])
        Render.GradientRect(x - 4, y+17+ 28 * off, w / 2 + 4, 1, 1, c.concat(0), c.concat(255))
        Render.GradientRect(x + w / 2, y+17+ 28 * off, w / 2 + 4, 1, 1, c.concat(255), c.concat(0))
        Northwood.I_Offset++;
    },
}

Performance.Load()
Cheat.RegisterCallback("Draw", "Performance.Draw")

function in_bounds(vec, x, y, x2, y2) {
    return (vec[0] > x) && (vec[1] > y) && (vec[0] < x2) && (vec[1] < y2)
}

function isEquals(element, index, array, text) {
    if (element.text == text)
        return true;
} 

if (!Array.prototype.find) {
    Object.defineProperty(Array.prototype, 'find', {
      value: function(predicate) {
       // 1. Let O be ? ToObject(this value).
        if (this == null) {
          throw new TypeError('"this" is null or not defined');
        }
 
        var o = Object(this);
 
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = o.length >>> 0;
 
        // 3. If IsCallable(predicate) is false, throw a TypeError exception.
        if (typeof predicate !== 'function') {
          throw new TypeError('predicate must be a function');
        }
 
        // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
        var thisArg = arguments[1];
 
        // 5. Let k be 0.
        var k = 0;
 
        // 6. Repeat, while k < len
        while (k < len) {
          // a. Let Pk be ! ToString(k).
          // b. Let kValue be ? Get(O, Pk).
          // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
          // d. If testResult is true, return kValue.
          var kValue = o[k];
          if (predicate.call(thisArg, kValue, k, o, arguments[1])) {
            return kValue;
          }
          // e. Increase k by 1.
          k++;
        }
 
        // 7. Return undefined.
        return undefined;
      },
      configurable: true,
      writable: true
    });
  }

var Hotkeys = {
    GRABBED: false,
    GRAB_X: 0,
    GRAB_Y: 0,
    GLOBAL_ALPHA: 0,
    MAX_WIDTH: 100,
    CUR_WIDTH: 100,
    active_list: new Array(),
    items_list: new Array(),
    Load: function() {
        GUI.SetEnabled(p.script_ui, "Show keybind states", 0);
        GUI.SetValue(p.script_ui, "Show keybind states", 0);
        UI.AddCheckbox(p.script_ui, "[NW] Keybinds");
        UI.AddSliderFloat(p.script_ui, "Keybinds split ratio", 0, 1)
        UI.AddSliderInt(p.script_ui, "Keybinds X", 0, screen_size[0])
        UI.AddSliderInt(p.script_ui, "Keybinds Y", 0, screen_size[1])
        GUI.SetEnabled(p.script_ui, "Keybinds X", 0)
        GUI.SetEnabled(p.script_ui, "Keybinds Y", 0)

        this.items_list.push({text: "Menu key", func: UI.IsMenuOpen, path: "nil", name: "nil", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Double tap", func: GUI.GetValue, path: ["Rage", "Exploits", "Keys", "Key assignment"], name: "Double tap", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "On shot anti-aim", func: GUI.GetValue, path: ["Rage", "Exploits", "Keys", "Key assignment"], name: "Hide shots", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force safe point", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force safe point", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Rage bot", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Ragebot activation", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Resolver override", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Resolver override", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force body aim", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force body aim", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force head aim", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force head aim", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force safe point", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force safe point", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Mouse direction", func: GUI.GetValue, path: p.antiaim_keys, name: "Mouse direction", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Jitter anti-aim", func: GUI.GetValue, path: p.antiaim_keys, name: "Jitter", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Slow motion", func: GUI.GetValue, path: p.antiaim_keys, name: "Slow walk", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Anti-aim inverter", func: GUI.GetValue, path: p.antiaim_keys, name: "AA Direction inverter", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Duck peek assist", func: GUI.GetValue, path: p.antiaim_keys, name: "Fake duck", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Freestanding", func: GUI.GetValue, path: p.antiaim_keys, name: "Freestanding", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Edge jump", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Edge jump", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Free look", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Freecam", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Quick peek assist", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Auto peek", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Zoom", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Zoom", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Damage override", func: GUI.GetValue, path: p.rage, name: "Minimum damage override", status: "[~]", alpha: 0, active: false})
    },
    Grabbing: function(x, y, w) {
        if (Global.IsKeyPressed(1) && UI.IsMenuOpen()) {
            const mouse_pos = Global.GetCursorPosition();
            if (in_bounds(mouse_pos, x, y, x + w, y + 22)) {
                if (!Hotkeys.GRABBED) {
                    Hotkeys.GRAB_X = mouse_pos[0] - x;
                    Hotkeys.GRAB_Y = mouse_pos[1] - y;
                }
                Hotkeys.GRABBED = true;
            }
        }
        else {
            Hotkeys.GRABBED = false;
        }

        if (Hotkeys.GRABBED) {
            GUI.SetValue(p.script_ui, "Keybinds X", mouse_pos[0] - Hotkeys.GRAB_X)
            GUI.SetValue(p.script_ui, "Keybinds Y", mouse_pos[1] - Hotkeys.GRAB_Y)
        }
    },
    HandleItems: function() {
        if (Hotkeys.active_list.length == 0)
            Hotkeys.MAX_WIDTH = 100;

        var t = Globals.Frametime() * 8 * 255

        for (var i=0; i < Hotkeys.items_list.length; i++) {
            var elem = Hotkeys.items_list[i];
            if (elem.path != "nil" && UI.GetHotkeyState(GUI.GetPath(elem.path, elem.name)) == "Always")
                continue;
            if (elem.func(elem.path, elem.name)) {
                elem.active = true;
                var elem_w = Render.TextSize(elem.text, Visuals.Fonts()[1])[0]
                if (elem_w + 80 > this.MAX_WIDTH)
                    this.MAX_WIDTH = elem_w + 80
                if (elem.alpha < 255)
                    elem.alpha = Math.min(255, elem.alpha + t)
                if (Hotkeys.active_list.indexOf(elem.text) == -1)
                    Hotkeys.active_list.push(elem.text)
            }
            else {
                if (elem.alpha > 0)
                    elem.alpha = Math.max(0, elem.alpha - t)
                else {
                    elem.active = false
                    var index = Hotkeys.active_list.indexOf(elem.text)
                    if (index !== -1) {
                        Hotkeys.active_list.splice(index, 1)
                        if (Hotkeys.active_list.length > 0)
                            this.MAX_WIDTH = 100
                    }
                }
            }
        }
        var active = false
        if (Hotkeys.active_list.length == 1) {
            //x => x.text == Hotkeys.active_list[0]
            var a_elem = Hotkeys.items_list.find(isEquals, Hotkeys.active_list[0]);
            if (!a_elem.func(a_elem.path, a_elem.name))
                active = true;
        }

        if (Hotkeys.active_list.length == 0 || active) {
            if (Hotkeys.GLOBAL_ALPHA > 0)
                this.GLOBAL_ALPHA = Math.max(0, this.GLOBAL_ALPHA - t)
        }
        else {
            if (Hotkeys.GLOBAL_ALPHA < 255)
                Hotkeys.GLOBAL_ALPHA = Math.min(255, Hotkeys.GLOBAL_ALPHA + t)
        }

        if (this.CUR_WIDTH > this.MAX_WIDTH)
            this.CUR_WIDTH = Math.max(this.CUR_WIDTH - t / 2, this.CUR_WIDTH - (this.CUR_WIDTH - this.MAX_WIDTH))
        else if (this.CUR_WIDTH < this.MAX_WIDTH)
            this.CUR_WIDTH = Math.min(this.CUR_WIDTH + t / 2, this.CUR_WIDTH + (this.MAX_WIDTH - this.CUR_WIDTH))
    },
    CalcAlpha: function(alpha) {
        return Math.min(this.GLOBAL_ALPHA, alpha);
    },
    GetStatus: function(path, name) {
        var status = "[~]"
        if (path == "nil")
            return status;
        switch (UI.GetHotkeyState(GUI.GetPath(path, name))) {
            case "Toggle":
                status = "[toggled]";
                break;
            case "Hold":
                status = "[holding]";
                break;
            case "Always":
                status = "[enabled]";
                break;
        }
        return status;       
    },
    Draw: function() {
        if (!GUI.GetValue(p.script_ui, "[NW] Keybinds") || !World.GetServerString())
            return;

        Hotkeys.HandleItems();

        var x = GUI.GetValue(p.script_ui, "Keybinds X")
        var y = GUI.GetValue(p.script_ui, "Keybinds Y")
        var c = Northwood.GetColor()
        var w = Hotkeys.CUR_WIDTH;
        switch (Northwood.GetStyle()) {
            case 0:
                Render.GradientRect(x, y-2, Math.floor(w / 2), 2, 1, [c[0], c[1], c[2], Hotkeys.CalcAlpha(255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio"))], [c[0], c[1], c[2], Hotkeys.CalcAlpha(255)])
                Render.GradientRect(x + Math.floor(w / 2), y-2, Math.floor(w / 2), 2, 1, [c[0], c[1], c[2], Hotkeys.CalcAlpha(255)], [c[0], c[1], c[2], Hotkeys.CalcAlpha(255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio"))])
                break;
            case 1:
                var fc = Northwood.GetFade();
                Render.FilledRect(x, y-2, w-1, 2, [0, 0, 0, Hotkeys.CalcAlpha(255)])
                /*Render.GradientRect(x - 4, 8, Math.floor((w + 8) / 2), 2, 1,  [fc[0][0], fc[0][1], fc[0][2], Hotkeys.CalcAlpha(fc[0][3])], [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])])
                Render.GradientRect(x - 4 + Math.floor((w + 7) / 2), 8, Math.floor((w + 8) / 2) + 1, 2, 1, [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])], [fc[2][0], fc[2][1], fc[2][2], Hotkeys.CalcAlpha(fc[2][3]))*/
                Render.GradientRect(x, y-2, Math.floor(w / 2), 2, 1, [fc[0][0], fc[0][1], fc[0][2], Hotkeys.CalcAlpha(fc[0][3])], [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])])
                Render.GradientRect(x + Math.floor(w / 2), y-2, Math.floor(w / 2), 2, 1, [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])], [fc[2][0], fc[2][1], fc[2][2], Hotkeys.CalcAlpha(fc[2][3])])
                Render.FilledRect(x, y-1, w, 1, [0, 0, 0, Hotkeys.CalcAlpha(40)])
                break;
        }
        Render.FilledRect(x, y, w, 17, [17, 17, 17, Hotkeys.CalcAlpha(c[3])])
        Visuals.Text(x + w/2, y+1, "c", "keybinds", [255, 255, 255, Hotkeys.CalcAlpha(255)])
        Hotkeys.Grabbing(x, y, w);

        for(var i=0; i < Hotkeys.active_list.length; i++) {
            var elem = Hotkeys.items_list.find(isEquals, Hotkeys.active_list[i]);
            var status = Hotkeys.GetStatus(elem.path, elem.name);
            if (elem.active && status != "[enabled]") {
                Render.FilledRect(x, y + 17 + (17*i), w, 17, [17, 17, 17, Hotkeys.CalcAlpha(Math.min(elem.alpha, c[3] * GUI.GetValue(p.script_ui, "Keybinds split ratio")))])
                Visuals.Text(x + 4, y + 17 + (17*i), "", elem.text, [255, 255, 255, Hotkeys.CalcAlpha(elem.alpha)])
                Visuals.Text(x + w - Render.TextSize(status, Visuals.Fonts()[1])[0] - 4, y + 17 + (17*i), "", status, [255, 255, 255, Hotkeys.CalcAlpha(elem.alpha)])
            }
        }
    },
}

Hotkeys.Load();
Cheat.RegisterCallback("Draw", "Hotkeys.Draw")

/*
* Section: Ragebot
*/

function VectorAngles(forward)
{
    var angles;
    var tmp, yaw, pitch;
    
    if (forward[1] == 0 && forward[0] == 0)
    {
        yaw = 0;
        if (forward[2] > 0)
            pitch = 270;
        else
            pitch = 90;
    }
    else
    {
        yaw = (Math.atan2(forward[1], forward[0]) * 180 / Math.PI);
        if (yaw < 0)
            yaw += 360;
        tmp = Math.sqrt (forward[0]*forward[0] + forward[1]*forward[1]);
        pitch = (Math.atan2(-forward[2], tmp) * 180 / Math.PI);
        if (pitch < 0)
            pitch += 360;
    }
    
    x = pitch;
    y = yaw;
    z = 0;
    angles = [x,y,z];
    
    return angles;
}
function can_shoot(Player){
    var index = Entity.GetWeapon(Player)
    var classid = Entity.GetClassID(index);
    
    var weapon =  classid == 107 || classid == 108 || classid == 96 || classid == 99 || classid ==112 || classid == 155 || classid == 47 || classid == 267;//checking if the selected weapon is knife or nade
    var clip = Entity.GetProp(index, "DT_BaseCombatWeapon", "m_iClip1");
    
    if(weapon || clip == 0 || UserCMD.GetButtons() & (1 << 1))//check if player is jumping or as an empty mag
        return false;
    return true;
}

var weaponNames = {
    "usp s": "USP", "glock 18": "Glock", "dual berettas": "Dualies", "r8 revolver": "Revolver", "desert eagle": "Deagle", "p250": "P250", "tec 9": "Tec-9",
    "mp9": "MP9", "mac 10": "Mac10", "pp bizon": "PP-Bizon", "ump 45": "UMP45", "ak 47": "AK47", "sg 553": "SG553", "aug": "AUG", "m4a1 s": "M4A1-S", "m4a4": "M4A4", "ssg 08": "SSG08",
    "awp": "AWP", "g3sg1": "G3SG1", "scar 20": "SCAR20", "xm1014": "XM1014", "mag 7": "MAG7", "m249": "M249", "negev": "Negev", "p2000": "P2000", "famas": "FAMAS", "five seven": "Five Seven", "mp7": "MP7",
    "ump 45": "UMP45", "p90": "P90", "cz75 auto": "CZ-75", "mp5 sd": "MP5", "galil ar": "GALIL", "sawed off": "Sawed off", "nova": "Nova"
};

for (var name in weaponNames) {
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Delay shot")
    UI.AddMultiDropdown(["Rage", "Target", weaponNames[name]], "Avoid unsafe hitboxes", ["Head", "Chest", "Stomach", "Arms", "Legs", "Feet"])
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Force body aim on peek")
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Damage override", 0, 130)
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Hitchance override", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override no scope hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "No scope hitchance", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override in air hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "In air hitchance", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override double tap damage");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Double tap damage", 0, 130);
}

UI.AddHotkey(p.rage_keys, "Force head aim", "Force head aim")
UI.AddHotkey(p.rage_keys, "Minimum damage override", "Damage override")
//UI.AddHotkey(p.rage_keys, "Dormant aimbot", "Dormant aimbot")

var Rage = {
    OldTime: Globals.Realtime(),
    /*DormantAimbot: function() {
        if (!Tickbase.CanShift(1) || !UI.GetValue(["Rage", "General", "General", "Key assignment", "Dormant aimbot"]))
            return;

        var enemies = Entity.GetEnemies()
        var d = enemies.filter(function(e){
            return Entity.IsDormant(e) && Entity.IsAlive(e) && Trace.Bullet(Entity.GetLocalPlayer(), e, Entity.GetEyePosition(Entity.GetLocalPlayer()), VectorAdd(Entity.GetRenderOrigin(e), [0, 0, 45]))[1] > 1
        })
        var c = d.sort(function(a, b){
            return Trace.Bullet(Entity.GetLocalPlayer(), a, Entity.GetEyePosition(Entity.GetLocalPlayer()), va(Entity.GetRenderOrigin(a), [0, 0, 45]))[1] - Trace.Bullet(Entity.GetLocalPlayer(), b, Entity.GetEyePosition(Entity.GetLocalPlayer()), va(Entity.GetRenderOrigin(b), [0, 0, 45]))[1]
        })[0]

        if(!c) return;
        Cheat.Print("Target found\n");
        var weapon_index = Entity.GetWeapon(Entity.GetLocalPlayer()); 
        
        var viewangle = VectorAngles(VectorSubtract(VectorAdd(Entity.GetRenderOrigin(c), [0, 0, 45]),Entity.GetEyePosition(Entity.GetLocalPlayer())))

        UserCMD.SetViewAngles(viewangle, true)
        UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 0))
        dmg = Trace.Bullet(Entity.GetLocalPlayer(), c, Entity.GetEyePosition(Entity.GetLocalPlayer()), VectorAdd(Entity.GetRenderOrigin(c), [0, 0, 45]))[1]
        Cheat.Print("Dormant fired\n");
    },*/
    CreateMove: function() {
        var target = Ragebot.GetTargets();
        var weaponName = Entity.GetName(Entity.GetWeapon(Entity.GetLocalPlayer()))

        Indicators.Damage = (weaponNames.hasOwnProperty(weaponName)) ? GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Damage override") : -1;
        if (weaponNames.hasOwnProperty(weaponName)) {
            for (var i in target) {
                // Hitchance override
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Delay shot") && Globals.ChokedCommands() != 0) {
                    for (var h = 0; h <= 18; h++) {
                            Ragebot.IgnoreTargetHitbox(target[i], h, true);
                    }
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override no scope hitchance") && !Entity.GetProp(Entity.GetLocalPlayer(), "CCSPlayer", "m_bIsScoped")) {
                    Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "No scope hitchance"))
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override in air hitchance") && !(Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer" ,"m_fFlags") & (1 << 0))) {
                    Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "In air hitchance"))
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override double tap damage") && Exploit.GetCharge() == 1) {
                    Ragebot.ForceTargetMinimumDamage(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Double tap damage"))
                }

                // Hitscan override
                if (GUI.GetValue(p.rage_keys, "Minimum damage override")) {
                    Ragebot.ForceTargetMinimumDamage(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Damage override"))

                    if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override hitchance"))
                        Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Hitchance override"))
                }

                // Avoid unsafe hitboxes
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 0)) {
                    Ragebot.ForceHitboxSafety(0)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 1)) {
                    Ragebot.ForceHitboxSafety(4)
                    Ragebot.ForceHitboxSafety(5)
                    Ragebot.ForceHitboxSafety(6)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 2)) {
                    Ragebot.ForceHitboxSafety(2)
                    Ragebot.ForceHitboxSafety(3)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 3)) {
                    Ragebot.ForceHitboxSafety(13)
                    Ragebot.ForceHitboxSafety(14)
                    Ragebot.ForceHitboxSafety(15)
                    Ragebot.ForceHitboxSafety(16)
                    Ragebot.ForceHitboxSafety(17)
                    Ragebot.ForceHitboxSafety(18)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 4)) {
                    Ragebot.ForceHitboxSafety(7)
                    Ragebot.ForceHitboxSafety(8)
                    Ragebot.ForceHitboxSafety(9)
                    Ragebot.ForceHitboxSafety(10)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 5)) {
                    Ragebot.ForceHitboxSafety(11)
                    Ragebot.ForceHitboxSafety(12)
                } 

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Force body aim on peek") && !GUI.GetValue(p.rage_keys, "Force head aim")) {
                    var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
                    var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
                    if (speed > 80) {
                        Ragebot.IgnoreTargetHitbox(target[i], 0)
                        Ragebot.IgnoreTargetHitbox(target[i], 1)
                        Ragebot.IgnoreTargetHitbox(target[i], 2)
                        Ragebot.IgnoreTargetHitbox(target[i], 7)
                        Ragebot.IgnoreTargetHitbox(target[i], 8)
                        Ragebot.IgnoreTargetHitbox(target[i], 9)
                        Ragebot.IgnoreTargetHitbox(target[i], 10)
                        Ragebot.IgnoreTargetHitbox(target[i], 11)
                        Ragebot.IgnoreTargetHitbox(target[i], 12)
                        Ragebot.IgnoreTargetHitbox(target[i], 13)
                        Ragebot.IgnoreTargetHitbox(target[i], 14)
                        Ragebot.IgnoreTargetHitbox(target[i], 15)
                        Ragebot.IgnoreTargetHitbox(target[i], 16)
                        Ragebot.IgnoreTargetHitbox(target[i], 17)
                        Ragebot.IgnoreTargetHitbox(target[i], 18)
                    }
                }

                if (GUI.GetValue(p.rage_keys, "Force head aim")) {
                    for (var h = 2; h <= 18; h++) {
                        Ragebot.IgnoreTargetHitbox(target[i], h, true);
                    }
                }
            }
        }
    },
    Draw: function() {
        if (Rage.OldTime + 0.1 < Globals.Curtime()) {
            Rage.OldTime = Globals.Curtime()
            for (var name in weaponNames) {
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "Hitchance override", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "In air hitchance", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override in air hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "No scope hitchance", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override no scope hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "Double tap damage", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override double tap damage"))
            }
        }
    },
}
Cheat.RegisterCallback("Draw", "Rage.Draw")
Cheat.RegisterCallback("CreateMove", "Rage.CreateMove")

/*
* Section: Welcome message
*/
var latest_load = Northwood.LatestLoad;
nlogs.push([String.format("Welcome, {0}! Northwood " + (Northwood.IsBeta() ? "(Beta) " : "(Release) ") + "loaded successfully.", Cheat.GetUsername()), Globals.Curtime(), 8, 0])
if (latest_load == "") {
    nlogs.push([String.format("You loaded script for the first time. Check #release-info at discord for instructions.", Cheat.GetUsername()), Globals.Curtime(), 15, 0])
}
Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
Cheat.PrintColor([220, 220, 220, 255], "Loaded successfully.\n")
Cheat.PrintColor([220, 220, 220, 255], "            Welcome, "); Cheat.PrintColor([220, 150, 255, 255], Cheat.GetUsername()); Cheat.PrintColor([220, 220, 220, 255], "!\n")
if (latest_load == "") {
    Cheat.PrintColor([220, 220, 220, 255], "            Thank you for purchasing \"Northwood\"!\n")
    Cheat.PrintColor([220, 220, 220, 255], "            You can read more info at #release-info Discord channel\n")
}
else {
    Cheat.PrintColor([220, 220, 220, 255], "            Latest load: "+latest_load+"\n")
}

function Notify_logs() {
    for(var i=0; i<nlogs.length; i++) {
        var j = nlogs[i][1];
        var k = nlogs[i][2];
        var l = nlogs[i][0];
        var time = j + k;
        var time_left = time - Globals.Curtime();
        //if (time >= Globals.Curtime()) {
        if (nlogs[i][3] < 1 && !(time_left < 0.6))
            nlogs[i][3] += Globals.Frametime() * 2;
        
        if (time_left < 0.6)
            nlogs[i][3] -= Globals.Frametime() * 2;
        if (i == 0) {
            if (speed < 1 && !(time_left < 0.6))
                speed += Globals.Frametime() * 4;
            
            /*if (time_left < 0.6)
                speed -= Globals.Frametime() * 4;*/
        
            if (time_left <= 0.01 && nlogs.length > 0)
                speed = 1;
        
            notify(l, Math.floor(speed * 20) + 20, Math.max(Math.min(1, nlogs[i][3]), 0));
        }
        else {
            notify(l, 40 * (i + 1), Math.max(Math.min(1, nlogs[i][3]), 0));
        }
        if (Math.max(Math.min(1, nlogs[i][3])) <= 0)
            nlogs.splice(i, 1);   
        /*}
        else {
            nlogs.splice(i, 1);           
        }*/
    }
    if (nlogs.length == 0)
        speed = 0;
}

Cheat.RegisterCallback("Draw", "Notify_logs");

/*
* Section: Grenade prediction
*/

const grenade_prediction = {
        'nades': [],
        'paths': []
};

const direction_t = {
    'LEFT': 0x0,
    'RIGHT': 0x1,
    'FORWARD': 0x2,
    'BACKWARD': 0x3,
    'UP': 0x4,
    'DOWN': 0x5
};

function extrapolate(a, b, c) {
    var TickInterval = Globals.TickInterval();
    return a[0x0] += b[0x0] * TickInterval * c, a[0x1] += b[0x1] * TickInterval * c, a[0x2] += b[0x2] * TickInterval * c, a;
}

function angle_to_vector(_0x2e6753) {
    var _0x264e09 = Math['sin'](deg2rad(_0x2e6753[0x0]))
    var _0x192a86 = Math['cos'](deg2rad(_0x2e6753[0x0]))
    var _0xb6c43a = Math['sin'](deg2rad(_0x2e6753[0x1]))
    var _0x57e0ce = Math['cos'](deg2rad(_0x2e6753[0x1]))
    return [_0x192a86 * _0x57e0ce, _0x192a86 * _0xb6c43a, -_0x264e09];
}

function vector_to_angles(_0x5a29c2) {
    var _0x140a2d, _0x3619c3, _0x5d797a, _0x572471 = [];
    if (_0x5a29c2[0x1] === 0x0 && _0x5a29c2[0x0] === 0x0) {
        _0x3619c3 = 0x0;
        if (_0x5a29c2[0x2] > 0x0) _0x5d797a = 0x10e;
        else _0x5d797a = 0x5a;
    } else {
        _0x3619c3 = Math['atan2'](_0x5a29c2[0x1], _0x5a29c2[0x0]) * 0xb4 / Math['PI'];
        if (_0x3619c3 < 0x0) _0x3619c3 += 0x168;
        _0x140a2d = Math['sqrt'](_0x5a29c2[0x0] * _0x5a29c2[0x0] + _0x5a29c2[0x1] * _0x5a29c2[0x1]), _0x5d797a = Math['atan2'](-_0x5a29c2[0x2], _0x140a2d) * 0xb4 / Math['PI'];
        if (_0x5d797a < 0x0) _0x5d797a += 0x168;
    }
    return _0x572471[0x0] = _0x5d797a, _0x572471[0x1] = _0x3619c3, _0x572471[0x2] = 0x0, _0x572471;
}

function compensate_for_collision(grenade, ticks) {
    var flags = 0x1 | 0x4000 | 0x2 | 0x2000000 | 0x8 | 0x80000
    var start_position = grenade['data']['start_position']
    var start_velocity = vector_to_angles(grenade['data']['start_velocity'])
    var compensated_velocity = [angle_to_vector([0x0, start_velocity[0x1] - 0x5a, 0x0]), angle_to_vector([0x0, start_velocity[0x1] + 0x5a, 0x0]), angle_to_vector([0x0, start_velocity[0x1], 0x0]), angle_to_vector([0x0, start_velocity[0x1] - 0xb4, 0x0]), angle_to_vector([start_velocity[0x0] - 0x5a, 0x0, 0x0]), angle_to_vector([start_velocity[0x0] + 0x5a, 0x0, 0x0])]
    var planes = [
        [0.5, -0.5, 0.25],
        [0.5, -0.5, 0.25],
        [-0.5, 0.5, 0.25],
        [-0.5, 0.5, 0.25],
        [0.5, 0.5, -0.25],
        [0.5, 0.5, -0.25]
    ]
    var grenade_info = {
        'origin': Render['WorldToScreen'](start_position),
        'point': []
    };
    for (var i = 0; i < 6; i++) {
        const ext_position = extrapolate([start_position[0x0] + compensated_velocity[i][0x0], start_position[0x1] + compensated_velocity[i][0x1], start_position[0x2] + compensated_velocity[i][0x2]], grenade['data']['start_velocity'], 0x1)
        const trace_result = Trace.RawLine(grenade['entity'], start_position, ext_position, flags, 0);
        if (!trace_result) continue;
        if (trace_result[0x1] < 0.98 && trace_result[0x0] !== Entity["GetProp"](grenade['entity'], "CBaseEntity", "m_hOwnerEntity")) {
            if (grenade['is_inferno'] && i === direction_t['DOWN']) {
                grenade['should_predict'] = false, grenade['data']['prediction_ticks'] = ticks;
                return;
            }
            grenade['data']['start_velocity'][0x0] *= planes[i][0x0], grenade['data']['start_velocity'][0x1] *= planes[i][0x1], grenade['data']['start_velocity'][0x2] *= planes[i][0x2];
        }
    }
}

var predicted_times = 0;

function register_grenades() {
    if (!GUI.GetValue(p.radar, "[NW] Predict grenade path"))
        return;

    const grenades = Entity.GetEntitiesByClassID(9).concat(Entity.GetEntitiesByClassID(114))
    for (var i = 0x0; i < grenades['length']; i++) {
        const grenade = grenades[i]
        const class_id = Entity.GetClassID(grenade)
        if (!grenade) continue;
        if (Entity.GetProp(grenade, "CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin")) {
            predicted_times = 0;
            continue;
        }
        const is_molotov = (class_id === 114);
        if (is_molotov) {
            if (Entity.GetProp(grenade, "CInferno", "m_nFireEffectTickBegin")) {
                predicted_times = 0;
                continue;
            }
        }
            

        if (grenade_prediction.nades.indexOf(grenade) === -1) {
            grenade_prediction.nades.push(grenade)
            grenade_prediction.paths[grenade] = {
            'entity': grenade,
            'simulated': false,
            'initialized': false,
            'ticks': 0x0,
            'should_predict': true,
            'should_follow': false,
            'data': {
                'start_velocity': [],
                'start_position': [],
                'prediction_ticks': 0x0
            },
            'paths': [],
            'is_inferno': is_molotov,
            }
            predict_grenades();
        }
    }
}

function predict_grenades() {
    if (!GUI.GetValue(p.radar, "[NW] Predict grenade path"))
        return;
        
    const TickInterval = Globals.TickInterval();
    const gravity = Convar.GetFloat("sv_gravity") * TickInterval;

    for (var i in grenade_prediction.paths) {
        var grenade = grenade_prediction.paths[i]
        var ticks = grenade['is_inferno'] ? 126 : 100;
        ticks -= GUI.GetValue(p.radar, "[NW] Re-predict grenade") * predicted_times;

        if (Entity.GetProp(grenade['entity'], "CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin") || Entity.GetProp(grenade['entity'], "CInferno", "m_nFireEffectTickBegin"))
            predicted_times = 0;

        if (grenade['simulated']) {
            grenade['ticks']++;
            if (grenade['ticks'] >= GUI.GetValue(p.radar, "[NW] Re-predict grenade")) {
                grenade_prediction['nades'].splice(grenade_prediction.nades.indexOf(grenade['entity'], 1))
                grenade_prediction['paths'].splice(i, 1)
                register_grenades()
            }
            continue;
        }
        for (var t = 0; t < ticks; t++) {
            if (!grenade['initialized']) {
                const origin = Entity.GetRenderOrigin(grenade['entity'])
                const velocity = Entity.GetProp(grenade['entity'], "CBaseGrenade", "m_vecVelocity")
                grenade['data']['start_position'] = origin
                grenade['data']['start_velocity'] = velocity
                grenade['initialized'] = true;
            }
            compensate_for_collision(grenade, t);
            grenade['data']['start_position'] = extrapolate(grenade['data']['start_position'], grenade['data']['start_velocity'], 1)
            grenade['data']['start_velocity'][2] -= gravity * 0.4;
            if (!grenade['should_predict']) {
                grenade['paths'].push(grenade['data']['start_position'])
                break;
            }
            if (t === ticks - 1) {
                grenade['paths'].push(grenade['data']['start_position'])
            }
        }
        grenade['simulated'] = true;
        grenade_prediction.paths[i] = grenade;
    }
}

/*Cheat.RegisterCallback('CreateMove', 'register_grenades')
Cheat.RegisterCallback('CreateMove', 'predict_grenades')*/

/*
* Section: Clantag
*/

var ui_clantag = UI.AddCheckbox(p.cheat, "[NW] Clantag")
var old_tick = 0;

function clantag() {
    if (!UI.GetValue(ui_clantag)) {
        if (old_tick != 0) {
            old_tick = 0;
            Local.SetClanTag("");
        }
        return;
    }
    if (!World.GetServerString() || old_tick == Math.floor(Globals.Curtime() * 2.7))
        return;

    old_tick = Math.floor(Globals.Curtime() * 2.7);

    switch (Math.floor((Globals.Curtime() * 2.7) % 24)) {
        case 0:
            Local.SetClanTag("         n")
            break;
        case 1:
            Local.SetClanTag("        no")
            break;
        case 2:
            Local.SetClanTag("       nor")
            break;
        case 3:
            Local.SetClanTag("      nort")
            break;
        case 4:
            Local.SetClanTag("     north")
            break;
        case 5:
            Local.SetClanTag("    northw")
            break;
        case 6:
            Local.SetClanTag("   northwo")
            break;
        case 7:
            Local.SetClanTag("  northwoo")
            break;
        case 8:
            Local.SetClanTag(" northwood")
            break;
        case 9:
        case 10:
        case 11:
        case 12:
        case 13:
        case 14:
            Local.SetClanTag("northwood ")
            break;
        case 15:
            Local.SetClanTag("orthwood  ")
            break;
        case 16:
            Local.SetClanTag("rthwood   ")
            break;
        case 17:
            Local.SetClanTag("thwood    ")
            break;
        case 18:
            Local.SetClanTag("hwood     ")
            break;
        case 19:
            Local.SetClanTag("wood      ")
            break;
        case 20:
            Local.SetClanTag("ood       ")
            break;
        case 21:
            Local.SetClanTag("od        ")
            break;
        case 22:
            Local.SetClanTag("d         ")
            break;
        case 23:
            Local.SetClanTag("          ")
            break;
    }
}

Cheat.RegisterCallback("Draw", "clantag")

/*
* Section: Commands
*/

if (Northwood.Get("console_filter:enabled")) {
    Cheat.ExecuteCommand("con_filter_enable 1")
    Cheat.ExecuteCommand("con_filter_text [onetap]")
}

UI.AddTextbox(p.general, "[NW] Command")
UI.AddCheckbox(p.general, "Execute command")
var Commands = {
    Handler: function() {
        if (GUI.GetValue(p.general, "Execute command") == 0)
            return;
        var command = GUI.GetString(p.general, "[NW] Command")
        var executed = false;
        if (command.includes("indicators:set_size ")) {
            var size = parseInt(command.replace("indicators:set_size ", ""), 10)
            if (size == NaN) {
                Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                Cheat.PrintColor([220, 220, 220, 255], "Syntax: `indicators:set_size <size>`\n")
                return;
            }
            Indicators.Size = size;
            Northwood.Write("indicators:size", size.toString())
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Indicators size set\n")
            executed = true;
        }
        if (command.includes("performance:set_freq ")) {
            var freq = parseInt(command.replace("performance:set_freq ", ""), 10)
            if (freq == NaN) {
                Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                Cheat.PrintColor([220, 220, 220, 255], "Syntax: `performance:set_freq <freq>`\n")
                return;
            }
            Performance.Freq = freq;
            Northwood.Write("performance:freq", freq.toString())
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Refresh frequency set\n")
            executed = true;
        }
        if (command.includes("presets:export ")) {
            var filename = command.replace("presets:export ", "")
            DataFile.Load(filename)

            DataFile.SetKey(filename, "antiaim_standing_yawbase", GUI.GetValue(p.antiaim, "[S] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_standing_yaw", GUI.GetValue(p.antiaim, "[S] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawoffset", GUI.GetValue(p.antiaim, "[S] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawjitter", GUI.GetValue(p.antiaim, "[S] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawjitteroffset", GUI.GetValue(p.antiaim, "[S] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_edgeyaw", GUI.GetValue(p.antiaim, "[S] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyaw", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_standing_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[S] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_bulletevasion", GUI.GetValue(p.antiaim_fake, "[S] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_walking_yawbase", GUI.GetValue(p.antiaim, "[W] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_walking_yaw", GUI.GetValue(p.antiaim, "[W] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawoffset", GUI.GetValue(p.antiaim, "[W] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawjitter", GUI.GetValue(p.antiaim, "[W] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawjitteroffset", GUI.GetValue(p.antiaim, "[W] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_edgeyaw", GUI.GetValue(p.antiaim, "[W] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyaw", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_walking_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[W] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_bulletevasion", GUI.GetValue(p.antiaim_fake, "[W] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_moving_yawbase", GUI.GetValue(p.antiaim, "[M] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_moving_yaw", GUI.GetValue(p.antiaim, "[M] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawoffset", GUI.GetValue(p.antiaim, "[M] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawjitter", GUI.GetValue(p.antiaim, "[M] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawjitteroffset", GUI.GetValue(p.antiaim, "[M] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_edgeyaw", GUI.GetValue(p.antiaim, "[M] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyaw", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_moving_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[M] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_bulletevasion", GUI.GetValue(p.antiaim_fake, "[M] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_general_lowerbody", GUI.GetValue(p.antiaim_fake, "Lower body yaw").toString())
            DataFile.Save(filename)
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Config exported into scripts directory\n")
            executed = true;
        }
        if (command.includes("presets:import ")) {
            var filename = command.replace("presets:import ", "")
            DataFile.Load(filename)

            GUI.SetValue(p.antiaim, "[S] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawbase")))
            GUI.SetValue(p.antiaim, "[S] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_yaw")))
            GUI.SetValue(p.antiaim, "[S] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawoffset")))
            GUI.SetValue(p.antiaim, "[S] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawjitter")))
            GUI.SetValue(p.antiaim, "[S] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[S] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[S] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_standing_bulletevasion")))

            GUI.SetValue(p.antiaim, "[W] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawbase")))
            GUI.SetValue(p.antiaim, "[W] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_yaw")))
            GUI.SetValue(p.antiaim, "[W] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawoffset")))
            GUI.SetValue(p.antiaim, "[W] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawjitter")))
            GUI.SetValue(p.antiaim, "[W] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[W] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[W] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_walking_bulletevasion")))

            GUI.SetValue(p.antiaim, "[M] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawbase")))
            GUI.SetValue(p.antiaim, "[M] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_yaw")))
            GUI.SetValue(p.antiaim, "[M] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawoffset")))
            GUI.SetValue(p.antiaim, "[M] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawjitter")))
            GUI.SetValue(p.antiaim, "[M] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[M] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[M] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_moving_bulletevasion")))

            GUI.SetValue(p.antiaim_fake, "Lower body yaw", parseInt(DataFile.GetKey(filename, "antiaim_general_lowerbody")))

            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Config imported successfully\n")
            executed = true;
        }

        if (!executed) {
            switch (command) {
                case "watermark:unlock_suffix":
                    if (Northwood.Get("watermark:unlock_suffix") == "true") {
                        Northwood.Write("watermark:unlock_suffix", "false")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark suffix disabled\n")
                        UI.RemoveItem(GUI.GetPath(p.script_ui, "Watermark suffix"))
                    }
                    else {
                        Northwood.Write("watermark:unlock_suffix", "true")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark suffix unlocked\n")
                        UI.AddTextbox(p.script_ui, "Watermark suffix")
                    }
                    break;
                case "watermark:unlock_prefix":
                    if (Northwood.Get("watermark:unlock_prefix") == "true") {
                        Northwood.Erase("watermark:unlock_prefix")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark prefix disabled\n")
                        UI.RemoveItem(GUI.GetPath(p.script_ui, "Watermark prefix"))
                    }
                    else {
                        Northwood.Write("watermark:unlock_prefix", "true")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark prefix unlocked\n")
                        UI.AddTextbox(p.script_ui, "Watermark prefix")
                    }
                    break;
                case "console_filter:enable":
                    Northwood.Write("console_filter:enabled", "true")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Console filter enabled\n")
                    Cheat.ExecuteCommand("con_filter_enable 1")
                    Cheat.ExecuteCommand("con_filter_text [onetap]")
                    break;
                case "console_filter:disable":
                    Northwood.Erase("console_filter:enabled")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Console filter disabled\n")
                    Cheat.ExecuteCommand("con_filter_enable 0")
                    break;
                case "visuals:weapon_icon":
                    Northwood.Write("visuals:weapon_icon", "true")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Weapon icon ESP enabled\n")
                    break;
                default:
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Unknown command\n")
                    break;
            }
        }
        GUI.SetValue(p.general, "Execute command", 0)
    }
}

UI.RegisterCallback(GUI.GetPath(p.general, "Execute command"), "Commands.Handler")

var ShotsHandler = {
    LastShotID: 0,
    LastTarget: -1,
    Shots: new Array(),
    Events: {
        aim_fire: function(shot) {
            Cheat.PrintColor([89, 119, 239, 255], String.format("[{0}] aim_fire: (target: {1}, hitbox: {2}, hit_chance: {3}, damage: {4}, priority: {5}, teleported: {6}, shifted: {7}, tick: {8})\n", shot.shot_id, Entity.GetName(shot.target), hitboxes[shot.hitbox], shot.hit_chance, shot.damage, shot.priority, shot.teleported, shot.shot_info.shifting, shot.tick))
        },
        aim_miss: function(shot) {
            Cheat.PrintColor([89, 119, 239, 255], String.format("[{0}] aim_miss: (target: {1}, hitbox: {2}, hit_chance: {3}, damage: {4}, priority: {5}, teleported: {6}, shifted: {7}, tick: {8}, reason: {9})\n", shot.shot_id, Entity.GetName(shot.target), hitboxes[shot.hitbox], shot.hit_chance, shot.damage, shot.priority, shot.teleported, shot.shot_info.shifting, shot.tick, shot.shot_info.reason))
        },
    },
    RagebotFire: function() {
        /*
        RagebotFire Object:
            id: // Shot ID
            target: // Target player entindex
            hitbox: // Targetted hitbox
            hit_chance: // Hitchance
            damage: // Predicted damage
            priority: // Was the shot at a high priority record
            teleported: // Was target player breaking lag comp
            tick: // Tick the shot was made at
            shot_info: {
                shifting:
            }
        */
       var shot = new Object();
       shot.shot_id = ShotsHandler.LastShotID;
       shot.target = Event.GetInt("target_index");
       shot.hitbox = Event.GetInt("hitbox");
       shot.hit_chance = Event.GetInt("hitchance");
       shot.damage = Trace.Bullet(Entity.GetLocalPlayer(), Event.GetInt("target_index"), Entity.GetEyePosition(Entity.GetLocalPlayer()), Entity.GetHitboxPosition(Event.GetInt("target_index"), Event.GetInt("hitbox")))[1];
       shot.priority = ShotsHandler.LastTarget === Event.GetInt("target_index");
       shot.teleported = false;
       shot.tick = Globals.Tickcount();

       shot.shot_info = {};
       shot.shot_info.shifting = false;

       ShotsHandler.Shots.push(shot);
       ShotsHandler.LastShotID = ShotsHandler.LastShotID + 1;
       ShotsHandler.LastTarget = Event.GetInt("target_index");

       ShotsHandler.Events.aim_fire(shot);
    },
    PlayerDeath: function() {
        if (Entity.GetEntityFromUserID(Event.GetInt('userid')) == Entity.GetLocalPlayer()) {
            if (ShotsHandler.Shots.length > 0) {
                var shot = ShotsHandler.Shots[ShotsHandler.Shots.length - 1];
                shot.shot_info.reason = "death";
                ShotsHandler.Events.aim_miss(shot);
                ShotsHandler.Shots = new Array();
                ShotsHandler.LastShotID = 0;
            }
        }
        else if (Entity.GetEntityFromUserID(Event.GetInt('userid')) == ShotsHandler.LastTarget) {
            if (ShotsHandler.Shots.length > 0) {
                var shot = ShotsHandler.Shots[ShotsHandler.Shots.length - 1];
                shot.shot_info.reason = "death";
                ShotsHandler.Events.aim_miss(shot);
                ShotsHandler.Shots.pop();
            }
        }
    },
    Load: function() {
        /*Cheat.RegisterCallback("ragebot_fire", "ShotsHandler.RagebotFire")
        Cheat.RegisterCallback("player_death", "ShotsHandler.PlayerDeath")*/
    },
}

//ShotsHandler.Load();

JavaScript:
UI.AddSubTab(["Visuals", "SUBTAB_MGR"], "Helper")
Cheat.Print(World.GetMapName());
var locations = require("locations\\locations.js")['locations'];
var grenades = locations[World.GetMapName()]

var path = ["Visuals", "Helper", "Helper"]

UI.AddHotkey(["Config", "Scripts", "Keys", "JS Keybinds"], "Throw grenade", "Grenade helper")
UI.AddHotkey(["Config", "Scripts", "Keys", "JS Keybinds"], "Setup grenade", "Setup grenade")
UI.AddColorPicker(path, "Accent color")
UI.AddMultiDropdown(path, "Enabled grenades", ["High Explosive", "Molotov"])
var ui_walls = UI.AddCheckbox(path, "Location through walls")

var ui_key = ["Config", "Scripts", "Keys", "JS Keybinds", "Throw grenade"]
var ui_setup = ["Config", "Scripts", "Keys", "JS Keybinds", "Setup grenade"]
var ui_color = path.concat("Accent color")
var ui_active = path.concat("Enabled grenades")

var vector = {
    multiply: function(a, b) {
        return [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
    },
    subtract: function(a, b) {
        return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; 
    },
    distance: function(a, b) {
        var x = a[0] - b[0]
        var y = a[1] - b[1]
        var z = a[2] - b[2]
        return Math.sqrt(x*x + y*y + z*z)
    },
    length: function(a) {
        return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
    }
}

var vector2d = {
    distance: function(a, b) {
        var x = a[0] - b[0]
        var y = a[1] - b[1]
        return Math.sqrt(x*x + y*y)
    }
}

function degtorad(degrees) {
    return degrees / 180 * Math.PI;
}

function angle_vec(ang) {
    var sp = Math.sin(degtorad(ang[0]));
    var sy = Math.sin(degtorad(ang[1]));
    var cp = Math.cos(degtorad(ang[0]));
    var cy = Math.cos(degtorad(ang[1]));

    return [cp * cy, cp * sy, -sp];
}

const DIR = {
    forward: 0,
    left: 1,
    right: 2,
    back: 3,
}

const STRENGTH = {
    high: 0,
    mid: 1,
    low: 2,
}

const TYPE = {
    grenade: "grenade",
}

function can_attack() {
    var me = Entity.GetLocalPlayer();
    var wpn = Entity.GetWeapon(me);

    if (me == null || wpn == null)
        return false;

    var curtime = Globals.Curtime()

    if (curtime < Entity.GetProp(me, "CCSPlayer", "m_flNextAttack"))
        return false;

    if (curtime < Entity.GetProp(wpn, "CBaseCombatWeapon", "m_flNextPrimaryAttack"))
        return false;

    return true;
}

function g_paint_handler() {
    var local = Entity.GetLocalPlayer()

    var f = {
        small: Render.GetFont("font.ttf", 16, false),
        normal: Render.GetFont("Verdana.ttf", 10, true),
        bold: Render.GetFont("Tahomabd.ttf", 10, true),
        icon: Render.GetFont("undefeated.ttf", 24, true)
    }

    if (grenades == undefined || grenades.length == 0)
        return;

    var t = Globals.Frametime() * 255;

    for (var i in grenades) {
        var g = grenades[i]

        if (g.active != undefined && !g.active)
            continue;

        if (g == temp_nade)
            var color = [255, 0, 0, 255]
        else
            var color = UI.GetColor(ui_color)
        
        var weapon = Entity.GetProp(Entity.GetWeapon(Entity.GetLocalPlayer()), "CBaseAttributableItem", "m_iItemDefinitionIndex");

        switch (weapon) {
            case 46:
            case 48:
                weapon = "weapon_molotov";
                break;
            case 44:
                weapon = "weapon_hegrenade";
                break;
            case 45:
                weapon = "weapon_smokegrenade";
                break;
            default:
                weapon = "weapon_unknown";
                break;
        }

        if (g.weapon == "weapon_hegrenade" && !(UI.GetValue(ui_active) & (1 << 0)))
            continue;

        if (g.weapon == "weapon_molotov" && !(UI.GetValue(ui_active) & (1 << 1)))
            continue;

        var pos = 0;
        pos = [g.position[0], g.position[1], g.position[2] - 63];

        var scr = Render.WorldToScreen(pos)
        var dist = vector.distance(pos, Entity.GetRenderOrigin(local))
        var width = Render.TextSize(g.name[0], f.normal)[0]

        if (g.alpha == undefined) {
            g.alpha = 0;
            g.alpha_2 = 0;
            g.width = 0;
            g.divider = 1;
            g.visible = false;
        }
            
        if (dist <= 500 && g.weapon == weapon) {
            g.width = Math.min(width + 12, g.width + t);
        }
        else {
            g.width = Math.max(0, g.width - t);
        }

        if (dist <= 1000 && g.weapon == weapon) {
            g.alpha = Math.min(255, g.alpha + t * 3);
        }
        else {
            g.alpha = Math.max(0, g.alpha - t * 3);
        }
            
        if (!g.visible) {
            if (UI.GetValue(ui_walls))
                g.divider = Math.min(2.3, g.divider + t / 255 * 4);
            else
                g.divider = 255;
        }
        else {
            if (UI.GetValue(ui_walls))
                g.divider = Math.max(1, g.divider - t / 255 * 4);
            else
                g.divider = 1;
        }

        switch (g.weapon) {
            case "weapon_molotov":
                var icon = "l";
                break;
            default:
                var icon = "j";
                break;
        }

        if (g.width < 1)
            continue;

        if (scr[2] && g.width > 1) {
            Render.Rect(scr[0] - Math.min(width / 2, g.width / 2) - 16, scr[1] - 30, 26 + Math.min(width + 6, g.width), 26, [17, 17, 17, Math.min(220 / g.divider, 220 * (g.width / width))]);
            Render.FilledRect(scr[0] - Math.min(width / 2, g.width / 2) - 15, scr[1] - 29, 24 + Math.min(width + 6, g.width), 24, [17, 17, 17, Math.min(150 / g.divider, 150 * (g.width / width))]);
            Render.String(scr[0] - Math.min(width / 2, g.width / 2) - 12, scr[1] - 30, 0, icon, [color[0], color[1], color[2], g.alpha / g.divider], f.icon)
            Render.Line(scr[0] - Math.min(width / 2, g.width / 2) + 7, scr[1] - 25, scr[0] - Math.min(width / 2, g.width / 2) + 7, scr[1] - 10, [color[0], color[1], color[2], Math.min(220 / g.divider, 220 * (g.width / width))])
            Render.String(scr[0] + 13, scr[1] - 4 - 20, 1, g.name[0], [0, 0, 0, Math.min(220 / g.divider, 220 * (g.width / width))], f.normal);
            Render.String(scr[0] + 12, scr[1] - 5 - 20, 1, g.name[0], [color[0], color[1], color[2], Math.min(220 / g.divider, 220 * (g.width / width))], f.normal);
        }

        if (dist > 100 || g.weapon != weapon) {
            g.alpha_2 = Math.max(g.alpha_2 - t / 255 * 4, 0);
        }
        else {
            g.alpha_2 = Math.min(g.alpha_2 + t / 255 * 4, 1);
        }

        if (g.alpha_2 < 0.1)
            continue;

        scr = angle_vec(g.viewangles)
        scr = Render.WorldToScreen([g.position[0] + scr[0] * 400, g.position[1] + scr[1] * 400, g.position[2] + scr[2] * 400]);
        if (scr[2]) {
            var to_width = Render.TextSize(g.name[1], f.bold)[0]
            if (g.description != undefined && g.description != "") {
                var desc_width = Render.TextSize(g.description.toUpperCase(), f.small)[0];
                if (to_width < desc_width)
                    to_width = desc_width - 8;
            }
            Render.Rect(scr[0] - 13, scr[1] - 10, to_width + 37, 27, [17, 17, 17, 220* g.alpha_2])
            Render.FilledRect(scr[0] - 12, scr[1] - 9, to_width + 35, 25, [17, 17, 17, 150* g.alpha_2])

            var c_color = [200, 200, 0]
            var scr_dist = vector2d.distance([Render.GetScreenSize()[0] / 2, Render.GetScreenSize()[1] / 2], scr);
            g.scr_dist = scr_dist;
            if (scr_dist > 300)
                c_color = [150, 150, 150];
            else if (!can_attack())
                c_color = [200, 0, 0];
            else if (dist < 2 || g == player.grenade)
                c_color = [0, 200, 0];
            

            Render.FilledCircle(scr[0] - 3, scr[1] + 3, 5, [0, 0, 0, 255 * g.alpha_2])
            Render.FilledCircle(scr[0] - 3, scr[1] + 3, 3, c_color.concat(255 * g.alpha_2))
            Render.Circle(scr[0] - 3, scr[1] + 3, 3, c_color.concat(230 * g.alpha_2))
            Render.Circle(scr[0] - 3, scr[1] + 3, 4, c_color.concat(210 * g.alpha_2))
            Render.Circle(scr[0] - 3, scr[1] + 3, 5, c_color.concat(190 * g.alpha_2))

            Render.Line(scr[0] + 7, scr[1] - 5, scr[0] + 7, scr[1] + 12, [color[0], color[1], color[2], 220 * g.alpha_2])

            var y_off = 0;

            if (g.description != undefined && g.description != "") {
                y_off = 5;
                var x = scr[0] + 11;
                var y = scr[1];
                var text = g.description.toUpperCase();
                Render.String(x-1, y-1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x+1, y-1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x-1, y+1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x+1, y+1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x, y-1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x+1, y, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x-1, y, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x, y+1, 0, text, [0, 0, 0, 200 * g.alpha_2], f.small)
                Render.String(x, y, 0, text, [color[0], color[1], color[2], 200 * g.alpha_2], f.small)
            }
                

            Render.Line(scr[0] + 13, scr[1]+2 - y_off, scr[0] + 15, scr[1]+4- y_off, [0, 0, 0, 220 * g.alpha_2])
            Render.Line(scr[0] + 15, scr[1]+4 - y_off, scr[0] + 13, scr[1]+6- y_off, [0, 0, 0, 220 * g.alpha_2])

            Render.Line(scr[0] + 16, scr[1]+2 - y_off, scr[0] + 18, scr[1]+4- y_off, [0, 0, 0, 220 * g.alpha_2])
            Render.Line(scr[0] + 18, scr[1]+4 - y_off, scr[0] + 16, scr[1]+6- y_off, [0, 0, 0, 220 * g.alpha_2])

            Render.Line(scr[0] + 12, scr[1]+1 - y_off, scr[0] + 14, scr[1]+3- y_off, [color[0], color[1], color[2], 220 * g.alpha_2])
            Render.Line(scr[0] + 14, scr[1]+3 - y_off, scr[0] + 12, scr[1]+5- y_off, [color[0], color[1], color[2], 220 * g.alpha_2])

            Render.Line(scr[0] + 15, scr[1]+1 - y_off, scr[0] + 17, scr[1]+3- y_off, [color[0], color[1], color[2], 220 * g.alpha_2])
            Render.Line(scr[0] + 17, scr[1]+3 - y_off, scr[0] + 15, scr[1]+5- y_off, [color[0], color[1], color[2], 220 * g.alpha_2])

            Render.String(scr[0] + 20, scr[1] - 2 - y_off, 0, g.name[1], [0, 0, 0, 220 * g.alpha_2], f.bold);
            Render.String(scr[0] + 19, scr[1] - 3 - y_off, 0, g.name[1], [color[0], color[1], color[2], 220 * g.alpha_2], f.bold);
        }
    }
}

function fix_movement(angle, viewangles, movement) {
    var a1, b1, c1;
    if (viewangles[1] < 0x0) a1 = 360 + viewangles[1];
    else a1 = viewangles[1];
    if (angle[1] < 0x0) b1 = 360 + angle[1];
    else b1 = angle[1];
    if (b1 < a1) c1 = Math['abs'](b1 - a1);
    else c1 = 360 - Math['abs'](a1 - b1);
    return [Math['cos'](degtorad(c1)) * movement[0] + Math['cos'](degtorad(c1 + 90)) * movement[1], Math['sin'](degtorad(c1)) * movement[0] + Math['sin'](degtorad(c1 + 90)) * movement[1], 0];

}
Cheat.LongPrint = function (string) {
    for (x = 0; x < string.length; x += 255) {
        Cheat.Print(string.substring(x, x + 255))
    }
}
function move(angle, forwardmove, sidemove) {
    var viewangles = Local.GetViewAngles();
    var movement = [forwardmove, sidemove, 0];
    movement = fix_movement(angle, viewangles, movement);
    UserCMD.SetMovement(movement);
    UserCMD.SetViewAngles(angle, true);
}

function move_to_point(position, g, some_bool) {
    player.grenade = g;
    var local = Entity.GetLocalPlayer();
    var origin = Entity.GetRenderOrigin(local);
    origin[2] = Entity.GetEyePosition(local)[2];
    var distance = vector.subtract(position, origin)
    var yaw = Local.GetViewAngles()[1];
    var movement = [];
    movement[0] = (Math.sin(yaw / 180 * Math.PI) * distance[1] + Math.cos(yaw / 180 * Math.PI) * distance[0]) * 10;
    movement[1] = (Math.sin(yaw / 180 * Math.PI) * distance[0] + Math.cos(yaw / 180 * Math.PI) * -distance[1]) * 10;
    movement[2] = 0;
    var some_var = vector.length(distance);
    var velocity = Entity.GetProp(local, "CCSPlayer", "m_vecVelocity[0]");
    velocity = vector.length(velocity);
    UserCMD.SetMovement(movement);
    return some_var < (some_bool ? some_bool : 2) && (velocity < 2 || some_bool);;
}
var player = {
    attacked: false,
    running: false,
    input: false,
    start: 0,
    next_ang: [],
    moved: false,
    run_start: 0,
    grenade: 0,
    recovering: false,
    end_move: false,
    recover_start: 0,
    recover_jump: 0,
    move_stopped: -1,
}
function g_move_handler() {
    if (grenades == undefined || grenades.length == 0)
        return;
        
    var local = Entity.GetLocalPlayer()

    for (var i in grenades) {
        var g = grenades[i]

        if (g.active != undefined && !g.active)
            continue;

        var pos = [g.position[0], g.position[1], g.position[2] - 63];
        var dist = vector.distance(pos, Entity.GetRenderOrigin(local))
        if (dist <= 1000) {
            var is_visible = Trace.Line(local, Local.GetCameraPosition(), pos)[1]
            g.visible = is_visible == 1;
        }

    }

    if (!UI.GetValue(ui_key) || grenades.length == 0 || player.move_stopped == 0) {
        if (player.grenade != 0) {
            Cheat.ExecuteCommand("-forward")
            Cheat.ExecuteCommand("-back")
            Cheat.ExecuteCommand("-moveleft")
            Cheat.ExecuteCommand("-moveright")
            Cheat.ExecuteCommand("-jump")
        }
        player = {
            attacked: false,
            running: false,
            input: false,
            start: 0,
            next_ang: [],
            moved: false,
            run_start: 0,
            grenade: 0,
            recovering: false,
            recover_start: 0,
            recover_jump: 0,
            move_stopped: -1,
        }
        return;
    }

    var weapon = Entity.GetProp(Entity.GetWeapon(Entity.GetLocalPlayer()), "CBaseAttributableItem", "m_iItemDefinitionIndex");

    switch (weapon) {
        case 46:
        case 48:
            weapon = "weapon_molotov";
            break;
        case 44:
            weapon = "weapon_hegrenade";
            break;
        case 45:
            weapon = "weapon_smokegrenade";
            break;
        default:
            weapon = "weapon_unknown";
            break;
    }
    var grens = grenades.filter(function(elem, index, array) {
        if (elem.weapon == weapon)
            return true;
        else
            return false;
    });
    var g = grens.sort(function(a, b) {
        var value = vector.distance(Entity.GetRenderOrigin(Entity.GetLocalPlayer()), a.position) - vector.distance(Entity.GetRenderOrigin(Entity.GetLocalPlayer()), b.position);
        if (value < 50) {
            var a_scr = angle_vec(a.viewangles)
            a_scr = Render.WorldToScreen([a.position[0] + a_scr[0] * 400, a.position[1] + a_scr[1] * 400, a.position[2] + a_scr[2] * 400]);
            var a_dist = vector2d.distance([Render.GetScreenSize()[0] / 2, Render.GetScreenSize()[1] / 2], a_scr);

            var b_scr = angle_vec(b.viewangles)
            b_scr = Render.WorldToScreen([b.position[0] + b_scr[0] * 400, b.position[1] + b_scr[1] * 400, b.position[2] + b_scr[2] * 400]);
            var b_dist = vector2d.distance([Render.GetScreenSize()[0] / 2, Render.GetScreenSize()[1] / 2], b_scr);

            return a_dist - b_dist;
        }

        return value;
    })[0];

    if (player.grenade != 0)
        g = player.grenade;

    if (player.input) {
        if (g.grenade != undefined && g.grenade.recover != undefined && player.recovering == 0) {
            player.recovering = Globals.Tickcount() + 8
        }
        UserCMD.Send();   
        UserCMD.SetViewAngles(player.next_ang.concat(0), true);
        Cheat.ExecuteCommand("-attack")
        Cheat.ExecuteCommand("-attack2")
        player.input = false;       
        return;
    }

    if (player.next_ang.length) {
        UserCMD.SetViewAngles(player.next_ang.concat(0), true);
        player.next_ang = [];
    }


    if (g === undefined || g.position === undefined)
        return;

    var dist = vector.distance(Entity.GetRenderOrigin(local), g.position);

    scr = angle_vec(g.viewangles)
    scr = Render.WorldToScreen([g.position[0] + scr[0] * 400, g.position[1] + scr[1] * 400, g.position[2] + scr[2] * 400]);

    if ((dist > 120 || g.scr_dist > 300) && !player.input && player.grenade == 0) {
        return;
    }

    var is_moved = (g.weapon == weapon && !player.attacked && player.recovering == 0 && can_attack() && !player.running) ? move_to_point(g.position, g) : false;
    if (player.recovering != 0 && player.recovering < Globals.Tickcount())
        is_moved = true;

    if (g.grenade != undefined) {
        if (g.grenade.run != undefined)
            g.grenade.run.duration *= (Globals.Tickrate() / 64)
        if (g.grenade.delay != undefined)
            g.grenade.delay *= (Globals.Tickrate() / 64)
    }

    if (is_moved || player.start != 0) {
        if (player.start == 0)
            player.start = Globals.Tickcount();
        
        if (g.weapon == weapon) {
            if (g.grenade != undefined && g.grenade.run != undefined && g.grenade.run.duration > 0 && (player.recovering == 0 || player.recovering > Globals.Tickcount())) {
                if (player.run_start + g.grenade.run.duration > Globals.Tickcount() || player.run_start == 0) {
                    player.running = true;
                    player.start = Number.MAX_SAFE_INTEGER;
                    if (player.run_start == 0)
                        player.run_start = Globals.Tickcount();
        
                    var moves = [0, 0]
                    //UserCMD.SetViewAngles(g.viewangles.concat(0), true);
                    switch (g.grenade.run.direction) {
                        case DIR.forward:
                            moves = [450, 0]
                            Cheat.ExecuteCommand("+forward")
                            break;
                        case DIR.back:
                            moves = [-450, 0]
                            Cheat.ExecuteCommand("+back")
                            break;
                        case DIR.left:
                            moves = [0, -450]
                            Cheat.ExecuteCommand("+moveleft")
                            break;
                        case DIR.right:
                            moves = [0, 450]
                            Cheat.ExecuteCommand("+moveright")
                            break;
                    }
    
                    if (g.grenade.run.walk)
                        UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 17))
    
                    move(g.viewangles, moves[0], moves[1])
                }
                else if (g.grenade != undefined && (player.recovering == 0 || player.recovering > Globals.Tickcount()) && player.run_start + g.grenade.run.duration + 4 > Globals.Tickcount()) {
                    if (player.running)
                        player.start = Globals.Tickcount();
    
                    player.running = false;
    
                    var moves = [0, 0]
                    //UserCMD.SetViewAngles(g.viewangles.concat(0), true);
                    switch (g.grenade.run.direction) {
                        case DIR.forward:
                            Cheat.ExecuteCommand("+forward")
                            break;
                        case DIR.back:
                            Cheat.ExecuteCommand("+back")
                            break;
                        case DIR.left:
                            Cheat.ExecuteCommand("+moveleft")
                            break;
                        case DIR.right:
                            Cheat.ExecuteCommand("+moveright")
                            break;
                    }
    
                    if (g.grenade.run.walk)
                        UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 17))
    
                    move(g.viewangles, moves[0], moves[1])       
                    player.move_stopped = 1;
                }
                else if (player.move_stopped == 1 && (g.grenade == undefined || g.grenade.recover == undefined))
                    player.move_stopped = 0;
            }
    
            if (g.grenade != undefined && g.grenade.jump && !player.running) {
                UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 1));
            }

            if (!player.attacked) {
                if (g.grenade != undefined && g.grenade.strength != undefined) {
                    if (g.grenade.strength == STRENGTH.high)
                        Cheat.ExecuteCommand("+attack")
                        //UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 0))
                    if (g.grenade.strength == STRENGTH.mid) {
                        //UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 0) | (1 << 11))
                        Cheat.ExecuteCommand("+attack")
                        Cheat.ExecuteCommand("+attack2")
                    }   
                    if (g.grenade.strength == STRENGTH.low)
                        Cheat.ExecuteCommand("+attack2")
                        //UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 11))
                    }
                else
                    Cheat.ExecuteCommand("+attack")
                    //UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 0))
                UserCMD.Send();
            }

            if (player.start <= Globals.Tickcount()) {
                

                if (player.start + (g.grenade != undefined && g.grenade.delay != undefined ? g.grenade.delay : 0) <= Globals.Tickcount()) {
                    player.attacked = true;
                    player.input = true;
                    player.next_ang = g.viewangles;
                    player.recover_start = 0;
                    UserCMD.Send();
                }
                
            }
        }

        if (g.grenade != undefined && g.grenade.recover != undefined && player.recovering != 0 && player.recovering < Globals.Tickcount()) {
            if ((player.recover_start == 0 || player.recover_start + g.grenade.run.duration * (g.grenade.jump ? 1 : 2) > Globals.Tickcount())) {
                player.running = true;
                player.start = Number.MAX_SAFE_INTEGER;
                if (player.recover_start == 0)
                    player.recover_start = Globals.Tickcount();

                Cheat.ExecuteCommand("-forward")
                Cheat.ExecuteCommand("-back")
                Cheat.ExecuteCommand("-moveleft")
                Cheat.ExecuteCommand("-moveright")

                switch (g.grenade.recover.direction) {
                    case DIR.forward:
                        Cheat.ExecuteCommand("+forward")
                        break;
                    case DIR.back:
                        Cheat.ExecuteCommand("+back")
                        break;
                    case DIR.left:
                        Cheat.ExecuteCommand("+moveleft")
                        break;
                    case DIR.right:
                        Cheat.ExecuteCommand("+moveright")
                        break;
                }

                if (g.grenade.jump && player.recover_jump < 12) {
                    player.recover_jump++;
                    Cheat.ExecuteCommand("+jump")
                }
                else {
                    Cheat.ExecuteCommand("-jump")
                }

                if (g.grenade.recover.walk)
                    UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 17))

                //move(g.viewangles, moves[0], moves[1])
            }
            else {
                player.move_stopped = 0;
            }
        }
    }
    else {
        player = {
            running: false,
            input: false,
            start: 0,
            next_ang: [],
            moved: false,
            run_start: 0,
            grenade: 0,
            recovering: false,
            recover_start: 0,
            recover_jump: 0,
            move_stopped: -1,
        }
    }
}

Cheat.RegisterCallback("CreateMove", "g_move_handler")
Cheat.RegisterCallback("Draw", "g_paint_handler")

var last_update = Globals.Curtime()

var setup_active = UI.AddCheckbox(path, "Setup grenade");

var setup_export = UI.AddCheckbox(path, "Export grenade");



UI.AddTextbox(path, "From")
var grenade_from = path.concat("From")
UI.AddTextbox(path, "To")
var grenade_to = path.concat("To")
UI.AddTextbox(path, "Description")
var grenade_desc = path.concat("Description")

UI.AddDropdown(path, "Weapon", ["weapon_molotov", "weapon_hegrenade"], 0)
var grenade_weapon = path.concat("Weapon")



var extended_settings = UI.AddMultiDropdown(path, "Extended settings", ["Jump", "Run", "Walk", "Recovery", "Delay", "Strength"])



UI.AddDropdown(path, "Run direction", ["Forward", "Left", "Right", "Back"], 0)
var run_direction = path.concat("Run direction");

UI.AddSliderInt(path, "Run duration", 0, 256)
var run_duration = path.concat("Run duration");

UI.AddDropdown(path, "Recovery direction", ["Forward", "Left", "Right", "Back"], 0)
var recovery_direction = path.concat("Recovery direction");

UI.AddSliderInt(path, "Delay", 0, 64)
var grenade_delay = path.concat("Delay");

UI.AddDropdown(path, "Strength", ["High", "Medium", "Low"], 0)
var grenade_strength = path.concat("Strength");

var temp_nade;

function ui_handler() {
    if (last_update + 0.2 > Globals.Curtime())
        return;

    var settings = UI.GetValue(extended_settings);

    if (UI.GetValue(ui_setup)) {
        var g = {};
        g.type = "grenade";
        g.name = [];
        g.name[0] = UI.GetString(grenade_from);
        g.name[1] = UI.GetString(grenade_to);
        if (UI.GetString(grenade_desc) != "")
            g.description = UI.GetString(grenade_desc);
        switch (UI.GetValue(grenade_weapon)) {
            case 0:
                g.weapon = "weapon_molotov";
                break;
            case 1:
                g.weapon = "weapon_hegrenade";
                break;
        }
        g.position = Entity.GetRenderOrigin(Entity.GetLocalPlayer())
        g.position[2] += 63;
        g.viewangles = [Local.GetViewAngles()[0], Local.GetViewAngles()[1]];

        if (settings & (1 << 0)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            g.grenade.jump = true;
        }
            

        if (settings & (1 << 1)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            if (g.grenade.run == undefined)
                g.grenade.run = new Object()
            g.grenade.run.direction = UI.GetValue(run_direction)
            g.grenade.run.duration = UI.GetValue(run_duration)
        }

        if (settings & (1 << 2)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            if (g.grenade.run == undefined)
                g.grenade.run = new Object()
            g.grenade.run.walk = true;
        }

        if (settings & (1 << 3)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            if (g.grenade.recover == undefined)
                g.grenade.recover = new Object()
            g.grenade.recover.direction = UI.GetValue(recovery_direction)
        }

        if (settings & (1 << 4)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            g.grenade.delay = UI.GetValue(grenade_delay)
        }

        if (settings & (1 << 5)) {
            if (g.grenade == undefined)
                g.grenade = new Object()
            g.grenade.strength = UI.GetValue(grenade_strength)
        }

        if (temp_nade != undefined)
           grenades.splice(grenades.indexOf(temp_nade), 1);

        grenades.push(g);
        temp_nade = g;
    }

    if (UI.GetValue(setup_export)) {
        UI.SetValue(setup_export, 0);
        
        temp_nade.alpha = undefined;
        temp_nade.alpha_2 = undefined;
        temp_nade.width = undefined;
        temp_nade.divider = undefined;
        temp_nade.visible = undefined;
        temp_nade.scr_dist = undefined
        Cheat.PrintColor([89, 119, 239, 255], "\n---------------GRENADE LOCATION START---------------\n")
        Cheat.LongPrint(JSON.stringify(temp_nade, null, '\t')+",");
        Cheat.PrintColor([89, 119, 239, 255], "\n----------------GRENADE LOCATION END----------------\n")
    }

    last_update = Globals.Curtime()
    if (UI.GetValue(setup_active)) {
        UI.SetEnabled(grenade_from, 1)
        UI.SetEnabled(grenade_to, 1)
        UI.SetEnabled(grenade_desc, 1)
        UI.SetEnabled(grenade_weapon, 1)
        UI.SetEnabled(extended_settings, 1)

        if (settings & (1 << 1)) {
            UI.SetEnabled(run_direction, 1)
            UI.SetEnabled(run_duration, 1)
        }
        else {
            UI.SetEnabled(run_direction, 0)
            UI.SetEnabled(run_duration, 0)
        }

        if (settings & (1 << 3)) {
            UI.SetEnabled(recovery_direction, 1)
        }
        else {
            UI.SetEnabled(recovery_direction, 0)
        }

        if (settings & (1 << 4)) {
            UI.SetEnabled(grenade_delay, 1)
            UI.SetEnabled(grenade_delay, 1)
        }
        else {
            UI.SetEnabled(grenade_delay, 0)
            UI.SetEnabled(grenade_delay, 0)
        }

        if (settings & (1 << 5)) {
            UI.SetEnabled(grenade_strength, 1)
            UI.SetEnabled(grenade_strength, 1)
        }
        else {
            UI.SetEnabled(grenade_strength, 0)
            UI.SetEnabled(grenade_strength, 0)
        }
    }
    else {
        UI.SetEnabled(grenade_from, 0)
        UI.SetEnabled(grenade_to, 0)
        UI.SetEnabled(grenade_desc, 0)
        UI.SetEnabled(grenade_weapon, 0)
        UI.SetEnabled(extended_settings, 0)
        UI.SetEnabled(run_direction, 0)
        UI.SetEnabled(run_duration, 0)
        UI.SetEnabled(recovery_direction, 0)
        UI.SetEnabled(grenade_delay, 0)
        UI.SetEnabled(grenade_delay, 0)
        UI.SetEnabled(grenade_strength, 0)
        UI.SetEnabled(grenade_strength, 0)
    }
    
}

Cheat.RegisterCallback("Draw", "ui_handler")

JavaScript:
const p = {
    exploits: ["Rage", "Exploits", "General"],
    rage: ["Rage", "General", "General"],
    rage_keys: ["Rage", "General", "General", "Key assignment"],
    antiaim: ["Rage", "Anti Aim", "Directions"],
    antiaim_fake: ["Rage", "Anti Aim", "Fake"],
    antiaim_keys: ["Rage", "Anti Aim", "General", "Key assignment"],
    visuals: ["Visuals", "ESP", "Enemy"],
    radar: ["Visuals", "Extra", "Radar"],
    cheat: ["Config", "Cheat", "General"],
    script_ui: ["Misc.", "Helpers", "General"],
    indicators: ["Misc.", "Helpers", "Client"],
    general: ["Config", "Scripts", "Scripts"]
}

var GUI = {
    GetPath: function(path, name) {
        if (path.length == 3)
            return [path[0], path[1], path[2], name];
        else
            return [path[0], path[1], path[2], path[3], name];
    },
    GetValue: function(path, name) {
        return UI.GetValue(GUI.GetPath(path, name));
    },
    GetColor: function(path, name) {
        return UI.GetColor(GUI.GetPath(path, name));
    },
    GetString: function(path, name) {
        return UI.GetString(GUI.GetPath(path, name));
    },
    SetValue: function(path, name, value) {
        UI.SetValue(GUI.GetPath(path, name), value);
    },
    SetEnabled: function(path, name, value) {
        UI.SetEnabled(GUI.GetPath(path, name), value);
    },
    RegisterCallback: function(path, name, func) {
        UI.RegisterCallback(GUI.GetPath(path, name), func);
    },
}

UI.AddDropdown(p.script_ui, "[NW] UI style", ["Flat", "Fade", "Dynamic fade"], 0);
UI.AddColorPicker(p.script_ui, "[NW] UI color");
if (GUI.GetColor(p.script_ui, "[NW] UI color") == [255, 255, 255, 255]);
    UI.SetColor(GUI.GetPath(p.script_ui, "[NW] UI color"), [89, 119, 239, 125]);
UI.AddSliderFloat(p.script_ui, "[NW] Fade offset", 0, 3.99)
UI.AddSliderFloat(p.script_ui, "[NW] Fade animation speed", 0.01, 10)
UI.AddSliderFloat(p.script_ui, "[NW] Fade split ratio", 0, 1)
UI.AddSliderFloat(p.script_ui, "[NW] Background split ratio", 0, 1)


// First, checks if it isn't implemented yet.
if (!String.format) {
    String.format = function(format) {
      var args = Array.prototype.slice.call(arguments, 1);
      return format.replace(/{(\d+)}/g, function(match, number) {
        return typeof args[number] != 'undefined'
          ? args[number]
          : match
        ;
      });
    };
}

var Northwood = {
    LatestLoad: 0,
    I_Offset: 0,
    Utils: {
        StatusColor: function(num, max, decl) {
            var Colors = [[255, 0, 0], [237, 27, 3], [235, 63, 6], [229, 104, 8],
            [228, 126, 10], [220, 169, 16], [213, 201, 19], [176, 205, 10], [124, 195, 13]];

            var int = (num > max ? max : num);
            var tmp = max / int;

            var declspec = Colors.length - 1;
            var i = declspec / tmp;
            if (decl)
                i += decl;
            i = (i >= 0 ? Math.floor(i + 0.5) : 0)
            i = Math.min(i, declspec);
            //Cheat.Print(String.format("i: {0}\n", i))
            return Colors[i];
        }
    },
    Get: function(dbname) {
        return DataFile.GetKey("northwood", dbname)
    },
    Write: function(dbname, dbvalue) {
        DataFile.SetKey("northwood", dbname, dbvalue)
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    Erase: function(dbname) {
        DataFile.EraseKey("northwood", dbname)
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    OnLoad: function() {
        DataFile.Load("northwood")
        Northwood.LatestLoad = DataFile.GetKey("northwood", "latest_load")
        var today = new Date()
        DataFile.SetKey("northwood", "latest_load", today.toString().substring(0, 16))
        DataFile.Save("northwood")
        DataFile.Load("northwood")
    },
    OnUnload: function() {
        DataFile.Save("northwood")
    },
    OnDraw: function() {
        Northwood.I_Offset = 0;

        if (GUI.GetValue(p.script_ui, "[NW] UI style") == 2)
            GUI.SetEnabled(p.script_ui, "[NW] Fade animation speed", 1)
        else
            GUI.SetEnabled(p.script_ui, "[NW] Fade animation speed", 0)
    },
    IsBeta: function() {
        return false;
    },
    GetColor: function() {
        return GUI.GetColor(p.script_ui, "[NW] UI color")
    },
    GetStyle: function() {
        switch (GUI.GetValue(p.script_ui, "[NW] UI style")) {
            case 0:
                return 0;
            case 1:
            case 2:
                return 1;
        }
    },
    GetFade: function() {
        if (GUI.GetValue(p.script_ui, "[NW] UI style") == 2)
            var value = (Globals.Curtime() * GUI.GetValue(p.script_ui, "[NW] Fade animation speed")) % 4
        else
            var value = GUI.GetValue(p.script_ui, "[NW] Fade offset")
        var alpha = GUI.GetValue(p.script_ui, "[NW] Fade split ratio")
        var maxv = 255 * (value % 1)
        var midv = 200 * (value % 1)
        var minv = 180 * (value % 1)
        var mminv = 55 * (value % 1)
        var mmminv = 75 * (value % 1)
        var r, g, b;
        if (value < 1) {
            r = [0 + maxv, 0, 255 - mmminv, 255 * alpha];
            g = [255 - mmminv, 0 + maxv, 0, 255 * alpha];
            b = [0, 255 - mmminv, 0 + maxv, 255 * alpha];
        }
        else if (value < 2) {
            r = [255 - mminv, 0 + maxv, 180 - minv, 255 * alpha];
            g = [180 - minv, 255, 0 + midv, 255 * alpha];
            b = [0 + maxv, 180 - minv, 255 - mminv, 255 * alpha];
        }
        else if (value < 3) {
            r = [200 - midv, 255, 0 + maxv, 255 * alpha];
            g = [0 + maxv, 255 - maxv, 200 + mminv, 255 * alpha];
            b = [255, 0 + maxv, 200 - midv, 255 * alpha];
        }
        else {
            r = [0, 255 - maxv, 255, 255 * alpha];
            g = [255, 0, 255 - maxv, 255 * alpha];
            b = [255 - maxv, 255, 0, 255 * alpha];
        }
        return [r, g, b]
    },
    GetBackground: function() {
        var value = GUI.GetValue(p.script_ui, "[NW] Background split ratio")
        var first = [17, 17, 17, Northwood.GetColor()[3] * value]
        var second = [17, 17, 17, Northwood.GetColor()[3]]
        return [first, second]
    }
}
Northwood.OnLoad();
Cheat.RegisterCallback("Unload", "Northwood.OnUnload")
Cheat.RegisterCallback("Draw", "Northwood.OnDraw")

var size = Render.GetScreenSize();
size = [size[0], size[1] - 60];
var nlogs = new Array();
var speed = 0;

function draw_arc1(a,n,o,r,t,h,M,c){M=360/M;for(var e=t;e<t+h;e+=M){var s=e*Math.PI/180,P=(e+M)*Math.PI/180,d=Math.cos(s),i=Math.sin(s),f=Math.cos(P),g=Math.sin(P),l=a+d*r,v=n+i*r,y=a+d*o,I=n+i*o,R=a+f*r,u=n+g*r,w=a+f*o,_=n+g*o;Render.Polygon([[y,I],[w,_],[l,v]],c),Render.Polygon([[l,v],[w,_],[R,u]],c)}};
function notify(e, i, r) {
    var n = Render.GetFont("Verdana.ttf", 11, true);
        d = Render.TextSize(e, n)[0],
        s = Math.floor(size[0] / 2) - 4 - Math.floor(d / 2);
        draw_arc1(s-1, size[1] - 60 - i, 15, 0, 90, 180, 60, [56, 56, 57, 150 * r])
        draw_arc1(s+d, size[1] - 60 - i, 15, 0, 270, 180, 60, [56, 56, 57, 150 * r])
        Render.FilledRect(s, size[1] - 60 - i - 15, d, 31, [56, 56, 57, 150 * r]);
        Render.FilledRect(s-1, size[1] - 60 - i - 15, 1, 31, [56, 56, 57, 100 * r]);
        Render.FilledRect(s+d, size[1] - 60 - i - 15, 1, 31, [56, 56, 57, 100 * r]);
        Render.String(s, size[1] - 60 - i - 8, 0, e, [255, 255, 255, 255 * r], n)
};

//GUI.SetEnabled(P.exploits, "Double tap", 0);
//GUI.RegisterCallback(P.exploits, "Double tap", "TestLog");

/*
Section: Tickbase
*/

UI.AddMultiDropdown(p.exploits, "Double tap options", ["Decrease recharge delay", "WIP: Tickbase correction"]);

var Tickbase = {
    LastShot: 0,
    MaxShift: function() {
        return Convar.GetInt("sv_maxusrcmdprocessticks");
    },
    CanShift: function(Ticks) {
        var me = Entity.GetLocalPlayer();
        var wpn = Entity.GetWeapon(me);
    
        if (me == null || wpn == null)
            return false;
    
        var tickbase = Entity.GetProp(me, "CCSPlayer", "m_nTickBase");
        //var tickbase = Globals.Tickcount();
        var curtime = Globals.TickInterval() * (tickbase-Ticks)
    
        if (curtime < Entity.GetProp(me, "CCSPlayer", "m_flNextAttack"))
            return false;
    
        if (curtime < Entity.GetProp(wpn, "CBaseCombatWeapon", "m_flNextPrimaryAttack"))
            return false;

        /*if ((Globals.Tickcount() - Ticks - (Globals.Latency() * Globals.TickInterval())) > Tickbase.LastShot)
            return true;*/
    
        return true;
    },
    CreateMove: function() {
        var Options = GUI.GetValue(p.exploits, "Double tap options");
        var Charge = Exploit.GetCharge();

        //Exploit.OverrideTolerance(0);
        //Exploit.OverrideShift(Tickbase.MaxShift())

        if (Options & 1 << 0) {
            Exploit[(Charge != 1 ? "Enable" : "Disable") + "Recharge"]()
            if (Tickbase.CanShift(1) && Charge != 1) {
                Exploit.DisableRecharge();
                if (Ragebot.GetTargets().length == 0)
                    Exploit.Recharge();
            }
        }
        else {
            Exploit.EnableRecharge()
        }
        if (Options & 1 << 1) {
            if (Charge == 1) {
                Exploit.OverrideMaxProcessTicks(Tickbase.MaxShift() + 1);
                Exploit.OverrideShift(Tickbase.MaxShift());
                GUI.SetValue(p.exploits, "Options", GUI.GetValue(p.exploits, "Options") & ~(1 << 5));
            }
            else {
                Exploit.OverrideMaxProcessTicks(Tickbase.MaxShift());
            }
        }
    }
}

Cheat.RegisterCallback("CreateMove", "Tickbase.CreateMove");



/*
Section: Anti-aim
*/

var aa_active = UI.AddCheckbox(p.antiaim, "Extended anti-aimbot angles");

UI.AddDropdown(p.antiaim, "Anti-aimbot mode", ["Standing", "Walking", "Moving"], 0);

//STANDING
UI.AddDropdown(p.antiaim, "[S] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[S] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[S] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[S] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[S] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[S] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[S] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[S] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[S] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[S] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[S] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//WALKING
UI.AddDropdown(p.antiaim, "[W] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[W] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[W] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[W] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[W] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[W] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[W] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[W] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[W] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[W] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[W] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//MOVING
UI.AddDropdown(p.antiaim, "[M] Yaw base", ["Local view", "At targets"], 0);
UI.AddDropdown(p.antiaim, "[M] Yaw", ["180"], 0);
UI.AddSliderInt(p.antiaim, "[M] Yaw offset", -180, 180);
UI.AddDropdown(p.antiaim, "[M] Yaw jitter", ["Offset", "Center", "Random"], 0);
UI.AddSliderInt(p.antiaim, "[M] Yaw jitter offset", -180, 180);
UI.AddCheckbox(p.antiaim, "[M] Edge yaw")
UI.AddDropdown(p.antiaim_fake, "[M] Fake yaw", ["Opposite", "Jitter", "Static"], 0);
UI.AddSliderInt(p.antiaim_fake, "[M] Fake yaw offset", -60, 60);
UI.AddSliderInt(p.antiaim_fake, "[M] Fake yaw limit", 0, 60);
UI.AddCheckbox(p.antiaim_fake, "[M] Freestand fake yaw");
UI.AddDropdown(p.antiaim_fake, "[M] Bullet evasion", ["Off", "Swap", "Reverse"], 0)

//UTILS
UI.AddCheckbox(["Rage", "Anti Aim", "General"], "Manual direction")
UI.AddColorPicker(["Rage", "Anti Aim", "General"], "Direction color")
UI.AddHotkey(p.antiaim_keys, "Freestanding", "Freestanding")
UI.AddDropdown(p.antiaim_fake, "Lower body yaw", ["Opposite", "Eye yaw"], 0);

function RandomInt(min, max) {
    return Math.floor(Math.random() * (max - min)) + min;
}

function Clamp(num, min, max) {
    return num <= min ? min : num >= max ? max : num;
}

function deg2rad( degress ) {
    return degress * Math.PI / 180.0;
}

function angle_to_vec( pitch, yaw ) {
    var p = deg2rad( pitch );
    var y = deg2rad( yaw )
    var sin_p = Math.sin( p );
    var cos_p = Math.cos( p );
    var sin_y = Math.sin( y );
    var cos_y = Math.cos( y );
    return [ cos_p * cos_y, cos_p * sin_y, -sin_p ];
}

function trace( entity_id, entity_angles ) {
    var entity_vec = angle_to_vec( entity_angles[0], entity_angles[1] );
    var entity_pos = Entity.GetRenderOrigin( entity_id );
    entity_pos[2] += 50;
    var stop = [ entity_pos[ 0 ] + entity_vec[0] * 8192, entity_pos[1] + entity_vec[1] * 8192, ( entity_pos[2] )  + entity_vec[2] * 8192 ];
    var traceResult = Trace.Line( entity_id, entity_pos, stop );
    if( traceResult[1] == 1.0 )
        return;
    stop = [ entity_pos[ 0 ] + entity_vec[0] * traceResult[1] * 8192, entity_pos[1] + entity_vec[1] * traceResult[1] * 8192, entity_pos[2] + entity_vec[2] * traceResult[1] * 8192 ];
    var distance = Math.sqrt( ( entity_pos[0] - stop[0] ) * ( entity_pos[0] - stop[0] ) + ( entity_pos[1] - stop[1] ) * ( entity_pos[1] - stop[1] ) + ( entity_pos[2] - stop[2] ) * ( entity_pos[2] - stop[2] ) );
    entity_pos = Render.WorldToScreen( entity_pos );
    stop = Render.WorldToScreen( stop );
    if( stop[2] != 1 || entity_pos[2] != 1 )
        return;

    return distance;
}

var lastHitTime = 0.0;
var lastImpactTimes =
[
    0.0
];
var lastImpacts =
[
    [0.0, 0.0, 0.0]
];

function radian(degree)
{
    return degree * Math.PI / 180.0;
}

function ExtendVector(vector, angle, extension)
{
    var radianAngle = radian(angle);
    return [extension * Math.cos(radianAngle) + vector[0], extension * Math.sin(radianAngle) + vector[1], vector[2]];
}

function VectorAdd(a, b)
{
    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
}

function VectorSubtract(a, b)
{
    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
}

function VectorMultiply(a, b)
{
    return [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
}

function VectorLength(x, y, z)
{
    return Math.sqrt(x * x + y * y + z * z);
}

function VectorNormalize(vec)
{
    var length = VectorLength(vec[0], vec[1], vec[2]);
    return [vec[0] / length, vec[1] / length, vec[2] / length];
}

function VectorDot(a, b)
{
    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

function VectorDistance(a, b)
{
    return VectorLength(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
}

function ClosestPointOnRay(target, rayStart, rayEnd)
{
    var to = VectorSubtract(target, rayStart);
    var dir = VectorSubtract(rayEnd, rayStart);
    var length = VectorLength(dir[0], dir[1], dir[2]);
    dir = VectorNormalize(dir);

    var rangeAlong = VectorDot(dir, to);
    if (rangeAlong < 0.0)
    {
        return rayStart;
    }
    if (rangeAlong > length)
    {
        return rayEnd;
    }
    return VectorAdd(rayStart, VectorMultiply(dir, [rangeAlong, rangeAlong, rangeAlong]));
}
var latest_impact = 0;
var Antiaim = {
    Counter: 0,
    Real: 0,
    Fake: 0,
    Lby: 0,
    Inverse: false,
    Enabled: false,
    ManualKey: "none",
    ManualLeft: false,
    ManualRight: false,
    ManualBack: false,
    GetMode: function() {
        var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
        var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
        var mode = 0;
        if (GUI.GetValue(p.antiaim_keys, "Slow walk"))
            mode = 1;
        else if (speed > 30)
            mode = 2;

        return mode;
    },
    HideGroups: function(standing, walking, moving) {
        //STANDING
        GUI.SetEnabled(p.antiaim, "[S] Yaw base", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw offset", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw jitter", standing);
        GUI.SetEnabled(p.antiaim, "[S] Yaw jitter offset", standing);
        GUI.SetEnabled(p.antiaim, "[S] Edge yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw offset", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Fake yaw limit", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Freestand fake yaw", standing);
        GUI.SetEnabled(p.antiaim_fake, "[S] Bullet evasion", standing);

        //WALKING
        GUI.SetEnabled(p.antiaim, "[W] Yaw base", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw offset", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw jitter", walking);
        GUI.SetEnabled(p.antiaim, "[W] Yaw jitter offset", walking);
        GUI.SetEnabled(p.antiaim, "[W] Edge yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw offset", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Fake yaw limit", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Freestand fake yaw", walking);
        GUI.SetEnabled(p.antiaim_fake, "[W] Bullet evasion", walking);

        //MOVING
        GUI.SetEnabled(p.antiaim, "[M] Yaw base",  moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw offset", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw jitter", moving);
        GUI.SetEnabled(p.antiaim, "[M] Yaw jitter offset", moving);
        GUI.SetEnabled(p.antiaim, "[M] Edge yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw offset", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Fake yaw limit", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Freestand fake yaw", moving);
        GUI.SetEnabled(p.antiaim_fake, "[M] Bullet evasion", moving);
    },
    HideElements: function(bool) {
        if (bool) {
            GUI.SetEnabled(p.antiaim, "At targets", 0);
            GUI.SetEnabled(p.antiaim, "Yaw offset", 0);
            GUI.SetEnabled(p.antiaim, "Jitter offset", 0);
            GUI.SetEnabled(p.antiaim, "Auto direction", 0);
            GUI.SetEnabled(p.antiaim, "Manual direction", 0);
            GUI.SetEnabled(p.antiaim, "Mouse direction", 0);
            GUI.SetEnabled(p.antiaim, "In Air mode", 0);
            GUI.SetEnabled(p.antiaim_fake, "Fake angles", 0);
            GUI.SetEnabled(p.antiaim_fake, "Jitter move", 0);
            GUI.SetEnabled(p.antiaim_fake, "On-shot desync", 0);
            GUI.SetEnabled(p.antiaim_fake, "Hide real angle", 0);
            GUI.SetEnabled(p.antiaim_fake, "Avoid overlap", 0);
            GUI.SetEnabled(p.antiaim_fake, "Fake desync", 0);
            GUI.SetEnabled(p.antiaim_fake, "Lower body yaw mode", 0);
            GUI.SetEnabled(p.antiaim_fake, "Inverter flip conditions", 0);
        }
        else {
            GUI.SetEnabled(p.antiaim, "At targets", 1);
            GUI.SetEnabled(p.antiaim, "Yaw offset", 1);
            GUI.SetEnabled(p.antiaim, "Jitter offset", 1);
            GUI.SetEnabled(p.antiaim, "Auto direction", 1);
            GUI.SetEnabled(p.antiaim, "Manual direction", 1);
            GUI.SetEnabled(p.antiaim, "Mouse direction", 1);
            GUI.SetEnabled(p.antiaim, "In Air mode", 1);
            GUI.SetEnabled(p.antiaim_fake, "Fake angles", 1);
            GUI.SetEnabled(p.antiaim_fake, "Jitter move", 1);
            GUI.SetEnabled(p.antiaim_fake, "On-shot desync", 1);
            GUI.SetEnabled(p.antiaim_fake, "Hide real angle", 1);
            GUI.SetEnabled(p.antiaim_fake, "Avoid overlap", 1);
            GUI.SetEnabled(p.antiaim_fake, "Fake desync", 1);
            GUI.SetEnabled(p.antiaim_fake, "Lower body yaw mode", 1);
            GUI.SetEnabled(p.antiaim_fake, "Inverter flip conditions", 1);
        }
    },
    Callback: function() {
        if (GUI.GetValue(p.antiaim, "Extended anti-aimbot angles")) {
            Antiaim.HideElements(true);
            AntiAim.SetOverride(1);
        }
        else {
            Antiaim.HideElements(false);
            AntiAim.SetOverride(0);
            Antiaim.HideGroups(0, 0, 0)
        }
    },
    Unload: function() {
        Antiaim.HideElements(false);
        AntiAim.SetOverride(0);
    },
    CreateMove: function() {
        if (UI.GetValue(aa_active)) {
            AntiAim.SetOverride(1);
        }
        else {
            AntiAim.SetOverride(0);
            return
        }

        GUI.SetValue(p.antiaim, "Manual direction", 0)
        UI.SetHotkeyState(p.antiaim_keys.concat("Left direction"), "Hold")
        UI.SetHotkeyState(p.antiaim_keys.concat("Back direction"), "Hold")
        UI.SetHotkeyState(p.antiaim_keys.concat("Right direction"), "Hold")
        

        if (GUI.GetValue(["Rage", "Anti Aim", "General"], "Manual direction")) {
            if (GUI.GetValue(p.antiaim_keys, "Left direction")) {
                if (!Antiaim.ManualLeft) {
                    Antiaim.ManualLeft = true;
                    if (Antiaim.ManualKey == "left")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "left"
                }
            }
            else
                Antiaim.ManualLeft = false

            if (GUI.GetValue(p.antiaim_keys, "Back direction")) {
                if (!Antiaim.ManualBack) {
                    Antiaim.ManualBack = true;
                    if (Antiaim.ManualKey == "back")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "back"
                }
            }
            else
                Antiaim.ManualBack = false
            
            if (GUI.GetValue(p.antiaim_keys, "Right direction")) {
                if (!Antiaim.ManualRight) {
                    Antiaim.ManualRight = true;
                    if (Antiaim.ManualKey == "right")
                        Antiaim.ManualKey = "none"
                    else
                        Antiaim.ManualKey = "right"
                }
            }
            else
                Antiaim.ManualRight = false
        }
        if (Globals.ChokedCommands() > 0)
            return;

        Antiaim.Counter++;
        var local = Entity.GetLocalPlayer();

        /*
        * Anti-aimbot: Real yaw
        */

        GUI.SetValue(p.antiaim, "Auto direction", GUI.GetValue(p.antiaim_keys, "Freestanding"))

        switch (Antiaim.GetMode()) {
            case 0:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[S] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[S] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[S] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[S] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[S] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[S] Yaw jitter offset"));
                        break;
                }
                if (GUI.GetValue(p.antiaim, "[S] Edge yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var forward_distance = trace(local, [0, eye_angles[1]]);
                    /*var left_distance = trace(local, [0, eye_angles[1] - 90]);
                    var right_distance = trace(local, [0, eye_angles[1] + 90]);
                    var back_distance = trace(local, [0, eye_angles[1] + 180]);*/

                    if (forward_distance < 30)
                        Antiaim.Real = 90;
                }
                break;
            case 1:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[W] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[W] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[W] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[W] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[W] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[W] Yaw jitter offset"));
                        break;
                }
                break;
            case 2:
                GUI.SetValue(p.antiaim, "At targets", GUI.GetValue(p.antiaim, "[M] Yaw base"))
                Antiaim.Real = GUI.GetValue(p.antiaim, "[M] Yaw offset");
                switch (GUI.GetValue(p.antiaim, "[M] Yaw jitter")) {
                    case 0:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") : 0)
                        break;
                    case 1:
                        Antiaim.Real += (Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") / 2 : GUI.GetValue(p.antiaim, "[M] Yaw jitter offset") / -2)
                        break;
                    case 2:
                        Antiaim.Real += RandomInt(-GUI.GetValue(p.antiaim, "[M] Yaw jitter offset"), GUI.GetValue(p.antiaim, "[M] Yaw jitter offset"));
                        break;
                }
                break;
        }
            

        /*
        * Anti-aimbot: Fake yaw
        */

        switch (Antiaim.GetMode()) {
            case 0:
                switch (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw())) < 1) {
                            Antiaim.Real *= -1;
                        } 
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[S] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
            case 1:
                switch (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(Math.abs(Local.GetRealYaw()) - Math.abs(Local.GetFakeYaw()) < 1)) {
                            Antiaim.Real *= -1;
                        }
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[W] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
            case 2:
                switch (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw")) {
                    case 0:
                        Antiaim.Fake = 60;
                        if (Math.abs(Math.abs(Local.GetRealYaw()) - Math.abs(Local.GetFakeYaw()) < 1)) {
                            Antiaim.Real *= -1;
                        } 
                        break;
                    case 1:
                        if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? 60 : -29
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") % 3 == 0) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") : 0
                        }
                        else if (GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") % 3 == 1) {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") : -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset")
                        }
                        else {
                            Antiaim.Fake = Antiaim.Counter % 2 ? GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset") / 2 : -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset");
                        }
                        break;
                    case 2:
                        Antiaim.Fake = GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset");
                        break;
                }
                Antiaim.Fake = Clamp(Antiaim.Fake, -GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit"), GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit"));

                if (GUI.GetValue(p.antiaim_fake, "[M] Freestand fake yaw")) {
                    var eye_angles = Local.GetViewAngles();
                    var left_distance = trace( local, [ 0, eye_angles[1] - 28] );
                    var right_distance = trace( local, [ 0, eye_angles[1] + 28] );
                    if ((left_distance < 600 || right_distance < 600) && left_distance > right_distance) {
                        Antiaim.Fake *= -1;
                    }
                }
                else {
                    Antiaim.Fake *= -1;
                }
                break;
        }

        /*
        * Anti-aimbot: Setting values
        */

        if (Antiaim.Inverse) {
            switch (Antiaim.GetMode()) {
                case 0:
                    switch (GUI.GetValue(p.antiaim_fake, "[S] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
                case 1:
                    switch (GUI.GetValue(p.antiaim_fake, "[W] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
                case 2:
                    switch (GUI.GetValue(p.antiaim_fake, "[M] Bullet evasion")) {
                        case 1:
                            Antiaim.Fake *= -1;
                            break;
                        case 2:
                            Antiaim.Fake *= -1;
                            Antiaim.Real *= -1;
                            break;
                    }
                    break;
            }
        }

        if (GUI.GetValue(p.antiaim_keys, "AA Direction inverter"))
            Antiaim.Fake *= -1;
        
        if (Antiaim.ManualKey == "left") {
            GUI.SetValue(p.antiaim, "At targets", 0)
            Antiaim.Real = -45;
        }
        else if (Antiaim.ManualKey == "right") {
            GUI.SetValue(p.antiaim, "At targets", 0)
            Antiaim.Real = 45;
        }

        switch (GUI.GetValue(p.antiaim_fake, "Lower body yaw")) {
            case 0:
                GUI.SetValue(p.antiaim, "Yaw offset", Antiaim.Real);
                AntiAim.SetFakeOffset(Antiaim.Real)
                AntiAim.SetRealOffset(Antiaim.Fake != 0 ? Antiaim.Fake * 2 + (Antiaim.Fake > 0 ? -60 : 60) : 60)
                AntiAim.SetLBYOffset(Antiaim.Fake > 0 ? -120 : 120);
                break;
            case 1:
                GUI.SetValue(p.antiaim, "Yaw offset", Antiaim.Real - Antiaim.Fake / 4);
                AntiAim.SetFakeOffset(Antiaim.Real)
                AntiAim.SetRealOffset(Antiaim.Real + Antiaim.Fake)
                AntiAim.SetLBYOffset(0);
                break;
        } 
    },
    ArrowsAlpha: 0,
    ArrowsText: "",
    AlphaShouldSwitch: false,
    MenuUpdate: Globals.Curtime(),
    Draw: function() {
        if (Antiaim.MenuUpdate + 0.16 < Globals.Curtime()) {
            Antiaim.MenuUpdate = Globals.Curtime()
            switch (GUI.GetValue(p.antiaim, "Anti-aimbot mode")) {
                case 0:
                    Antiaim.HideGroups(1, 0, 0);
                    break;
                case 1:
                    Antiaim.HideGroups(0, 1, 0);
                    break;
                case 2:
                    Antiaim.HideGroups(0, 0, 1);
                    break;
            }
            Antiaim.Callback()
        }
        
        // Arrows
        if (World.GetServerString() && Entity.IsAlive(Entity.GetLocalPlayer())) {
            var t = Globals.Frametime() * 1.5 * 255;
            if (GUI.GetValue(["Rage", "Anti Aim", "General"], "Manual direction")) {
                var color = GUI.GetColor(["Rage", "Anti Aim", "General"], "Direction color")
                color[3] = Antiaim.ArrowsAlpha
                var y = center_screen[1]
                if (Antiaim.ManualKey == "left") {
                    Antiaim.ArrowsText = "left"
                    if (Antiaim.ArrowsAlpha == 255) AlphaShouldSwitch = true;
                    else if (Antiaim.ArrowsAlpha == 0) AlphaShouldSwitch = false;
                    Antiaim.ArrowsAlpha += (AlphaShouldSwitch ? -t : t);
                }
                else if (Antiaim.ManualKey == "right") {
                    Antiaim.ArrowsText = "right"
                    if (Antiaim.ArrowsAlpha == 255) AlphaShouldSwitch = true;
                    else if (Antiaim.ArrowsAlpha == 0) AlphaShouldSwitch = false;
                    Antiaim.ArrowsAlpha += (AlphaShouldSwitch ? -t : t);
                }
                else {
                    Antiaim.ArrowsAlpha -= t * 2;
                } 
                Antiaim.ArrowsAlpha = Clamp(Antiaim.ArrowsAlpha, 0, 255)
                if (Antiaim.ArrowsText == "left") {
                    var x = center_screen[0] - 50
                    Render.Polygon( [[x, y], [x+15, y-8], [x+12, y]], color);
                    Render.Polygon( [[x+12, y], [x+15, y+8], [x, y]], color);
                    Render.Polygon( [[x, y], [x+15, y-8], [x+12, y]], [255, 255, 255, 25 * (Antiaim.ArrowsAlpha / 255)]);
                    Render.Polygon( [[x+12, y], [x+15, y+8], [x, y]], [0, 0, 0, 50 * (Antiaim.ArrowsAlpha / 255)]);
                }
                else if (Antiaim.ArrowsText == "right") {
                    var x = center_screen[0] + 50
                    Render.Polygon( [[x-12, y], [x-15, y-8], [x, y]], color);
                    Render.Polygon( [[x-15, y+8], [x-12, y], [x, y]], color);
                    Render.Polygon( [[x-12, y], [x-15, y-8], [x, y]], [255, 255, 255, 25 * (Antiaim.ArrowsAlpha / 255)]);
                    Render.Polygon( [[x-15, y+8], [x-12, y], [x, y]], [0, 0, 0, 50 * (Antiaim.ArrowsAlpha / 255)]);
                }
                
                //Visuals.Text(center_screen[0] + (Antiaim.ArrowsText == "<" ? -50 : 50), center_screen[1] - 10, "+", Antiaim.ArrowsText, color)
              
            }
        }
        
        
    },
    BulletImpact: function() {
        var curtime = Global.Curtime();

        if (Entity.GetEntityFromUserID(Event.GetInt("userid")) == Entity.GetLocalPlayer())
            latest_impact = Globals.Tickcount();

        if (Math.abs(lastHitTime - curtime) < 0.5) return;

        var entity = Entity.GetEntityFromUserID(Event.GetInt("userid"));
        var impact = [Event.GetFloat("x"), Event.GetFloat("y"), Event.GetFloat("z"), curtime];
        var source;
        if (Entity.IsValid(entity) && Entity.IsEnemy(entity))
        {
            if (!Entity.IsDormant(entity))
            {
                source = Entity.GetEyePosition(entity);
            }
            else if (Math.abs(lastImpactTimes[entity] - curtime) < 0.1)
            {
                source = lastImpacts[entity];
            }
            else
            {
                lastImpacts[entity] = impact;
                lastImpactTimes[entity] = curtime;
                return;
            }
            var local = Entity.GetLocalPlayer();
            var localEye = Entity.GetEyePosition(local);
            var localOrigin = Entity.GetProp(local, "CBaseEntity", "m_vecOrigin");
            var localBody = VectorMultiply(VectorAdd(localEye, localOrigin), [0.5, 0.5, 0.5]);

            var bodyVec = ClosestPointOnRay(localBody, source, impact);
            var bodyDist = VectorDistance(localBody, bodyVec);
        
            if (bodyDist < 150)       //he clearly shot at us!
            {
                var realAngle = Local.GetRealYaw();
                var fakeAngle = Local.GetFakeYaw();

                var headVec = ClosestPointOnRay(localEye, source, impact);
                var headDist = VectorDistance(localEye, headVec);
                var feetVec = ClosestPointOnRay(localOrigin, source, impact);
                var feetDist = VectorDistance(localOrigin, feetVec);

                var closestRayPoint;
                var realPos;
                var fakePos;

                if (bodyDist < headDist && bodyDist < feetDist)     //that's a pelvis
                {                                                   //pelvis direction = goalfeetyaw + 180   
                    closestRayPoint = bodyVec;
                    realPos = ExtendVector(bodyVec, realAngle + 180.0, 10.0);
                    fakePos = ExtendVector(bodyVec, fakeAngle + 180.0, 10.0);
                }
                else if (feetDist < headDist)                       //ow my toe
                {                                                   //toe direction = goalfeetyaw -30 +- 90
                    closestRayPoint = feetVec;
                    var realPos1 = ExtendVector(bodyVec, realAngle - 30.0 + 60.0, 10.0);
                    var realPos2 = ExtendVector(bodyVec, realAngle - 30.0 - 60.0, 10.0);
                    var fakePos1 = ExtendVector(bodyVec, fakeAngle - 30.0 + 60.0, 10.0);
                    var fakePos2 = ExtendVector(bodyVec, fakeAngle - 30.0 - 60.0, 10.0);
                    if (VectorDistance(feetVec, realPos1) < VectorDistance(feetVec, realPos2))
                    {
                        realPos = realPos1;
                    }
                    else
                    {
                        realPos = realPos2;
                    }
                    if (VectorDistance(feetVec, fakePos1) < VectorDistance(feetVec, fakePos2))
                    {
                        fakePos = fakePos1;
                    }
                    else
                    {
                        fakePos = fakePos2;
                    }
                }
                else                                                //ow my head i feel like i slept for 2 days
                {
                    closestRayPoint = headVec;
                    realPos = ExtendVector(bodyVec, realAngle, 10.0);
                    fakePos = ExtendVector(bodyVec, fakeAngle, 10.0);
                }

                if (VectorDistance(closestRayPoint, fakePos) < VectorDistance(closestRayPoint, realPos))        //they shot at our fake. they will probably not gonna shoot it again.
                {
                    lastHitTime = curtime;
                    Antiaim.Inverse = !Antiaim.Inverse
                }
            }

            lastImpacts[entity] = impact;
            lastImpactTimes[entity] = curtime;
        }
    },
}

Antiaim.HideElements(GUI.GetValue(p.antiaim, "Extended anti-aimbot angles"));
Antiaim.HideGroups(0, 0, 0);
Antiaim.Callback();
GUI.RegisterCallback(p.antiaim, "Extended anti-aimbot angles", "Antiaim.Callback");
Cheat.RegisterCallback("CreateMove", "Antiaim.CreateMove");
Cheat.RegisterCallback("bullet_impact", "Antiaim.BulletImpact")
Cheat.RegisterCallback("Unload", "Antiaim.Unload");
Cheat.RegisterCallback("Draw", "Antiaim.Draw");

/*
* Section: Materials
*/

var mats = []
var subtab = ["Visuals", "Chams", "Global"]
var editor_array = []

function makemat(name) {
    Material.Create(name)
    editor_array.push(name)
    mats.push({
        mat_name: name,
        ui_color: subtab.concat(name + " color"),
        update: true,
        update_color: true,
        first: true
    })
}
function lerp(a, b, c) {
    return (b - a) * c + a
}
function HSVtoRGB(h, s, v) {
    var r, g, b, i, f, p, q, t;
    if (arguments.length === 1) {
        s = h.s, v = h.v, h = h.h;
    }
    i = Math.floor(h * 6);
    f = h * 6 - i;
    p = v * (1 - s);
    q = v * (1 - f * s);
    t = v * (1 - (1 - f) * s);
    switch (i % 6) {
        case 0: r = v, g = t, b = p; break;
        case 1: r = q, g = v, b = p; break;
        case 2: r = p, g = v, b = t; break;
        case 3: r = p, g = q, b = v; break;
        case 4: r = t, g = p, b = v; break;
        case 5: r = v, g = p, b = q; break;
    }
    return [
        Math.round(r * 255),
        Math.round(g * 255),
        Math.round(b * 255),
        255
    ]
}
function Glow_Material() {
    for (i in mats) {
        var mat = Material.Get(mats[i].mat_name)
        var refresh = false
        if (mats[i].first) {
            mats[i].first = false
            Material.SetKeyValue(mat, "$basetexture", "vgui/white")
            Material.SetKeyValue(mat, "$envmap", "models/effects/cube_white")
            Material.SetKeyValue(mat, "$envmapfresnel", "1")
            refresh = true
        }
        if (mats[i].update) {
            mats[i].update = false
            refresh = true
        }
        if (mats[i].update_color) {
            mats[i].update_color = false
            var uicol = UI.GetColor(mats[i].ui_color)
            Material.SetKeyValue(mat, "$envmaptint", "[" + uicol[0] / 255 + " " + uicol[1] / 255 + " " + uicol[2] / 255 + "]")
            var alpha_fraction = uicol[3] / 255
            if (alpha_fraction > 1)
                alpha_fraction = 1
            var first = lerp(12, 1, alpha_fraction)
            var second = lerp(24, 2, alpha_fraction)
            Material.SetKeyValue(mat, "$envmapfresnelminmaxexp", "[0 " + first + " " + second + "]")
            refresh = true
        }
        if (refresh)
            Material.Refresh(mat)
    }
}
function Glow_Unload() {
    for (i in mats)
        Material.Destroy(mats[i].mat_name)
}
var lasttime = 0
var last_ui_values = {}
var last_ui_colors = {}
var last_editor_value = -1
var last_current_mat_settings = []
function Glow_Draw() {
    // update every 16.6666667 ms to save some fps :)
    var time = Globals.Realtime()
    if (time - lasttime > (16.6666667) / 1000) {
        for (i in mats) {
            var ui_col = UI.GetColor(mats[i].ui_color)
                
            if (last_ui_colors[mats[i].mat_name] == null)
                last_ui_colors[mats[i].mat_name] = ui_col
                
            if (last_ui_colors[mats[i].mat_name][0] != ui_col[0] ||
                last_ui_colors[mats[i].mat_name][1] != ui_col[1] ||
                last_ui_colors[mats[i].mat_name][2] != ui_col[2] ||
                last_ui_colors[mats[i].mat_name][3] != ui_col[3]) {
                last_ui_colors = ui_col
                mats[i].update_color = true
            }
        }
        var editor_value = UI.GetValue(subtab.concat("Editor"))
      
        if (editor_value != last_editor_value) {
            last_editor_value = editor_value
            var mat = mats[editor_value]
            UI.SetEnabled(subtab.concat(mat.mat_name + " color"), 1)
            for (i in mats) {
                if (mats[i].mat_name == mat.mat_name)
                    continue
                UI.SetEnabled(subtab.concat(mats[i].mat_name + " color"), 0)
            }
        }
    }
}

makemat("Glow (1)")
makemat("Glow (2)")
makemat("Glow (3)")
UI.AddDropdown(subtab, "Editor", editor_array, 0)
for (i in mats) {
    var name = mats[i].mat_name
    UI.AddColorPicker(subtab, name + " color")
}
for (i in mats) {
    mats[i].first = true
}

Cheat.RegisterCallback("Draw", "Glow_Draw")
Cheat.RegisterCallback("Unload", "Glow_Unload")
Cheat.RegisterCallback("Material", "Glow_Material")

/*
* Section: Visuals
*/

UI.AddCheckbox(p.visuals, "[NW] HP Bar")
UI.AddCheckbox(p.visuals, "[NW] Weapon name")
UI.AddCheckbox(p.visuals, "[NW] Zeus warning")
UI.AddCheckbox(p.visuals, "[NW] Ping warning")
UI.AddCheckbox(p.visuals, "Show difference between delays");

UI.AddCheckbox(p.radar, "[NW] Hostages")
UI.AddCheckbox(p.radar, "[NW] Bomb")
UI.AddCheckbox(p.radar, "[NW] FOV Arrows")
UI.AddCheckbox(p.radar, "[NW] Dormant arrows")

var screen_size = Render.GetScreenSize();
var center_screen = [screen_size[0]/2, screen_size[1]/2 ]
var lp = Entity.GetLocalPlayer;
function rad( deg )
{
    return deg * Math.PI / 180
}

function normalize_yaw(angle) {
    angle = (angle % 360 + 360) % 360;
    return angle > 180 ? angle - 360 : angle;
}

function calculate_yaw(src, to) {
    var delta = [src[0] - to[0], src[1] - to[1]]
    var yaw = Math.atan(delta[1]/delta[0])
    yaw = normalize_yaw(yaw * 180 / Math.PI)

    if (delta[0] >= 0)
        yaw = normalize_yaw(yaw + 180)

    return yaw
}
function rotate_angle(cx, cy, deg, distance)
{

    var viewAngles = Local.GetViewAngles()

    deg = rad( deg - viewAngles[1] )

    var x = Math.sin( deg ) * distance
    var y = Math.cos( deg ) * distance

    x = cx - x
    y = cy - y

    return [ x, y ]
}
function calculate_angles(x, y) {
    var _0x1a38f0 = [y[0x0] - x[0x0], y[0x1] - x[0x1], y[0x2] - x[0x2]];
    var _0x53da66 = -radian_to_degree(Math.atan2(_0x1a38f0[0x2], Math.hypot(_0x1a38f0[0x0], _0x1a38f0[0x1])));
    var _0x136715 = radian_to_degree(Math.atan2(_0x1a38f0[0x1], _0x1a38f0[0x0]));
    return [_0x53da66, _0x136715, 0x0];
}
/*function drawArrow(angle) {
    const pulse = Clamp(Math.floor(Math.sin(Globals.Realtime() * 4) * 127 + 128), 0, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance")
    var size = Math.pow(GUI.GetValue(p.radar, "Arrow size"), 5)
    var color = GUI.GetColor(p.radar, "FOV arrows")

    /*
    var radius = 50 + ((screen_size[0] / 4) * distance)

    var pos = [center_screen[0] + radius * Math.cos(angle), center_screen[1] + radius * Math.sin(angle)]
    var line = [pos[0] - center_screen[0], pos[1] - center_screen[1]]
    var arrowBase = [pos[0] - line[0] * (size / (2 * (Math.tan(rad(45)) / 2) * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), pos[1] - line[1] * (size / (2 * (Math.tan(rad(45)) / 2) * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    var arrowNormal = [-line[1], line[0]]
    var arrowLeft = [arrowBase[0] + arrowNormal[0] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), arrowBase[1] + arrowNormal[1] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    var arrowRight = [arrowBase[0] + arrowNormal[0] * (-size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1]))), arrowBase[1] + arrowNormal[1] * (size / (2 * Math.sqrt(line[0] * line[0] + line[1] * line[1])))]
    
    var new_point = rotate_angle(center_screen[0], center_screen[1], angle, distance, 1, 1.2)

    var top = rotate_angle(new_point[0], new_point[1], angle, 50, 1, 1)
    var left = rotate_angle( new_point[0], new_point[1], angle + (50/2),  50/2, 1.2, 1)
    var right = rotate_angle( new_point[0], new_point[1], angle - (50/2), 50/2, 1.2, 1)


    Render.Polygon( [top, left, right], [color[0], color[1], color[2],pulse] );
 
}*/

function drawArrow(angle) {
    const pulse = Clamp((Math.floor(Math.sin(Globals.Realtime() * 5) * 127) + 128) + 20, 20, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance") * 600
    var size = GUI.GetValue(p.radar, "Arrow size") * 30
    var color = GUI.GetColor(p.radar, "FOV arrows")

    var new_point = rotate_angle(center_screen[0], center_screen[1], angle, distance)

    var top = rotate_angle(new_point[0], new_point[1], angle, size)
    var left = rotate_angle( new_point[0], new_point[1], angle + (size/2),  size/2)
    var right = rotate_angle( new_point[0], new_point[1], angle - (size/2), size/2)

    Render.Polygon([top, right, left], [color[0], color[1], color[2], pulse]);     
}

/*function drawArrow(angle) {
    const pulse = Clamp((Math.floor(Math.sin(Globals.Realtime() * 5) * 127) + 128) + 20, 20, 255)
    var distance = GUI.GetValue(p.radar, "Arrow distance") * 600
    var size = GUI.GetValue(p.radar, "Arrow size") * 30
    var color = GUI.GetColor(p.radar, "FOV arrows")

    angle = Local.GetCameraAngles()[1] - angle - 90;

    const _0x55b844 = deg2rad(angle)
    var x = center_screen[0] + Math.cos(_0x55b844) * distance;
    var y = center_screen[1] + Math.sin(_0x55b844) * distance;


}*/

function world_point_visible(origin) {
    var w2s = Render.WorldToScreen(origin)
    if (w2s[0] < 0 || w2s[0] > screen_size[0] || w2s[1] < 0 || w2s[1] > screen_size[1])
        return false
    else
        return true
}

function paint() {
    if (!GUI.GetValue(p.radar, "[NW] FOV Arrows") || Entity.IsAlive(lp()) == false)
        return

    var players = Entity.GetEnemies();

    var local_origin = Local.GetCameraPosition();

    for (var i in players) {
        var player = players[i]
        if (Entity.IsValid(player) && Entity.IsAlive(player)) {
            var player_origin = Entity.GetRenderOrigin(player);
            var angles = calculate_yaw(local_origin, player_origin);

            var do_draw = world_point_visible(player_origin)
            if (!do_draw && ((GUI.GetValue(p.radar, "[NW] Dormant arrows") && Visuals.LastSeen[player] + 10 > Globals.Curtime()) || !Entity.IsDormant(player)))
                drawArrow(angles)
        }
    }
}

Cheat.RegisterCallback("Draw", "paint");

function get_icon_name(a) {
    var letter = ""
    switch (a) {
        case "desert eagle":
            letter = "A"
            break
        case "dual berettas":
            letter = "B"
            break
        case "five seven":
            letter = "C"
            break
        case "glock 18":
            letter = "D"
            break
        case "ak 47":
            letter = "W"
            break
        case "aug":
            letter = "U"
            break
        case "awp":
            letter = "Z"
            break
        case "famas":
            letter = "R"
            break
        case "m249":
            letter = "g"
            break
        case "g3sg1":
            letter = "X"
            break
        case "galil ar":
            letter = "Q"
            break
        case "m4a4":
            letter = "S"
            break
        case "m4a1 s":
            letter = "T"
            break
        case "mac 10":
            letter = "K"
            break
        case "p2000":
            letter = "E"
            break
        case "ump 45":
            letter = "L"
            break
        case "xm1014":
            letter = "b"
            break
        case "pp bizon":
            letter = "M"
            break
        case "mag 7":
            letter = "d"
            break
        case "negev":
            letter = "f"
            break
        case "sawed off":
            letter = "c"
            break
        case "tec 9":
            letter = "w"
            break
        case "zeus x27":
            letter = "h"
            break
        case "p250":
            letter = "F"
            break
        case "mp7":
            letter = "N"
            break
        case "mp9":
            letter = "O"
            break
        case "nova":
            letter = "e"
            break
        case "p90":
            letter = "P"
            break
        case "scar 20":
            letter = "Y"
            break
        case "sg 553":
            letter = "V"
            break
        case "ssg 08":
            letter = "a"
            break
        case "knife":
            letter = "["
            break
        case "flashbang":
            letter = "i"
            break
        case "high explosive grenade":
            letter = "j"
            break
        case "smoke grenade":
            letter = "k"
            break
        case "molotov":
            letter = "l"
            break
        case "decoy grenade":
            letter = "m"
            break
        case "incendiary grenade":
            letter = "n"
            break
        case "c4 explosive":
            letter = "o"
            break
        case "usp s":
            letter = "G"
            break
        case "cz75 auto":
            letter = "I"
            break
        case "r8 revolver":
            letter = "J"
            break
        case "bayonet":
            letter = "1"
            break
        case "flip knife":
            letter = "2"
            break
        case "gut knife":
            letter = "3"
            break
        case "karambit":
            letter = "4"
            break
        case "m9 bayonet":
            letter = "5"
            break
        case "falchion knife":
            letter = "0"
            break
        case "bowie knife":
            letter = "7"
            break
        case "butterfly knife":
            letter = "8"
            break
        case "shadow daggers":
            letter = "9"
            break
        case "ursus knife":
            letter = "6"
            break
        case "navaja knife":
            letter = "0"
            break
        case "stiletto knife":
            letter = "1"
            break
        case "skeleton knife":
            letter = "8"
            break
        case "huntsman knife":
            letter = "6"
            break
        case "talon knife":
            letter = "4"
            break
        case "classic knife":
            letter = "7"
            break
        case "paracord knife":
            letter = "1"
            break
        case "survival knife":
            letter = "2"
            break
        case "nomad knife":
            letter = "6"
            break
        default:
            letter = ""
            break
    }
    return letter
}

Entity.IsFakeDucking = function(player) {
    const DuckSpeed = Entity.GetProp(player, "CBasePlayer", "m_flDuckSpeed");
    const DuckAmount = Entity.GetProp(player, "CBasePlayer", "m_flDuckAmount");
    const Flags = Entity.GetProp(player, "CBasePlayer", "m_fFlags");
    
    if (DuckSpeed == 8 && DuckAmount > 0 && !(Flags & (1 << 1)))
        return true;
    
    return false;
}

var Visuals = {
    LastSeen: new Array(64),
    PFlags: new Object(),
    Hittables: new Array(),
    Fonts: function() {
        var sfont = Render.GetFont("font.ttf", 16, false)
        var nfont = Render.GetFont("Verdana.ttf", 10, true)
        var bfont = Render.GetFont("Calibrib.ttf", Indicators.Size, true)
        if (Northwood.Get("visuals:weapon_icon") == "true")
            var ifont = Render.GetFont("undefeated.ttf", 14, true)
        return [sfont, nfont, bfont, ifont]
    },
    Text: function(x, y, flags, text, color) {
        var sfont = Render.GetFont("font.ttf", 16, false)
        var nfont = Render.GetFont("Verdana.ttf", 10, true)
        var bfont = Render.GetFont("Calibrib.ttf", Indicators.Size, true)
        if (Northwood.Get("visuals:weapon_icon") == "true")
            var ifont = Render.GetFont("undefeated.ttf", 14, true)
        if (flags.includes("-")) {
            Render.String(x-1, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x-1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y-1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x+1, y, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x-1, y, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], sfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, sfont)
        }
        else if (flags.includes("+")) {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], bfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, bfont)
        }
        else if (flags.includes("i")) {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], ifont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, ifont)
        }
        else {
            Render.String(x+1, y+1, flags.includes("c") ? 1 : 0, text, [0, 0, 0, color[3]], nfont)
            Render.String(x, y, flags.includes("c") ? 1 : 0, text, color, nfont)
        }
    },
    WeaponName: function(ply) {
        var weaponname = Entity.GetName(Entity.GetWeapon(ply)).toUpperCase()
        switch (weaponname) {
            case "SCAR 20":
                weaponname = "SCAR-20"
                break;
        }
        return weaponname;
    },
    CreateMove: function() {
        Visuals.Hittables = new Array();
        var enem = Entity.GetEnemies();
        var lp = Entity.GetLocalPlayer();
        for (var i = 0; i < enem.length; i++) {
            var ply = enem[i];

            if (!Entity.IsAlive(ply) || Entity.GetName(Entity.GetWeapon(ply)).includes("knife"))
                continue;

            var target_body = Entity.GetHitboxPosition(ply, 2);
            var target_head = Entity.GetHitboxPosition(ply, 0);
            var local_eye = Entity.GetEyePosition(lp);

            var trace = Trace.Bullet(lp, ply, local_eye, target_body);

            if (trace !== undefined && trace[1] > 0)
                Visuals.Hittables.push(ply);
            else {
                trace = Trace.Bullet(lp, ply, local_eye, target_head);
                if (trace !== undefined && trace[1] > 0)
                    Visuals.Hittables.push(ply);
            }
        }
    },
    Draw: function() {
        var enem = Entity.GetEnemies();
        for (var i = 0; i < enem.length; i++) {
            var ply = enem[i];

            if (!Entity.IsAlive(ply))
                continue;

            var b = Entity.GetRenderBox(ply);
            var w = b[3] - b[1];
            var h = b[4] - b[2];
            var dcolor = GUI.GetColor(["Visuals", "Extra", "General"], "Dormant ESP");
            var dalpha = 1;
            if (!Entity.IsDormant(ply))
                Visuals.LastSeen[i] = Globals.Curtime();
            else { dalpha = 0.7 }
            if (Visuals.LastSeen[i] + 11 > Globals.Curtime() && Visuals.LastSeen[i] + 10 < Globals.Curtime()) {
                dalpha = Math.max(0.7 + (Visuals.LastSeen[i] + 10 - Globals.Curtime()), 0)
            }
            dcolor = [dcolor[0], dcolor[1], dcolor[2], dcolor[3] * dalpha]

            if (Visuals.LastSeen[i] + 11 < Globals.Curtime() || Visuals.LastSeen[i] == undefined)
                continue;

            Visuals.PFlags[ply] = new Array();

            Visuals.PFlags[ply].push(["$"+Entity.GetProp(ply, "CCSPlayer", "m_iAccount").toString(), [140, 200, 40, 175]]);

            if (Entity.GetProp(ply, "CCSPlayerResource", "m_iArmor") > 0)
                Visuals.PFlags[ply].push([(Entity.GetProp(ply, "CCSPlayer", "m_bHasHelmet") ? "HK" : "K"), [255, 255, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_bIsScoped") > 0)   
                Visuals.PFlags[ply].push(["ZOOM", [87, 175, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_flFlashDuration") > 0)   
                Visuals.PFlags[ply].push(["BLIND", [87, 175, 255, 175]]);

            var weapons = Entity.GetWeapons(ply);
            var hasc4 = false;

            for (var wn in weapons) {
                if (Entity.GetName(weapons[wn]) == "c4 explosive")
                hasc4 = true;
            }

            if (hasc4)
                Visuals.PFlags[ply].push(["B", [255, 0, 0, 175]]);

            if (Entity.IsFakeDucking(ply))
                Visuals.PFlags[ply].push(["FD", [255, 255, 255, 175]]);

            if (Entity.GetProp(ply, "CCSPlayer", "m_hCarriedHostage").toString() != "m_hCarriedHostage")
                Visuals.PFlags[ply].push(["VIP", [255, 0, 0, 175]]);

            if (Entity.GetProp(Entity.GetWeapon(ply), "CBaseCSGrenade", "m_bPinPulled"))
                Visuals.PFlags[ply].push(["PIN", [255, 0, 0, 175]]);

            if (Visuals.Hittables.indexOf(ply) !== -1)
                Visuals.PFlags[ply].push(["HIT", [255, 255, 255, 175]]);

            if (Northwood.Get("visuals:weapon_icon") && b[0]) {
                var flags = Visuals.PFlags[ply];
                for (var f in flags) {
                    var ft = flags[f][0];
                    var fc = !Entity.IsDormant(ply) ? flags[f][1] : dcolor;
                    if (Entity.IsDormant(ply))
                        fc[3] *= 1.2;

                    Visuals.Text(b[3] + 3, Math.floor(b[2] - 5 + (10 * f)), "-", ft, fc)
                }
            }

            if (GUI.GetValue(p.visuals, "[NW] HP Bar")) {
                    /*
                    * HP BAR
                    */
                    if (b[0]) {
                        var hp = Entity.GetProp(ply, "CCSPlayer", "m_iHealth")
                        var maxhp = 100;
                        var hpheight = Math.ceil(h / maxhp * Math.min(hp, 100))
                        
                        var color = GUI.GetColor(p.visuals, "Health color override")

                        if (Northwood.Get("visuals:weapon_icon") == "true") {
                            if (hp <= 30)
                                color = [200, 100, 90, 255];
                            else if (hp <= 50)
                                color = [200, 200, 90, 255];
                            else
                                color = [90, 200, 100, 255];
                        }
                        /*if (hp <= 30)
                            color = [90, 50, 150, 255];
                        else if (hp <= 50)
                            color = [50, 90, 150, 255];*/
                        
                        Render.FilledRect(b[1] - 6, b[2] - 1, 4, h + 2, [0, 0, 0, 125 * dalpha]);
                        Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, !Entity.IsDormant(ply) ? color : dcolor);
                        if (!Entity.IsDormant(ply) && Northwood.Get("visuals:weapon_icon") != "true") {
                            if (hp <= 30)
                                Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, [0, 0, 0, 150]);
                            else if (hp <= 50)
                                Render.FilledRect(b[1] - 5, Math.floor(b[2] + (h / maxhp * (maxhp - hp))), 2, hpheight, [0, 0, 0, 80]);
                        }
                        if (hp < 95 || hp > 100)
                            Visuals.Text(b[1] - 4, b[2] + (h / maxhp * (maxhp - hp)) - 6, "c-", hp.toString(), [255, 255, 255, 200 * dalpha])
                    }
            }
            if (GUI.GetValue(p.visuals, "[NW] Weapon name")) {
                /*
                * WEAPON NAME
                */
                if (b[0] && Visuals.WeaponName(ply) != Entity.GetName(ply).toUpperCase())
                    Visuals.Text(b[1] + w/2, b[4] + (!Entity.IsDormant(ply) ? 4 : 0), "c-", Visuals.WeaponName(ply), [255, 255, 255, 220 * dalpha])
            }


            
            if (Northwood.Get("visuals:weapon_icon") == "true" && b[0] && Visuals.WeaponName(ply) != Entity.GetName(ply).toUpperCase())
                Visuals.Text(b[1] + w/2, b[4] + (!Entity.IsDormant(ply) && !Entity.GetName(Entity.GetWeapon(ply)).includes("knife") ? 6 : 2), "ci", get_icon_name(Entity.GetName(Entity.GetWeapon(ply))), [255, 255, 255, 220 * dalpha])

            if (GUI.GetValue(p.visuals, "[NW] Zeus warning")) {
                if (b[0] && !Entity.IsDormant(ply)) {
                    var flag = false;
                    for (var wpn in Entity.GetWeapons(ply)) {
                        if (Entity.GetName(Entity.GetWeapons(ply)[wpn]) == "zeus x27")
                            flag = true;
                    }
    
                    if (flag) {
                        var x = b[1] - 14;
                        var y = b[2];
                        Render.Polygon([[x, y], [x, y+7], [x-6, y+7]], [255, 255, 0, 255])
                        Render.Polygon([[x, y], [x+4, y], [x-2, y+7]], [255, 255, 0, 255])
                        Render.Polygon([[x-1, y+5], [x+6, y+5], [x-3, y+12]], [255, 255, 0, 255])
                    }   
                }
            }

            if (GUI.GetValue(p.visuals, "[NW] Ping warning")) {
                if (b[0]) {
                    var localping = Math.floor(Entity.GetProp(Entity.GetLocalPlayer(), "CPlayerResource", "m_iPing"));
                    var ping = Math.floor(Entity.GetProp(ply, "CPlayerResource", "m_iPing"));
                    if (GUI.GetValue(p.visuals, "Show difference between delays")) {
                        if (localping - ping > 0) {
                            var color = Northwood.Utils.StatusColor(Math.max(0, 100 - (localping - ping)), 100);
                            Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("+{0} MS", localping - ping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                        }
                        else {
                            var color = Northwood.Utils.StatusColor(Math.max(0, ping - localping), 100, 5);
                            Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("-{0} MS", ping - localping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                        }
                        
                    }
                    else {
                        var color = Northwood.Utils.StatusColor(Math.max(0, 150 - ping), 150);
                        Visuals.Text(Math.floor(b[1] + w/2) - 1, b[2] - 25, "c-", String.format("{0} MS", ping), Entity.IsDormant(ply) ? dcolor : color.concat(200));
                    }
                }
            }
        }
    },
    DrawEntities: function() {
        if (GUI.GetValue(p.radar, "[NW] Hostages")) {
            var ents = Entity.GetEntitiesByClassID(97);
            for(i=0; i < ents.length; i++) {
                var ent = ents[i];
                var origin = Entity.GetRenderOrigin(ent);
                var scr = Render.WorldToScreen(origin)
                
                if (scr[2] && calcDist(Entity.GetRenderOrigin(lp()), origin) < 1200)
                    Visuals.Text(scr[0] - 20, Math.max(scr[1] - 20, 0), "-", "HOSTAGE", [56, 159, 252, 201])
            }
        }
        
        if (GUI.GetValue(p.radar, "[NW] Bomb")) {
            var ents = Entity.GetEntitiesByClassID(34);
            for(i=0; i < ents.length; i++) {
                var ent = ents[i];
                var origin = Entity.GetRenderOrigin(ent);
                var scr = Render.WorldToScreen(origin)
                
                if (scr[2] && Entity.GetProp(ent, "CBaseEntity", "m_hOwnerEntity").toString() == "m_hOwnerEntity")
                    Visuals.Text(scr[0] - 10, scr[1] - 10, "-", "BOMB", [150, 200, 60, 255])
            }
        }
    }
}

Cheat.RegisterCallback("Draw", "Visuals.Draw")
Cheat.RegisterCallback("CreateMove", "Visuals.CreateMove")
Cheat.RegisterCallback("Draw", "Visuals.DrawEntities")

UI.AddCheckbox(p.radar, "[NW] Grenade proximity warning")
/*UI.AddCheckbox(p.radar, "[NW] Predict grenade path")
UI.AddSliderInt(p.radar, "[NW] Re-predict grenade", 0, 126)
if (GUI.GetValue(p.radar, "[NW] Re-predict grenade") == 0)
    GUI.SetValue(p.radar, "[NW] Re-predict grenade", 126)*/

function GrenadeWarning()
{
    if (!Entity.IsAlive(lp()) || !GUI.GetValue(p.radar, "[NW] Grenade proximity warning"))
        return;

    var font1 = Render.GetFont("Calibrib.ttf", 25, true);
    var font2 = Render.GetFont("Verdanab.ttf", 10, true);
    var DistanceInFeet = function(origin, destination) {
            var sub = [destination[0] - origin[0], destination[1] - origin[1], destination[2] - origin[2]];
            return Math.round(Math.sqrt(sub[0] ** 2 + sub[1] ** 2 + sub[2] ** 2) / 12);
    }

    GrenadePrediction.Run();

    var origin = Entity.GetRenderOrigin(lp());
    var grenades = GrenadePrediction.GetLiveGrenades();

    /*for (var i in grenades)
    {
        var g = grenades[i];
        var destination = g.Position;
        var distance = DistanceInFeet(origin, destination);
        var screen = Render.WorldToScreen(destination);

        if (distance > 50)
        {
            continue;
        }

        if (!g.IsLive)
            continue;

        Render.FilledCircle(screen[0], screen[1] -50, 30, [Math.max(0, 255 - Math.pow(distance, 1.7)), 0, 0, 255])
        draw_arc1(screen[0]-1, screen[1] - 50, 31, 29, 270, 360, 30, [10, 10, 10, 255]);
        Render.String(screen[0], screen[1] - 68, 1, "!", [255, 250, 20, 200], font1);
        Render.String(screen[0], screen[1] - 45, 1, distance + " ft", [232, 232, 232, 200], font2);
        if (g.Type == "Molotov") {
            time = Entity.GetProp(g.EntityIndex, "CInferno", "m_nFireEffectTickBegin") * Globals.TickInterval();
            factor = Clamp(((time + 7) - Globals.Curtime()) / 7, 0, 7);
            draw_arc1(screen[0]-1, screen[1] - 50, 31, 29, 270, 360 * factor, 150, [232, 232, 232, 200]);
        }
    }*/

    for (var i in grenades) {
        var g = grenades[i];

        if (g.Type != "Molotov" && g.Type != "Grenade")
            return;

        var destination = g.Position;
        var distance = DistanceInFeet(origin, destination)
        var Hit = true;
        var screen = Render.WorldToScreen(destination)
        screen[1] += 30;

        if (g.Type == "Grenade") {
            Hit = false;
            for (var d in g.Hits) {
                var hit = g.Hits[d];
                if (hit.EntityIndex == Entity.GetLocalPlayer()) {
                    distance = hit.Damage;
                    Hit = true;
                    break;
                }
            }
        }

        if ((g.Type == "Grenade" && !Hit) || (g.Type == "Molotov" && distance > 25))
            continue;

        if (!g.IsLive)
            continue;
        
        /*if (screen[2]) {
            Render.FilledCircle(screen[0], screen[1] -50, Math.max(30, 40 - distance), [Math.max(0, 255 - Math.pow(distance, 1.8)), 0, 0, 220])
            Render.Circle(screen[0], screen[1] -50, Math.max(30, 40 - distance), [10, 10, 10, 255])
            Render.Circle(screen[0], screen[1] -50, Math.max(30, 40 - distance) - 1, [10, 10, 10, 255])
            //draw_arc1(screen[0]-1, screen[1] - 50, Math.max(30, 40 - distance) + 1, Math.max(30, 40 - distance) - 1, 270, 360, 30, [10, 10, 10, 255]);
            Render.String(screen[0], screen[1] - 68, 1, "!", [255, 250, 20, 200], font1);
            Render.String(screen[0], screen[1] - 45, 1, distance + (g.Type == "Grenade" ? " hp" : " ft"), [232, 232, 232, 200], font2);
        }*/

        else {
            var yaw = calculate_yaw(origin, destination);
            var new_point = rotate_angle(center_screen[0], center_screen[1], yaw, center_screen[1] / 1.15)
            new_point = rotate_angle(new_point[0], new_point[1], yaw, 50 / Math.tan(rad(45)))
            Render.FilledCircle(new_point[0], new_point[1] -50, 30, [Math.max(17, 255 - Math.pow(distance, 1.8)), 17, 17, 220])
            Render.Circle(new_point[0], new_point[1] -50, 30, [10, 10, 10, 255])
            Render.Circle(new_point[0], new_point[1] -50, 30 - 1, [10, 10, 10, 255])
            //draw_arc1(new_point[0]-1, new_point[1] - 50, 30 + 1, 29, 270, 360, 30, [0, 0, 0, 200]);
            Render.String(new_point[0], new_point[1] - 68, 1, "!", [255, 250, 20, 200], font1);
            Render.String(new_point[0], new_point[1] - 45, 1, distance + (g.Type == "Grenade" ? " hp" : " ft"), [232, 232, 232, 200], font2);
        }         
    }
}

Cheat.RegisterCallback("Draw", "GrenadeWarning");

/*
* Section: Logs
*/

UI.AddCheckbox(p.cheat, "Override event logs")
UI.AddDropdown(p.cheat, "Event logs output", ["Console", "Console + Screen"], 0)
UI.AddMultiDropdown(p.cheat, "Event logs triggers", ["Item purchase", "Aimbot fire", "Player hurt", "Missed shots"])
var logs = new Array();
function event_log(text) {
    if (!GUI.GetValue(p.cheat, "Override event logs"))
        return;

    if (!GUI.GetValue(p.cheat, "Event logs output")) {
        Cheat["PrintColor"](GUI.GetColor(p.cheat, "Log color"), "[onetap] "+text+"\n");
    }
    else {
        //Cheat["PrintLog"](text, GUI.GetColor(p.cheat, "Log color"));
        Cheat["PrintColor"](GUI.GetColor(p.cheat, "Log color"), "[onetap] "+text+"\n");
        logs.push({text: text, time: Globals.Curtime(), color: [255, 255, 255], alpha: 255, y: 0});
    }
}

function draw_logs() {
    while (logs.length > 6) {
        logs.shift();
    }
    
    for (var l in logs) {
        if (logs[l].time + 6 < Globals.Curtime()) {
            logs[l].alpha -= Globals.Frametime() * 1.5 * 255;
            if (logs[l].alpha <= 80) {
                logs[l].y += Globals.Frametime() * 180;
            }
            if (logs[l].alpha <= 0)
                logs.shift();
        }
    }

    var cfont = Render.GetFont("lucidaconsolenoa3.ttf", 16, false);
    for (var l in logs) {
        log = logs[l];
        Render.String(9, (3 + 12 * l) - Math.floor(log.y), 0, log.text, [0, 0, 0, log.alpha], cfont);
        Render.String(8, (2 + 12 * l) - Math.floor(log.y), 0, log.text, log.color.concat(log.alpha), cfont);
    }
}

//Cheat.RegisterCallback("Draw", "draw_logs")

function eventlog_handle_ui() {
    if (!GUI.GetValue(p.cheat, "Override event logs")) {
        GUI.SetEnabled(p.cheat, "Event logs output", 0)
        GUI.SetEnabled(p.cheat, "Event logs triggers", 0)
        GUI.SetEnabled(p.cheat, "Log output", 1)
        GUI.SetEnabled(p.cheat, "Log events", 1)
    }
    else {
        GUI.SetEnabled(p.cheat, "Event logs output", 1)
        GUI.SetEnabled(p.cheat, "Event logs triggers", 1)
        GUI.SetEnabled(p.cheat, "Log output", 0)
        GUI.SetEnabled(p.cheat, "Log events", 0)
        GUI.SetValue(p.cheat, "Log output", 0)
    }
}

var hitgroups = ["generic", "head", "chest", "stomach", "left arm", "right arm", "left leg", "right leg", "unknown"];
var hitboxes = ["head", "head", "stomach", "stomach", "chest", "chest", "chest", "left leg", "right leg", "left leg", "right leg", "left leg", "right leg", "left arm", "right arm", "left arm", "left arm", "right arm", "generic"];

var choked = 0;
var choked_prev = 0;
var choked_max = 0;
var choked_prev_cmd = 0;
var tickcount = 0;
var tickcount_prev = 0;
function fakelag_handler() {
    choked_prev = choked;
    choked = Globals.ChokedCommands();
    if (choked > choked_max)
        choked_max = choked;
    else if (choked == 0 && choked_prev != 0)
        choked_max = choked_prev;
    else if (choked == 0 && choked_prev_cmd == 0)
        choked_max = 0;
    
    tickcount = Globals.Tickcount();
    if (tickcount != tickcount_prev) {
        choked_prev_cmd = choked_prev_cmd;
        tickcount_prev = tickcount;
    }
}

Global.RegisterCallback("CreateMove", "fakelag_handler");

function on_player_hurt() {
    if (!(GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 2) || Entity.GetEntityFromUserID(Event.GetInt("attacker")) != Entity.GetLocalPlayer())
        return;

    var hit_type = "Hit"
    switch (Event.GetString("weapon")) {
        case "hegrenade":
            hit_type = "Naded"
            break;
        case "inferno":
            hit_type = "Burned"
            break;
        default:
            hit_type = "Hit"
            break;
    }

    if (Event.GetString("weapon").includes("knife"))
        hit_type = "Knifed"

    var ply = Entity.GetEntityFromUserID(Event.GetInt("userid"))

    if (hit_type == "Hit") {
        ragebot_hit++;   
        event_log(String.format("Hit {0} in the {1} for {2} damage ({3} health remaining)", Entity.GetName(ply), hitgroups[Event.GetInt("hitgroup")], Event.GetInt("dmg_health").toString(), Event.GetInt("health").toString()))
    }
        
    else
        event_log(String.format("{0} {1} for {2} damage ({3} health remaining)", hit_type, Entity.GetName(ply), Event.GetInt("dmg_health").toString(), Event.GetInt("health").toString()))
}

var entities = {}

var cl_data = {
    tick_shifted: false,
    extrapolated: false,
}

var tickbase_prev = 0;
var tickbase = 0;
var ragebot_shots = 0;
var ragebot_hit = 0;
var latest_shot = {
    name: "",
    hitchance: 0,
    safety: 0,
    hitbox: 0,
};
function anglevector(a) {
    var sy = Math.sin(a[1] / 180 * Math.PI)
    var cy = Math.cos(a[1] / 180 * Math.PI)
    var sp = Math.sin(a[0] / 180 * Math.PI)
    var cp = Math.cos(a[0] / 180 * Math.PI)
    return [cp * cy, cp * sy, -sp]
}
function vecmulfl(a, b) {
    return [a[0] * b, a[1] * b, a[2] * b]
}
function vecadd(a, b) {
    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
}

function flags_handler() {
    for (var i in Entity.GetEnemies()) {
        var ply = Entity.GetEnemies()[i]
        entities[ply] = {
            shots: Entity.GetProp(ply, "CCSPlayer", "m_iShotsFired"),
        }
    }
    //tickbase = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_nTickBase")
    tickbase = Exploit.GetPredictedTickbase();
    if (tickbase_prev + 2 < tickbase)
        cl_data.tick_shifted = true;
    else
        cl_data.tick_shifted = false;

    cl_data.extrapolated = Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) > 40960;
    tickbase_prev = tickbase;

    if (GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 3) {
        if (latest_impact == Globals.Tickcount()) {
            if (ragebot_shots > ragebot_hit) {
                var reason = "unknown"
                if (latest_shot.safety > 0 && latest_shot.hitchance <= 95)
                    reason = "spread";
                else if (latest_shot.safety > 0 && latest_shot.hitchance > 95)
                    reason = "prediction error";
                else if (latest_shot.safety == 0) {
                    if (latest_shot.hitchance > 35)
                        reason = "correction";
                    else
                        reason = "spread";
                }
                event_log(String.format("Missed shot at {0}'s {1} due to {4} (hc={2}; safe={3})", latest_shot.name, hitboxes[latest_shot.hitbox], latest_shot.hitchance, latest_shot.safety, reason))
                latest_impact = 0;
            }
            ragebot_hit = ragebot_shots;
        }
    }
}

function on_weapon_fire() {
    if (Event.GetInt("exploit") == 0)
        ragebot_shots++;
      
    var ply = Event.GetInt("target_index")
    var hitbox = hitboxes[Event.GetInt("hitbox")]
    var flags = "";
    if (Event.GetInt("exploit") > 0)
        flags += "S";
    if (Event.GetInt("hitchance") == 0)
        flags += "T";
    if (entities[ply].shots > 0 || Entity.GetProp(ply, "CCSPlayer", "m_iShotsFired") > 0)
        flags += "H";
    if (GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 1)
        event_log(String.format("Fired at {0}'s {1} (hc={2}; safe={3}; fl={4}"+(flags != "" ? "; flags={5}" : "")+")", Entity.GetName(ply), hitbox, Event.GetInt("hitchance"), Event.GetInt("safepoint"), choked_max, flags))
    latest_shot = {
        name: Entity.GetName(ply),
        hitchance: Event.GetInt("hitchance"),
        safety: Event.GetInt("safepoint"),
        hitbox: Event.GetInt("hitbox"),
    }
}

function on_item_purchase() {
    if (!(GUI.GetValue(p.cheat, "Event logs triggers") & 1 << 0))
        return;

    if (Event.GetString("weapon") == "weapon_unknown")
        return;

    var ply = Entity.GetEntityFromUserID(Event.GetInt("userid"))
    if (ply != Entity.GetLocalPlayer())
        event_log(String.format("{0} bought {1}", Entity.GetName(ply), Event.GetString("weapon")))
}

function weapon_fire() {
    Tickbase.LastShot = Globals.Tickcount();
}

Cheat.RegisterCallback("FRAME_NET_UPDATE_END", "flags_handler")
Cheat.RegisterCallback("ragebot_fire", "on_weapon_fire")
Cheat.RegisterCallback("weapon_fire", "weapon_fire")
Cheat.RegisterCallback("player_hurt", "on_player_hurt")
Cheat.RegisterCallback("item_purchase", "on_item_purchase")
Cheat.RegisterCallback("Draw", "eventlog_handle_ui")

/*
* Section: Indicators
*/



UI.AddCheckbox(p.indicators, "[NW] Indicators")
UI.AddCheckbox(p.indicators, "Fake indicator")
UI.AddCheckbox(p.indicators, "Fake lag indicator")
UI.AddCheckbox(p.indicators, "Damage override indicator")
UI.AddMultiDropdown(p.indicators, "On-screen indicators", ["Double tap", "Hide shots", "Damage override", "Fake duck", "Inverter", "Safe points", "Body aim", "Freestanding", "Slow walk", "Auto peek", "Edge jump", "Fake angles"])
UI.AddDropdown(p.indicators, "On-screen indicators font", ["Normal", "Small"], 0)
UI.AddCheckbox(p.indicators, "On-screen indicators short text")

function calcDist(local, target) {
    var lx = local[0];
    var ly = local[1];
    var lz = local[2];
    var tx = target[0];
    var ty = target[1];
    var tz = target[2];
    var dx = lx - tx;
    var dy = ly - ty;
    var dz = lz - tz;

    return Math.sqrt(dx * dx + dy * dy + dz * dz);
}

var lc = false;

var Indicators = {
    Size: (Northwood.Get("indicators:size") == "" ? 24 : parseInt(Northwood.Get("indicators:size"))),
    last_origin: [0, 0, 0],
    last_origin_sqr: 0,
    origin_sqr: 0,
    Offset: 0,
    Air_tickcount: Globals.Tickcount(),
    Planting: false,
    Defusing: false,
    PlantingTimer: Globals.Curtime(),
    DefusingTimer: Globals.Curtime(),
    APlants: [454, 372, 102, 276, 174, 121, 301, 142, 408, 97, 213, 216],
    PlantIndex: 0,
    Damage: 0,
    Alpha: {
        ['Double tap']: 0,
        ['Hide shots']: 0,
        ['Damage override']: 0,
        ['Fake duck']: 0,
        ['Inverter']: 0,
        ['Safe points']: 0,
        ['Body aim']: 0,
        ['Freestanding']: 0,
        ['Slow walk']: 0,
        ['Auto peek']: 0,
        ['Edge jump']: 0,
    },
    OnPlanting: function() {
        Indicators.Planting = true;
        Indicators.PlantingTimer = Globals.Curtime() + 3;
        Indicators.PlantIndex = Event.GetInt("site");
        //Cheat.Print(Event.GetInt("site").toString())
    },
    OnAbortPlanting: function() {
        Indicators.Planting = false;
    },
    OnDefusing: function() {
        Indicators.Defusing = true;
        Indicators.DefusingTimer = Globals.Curtime() + (Event.GetInt("haskit") ? 5 : 10)
    },
    OnAbortDefusing: function() {
        Indicators.Defusing = false;
    },
    Circle: function(x, y, radius, thickness, color) {
        var inner = radius - thickness;

        for(; radius > inner; --radius)
        {
            Render.Circle(x, y, radius, color);
        }
    },
    Arc: function(x, y, radius, radius_inner, start_angle, end_angle, segments, color) {
        segments = 360 / segments;

    for (var i = start_angle; i < start_angle + end_angle; i = i + segments)
    {

        var rad = i * Math.PI / 180;
        var rad2 = (i + segments) * Math.PI / 180;

        var rad_cos = Math.cos(rad);
        var rad_sin = Math.sin(rad);

        var rad2_cos = Math.cos(rad2);
        var rad2_sin = Math.sin(rad2);

        var x1_inner = x + rad_cos * radius_inner;
        var y1_inner = y + rad_sin * radius_inner;

        var x1_outer = x + rad_cos * radius;
        var y1_outer = y + rad_sin * radius;

        var x2_inner = x + rad2_cos * radius_inner;
        var y2_inner = y + rad2_sin * radius_inner;

        var x2_outer = x + rad2_cos * radius;
        var y2_outer = y + rad2_sin * radius;

        Render.Polygon( [
            [ x1_outer, y1_outer ],
            [ x2_outer, y2_outer ],
            [ x1_inner, y1_inner ] ],
            color
        );

        Render.Polygon( [
            [ x1_inner, y1_inner ],
            [ x2_outer, y2_outer ],
            [ x2_inner, y2_inner ] ],
            color
        );
    }
    },
    Add: function(text, color) {
        var tw = Render.TextSize(text, Visuals.Fonts()[2])[0]
        Render.GradientRect(11, screen_size[1] - 340 - 37 * this.Offset - 6, Math.floor(tw/2), 33 * (Indicators.Size / 24), 1, [0, 0, 0, 5], [0, 0, 0, 60])
        Render.GradientRect(11 + Math.floor(tw/2), screen_size[1] - 340 - 37 * this.Offset - 6, Math.floor(tw/2), 33 * (Indicators.Size / 24), 1, [0, 0, 0, 60], [0, 0, 0, 5])
        Visuals.Text(20, screen_size[1] - 340 - 37 * this.Offset, "+", text, color)
        this.Offset++;
        return (screen_size[1] - 340 - 37 * (this.Offset - 1))
    },
    Draw: function() {
        if (GUI.GetValue(p.indicators, "[NW] Indicators")) {

            Indicators.Offset = 0;
            var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
            var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
            var flags = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer" ,"m_fFlags")
            var fake = Math.abs(normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw()))
            if (GUI.GetValue(p.indicators, "Fake indicator") && Entity.IsAlive(Entity.GetLocalPlayer())) {
                //[255 - Math.min(57, fake)*2.3682, Math.min(57, fake)*3.4210, Math.min(57, fake)*0.22807, 255]
                var y = Indicators.Add("FAKE", Northwood.Utils.StatusColor(fake, 60).concat(255));
                Indicators.Arc(90, y+11*(Indicators.Size / 24), 10, 5, 0, 360, 15, [0, 0, 0, 180]);
                Indicators.Arc(90, y+11*(Indicators.Size / 24), 9, 6, 0, fake * 6, 60, Northwood.Utils.StatusColor(fake, 60).concat(255));
            }

            if (GUI.GetValue(p.indicators, "Fake lag indicator") && Entity.IsAlive(Entity.GetLocalPlayer())) {
                var c = Northwood.GetColor();
                c[3] = 255;
                var y = Indicators.Add("FL", c);
                Indicators.Arc(60, y+11*(Indicators.Size / 24), 10, 5, 0, 360, 15, [0, 0, 0, 180])
                Indicators.Arc(60, y+11*(Indicators.Size / 24), 9, 6, 0, Math.min(360, Globals.ChokedCommands() * (360 / 14)), 56, c)
            }
            if (GUI.GetValue(p.indicators, "Damage override indicator") && GUI.GetValue(p.rage, "Minimum damage override") && Indicators.Damage >= 0) {
                Indicators.Add("DMG: "+Indicators.Damage.toString(), [150, 160, 170, 255]);
            }
            if (Indicators.Planting) {
                var y = Indicators.Add("Bombsite " + (Indicators.APlants.indexOf(Indicators.PlantIndex) === -1 ? "B" : "A"), [255, 240, 100, 255]);
                //Indicators.Circle(150, y+12, 10, 7, [0, 0, 0, 180])
                Indicators.Arc(155, y+10, 10, 5, 0, 360, 15, [0, 0, 0, 180])
                Indicators.Arc(155, y+10, 9, 6, 0, Math.min(360 - (Indicators.PlantingTimer - Globals.Curtime()) * 120, 360), 60, [255, 255, 255, 255])
            }

            if (GUI.GetValue(p.antiaim_keys, "Fake duck") && Entity.IsAlive(Entity.GetLocalPlayer()))
                Indicators.Add("DUCK", [255, 255, 255, 255]);

            if (!(flags & 1))
                Indicators.Air_tickcount = Globals.Tickcount()

            if (speed > 180 && (!(flags & 1) || Globals.Tickcount() < Indicators.Air_tickcount + 2) && Entity.IsAlive(Entity.GetLocalPlayer())) {
                lc = true;
            }

            if (lc)
                Indicators.Add("LC",  Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) > 40960 ? [123, 195, 21, 255] : [255, 0, 0, 255]);

            if (speed > 230 && (!(flags & 1) || Globals.Tickcount() < Indicators.Air_tickcount + 2) && Entity.IsAlive(Entity.GetLocalPlayer())) {
                lc = true;
            }
            else {
                lc = false;
            }

            

            var C4 = Entity.GetEntitiesByClassID(129)[0];
            
            if (C4 !== undefined) {
                var local = lp()
                if (!Entity.IsAlive(Entity.GetLocalPlayer()))
                    local = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_hObserverTarget")

                if (local == "m_hObserverTarget")
                    return;

                if (Entity.GetProp(C4, "CPlantedC4", "m_bBombDefused") == 1)
                    return;

                var eLoc = Entity.GetRenderOrigin(C4);
                var lLoc = Entity.GetRenderOrigin(local)
                var distance = calcDist(eLoc, lLoc);
                var dmg = 0;
                var armor = Entity.GetProp(local, "CCSPlayerResource", "m_iArmor");
                var health = Entity.GetProp(local, "CBasePlayer", "m_iHealth");
                var timer = Entity.GetProp(C4, "CPlantedC4", "m_flC4Blow") - Globals.Curtime();
                var bombsite = Entity.GetProp(C4, "CPlantedC4", "m_nBombSite");
                bombsite = (bombsite == 0 ? "A" : "B")

                const a = 450.7;
                const b = 75.68;
                const c = 789.2;

                const d = (distance - b) / c;

                var damage = a * Math.exp(-d * d);

                if (armor > 0) {
                    var newDmg = damage * 0.5;
                    var armorDmg = (damage - newDmg) * 0.5;

                    if (armorDmg > armor) {
                        armor = armor * (1 / .5);
                        newDmg = damage - armorDmg;
                    }
                    damage = newDmg;
                }
                dmg = Math.ceil(damage);

                if (timer > 0)
                    Indicators.Add(String.format("{0} - {1}s", bombsite, timer.toFixed(1)), [255, 255, 255, 255]);

                if (dmg > 1 && timer > 0)
                    Indicators.Add(dmg >= health ? "FATAL" : String.format("-{0} HP", dmg), dmg >= health ? [255, 0, 0, 255] : [255, 240, 100, 255]);
            }

            if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap") && Entity.IsAlive(Entity.GetLocalPlayer()))
                Indicators.Add("DT", Exploit.GetCharge() > 0.8 ? [210, 210, 210, 255] : [255, 0, 0, 255]);

            if (Indicators.Defusing) {
                Render.FilledRect(0, 0, 20, screen_size[1], [0, 0, 0, 150]);
                Render.FilledRect(0, screen_size[1] - (screen_size[1] / 10) *  (Indicators.DefusingTimer - Globals.Curtime()), 19, (screen_size[1] / 10) *  (Indicators.DefusingTimer - Globals.Curtime()), (Indicators.DefusingTimer - Globals.Curtime() > timer ? [180, 0, 0, 120] : [0, 180, 50, 120]));
            }
        }
        if (GUI.GetValue(p.indicators, "On-screen indicators") != 0) {
            if (!Entity.IsAlive(Entity.GetLocalPlayer()))
                    return;
            var t = Globals.Frametime() * 255 * 8;
            var options = GUI.GetValue(p.indicators, "On-screen indicators")
            var flags = "c";
            var offset = 1;
            var offset_size = GUI.GetValue(p.indicators, "On-screen indicators font") == 1 ? 10 : 13;
            if (options & (1 << 11))
                offset += 2;
            var short = GUI.GetValue(p.indicators, "On-screen indicators short text")
            switch (GUI.GetValue(p.indicators, "On-screen indicators font")) {
                case 1:
                    flags += "-";
                    break;
            }
            if (options & (1 << 0)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "DT" : "DOUBLE TAP", Exploit.GetCharge() == 1 || (Indicators.Alpha['Double tap'] < 220 && !GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap")) ? [140, 200, 0, Indicators.Alpha['Double tap']] : [255, 60, 30, Indicators.Alpha['Double tap']])
                if (Indicators.Alpha['Double tap'] !== 0)
                    offset++;
                if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Double tap")) {
                    Indicators.Alpha['Double tap'] = Math.min(220, Indicators.Alpha["Double tap"] + t);
                }
                else {
                    Indicators.Alpha['Double tap'] = Math.max(0, Indicators.Alpha["Double tap"] - t);
                }
            }
            if (options & (1 << 1)) {
                Visuals.Text(center_screen[0] + (short ? 0 : -1), center_screen[1] + offset * offset_size, flags, short ? "HS" : "HIDESHOTS", [80, 130, 230, Indicators.Alpha["Hide shots"]])
                if (Indicators.Alpha["Hide shots"] !== 0)
                    offset++;
                if (GUI.GetValue(["Rage", "Exploits", "Keys", "Key assignment"], "Hide shots")) {
                    Indicators.Alpha["Hide shots"] = Math.min(220, Indicators.Alpha["Hide shots"] + t);
                }
                else {
                    Indicators.Alpha["Hide shots"] = Math.max(0, Indicators.Alpha["Hide shots"] - t);
                }
            }
            if (options & (1 << 2)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "DMG" : "DAMAGE OVERRIDE", [80, 80, 230, Indicators.Alpha['Damage override']])
                if (Indicators.Alpha['Damage override'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Minimum damage override")) {
                    Indicators.Alpha['Damage override'] = Math.min(220, Indicators.Alpha['Damage override'] + t);
                }
                else {
                    Indicators.Alpha['Damage override'] = Math.max(0, Indicators.Alpha['Damage override'] - t);
                }
            }
            if (options & (1 << 3)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "FD" : "FAKE DUCK", [130, 80, 230, Indicators.Alpha['Fake duck']])
                if (Indicators.Alpha['Fake duck'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Fake duck")) {
                    Indicators.Alpha['Fake duck'] = Math.min(220, Indicators.Alpha['Fake duck'] + t);
                }
                else {
                    Indicators.Alpha['Fake duck'] = Math.max(0, Indicators.Alpha['Fake duck'] - t);
                }
            }
            if (options & (1 << 4)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "INV" : "INVERTER", [230, 230, 230, Indicators.Alpha['Inverter']])
                if (Indicators.Alpha['Inverter'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "AA Direction inverter")) {
                    Indicators.Alpha['Inverter'] = Math.min(220, Indicators.Alpha['Inverter'] + t);
                }
                else {
                    Indicators.Alpha['Inverter'] = Math.max(0, Indicators.Alpha['Inverter'] - t);
                }
            }
            if (options & (1 << 5)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "SP" : "SAFE POINTS", [80, 230, 180, Indicators.Alpha['Safe points']])
                if (Indicators.Alpha['Safe points'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Force safe point")) {
                    Indicators.Alpha['Safe points'] = Math.min(220, Indicators.Alpha['Safe points'] + t);
                }
                else {
                    Indicators.Alpha['Safe points'] = Math.max(0, Indicators.Alpha['Safe points'] - t);
                }
            }
            if (options & (1 << 6)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "BAIM" : "BODY AIM", [230, 80, 60, Indicators.Alpha['Body aim']])
                if (Indicators.Alpha['Body aim'] !== 0)
                    offset++;
                if (GUI.GetValue(p.rage, "Force body aim")) {
                    Indicators.Alpha['Body aim'] = Math.min(220, Indicators.Alpha['Body aim'] + t);
                }
                else {
                    Indicators.Alpha['Body aim'] = Math.max(0, Indicators.Alpha['Body aim'] - t);
                }
            }
            if (options & (1 << 7)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "FS" : "FREESTAND", [0, 230, 230, Indicators.Alpha['Freestanding']])
                if (Indicators.Alpha['Freestanding'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Freestanding")) {
                    Indicators.Alpha['Freestanding'] = Math.min(220, Indicators.Alpha['Freestanding'] + t);
                }
                else {
                    Indicators.Alpha['Freestanding'] = Math.max(0, Indicators.Alpha['Freestanding'] - t);
                }
            }
            if (options & (1 << 8)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "SM" : "SLOWMOTION", [230, 100, 180, Indicators.Alpha['Slow walk']])
                if (Indicators.Alpha['Slow walk'] !== 0)
                    offset++;
                if (GUI.GetValue(p.antiaim_keys, "Slow walk")) {
                    Indicators.Alpha['Slow walk'] = Math.min(220, Indicators.Alpha['Slow walk'] + t);
                }
                else {
                    Indicators.Alpha['Slow walk'] = Math.max(0, Indicators.Alpha['Slow walk'] - t);
                }
            }
            if (options & (1 << 9)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "AP" : "AUTO PEEK", [230, 180, 130, Indicators.Alpha['Auto peek']])
                if (Indicators.Alpha['Auto peek'] !== 0)
                    offset++;
                if (GUI.GetValue(["Misc.", "Keys", "Keys", "Key assignment"], "Auto peek")) {
                    Indicators.Alpha['Auto peek'] = Math.min(220, Indicators.Alpha['Auto peek'] + t);
                }
                else {
                    Indicators.Alpha['Auto peek'] = Math.max(0, Indicators.Alpha['Auto peek'] - t);
                }
            }
            if (options & (1 << 10)) {
                Visuals.Text(center_screen[0], center_screen[1] + offset * offset_size, flags, short ? "EJ" : "EDGE JUMP", [230, 180, 60, Indicators.Alpha['Edge jump']])
                if (Indicators.Alpha['Edge jump'] !== 0)
                    offset++;
                if (GUI.GetValue(["Misc.", "Keys", "Keys", "Key assignment"], "Edge jump")) {
                    Indicators.Alpha['Edge jump'] = Math.min(220, Indicators.Alpha['Edge jump'] + t);
                }
                else {
                    Indicators.Alpha['Edge jump'] = Math.max(0, Indicators.Alpha['Edge jump'] - t);
                }
            }

            if (options & (1 << 11)) {
                var c = Northwood.GetColor();
                c[3] = 255;
                Visuals.Text(center_screen[0], center_screen[1] + 13, flags, "FAKE YAW", c)
                var w = Math.ceil(Math.min(60, Math.abs(Fakepanel.Delta)) / 1.3);
                Render.GradientRect(center_screen[0] - w, center_screen[1] + 29, w, 3, 1, [c[0], c[1], c[2], 0], c);
                Render.GradientRect(center_screen[0], center_screen[1] + 29, w, 3, 1, c, [c[0], c[1], c[2], 0]);
            }
        }
    },
    CreateMove: function() {
        if (Globals.ChokedCommands() == 0) {
            if (Indicators.last_origin != Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")) {
                Indicators.last_origin_sqr = Indicators.last_origin[0] * Indicators.last_origin[0] + Indicators.last_origin[1] * Indicators.last_origin[1];
                Indicators.origin_sqr = Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[0] * Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[0] + Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[1] * Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin")[1];
                Indicators.last_origin = Entity.GetProp(Entity.GetLocalPlayer(),"DT_BasePlayer", "m_vecOrigin");
            }
        }
    }
}
Cheat.RegisterCallback("bomb_beginplant", "Indicators.OnPlanting")
Cheat.RegisterCallback("bomb_abortplant", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("bomb_planted", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("round_prestart", "Indicators.OnAbortPlanting")
Cheat.RegisterCallback("client_disconnect", "Indicators.OnAbortPlanting")

Cheat.RegisterCallback("bomb_begindefuse", "Indicators.OnDefusing")
Cheat.RegisterCallback("round_prestart", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_abortdefuse", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_exploded", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("bomb_defused", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("client_disconnect", "Indicators.OnAbortDefusing")
Cheat.RegisterCallback("Draw", "Indicators.Draw")
Cheat.RegisterCallback("CreateMove", "Indicators.CreateMove")

/*
* Section: Utilities
*/

var Watermark = {
    Load: function() {
        GUI.SetEnabled(p.script_ui, "Watermark", 0);
        GUI.SetValue(p.script_ui, "Watermark", 0);
        UI.AddCheckbox(p.script_ui, "[NW] Watermark");
        UI.AddDropdown(p.script_ui, "Watermark style", ["northwood", "onetap", "onetap.com"], 0);
        UI.AddTextbox(p.script_ui, "Watermark username");
        if (Northwood.Get("watermark:unlock_prefix") == "true")
            UI.AddTextbox(p.script_ui, "Watermark prefix")
        if (Northwood.Get("watermark:unlock_suffix") == "true")
            UI.AddTextbox(p.script_ui, "Watermark suffix")
        UI.AddCheckbox(p.script_ui, "Fade at top");
    },
    GradientBar: function() {
        if (!GUI.GetValue(p.script_ui, "Fade at top"))
            return;

        var c = Northwood.GetFade();
        Render.GradientRect(0, 0, screen_size[0] / 2, 3, 1, c[0], c[1]);
        Render.GradientRect(screen_size[0] / 2, 0, screen_size[0] / 2, 3, 1, c[1], c[2]);
        Render.FilledRect(0, 1, screen_size[0], 1, [0, 0, 0, 20]);
        Render.FilledRect(0, 2, screen_size[0], 1, [0, 0, 0, 40]);
    },
    Draw: function() {
        if (!GUI.GetValue(p.script_ui, "[NW] Watermark"))
            return;

        var prefix;
        switch (GUI.GetValue(p.script_ui, "Watermark style")) {
            case 0:
                prefix = "northwood"
                break;
            case 1:
                prefix = "onetap"
                break;
            case 2:
                prefix = "onetap.com"
                break;
        }
        if (Northwood.Get("watermark:unlock_prefix") == "true" && GUI.GetString(p.script_ui, "Watermark prefix") != "")
            prefix = GUI.GetString(p.script_ui, "Watermark prefix");
        if (Northwood.Get("watermark:unlock_suffix") == "true" && GUI.GetString(p.script_ui, "Watermark suffix") != "")
            prefix += " ["+GUI.GetString(p.script_ui, "Watermark suffix")+"]"

        var username = GUI.GetString(p.script_ui, "Watermark username") == "" ? Cheat.GetUsername() : GUI.GetString(p.script_ui, "Watermark username")

        var today = new Date()
        today = today.toTimeString().substring(0, 8)

        if (typeof prefix == "Symbol") {
            prefix = prefix.toString();
            prefix = prefix.replace("Symbol(")
            prefix = prefix.replace(")")
        }

        if (typeof username == "Symbol") {
            username = username.toString();
            username = username.replace("Symbol(")
            username = username.replace(")")
        }

        if (!World.GetServerString())
            var text = String.format("{0} | {1} | {2}", prefix, username, today)
        else
            var text = String.format("{0} | {1} | delay: {2}ms | {3}tick | {4}", prefix, username, Math.floor(Entity.GetProp(Entity.GetLocalPlayer(), "CPlayerResource", "m_iPing")), Globals.Tickrate(), today)

        var off = Northwood.I_Offset;
        var c = Northwood.GetColor()
        var w = Math.floor(Render.TextSize(text, Visuals.Fonts()[1])[0])
        var x = size[0] - w - 14
        switch (Northwood.GetStyle()) {
            case 0:
                Render.GradientRect(x - 4, 8 + 22 * off, Math.floor((w + 8) / 2), 2, 1, [c[0], c[1], c[2], 255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio")], [c[0], c[1], c[2], 255])
                Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), 8 + 22 * off, Math.floor((w + 8) / 2) + 1, 2, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio")])
                break;
            case 1:
                var fc = Northwood.GetFade();
                Render.FilledRect(x - 4, 8 + 22 * off, w + 8, 2, [0,0,0,255])
                Render.GradientRect(x - 4, 8 + 22 * off, Math.ceil((w + 8) / 2), 2, 1, fc[0], fc[1])
                Render.GradientRect(x - 4 + Math.ceil((w + 8) / 2), 8 + 22 * off, Math.floor((w + 8) / 2), 2, 1, fc[1], fc[2])
                Render.FilledRect(x - 4, 9 + 22 * off, w + 8, 1, [0,0,0,40])
                break;
        }

        Render.GradientRect(x - 4, 10 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), 10 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])

        Visuals.Text(x, 11 + 22 * off, "", text, [255, 255, 255, 255]);
        Northwood.I_Offset++;
    }
}

Watermark.Load();
Cheat.RegisterCallback("Draw", "Watermark.Draw")
Cheat.RegisterCallback("Draw", "Watermark.GradientBar")

/*
* Section: Fakepanel
*/

var Fakepanel = {
    Load: function() {
        UI.AddCheckbox(p.script_ui, "[NW] Fake yaw panel");
        UI.AddCheckbox(p.script_ui, "[NW] Fake lag panel");
    },
    SetPrev: false,
    Delta: 0,
    CreateMove: function() {
        if (Globals.ChokedCommands() != 0)
            return;


        var Delto = normalize_yaw(Local.GetRealYaw() - Local.GetFakeYaw())
        if (Math.abs(Delto - Fakepanel.Delta) > 3 && !Fakepanel.SetPrev) {
            Fakepanel.SetPrev = true
        }
        else {
            Fakepanel.SetPrev = false
            Fakepanel.Delta = Delto
        }

        //Cheat.Print(String.format("Delto: {0} SetPrev: {1} Delta: {2}\n", Delto, Fakepanel.SetPrev, Fakepanel.Delta))
    },
    Color: function(delta) {
        return [255 - Math.min(58, delta)*2.3682, Math.min(58, delta)*3.4210, Math.min(58, delta)*0.22807, 255]
    },
    Draw: function() {
        if (!World.GetServerString() || !Entity.IsAlive(Entity.GetLocalPlayer()) || (!GUI.GetValue(p.script_ui, "[NW] Fake yaw panel") && !GUI.GetValue(p.script_ui, "[NW] Fake lag panel")))
            return;
        if (!GUI.GetValue(p.script_ui, "[NW] Fake lag panel")) {
            var side = "-";

            if ((Fakepanel.Delta > 1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) > 60)))
                side = "<"
            else if ((Fakepanel.Delta < -1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) < 60)))
                side = "<"
            else if ((Fakepanel.Delta < -1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) > 60)))
                side = ">"
            else if ((Fakepanel.Delta > 1 && (Math.abs(normalize_yaw(Local.GetViewAngles()[1] - Local.GetRealYaw())) < 60)))
                side = ">"

            var text = String.format("FAKE ({0} ) | safety: {1}% | side: {2}", Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1), Math.abs(Math.floor(Math.min(Math.abs(Fakepanel.Delta), 116) / 116 * 100)), side)
        }
        else {
            var text = String.format("FAKE ({0} )",  Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1))
            if (Globals.Tickcount() < Indicators.Air_tickcount + 3 || Exploit.GetCharge() == 1)
                var text_fl = String.format("FL: {0} | {1}", choked_max, (Exploit.GetCharge() == 1 ? "SHIFTING " : "dst:        "))
            else
                var text_fl = String.format("FL: {0}", choked_max)
        }
        var off = Northwood.I_Offset;
        var w = Render.TextSize(text, Visuals.Fonts()[1])[0] + 5
        var x = screen_size[0] - 10 - w - (GUI.GetValue(p.script_ui, "[NW] Fake lag panel") ? Render.TextSize(text_fl, Visuals.Fonts()[1])[0] + 15 : 0)
        var a = Northwood.GetColor()[3]
        if (GUI.GetValue(p.script_ui, "[NW] Fake yaw panel")) {
            Render.GradientRect(x - 6, 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
            Render.GradientRect(x - 6 + Math.floor((w + 8) / 2), 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
            var color = Northwood.Utils.StatusColor(Math.abs(Fakepanel.Delta), 60);
            Render.GradientRect(x-8, 13 + 22 * off, 2, 8, 0, color.concat(50), color.concat(255));
            Render.GradientRect(x-8, 21 + 22 * off, 2, 9, 0, color.concat(255), color.concat(50));
            Visuals.Text(x-2, 14 + 22 * off, "", text, [255, 255, 255, 255])
            Render.Circle(x + Render.TextSize(String.format("FAKE ({0}",  Math.min(Math.abs(Fakepanel.Delta), 60).toFixed(1)), Visuals.Fonts()[1])[0], 18 + 22 * off, 1, [255, 255, 255, 255])
        }
        Northwood.I_Offset++;
        if (GUI.GetValue(p.script_ui, "[NW] Fake lag panel")) {
            w = Render.TextSize(text_fl, Visuals.Fonts()[1])[0] + 5
            x = screen_size[0] - 10 - w
            a = Northwood.GetColor()[3]
            var c = [180, 190, 190]
            if (Exploit.GetCharge() == 1)
                c = [255, 150, 0]
            Render.GradientRect(x - 5, 13 + 22 * off, Math.floor((w) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
            Render.GradientRect(x - 5 + Math.floor((w) / 2), 13 + 22 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
            Render.GradientRect(x - 5, 30 + 22 * off, Math.floor((w) / 2), 1, 1, [c[0], c[1], c[2], 0], [c[0], c[1], c[2], 255])
            Render.GradientRect(x - 5 + Math.floor((w) / 2), 30 + 22 * off, Math.floor((w + 8) / 2), 1, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 0])
            //Cheat.Print(Indicators.Air_tickcount.toString())
            if (Exploit.GetCharge() != 1 && Globals.Tickcount() < Indicators.Air_tickcount + 2) {
                c = Northwood.GetColor()
                var add_w = Render.TextSize(String.format("FL: {0} | {1}", choked_max, "dst: "), Visuals.Fonts()[1])[0];
                Render.GradientRect(x - 1 + add_w, 19 + 22 * off, Math.min(25, (Math.abs(Indicators.last_origin_sqr - Indicators.origin_sqr) / 10) / 1024), 6, 1, [c[0], c[1], c[2], 255], [c[0], c[1], c[2], 0])
            }
            Visuals.Text(x - 1, 14 + 22 * off, "", text_fl, [255, 255, 255, 255])
        }
    },
}

Fakepanel.Load()
Cheat.RegisterCallback("Draw", "Fakepanel.Draw")
Cheat.RegisterCallback("CreateMove", "Fakepanel.CreateMove")

var Performance = {
    Freq: (Northwood.Get("performance:freq") == "" ? 60 : parseInt(Northwood.Get("performance:freq"))),
    RequestTime: Globals.Curtime(),
    Frametime: Globals.Frametime(),
    Frametimes: [],
    Load: function() {
        UI.AddCheckbox(p.script_ui, "[NW] Performance panel");
    },
    Draw: function() {
        if (!World.GetServerString() || !GUI.GetValue(p.script_ui, "[NW] Performance panel"))
            return;

        if (Performance.RequestTime + 1 < Globals.Curtime()) {
            Performance.Frametime = Globals.Frametime()
            Performance.RequestTime = Globals.Curtime()
            Performance.Frametimes.unshift(Performance.Frametime)
            if (Performance.Frametimes.length > 4)
                Performance.Frametimes.pop()
        } 
        var off = Northwood.I_Offset;
        var text_ie = "IO | ";
        var text_freq = String.format("{0}ms / {1}hz", Math.abs((Performance.Frametime * 1000).toFixed(1)), Performance.Freq)
        var y = 8
        var w = Render.TextSize(text_ie, Visuals.Fonts()[1])[0] + 24
        var x = screen_size[0] - 24 - w - Render.TextSize(text_freq, Visuals.Fonts()[1])[0]
        Render.GradientRect(x - 4, y + 28 * off, Math.floor((w + 4) /2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 4) /2), y + 28 * off, Math.floor((w + 4) /2), 17, 1, Northwood.GetBackground()[1], Northwood.GetBackground()[0])
        //Render.FilledRect(x - 4, y + 28 * off, w + 4, 17, [17, 17, 17, Northwood.GetColor()[3]])
        Visuals.Text(x, y+1 + 28 * off, "", text_ie, [255, 255, 255, 255])

        for (var i in Performance.Frametimes) {
            var ft = Performance.Frametimes[i]
            var c = Northwood.GetColor()
            Render.GradientRect(x + w - 9 - (5 * i), y + 28 * off + 14 - Math.floor(Math.min(12, ft / 1 * 1000)), 5, Math.floor(Math.min(12, ft / 1 * 1000)), 0, [c[0], c[1], c[2], 0], [c[0], c[1], c[2], 255])
        }

        w = Render.TextSize(text_freq, Visuals.Fonts()[1])[0]
        x = screen_size[0] - 10 - w - 4
        var c = [0, 255, 0]
        var ft = Performance.Frametime * 1000
        if (ft > 15)
            c = [255, 0, 0]
        else if (ft > 12)
            c = [255, 170, 0]
        else if (ft > 10)
            c = [255, 255, 0]
        else if (ft > 7.5)
            c = [150, 255, 0]
        else if (ft > 5)
            c = [70, 255, 0]

        Render.GradientRect(x - 4, y+ 28 * off, Math.floor((w + 8) / 2), 17, 1, Northwood.GetBackground()[0], Northwood.GetBackground()[1])
        Render.GradientRect(x - 4 + Math.floor((w + 8) / 2), y + 28 * off, Math.floor((w + 8) / 2), 17, 1,  Northwood.GetBackground()[1], Northwood.GetBackground()[0])
        //Render.FilledRect(x - 4, y+ 28 * off, w + 8, 17, [17, 17, 17, Northwood.GetColor()[3]])
        Visuals.Text(x, y+1+ 28 * off, "", text_freq, [255, 255, 255, 255])
        Render.GradientRect(x - 4, y+17+ 28 * off, w / 2 + 4, 1, 1, c.concat(0), c.concat(255))
        Render.GradientRect(x + w / 2, y+17+ 28 * off, w / 2 + 4, 1, 1, c.concat(255), c.concat(0))
        Northwood.I_Offset++;
    },
}

Performance.Load()
Cheat.RegisterCallback("Draw", "Performance.Draw")

function in_bounds(vec, x, y, x2, y2) {
    return (vec[0] > x) && (vec[1] > y) && (vec[0] < x2) && (vec[1] < y2)
}

function isEquals(element, index, array, text) {
    if (element.text == text)
        return true;
} 

if (!Array.prototype.find) {
    Object.defineProperty(Array.prototype, 'find', {
      value: function(predicate) {
       // 1. Let O be ? ToObject(this value).
        if (this == null) {
          throw new TypeError('"this" is null or not defined');
        }
 
        var o = Object(this);
 
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = o.length >>> 0;
 
        // 3. If IsCallable(predicate) is false, throw a TypeError exception.
        if (typeof predicate !== 'function') {
          throw new TypeError('predicate must be a function');
        }
 
        // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
        var thisArg = arguments[1];
 
        // 5. Let k be 0.
        var k = 0;
 
        // 6. Repeat, while k < len
        while (k < len) {
          // a. Let Pk be ! ToString(k).
          // b. Let kValue be ? Get(O, Pk).
          // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
          // d. If testResult is true, return kValue.
          var kValue = o[k];
          if (predicate.call(thisArg, kValue, k, o, arguments[1])) {
            return kValue;
          }
          // e. Increase k by 1.
          k++;
        }
 
        // 7. Return undefined.
        return undefined;
      },
      configurable: true,
      writable: true
    });
  }

var Hotkeys = {
    GRABBED: false,
    GRAB_X: 0,
    GRAB_Y: 0,
    GLOBAL_ALPHA: 0,
    MAX_WIDTH: 100,
    CUR_WIDTH: 100,
    active_list: new Array(),
    items_list: new Array(),
    Load: function() {
        GUI.SetEnabled(p.script_ui, "Show keybind states", 0);
        GUI.SetValue(p.script_ui, "Show keybind states", 0);
        UI.AddCheckbox(p.script_ui, "[NW] Keybinds");
        UI.AddSliderFloat(p.script_ui, "Keybinds split ratio", 0, 1)
        UI.AddSliderInt(p.script_ui, "Keybinds X", 0, screen_size[0])
        UI.AddSliderInt(p.script_ui, "Keybinds Y", 0, screen_size[1])
        GUI.SetEnabled(p.script_ui, "Keybinds X", 0)
        GUI.SetEnabled(p.script_ui, "Keybinds Y", 0)

        this.items_list.push({text: "Menu key", func: UI.IsMenuOpen, path: "nil", name: "nil", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Double tap", func: GUI.GetValue, path: ["Rage", "Exploits", "Keys", "Key assignment"], name: "Double tap", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "On shot anti-aim", func: GUI.GetValue, path: ["Rage", "Exploits", "Keys", "Key assignment"], name: "Hide shots", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force safe point", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force safe point", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Rage bot", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Ragebot activation", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Resolver override", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Resolver override", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force body aim", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force body aim", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force head aim", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force head aim", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Force safe point", func: GUI.GetValue, path: ["Rage", "General", "General", "Key assignment"], name: "Force safe point", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Mouse direction", func: GUI.GetValue, path: p.antiaim_keys, name: "Mouse direction", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Jitter anti-aim", func: GUI.GetValue, path: p.antiaim_keys, name: "Jitter", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Slow motion", func: GUI.GetValue, path: p.antiaim_keys, name: "Slow walk", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Anti-aim inverter", func: GUI.GetValue, path: p.antiaim_keys, name: "AA Direction inverter", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Duck peek assist", func: GUI.GetValue, path: p.antiaim_keys, name: "Fake duck", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Freestanding", func: GUI.GetValue, path: p.antiaim_keys, name: "Freestanding", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Edge jump", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Edge jump", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Free look", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Freecam", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Quick peek assist", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Auto peek", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Zoom", func: GUI.GetValue, path: ["Misc.", "Keys", "Keys", "Key assignment"], name: "Zoom", status: "[~]", alpha: 0, active: false})
        this.items_list.push({text: "Damage override", func: GUI.GetValue, path: p.rage, name: "Minimum damage override", status: "[~]", alpha: 0, active: false})
    },
    Grabbing: function(x, y, w) {
        if (Global.IsKeyPressed(1) && UI.IsMenuOpen()) {
            const mouse_pos = Global.GetCursorPosition();
            if (in_bounds(mouse_pos, x, y, x + w, y + 22)) {
                if (!Hotkeys.GRABBED) {
                    Hotkeys.GRAB_X = mouse_pos[0] - x;
                    Hotkeys.GRAB_Y = mouse_pos[1] - y;
                }
                Hotkeys.GRABBED = true;
            }
        }
        else {
            Hotkeys.GRABBED = false;
        }

        if (Hotkeys.GRABBED) {
            GUI.SetValue(p.script_ui, "Keybinds X", mouse_pos[0] - Hotkeys.GRAB_X)
            GUI.SetValue(p.script_ui, "Keybinds Y", mouse_pos[1] - Hotkeys.GRAB_Y)
        }
    },
    HandleItems: function() {
        if (Hotkeys.active_list.length == 0)
            Hotkeys.MAX_WIDTH = 100;

        var t = Globals.Frametime() * 8 * 255

        for (var i=0; i < Hotkeys.items_list.length; i++) {
            var elem = Hotkeys.items_list[i];
            if (elem.path != "nil" && UI.GetHotkeyState(GUI.GetPath(elem.path, elem.name)) == "Always")
                continue;
            if (elem.func(elem.path, elem.name)) {
                elem.active = true;
                var elem_w = Render.TextSize(elem.text, Visuals.Fonts()[1])[0]
                if (elem_w + 80 > this.MAX_WIDTH)
                    this.MAX_WIDTH = elem_w + 80
                if (elem.alpha < 255)
                    elem.alpha = Math.min(255, elem.alpha + t)
                if (Hotkeys.active_list.indexOf(elem.text) == -1)
                    Hotkeys.active_list.push(elem.text)
            }
            else {
                if (elem.alpha > 0)
                    elem.alpha = Math.max(0, elem.alpha - t)
                else {
                    elem.active = false
                    var index = Hotkeys.active_list.indexOf(elem.text)
                    if (index !== -1) {
                        Hotkeys.active_list.splice(index, 1)
                        if (Hotkeys.active_list.length > 0)
                            this.MAX_WIDTH = 100
                    }
                }
            }
        }
        var active = false
        if (Hotkeys.active_list.length == 1) {
            //x => x.text == Hotkeys.active_list[0]
            var a_elem = Hotkeys.items_list.find(isEquals, Hotkeys.active_list[0]);
            if (!a_elem.func(a_elem.path, a_elem.name))
                active = true;
        }

        if (Hotkeys.active_list.length == 0 || active) {
            if (Hotkeys.GLOBAL_ALPHA > 0)
                this.GLOBAL_ALPHA = Math.max(0, this.GLOBAL_ALPHA - t)
        }
        else {
            if (Hotkeys.GLOBAL_ALPHA < 255)
                Hotkeys.GLOBAL_ALPHA = Math.min(255, Hotkeys.GLOBAL_ALPHA + t)
        }

        if (this.CUR_WIDTH > this.MAX_WIDTH)
            this.CUR_WIDTH = Math.max(this.CUR_WIDTH - t / 2, this.CUR_WIDTH - (this.CUR_WIDTH - this.MAX_WIDTH))
        else if (this.CUR_WIDTH < this.MAX_WIDTH)
            this.CUR_WIDTH = Math.min(this.CUR_WIDTH + t / 2, this.CUR_WIDTH + (this.MAX_WIDTH - this.CUR_WIDTH))
    },
    CalcAlpha: function(alpha) {
        return Math.min(this.GLOBAL_ALPHA, alpha);
    },
    GetStatus: function(path, name) {
        var status = "[~]"
        if (path == "nil")
            return status;
        switch (UI.GetHotkeyState(GUI.GetPath(path, name))) {
            case "Toggle":
                status = "[toggled]";
                break;
            case "Hold":
                status = "[holding]";
                break;
            case "Always":
                status = "[enabled]";
                break;
        }
        return status;       
    },
    Draw: function() {
        if (!GUI.GetValue(p.script_ui, "[NW] Keybinds") || !World.GetServerString())
            return;

        Hotkeys.HandleItems();

        var x = GUI.GetValue(p.script_ui, "Keybinds X")
        var y = GUI.GetValue(p.script_ui, "Keybinds Y")
        var c = Northwood.GetColor()
        var w = Hotkeys.CUR_WIDTH;
        switch (Northwood.GetStyle()) {
            case 0:
                Render.GradientRect(x, y-2, Math.floor(w / 2), 2, 1, [c[0], c[1], c[2], Hotkeys.CalcAlpha(255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio"))], [c[0], c[1], c[2], Hotkeys.CalcAlpha(255)])
                Render.GradientRect(x + Math.floor(w / 2), y-2, Math.floor(w / 2), 2, 1, [c[0], c[1], c[2], Hotkeys.CalcAlpha(255)], [c[0], c[1], c[2], Hotkeys.CalcAlpha(255 * GUI.GetValue(p.script_ui, "[NW] Fade split ratio"))])
                break;
            case 1:
                var fc = Northwood.GetFade();
                Render.FilledRect(x, y-2, w-1, 2, [0, 0, 0, Hotkeys.CalcAlpha(255)])
                /*Render.GradientRect(x - 4, 8, Math.floor((w + 8) / 2), 2, 1,  [fc[0][0], fc[0][1], fc[0][2], Hotkeys.CalcAlpha(fc[0][3])], [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])])
                Render.GradientRect(x - 4 + Math.floor((w + 7) / 2), 8, Math.floor((w + 8) / 2) + 1, 2, 1, [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])], [fc[2][0], fc[2][1], fc[2][2], Hotkeys.CalcAlpha(fc[2][3]))*/
                Render.GradientRect(x, y-2, Math.floor(w / 2), 2, 1, [fc[0][0], fc[0][1], fc[0][2], Hotkeys.CalcAlpha(fc[0][3])], [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])])
                Render.GradientRect(x + Math.floor(w / 2), y-2, Math.floor(w / 2), 2, 1, [fc[1][0], fc[1][1], fc[1][2], Hotkeys.CalcAlpha(fc[1][3])], [fc[2][0], fc[2][1], fc[2][2], Hotkeys.CalcAlpha(fc[2][3])])
                Render.FilledRect(x, y-1, w, 1, [0, 0, 0, Hotkeys.CalcAlpha(40)])
                break;
        }
        Render.FilledRect(x, y, w, 17, [17, 17, 17, Hotkeys.CalcAlpha(c[3])])
        Visuals.Text(x + w/2, y+1, "c", "keybinds", [255, 255, 255, Hotkeys.CalcAlpha(255)])
        Hotkeys.Grabbing(x, y, w);

        for(var i=0; i < Hotkeys.active_list.length; i++) {
            var elem = Hotkeys.items_list.find(isEquals, Hotkeys.active_list[i]);
            var status = Hotkeys.GetStatus(elem.path, elem.name);
            if (elem.active && status != "[enabled]") {
                Render.FilledRect(x, y + 17 + (17*i), w, 17, [17, 17, 17, Hotkeys.CalcAlpha(Math.min(elem.alpha, c[3] * GUI.GetValue(p.script_ui, "Keybinds split ratio")))])
                Visuals.Text(x + 4, y + 17 + (17*i), "", elem.text, [255, 255, 255, Hotkeys.CalcAlpha(elem.alpha)])
                Visuals.Text(x + w - Render.TextSize(status, Visuals.Fonts()[1])[0] - 4, y + 17 + (17*i), "", status, [255, 255, 255, Hotkeys.CalcAlpha(elem.alpha)])
            }
        }
    },
}

Hotkeys.Load();
Cheat.RegisterCallback("Draw", "Hotkeys.Draw")

/*
* Section: Ragebot
*/

function VectorAngles(forward)
{
    var angles;
    var tmp, yaw, pitch;
    
    if (forward[1] == 0 && forward[0] == 0)
    {
        yaw = 0;
        if (forward[2] > 0)
            pitch = 270;
        else
            pitch = 90;
    }
    else
    {
        yaw = (Math.atan2(forward[1], forward[0]) * 180 / Math.PI);
        if (yaw < 0)
            yaw += 360;
        tmp = Math.sqrt (forward[0]*forward[0] + forward[1]*forward[1]);
        pitch = (Math.atan2(-forward[2], tmp) * 180 / Math.PI);
        if (pitch < 0)
            pitch += 360;
    }
    
    x = pitch;
    y = yaw;
    z = 0;
    angles = [x,y,z];
    
    return angles;
}
function can_shoot(Player){
    var index = Entity.GetWeapon(Player)
    var classid = Entity.GetClassID(index);
    
    var weapon =  classid == 107 || classid == 108 || classid == 96 || classid == 99 || classid ==112 || classid == 155 || classid == 47 || classid == 267;//checking if the selected weapon is knife or nade
    var clip = Entity.GetProp(index, "DT_BaseCombatWeapon", "m_iClip1");
    
    if(weapon || clip == 0 || UserCMD.GetButtons() & (1 << 1))//check if player is jumping or as an empty mag
        return false;
    return true;
}

var weaponNames = {
    "usp s": "USP", "glock 18": "Glock", "dual berettas": "Dualies", "r8 revolver": "Revolver", "desert eagle": "Deagle", "p250": "P250", "tec 9": "Tec-9",
    "mp9": "MP9", "mac 10": "Mac10", "pp bizon": "PP-Bizon", "ump 45": "UMP45", "ak 47": "AK47", "sg 553": "SG553", "aug": "AUG", "m4a1 s": "M4A1-S", "m4a4": "M4A4", "ssg 08": "SSG08",
    "awp": "AWP", "g3sg1": "G3SG1", "scar 20": "SCAR20", "xm1014": "XM1014", "mag 7": "MAG7", "m249": "M249", "negev": "Negev", "p2000": "P2000", "famas": "FAMAS", "five seven": "Five Seven", "mp7": "MP7",
    "ump 45": "UMP45", "p90": "P90", "cz75 auto": "CZ-75", "mp5 sd": "MP5", "galil ar": "GALIL", "sawed off": "Sawed off", "nova": "Nova"
};

for (var name in weaponNames) {
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Delay shot")
    UI.AddMultiDropdown(["Rage", "Target", weaponNames[name]], "Avoid unsafe hitboxes", ["Head", "Chest", "Stomach", "Arms", "Legs", "Feet"])
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Force body aim on peek")
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Damage override", 0, 130)
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Hitchance override", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override no scope hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "No scope hitchance", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override in air hitchance");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "In air hitchance", 0, 100);
    UI.AddCheckbox(["Rage", "Target", weaponNames[name]], "Override double tap damage");
    UI.AddSliderInt(["Rage", "Target", weaponNames[name]], "Double tap damage", 0, 130);
}

UI.AddHotkey(p.rage_keys, "Force head aim", "Force head aim")
UI.AddHotkey(p.rage_keys, "Minimum damage override", "Damage override")
//UI.AddHotkey(p.rage_keys, "Dormant aimbot", "Dormant aimbot")

var Rage = {
    OldTime: Globals.Realtime(),
    /*DormantAimbot: function() {
        if (!Tickbase.CanShift(1) || !UI.GetValue(["Rage", "General", "General", "Key assignment", "Dormant aimbot"]))
            return;

        var enemies = Entity.GetEnemies()
        var d = enemies.filter(function(e){
            return Entity.IsDormant(e) && Entity.IsAlive(e) && Trace.Bullet(Entity.GetLocalPlayer(), e, Entity.GetEyePosition(Entity.GetLocalPlayer()), VectorAdd(Entity.GetRenderOrigin(e), [0, 0, 45]))[1] > 1
        })
        var c = d.sort(function(a, b){
            return Trace.Bullet(Entity.GetLocalPlayer(), a, Entity.GetEyePosition(Entity.GetLocalPlayer()), va(Entity.GetRenderOrigin(a), [0, 0, 45]))[1] - Trace.Bullet(Entity.GetLocalPlayer(), b, Entity.GetEyePosition(Entity.GetLocalPlayer()), va(Entity.GetRenderOrigin(b), [0, 0, 45]))[1]
        })[0]

        if(!c) return;
        Cheat.Print("Target found\n");
        var weapon_index = Entity.GetWeapon(Entity.GetLocalPlayer()); 
        
        var viewangle = VectorAngles(VectorSubtract(VectorAdd(Entity.GetRenderOrigin(c), [0, 0, 45]),Entity.GetEyePosition(Entity.GetLocalPlayer())))

        UserCMD.SetViewAngles(viewangle, true)
        UserCMD.SetButtons(UserCMD.GetButtons() | (1 << 0))
        dmg = Trace.Bullet(Entity.GetLocalPlayer(), c, Entity.GetEyePosition(Entity.GetLocalPlayer()), VectorAdd(Entity.GetRenderOrigin(c), [0, 0, 45]))[1]
        Cheat.Print("Dormant fired\n");
    },*/
    CreateMove: function() {
        var target = Ragebot.GetTargets();
        var weaponName = Entity.GetName(Entity.GetWeapon(Entity.GetLocalPlayer()))

        Indicators.Damage = (weaponNames.hasOwnProperty(weaponName)) ? GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Damage override") : -1;
        if (weaponNames.hasOwnProperty(weaponName)) {
            for (var i in target) {
                // Hitchance override
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Delay shot") && Globals.ChokedCommands() != 0) {
                    for (var h = 0; h <= 18; h++) {
                            Ragebot.IgnoreTargetHitbox(target[i], h, true);
                    }
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override no scope hitchance") && !Entity.GetProp(Entity.GetLocalPlayer(), "CCSPlayer", "m_bIsScoped")) {
                    Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "No scope hitchance"))
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override in air hitchance") && !(Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer" ,"m_fFlags") & (1 << 0))) {
                    Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "In air hitchance"))
                }

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override double tap damage") && Exploit.GetCharge() == 1) {
                    Ragebot.ForceTargetMinimumDamage(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Double tap damage"))
                }

                // Hitscan override
                if (GUI.GetValue(p.rage_keys, "Minimum damage override")) {
                    Ragebot.ForceTargetMinimumDamage(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Damage override"))

                    if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Override hitchance"))
                        Ragebot.ForceTargetHitchance(target[i], GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Hitchance override"))
                }

                // Avoid unsafe hitboxes
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 0)) {
                    Ragebot.ForceHitboxSafety(0)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 1)) {
                    Ragebot.ForceHitboxSafety(4)
                    Ragebot.ForceHitboxSafety(5)
                    Ragebot.ForceHitboxSafety(6)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 2)) {
                    Ragebot.ForceHitboxSafety(2)
                    Ragebot.ForceHitboxSafety(3)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 3)) {
                    Ragebot.ForceHitboxSafety(13)
                    Ragebot.ForceHitboxSafety(14)
                    Ragebot.ForceHitboxSafety(15)
                    Ragebot.ForceHitboxSafety(16)
                    Ragebot.ForceHitboxSafety(17)
                    Ragebot.ForceHitboxSafety(18)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 4)) {
                    Ragebot.ForceHitboxSafety(7)
                    Ragebot.ForceHitboxSafety(8)
                    Ragebot.ForceHitboxSafety(9)
                    Ragebot.ForceHitboxSafety(10)
                }
                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Avoid unsafe hitboxes") & (1 << 5)) {
                    Ragebot.ForceHitboxSafety(11)
                    Ragebot.ForceHitboxSafety(12)
                } 

                if (GUI.GetValue(["Rage", "Target", weaponNames[weaponName]], "Force body aim on peek") && !GUI.GetValue(p.rage_keys, "Force head aim")) {
                    var velocity = Entity.GetProp(Entity.GetLocalPlayer(), "CBasePlayer", "m_vecVelocity[0]");
                    var speed = Math.sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
                    if (speed > 80) {
                        Ragebot.IgnoreTargetHitbox(target[i], 0)
                        Ragebot.IgnoreTargetHitbox(target[i], 1)
                        Ragebot.IgnoreTargetHitbox(target[i], 2)
                        Ragebot.IgnoreTargetHitbox(target[i], 7)
                        Ragebot.IgnoreTargetHitbox(target[i], 8)
                        Ragebot.IgnoreTargetHitbox(target[i], 9)
                        Ragebot.IgnoreTargetHitbox(target[i], 10)
                        Ragebot.IgnoreTargetHitbox(target[i], 11)
                        Ragebot.IgnoreTargetHitbox(target[i], 12)
                        Ragebot.IgnoreTargetHitbox(target[i], 13)
                        Ragebot.IgnoreTargetHitbox(target[i], 14)
                        Ragebot.IgnoreTargetHitbox(target[i], 15)
                        Ragebot.IgnoreTargetHitbox(target[i], 16)
                        Ragebot.IgnoreTargetHitbox(target[i], 17)
                        Ragebot.IgnoreTargetHitbox(target[i], 18)
                    }
                }

                if (GUI.GetValue(p.rage_keys, "Force head aim")) {
                    for (var h = 2; h <= 18; h++) {
                        Ragebot.IgnoreTargetHitbox(target[i], h, true);
                    }
                }
            }
        }
    },
    Draw: function() {
        if (Rage.OldTime + 0.1 < Globals.Curtime()) {
            Rage.OldTime = Globals.Curtime()
            for (var name in weaponNames) {
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "Hitchance override", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "In air hitchance", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override in air hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "No scope hitchance", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override no scope hitchance"))
                GUI.SetEnabled(["Rage", "Target", weaponNames[name]], "Double tap damage", GUI.GetValue(["Rage", "Target", weaponNames[name]], "Override double tap damage"))
            }
        }
    },
}
Cheat.RegisterCallback("Draw", "Rage.Draw")
Cheat.RegisterCallback("CreateMove", "Rage.CreateMove")

/*
* Section: Welcome message
*/
var latest_load = Northwood.LatestLoad;
nlogs.push([String.format("Welcome, {0}! Northwood " + (Northwood.IsBeta() ? "(Beta) " : "(Release) ") + "loaded successfully.", Cheat.GetUsername()), Globals.Curtime(), 8, 0])
if (latest_load == "") {
    nlogs.push([String.format("You loaded script for the first time. Check #release-info at discord for instructions.", Cheat.GetUsername()), Globals.Curtime(), 15, 0])
}
Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
Cheat.PrintColor([220, 220, 220, 255], "Loaded successfully.\n")
Cheat.PrintColor([220, 220, 220, 255], "            Welcome, "); Cheat.PrintColor([220, 150, 255, 255], Cheat.GetUsername()); Cheat.PrintColor([220, 220, 220, 255], "!\n")
if (latest_load == "") {
    Cheat.PrintColor([220, 220, 220, 255], "            Thank you for purchasing \"Northwood\"!\n")
    Cheat.PrintColor([220, 220, 220, 255], "            You can read more info at #release-info Discord channel\n")
}
else {
    Cheat.PrintColor([220, 220, 220, 255], "            Latest load: "+latest_load+"\n")
}

function Notify_logs() {
    for(var i=0; i<nlogs.length; i++) {
        var j = nlogs[i][1];
        var k = nlogs[i][2];
        var l = nlogs[i][0];
        var time = j + k;
        var time_left = time - Globals.Curtime();
        //if (time >= Globals.Curtime()) {
        if (nlogs[i][3] < 1 && !(time_left < 0.6))
            nlogs[i][3] += Globals.Frametime() * 2;
        
        if (time_left < 0.6)
            nlogs[i][3] -= Globals.Frametime() * 2;
        if (i == 0) {
            if (speed < 1 && !(time_left < 0.6))
                speed += Globals.Frametime() * 4;
            
            /*if (time_left < 0.6)
                speed -= Globals.Frametime() * 4;*/
        
            if (time_left <= 0.01 && nlogs.length > 0)
                speed = 1;
        
            notify(l, Math.floor(speed * 20) + 20, Math.max(Math.min(1, nlogs[i][3]), 0));
        }
        else {
            notify(l, 40 * (i + 1), Math.max(Math.min(1, nlogs[i][3]), 0));
        }
        if (Math.max(Math.min(1, nlogs[i][3])) <= 0)
            nlogs.splice(i, 1);   
        /*}
        else {
            nlogs.splice(i, 1);           
        }*/
    }
    if (nlogs.length == 0)
        speed = 0;
}

Cheat.RegisterCallback("Draw", "Notify_logs");

/*
* Section: Grenade prediction
*/

const grenade_prediction = {
        'nades': [],
        'paths': []
};

const direction_t = {
    'LEFT': 0x0,
    'RIGHT': 0x1,
    'FORWARD': 0x2,
    'BACKWARD': 0x3,
    'UP': 0x4,
    'DOWN': 0x5
};

function extrapolate(a, b, c) {
    var TickInterval = Globals.TickInterval();
    return a[0x0] += b[0x0] * TickInterval * c, a[0x1] += b[0x1] * TickInterval * c, a[0x2] += b[0x2] * TickInterval * c, a;
}

function angle_to_vector(_0x2e6753) {
    var _0x264e09 = Math['sin'](deg2rad(_0x2e6753[0x0]))
    var _0x192a86 = Math['cos'](deg2rad(_0x2e6753[0x0]))
    var _0xb6c43a = Math['sin'](deg2rad(_0x2e6753[0x1]))
    var _0x57e0ce = Math['cos'](deg2rad(_0x2e6753[0x1]))
    return [_0x192a86 * _0x57e0ce, _0x192a86 * _0xb6c43a, -_0x264e09];
}

function vector_to_angles(_0x5a29c2) {
    var _0x140a2d, _0x3619c3, _0x5d797a, _0x572471 = [];
    if (_0x5a29c2[0x1] === 0x0 && _0x5a29c2[0x0] === 0x0) {
        _0x3619c3 = 0x0;
        if (_0x5a29c2[0x2] > 0x0) _0x5d797a = 0x10e;
        else _0x5d797a = 0x5a;
    } else {
        _0x3619c3 = Math['atan2'](_0x5a29c2[0x1], _0x5a29c2[0x0]) * 0xb4 / Math['PI'];
        if (_0x3619c3 < 0x0) _0x3619c3 += 0x168;
        _0x140a2d = Math['sqrt'](_0x5a29c2[0x0] * _0x5a29c2[0x0] + _0x5a29c2[0x1] * _0x5a29c2[0x1]), _0x5d797a = Math['atan2'](-_0x5a29c2[0x2], _0x140a2d) * 0xb4 / Math['PI'];
        if (_0x5d797a < 0x0) _0x5d797a += 0x168;
    }
    return _0x572471[0x0] = _0x5d797a, _0x572471[0x1] = _0x3619c3, _0x572471[0x2] = 0x0, _0x572471;
}

function compensate_for_collision(grenade, ticks) {
    var flags = 0x1 | 0x4000 | 0x2 | 0x2000000 | 0x8 | 0x80000
    var start_position = grenade['data']['start_position']
    var start_velocity = vector_to_angles(grenade['data']['start_velocity'])
    var compensated_velocity = [angle_to_vector([0x0, start_velocity[0x1] - 0x5a, 0x0]), angle_to_vector([0x0, start_velocity[0x1] + 0x5a, 0x0]), angle_to_vector([0x0, start_velocity[0x1], 0x0]), angle_to_vector([0x0, start_velocity[0x1] - 0xb4, 0x0]), angle_to_vector([start_velocity[0x0] - 0x5a, 0x0, 0x0]), angle_to_vector([start_velocity[0x0] + 0x5a, 0x0, 0x0])]
    var planes = [
        [0.5, -0.5, 0.25],
        [0.5, -0.5, 0.25],
        [-0.5, 0.5, 0.25],
        [-0.5, 0.5, 0.25],
        [0.5, 0.5, -0.25],
        [0.5, 0.5, -0.25]
    ]
    var grenade_info = {
        'origin': Render['WorldToScreen'](start_position),
        'point': []
    };
    for (var i = 0; i < 6; i++) {
        const ext_position = extrapolate([start_position[0x0] + compensated_velocity[i][0x0], start_position[0x1] + compensated_velocity[i][0x1], start_position[0x2] + compensated_velocity[i][0x2]], grenade['data']['start_velocity'], 0x1)
        const trace_result = Trace.RawLine(grenade['entity'], start_position, ext_position, flags, 0);
        if (!trace_result) continue;
        if (trace_result[0x1] < 0.98 && trace_result[0x0] !== Entity["GetProp"](grenade['entity'], "CBaseEntity", "m_hOwnerEntity")) {
            if (grenade['is_inferno'] && i === direction_t['DOWN']) {
                grenade['should_predict'] = false, grenade['data']['prediction_ticks'] = ticks;
                return;
            }
            grenade['data']['start_velocity'][0x0] *= planes[i][0x0], grenade['data']['start_velocity'][0x1] *= planes[i][0x1], grenade['data']['start_velocity'][0x2] *= planes[i][0x2];
        }
    }
}

var predicted_times = 0;

function register_grenades() {
    if (!GUI.GetValue(p.radar, "[NW] Predict grenade path"))
        return;

    const grenades = Entity.GetEntitiesByClassID(9).concat(Entity.GetEntitiesByClassID(114))
    for (var i = 0x0; i < grenades['length']; i++) {
        const grenade = grenades[i]
        const class_id = Entity.GetClassID(grenade)
        if (!grenade) continue;
        if (Entity.GetProp(grenade, "CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin")) {
            predicted_times = 0;
            continue;
        }
        const is_molotov = (class_id === 114);
        if (is_molotov) {
            if (Entity.GetProp(grenade, "CInferno", "m_nFireEffectTickBegin")) {
                predicted_times = 0;
                continue;
            }
        }
            

        if (grenade_prediction.nades.indexOf(grenade) === -1) {
            grenade_prediction.nades.push(grenade)
            grenade_prediction.paths[grenade] = {
            'entity': grenade,
            'simulated': false,
            'initialized': false,
            'ticks': 0x0,
            'should_predict': true,
            'should_follow': false,
            'data': {
                'start_velocity': [],
                'start_position': [],
                'prediction_ticks': 0x0
            },
            'paths': [],
            'is_inferno': is_molotov,
            }
            predict_grenades();
        }
    }
}

function predict_grenades() {
    if (!GUI.GetValue(p.radar, "[NW] Predict grenade path"))
        return;
        
    const TickInterval = Globals.TickInterval();
    const gravity = Convar.GetFloat("sv_gravity") * TickInterval;

    for (var i in grenade_prediction.paths) {
        var grenade = grenade_prediction.paths[i]
        var ticks = grenade['is_inferno'] ? 126 : 100;
        ticks -= GUI.GetValue(p.radar, "[NW] Re-predict grenade") * predicted_times;

        if (Entity.GetProp(grenade['entity'], "CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin") || Entity.GetProp(grenade['entity'], "CInferno", "m_nFireEffectTickBegin"))
            predicted_times = 0;

        if (grenade['simulated']) {
            grenade['ticks']++;
            if (grenade['ticks'] >= GUI.GetValue(p.radar, "[NW] Re-predict grenade")) {
                grenade_prediction['nades'].splice(grenade_prediction.nades.indexOf(grenade['entity'], 1))
                grenade_prediction['paths'].splice(i, 1)
                register_grenades()
            }
            continue;
        }
        for (var t = 0; t < ticks; t++) {
            if (!grenade['initialized']) {
                const origin = Entity.GetRenderOrigin(grenade['entity'])
                const velocity = Entity.GetProp(grenade['entity'], "CBaseGrenade", "m_vecVelocity")
                grenade['data']['start_position'] = origin
                grenade['data']['start_velocity'] = velocity
                grenade['initialized'] = true;
            }
            compensate_for_collision(grenade, t);
            grenade['data']['start_position'] = extrapolate(grenade['data']['start_position'], grenade['data']['start_velocity'], 1)
            grenade['data']['start_velocity'][2] -= gravity * 0.4;
            if (!grenade['should_predict']) {
                grenade['paths'].push(grenade['data']['start_position'])
                break;
            }
            if (t === ticks - 1) {
                grenade['paths'].push(grenade['data']['start_position'])
            }
        }
        grenade['simulated'] = true;
        grenade_prediction.paths[i] = grenade;
    }
}

/*Cheat.RegisterCallback('CreateMove', 'register_grenades')
Cheat.RegisterCallback('CreateMove', 'predict_grenades')*/

/*
* Section: Clantag
*/

var ui_clantag = UI.AddCheckbox(p.cheat, "[NW] Clantag")
var old_tick = 0;

function clantag() {
    if (!UI.GetValue(ui_clantag)) {
        if (old_tick != 0) {
            old_tick = 0;
            Local.SetClanTag("");
        }
        return;
    }
    if (!World.GetServerString() || old_tick == Math.floor(Globals.Curtime() * 2.7))
        return;

    old_tick = Math.floor(Globals.Curtime() * 2.7);

    switch (Math.floor((Globals.Curtime() * 2.7) % 24)) {
        case 0:
            Local.SetClanTag("         n")
            break;
        case 1:
            Local.SetClanTag("        no")
            break;
        case 2:
            Local.SetClanTag("       nor")
            break;
        case 3:
            Local.SetClanTag("      nort")
            break;
        case 4:
            Local.SetClanTag("     north")
            break;
        case 5:
            Local.SetClanTag("    northw")
            break;
        case 6:
            Local.SetClanTag("   northwo")
            break;
        case 7:
            Local.SetClanTag("  northwoo")
            break;
        case 8:
            Local.SetClanTag(" northwood")
            break;
        case 9:
        case 10:
        case 11:
        case 12:
        case 13:
        case 14:
            Local.SetClanTag("northwood ")
            break;
        case 15:
            Local.SetClanTag("orthwood  ")
            break;
        case 16:
            Local.SetClanTag("rthwood   ")
            break;
        case 17:
            Local.SetClanTag("thwood    ")
            break;
        case 18:
            Local.SetClanTag("hwood     ")
            break;
        case 19:
            Local.SetClanTag("wood      ")
            break;
        case 20:
            Local.SetClanTag("ood       ")
            break;
        case 21:
            Local.SetClanTag("od        ")
            break;
        case 22:
            Local.SetClanTag("d         ")
            break;
        case 23:
            Local.SetClanTag("          ")
            break;
    }
}

Cheat.RegisterCallback("Draw", "clantag")

/*
* Section: Commands
*/

if (Northwood.Get("console_filter:enabled")) {
    Cheat.ExecuteCommand("con_filter_enable 1")
    Cheat.ExecuteCommand("con_filter_text [onetap]")
}

UI.AddTextbox(p.general, "[NW] Command")
UI.AddCheckbox(p.general, "Execute command")
var Commands = {
    Handler: function() {
        if (GUI.GetValue(p.general, "Execute command") == 0)
            return;
        var command = GUI.GetString(p.general, "[NW] Command")
        var executed = false;
        if (command.includes("indicators:set_size ")) {
            var size = parseInt(command.replace("indicators:set_size ", ""), 10)
            if (size == NaN) {
                Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                Cheat.PrintColor([220, 220, 220, 255], "Syntax: `indicators:set_size <size>`\n")
                return;
            }
            Indicators.Size = size;
            Northwood.Write("indicators:size", size.toString())
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Indicators size set\n")
            executed = true;
        }
        if (command.includes("performance:set_freq ")) {
            var freq = parseInt(command.replace("performance:set_freq ", ""), 10)
            if (freq == NaN) {
                Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                Cheat.PrintColor([220, 220, 220, 255], "Syntax: `performance:set_freq <freq>`\n")
                return;
            }
            Performance.Freq = freq;
            Northwood.Write("performance:freq", freq.toString())
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Refresh frequency set\n")
            executed = true;
        }
        if (command.includes("presets:export ")) {
            var filename = command.replace("presets:export ", "")
            DataFile.Load(filename)

            DataFile.SetKey(filename, "antiaim_standing_yawbase", GUI.GetValue(p.antiaim, "[S] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_standing_yaw", GUI.GetValue(p.antiaim, "[S] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawoffset", GUI.GetValue(p.antiaim, "[S] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawjitter", GUI.GetValue(p.antiaim, "[S] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_standing_yawjitteroffset", GUI.GetValue(p.antiaim, "[S] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_edgeyaw", GUI.GetValue(p.antiaim, "[S] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyaw", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_standing_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[S] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_standing_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[S] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_standing_bulletevasion", GUI.GetValue(p.antiaim_fake, "[S] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_walking_yawbase", GUI.GetValue(p.antiaim, "[W] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_walking_yaw", GUI.GetValue(p.antiaim, "[W] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawoffset", GUI.GetValue(p.antiaim, "[W] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawjitter", GUI.GetValue(p.antiaim, "[W] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_walking_yawjitteroffset", GUI.GetValue(p.antiaim, "[W] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_edgeyaw", GUI.GetValue(p.antiaim, "[W] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyaw", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_walking_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[W] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_walking_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[W] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_walking_bulletevasion", GUI.GetValue(p.antiaim_fake, "[W] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_moving_yawbase", GUI.GetValue(p.antiaim, "[M] Yaw base").toString())
            DataFile.SetKey(filename, "antiaim_moving_yaw", GUI.GetValue(p.antiaim, "[M] Yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawoffset", GUI.GetValue(p.antiaim, "[M] Yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawjitter", GUI.GetValue(p.antiaim, "[M] Yaw jitter").toString())
            DataFile.SetKey(filename, "antiaim_moving_yawjitteroffset", GUI.GetValue(p.antiaim, "[M] Yaw jitter offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_edgeyaw", GUI.GetValue(p.antiaim, "[M] Edge yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyaw", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyawoffset", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw offset").toString())
            DataFile.SetKey(filename, "antiaim_moving_fakeyawlimit", GUI.GetValue(p.antiaim_fake, "[M] Fake yaw limit").toString())
            DataFile.SetKey(filename, "antiaim_moving_freestandfakeyaw", GUI.GetValue(p.antiaim_fake, "[M] Freestand fake yaw").toString())
            DataFile.SetKey(filename, "antiaim_moving_bulletevasion", GUI.GetValue(p.antiaim_fake, "[M] Bullet evasion").toString())

            DataFile.SetKey(filename, "antiaim_general_lowerbody", GUI.GetValue(p.antiaim_fake, "Lower body yaw").toString())
            DataFile.Save(filename)
            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Config exported into scripts directory\n")
            executed = true;
        }
        if (command.includes("presets:import ")) {
            var filename = command.replace("presets:import ", "")
            DataFile.Load(filename)

            GUI.SetValue(p.antiaim, "[S] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawbase")))
            GUI.SetValue(p.antiaim, "[S] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_yaw")))
            GUI.SetValue(p.antiaim, "[S] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawoffset")))
            GUI.SetValue(p.antiaim, "[S] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawjitter")))
            GUI.SetValue(p.antiaim, "[S] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[S] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[S] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_standing_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[S] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_standing_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[S] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_standing_bulletevasion")))

            GUI.SetValue(p.antiaim, "[W] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawbase")))
            GUI.SetValue(p.antiaim, "[W] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_yaw")))
            GUI.SetValue(p.antiaim, "[W] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawoffset")))
            GUI.SetValue(p.antiaim, "[W] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawjitter")))
            GUI.SetValue(p.antiaim, "[W] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[W] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[W] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_walking_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[W] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_walking_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[W] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_walking_bulletevasion")))

            GUI.SetValue(p.antiaim, "[M] Yaw base", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawbase")))
            GUI.SetValue(p.antiaim, "[M] Yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_yaw")))
            GUI.SetValue(p.antiaim, "[M] Yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawoffset")))
            GUI.SetValue(p.antiaim, "[M] Yaw jitter", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawjitter")))
            GUI.SetValue(p.antiaim, "[M] Yaw jitter offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_yawjitteroffset")))
            GUI.SetValue(p.antiaim, "[M] Edge yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_edgeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw offset", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyawoffset")))
            GUI.SetValue(p.antiaim_fake, "[M] Fake yaw limit", parseInt(DataFile.GetKey(filename, "antiaim_moving_fakeyawlimit")))
            GUI.SetValue(p.antiaim_fake, "[M] Freestand fake yaw", parseInt(DataFile.GetKey(filename, "antiaim_moving_freestandfakeyaw")))
            GUI.SetValue(p.antiaim_fake, "[M] Bullet evasion", parseInt(DataFile.GetKey(filename, "antiaim_moving_bulletevasion")))

            GUI.SetValue(p.antiaim_fake, "Lower body yaw", parseInt(DataFile.GetKey(filename, "antiaim_general_lowerbody")))

            Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
            Cheat.PrintColor([220, 220, 220, 255], "Config imported successfully\n")
            executed = true;
        }

        if (!executed) {
            switch (command) {
                case "watermark:unlock_suffix":
                    if (Northwood.Get("watermark:unlock_suffix") == "true") {
                        Northwood.Write("watermark:unlock_suffix", "false")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark suffix disabled\n")
                        UI.RemoveItem(GUI.GetPath(p.script_ui, "Watermark suffix"))
                    }
                    else {
                        Northwood.Write("watermark:unlock_suffix", "true")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark suffix unlocked\n")
                        UI.AddTextbox(p.script_ui, "Watermark suffix")
                    }
                    break;
                case "watermark:unlock_prefix":
                    if (Northwood.Get("watermark:unlock_prefix") == "true") {
                        Northwood.Erase("watermark:unlock_prefix")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark prefix disabled\n")
                        UI.RemoveItem(GUI.GetPath(p.script_ui, "Watermark prefix"))
                    }
                    else {
                        Northwood.Write("watermark:unlock_prefix", "true")
                        Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                        Cheat.PrintColor([220, 220, 220, 255], "Watermark prefix unlocked\n")
                        UI.AddTextbox(p.script_ui, "Watermark prefix")
                    }
                    break;
                case "console_filter:enable":
                    Northwood.Write("console_filter:enabled", "true")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Console filter enabled\n")
                    Cheat.ExecuteCommand("con_filter_enable 1")
                    Cheat.ExecuteCommand("con_filter_text [onetap]")
                    break;
                case "console_filter:disable":
                    Northwood.Erase("console_filter:enabled")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Console filter disabled\n")
                    Cheat.ExecuteCommand("con_filter_enable 0")
                    break;
                case "visuals:weapon_icon":
                    Northwood.Write("visuals:weapon_icon", "true")
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Weapon icon ESP enabled\n")
                    break;
                default:
                    Cheat.PrintColor([190, 220, 255, 255], "[northwood] ")
                    Cheat.PrintColor([220, 220, 220, 255], "Unknown command\n")
                    break;
            }
        }
        GUI.SetValue(p.general, "Execute command", 0)
    }
}

UI.RegisterCallback(GUI.GetPath(p.general, "Execute command"), "Commands.Handler")

var ShotsHandler = {
    LastShotID: 0,
    LastTarget: -1,
    Shots: new Array(),
    Events: {
        aim_fire: function(shot) {
            Cheat.PrintColor([89, 119, 239, 255], String.format("[{0}] aim_fire: (target: {1}, hitbox: {2}, hit_chance: {3}, damage: {4}, priority: {5}, teleported: {6}, shifted: {7}, tick: {8})\n", shot.shot_id, Entity.GetName(shot.target), hitboxes[shot.hitbox], shot.hit_chance, shot.damage, shot.priority, shot.teleported, shot.shot_info.shifting, shot.tick))
        },
        aim_miss: function(shot) {
            Cheat.PrintColor([89, 119, 239, 255], String.format("[{0}] aim_miss: (target: {1}, hitbox: {2}, hit_chance: {3}, damage: {4}, priority: {5}, teleported: {6}, shifted: {7}, tick: {8}, reason: {9})\n", shot.shot_id, Entity.GetName(shot.target), hitboxes[shot.hitbox], shot.hit_chance, shot.damage, shot.priority, shot.teleported, shot.shot_info.shifting, shot.tick, shot.shot_info.reason))
        },
    },
    RagebotFire: function() {
        /*
        RagebotFire Object:
            id: // Shot ID
            target: // Target player entindex
            hitbox: // Targetted hitbox
            hit_chance: // Hitchance
            damage: // Predicted damage
            priority: // Was the shot at a high priority record
            teleported: // Was target player breaking lag comp
            tick: // Tick the shot was made at
            shot_info: {
                shifting:
            }
        */
       var shot = new Object();
       shot.shot_id = ShotsHandler.LastShotID;
       shot.target = Event.GetInt("target_index");
       shot.hitbox = Event.GetInt("hitbox");
       shot.hit_chance = Event.GetInt("hitchance");
       shot.damage = Trace.Bullet(Entity.GetLocalPlayer(), Event.GetInt("target_index"), Entity.GetEyePosition(Entity.GetLocalPlayer()), Entity.GetHitboxPosition(Event.GetInt("target_index"), Event.GetInt("hitbox")))[1];
       shot.priority = ShotsHandler.LastTarget === Event.GetInt("target_index");
       shot.teleported = false;
       shot.tick = Globals.Tickcount();

       shot.shot_info = {};
       shot.shot_info.shifting = false;

       ShotsHandler.Shots.push(shot);
       ShotsHandler.LastShotID = ShotsHandler.LastShotID + 1;
       ShotsHandler.LastTarget = Event.GetInt("target_index");

       ShotsHandler.Events.aim_fire(shot);
    },
    PlayerDeath: function() {
        if (Entity.GetEntityFromUserID(Event.GetInt('userid')) == Entity.GetLocalPlayer()) {
            if (ShotsHandler.Shots.length > 0) {
                var shot = ShotsHandler.Shots[ShotsHandler.Shots.length - 1];
                shot.shot_info.reason = "death";
                ShotsHandler.Events.aim_miss(shot);
                ShotsHandler.Shots = new Array();
                ShotsHandler.LastShotID = 0;
            }
        }
        else if (Entity.GetEntityFromUserID(Event.GetInt('userid')) == ShotsHandler.LastTarget) {
            if (ShotsHandler.Shots.length > 0) {
                var shot = ShotsHandler.Shots[ShotsHandler.Shots.length - 1];
                shot.shot_info.reason = "death";
                ShotsHandler.Events.aim_miss(shot);
                ShotsHandler.Shots.pop();
            }
        }
    },
    Load: function() {
        /*Cheat.RegisterCallback("ragebot_fire", "ShotsHandler.RagebotFire")
        Cheat.RegisterCallback("player_death", "ShotsHandler.PlayerDeath")*/
    },
}

//ShotsHandler.Load();
JavaScript:
var locations = {
de_lake: [
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_molotov",
    "position": [
        3140.78369140625,
        -3450.83837890625,
        -67.22456359863281
    ],
    "viewangles": [
        -19.69611358642578,
        -146.4047393798828
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 44
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_molotov",
    "position": [
        4205.00634765625,
        -3367.428466796875,
        -88.99531555175781
    ],
    "viewangles": [
        -25.410022735595703,
        -167.97454833984375
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 29
        }
    }
},
],
de_shortdust: [
{
    "type": "grenade",
    "name": [
        "Tunnel",
        "Tunnel"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -246.3869171142578,
        531.03955078125,
        41.693925857543945
    ],
    "viewangles": [
        -18.48615074157715,
        23.387554168701172
    ]
},
{
    "type": "grenade",
    "name": [
        "Tunnel",
        "Tunnel"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -247.0117645263672,
        531.242919921875,
        41.608402252197266
    ],
    "viewangles": [
        -12.772226333618164,
        23.195058822631836
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 17
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -244.41287231445313,
        556.8860473632813,
        41.411285400390625
    ],
    "viewangles": [
        -21.64558982849121,
        -34.784629821777344
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 8
        },
        "recover": {
            "direction": 2
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Short",
        "Short"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        361.0484313964844,
        -182.86325073242188,
        167.6671142578125
    ],
    "viewangles": [
        4.031111717224121,
        137.37693786621094
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 3
        },
        "delay": 7
    }
},
{
    "type": "grenade",
    "name": [
        "Full Car/Pit",
        "Full Car/Pit"
    ],
    "weapon": "weapon_molotov",
    "position": [
        686.85791015625,
        935.8990478515625,
        95.03125
    ],
    "viewangles": [
        -13.379462242126465,
        -152.9184112548828
    ],
    "grenade": {
        "delay": 7,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Pit/Near Car",
        "Pit/Near Car"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        686.9653930664063,
        936.15625,
        95.03125
    ],
    "viewangles": [
        -9.211703300476074,
        -156.6160430908203
    ],
    "grenade": {
        "delay": 3,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Short",
        "Short"
    ],
    "weapon": "weapon_molotov",
    "position": [
        361.0484313964844,
        -182.86325073242188,
        167.6671142578125
    ],
    "viewangles": [
        4.031111717224121,
        137.37693786621094
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 3
        },
        "delay": 7
    }
},
{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -228.40750122070313,
        611.0630493164063,
        42.79629135131836
    ],
    "viewangles": [
        -30.518749237060547,
        -49.38353729248047
    ],
    "grenade": {
        "delay": 5,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -367.5015869140625,
        508.68621826171875,
        98.03118896484375
    ],
    "viewangles": [
        -6.78947114944458,
        -45.918399810791016
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 8
        },
        "recover": {
            "direction": 1
        },
        "delay": 8
    }
},
{
    "type": "grenade",
    "name": [
        "Peek Spot",
        "Peek Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -812.527099609375,
        924.7133178710938,
        63.03125
    ],
    "viewangles": [
        15.272916793823242,
        -18.83675193786621
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 9
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Car",
        "Car"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -809.0723266601563,
        920.7889404296875,
        63.03125
    ],
    "viewangles": [
        3.2782485485076904,
        -24.191303253173828
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 6
        },
        "recover": {
            "direction": 1
        },
        "delay": 2
    }
},
{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -363.0677795410156,
        762.2527465820313,
        99.03125
    ],
    "viewangles": [
        -21.298158645629883,
        -54.21849060058594
    ]
},
{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -736.564208984375,
        799.7855834960938,
        99.03125
    ],
    "viewangles": [
        -23.019092559814453,
        -42.272186279296875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 19
        },
        "recover": {
            "direction": 1
        },
        "delay": 21
    }
},
{
    "type": "grenade",
    "name": [
        "Car",
        "Car"
    ],
    "description": "UNSAFE",
    "weapon": "weapon_hegrenade",
    "position": [
        -828.4098510742188,
        926.2717895507813,
        63.03125
    ],
    "viewangles": [
        6.935151100158691,
        0.9576676487922668
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 12
        },
        "recover": {
            "direction": 1
        },
        "delay": 0,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -861.98046875,
        955.3460693359375,
        63.03125
    ],
    "viewangles": [
        0.6453616619110107,
        -43.6
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Peek Spot",
        "Peek Spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -812.527099609375,
        924.7133178710938,
        63.03125
    ],
    "viewangles": [
        14.7,
        -18.83675193786621
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 9
        },
        "recover": {
            "direction": 1
        }
    }
},
],
de_train: [
{
    "type": "grenade",
    "name": [
        "Window",
        "Window"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -52.00689697265625,
        418.9811096191406,
        -152.96875
    ],
    "viewangles": [
        -15.541741371154785,
        -45.27230453491211
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 1
        },
        "delay": 8
    }
},
{
    "type": "grenade",
    "name": [
        "Left Peek Spot",
        "Left Peek Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        36.16081237792969,
        367.9725341796875,
        -152.96875
    ],
    "viewangles": [
        -5.810218334197998,
        -16.582242965698242
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 14
        },
        "recover": {
            "direction": 0
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Right Peek Spot",
        "Right Peek Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        36.621463775634766,
        367.9664001464844,
        -152.96875
    ],
    "viewangles": [
        -18.2329158782959,
        -46.966670989990234
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 6
        },
        "recover": {
            "direction": 0
        },
        "delay": 17
    }
},
{
    "type": "grenade",
    "name": [
        "Window",
        "Window"
    ],
    "weapon": "weapon_molotov",
    "position": [
        812.1392822265625,
        733.8515014648438,
        -91.96875
    ],
    "viewangles": [
        -27.482606887817383,
        -92.63993835449219
    ]
},
{
    "type": "grenade",
    "name": [
        "Full Side",
        "Full Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        735.3755493164063,
        -669.9736938476563,
        -148.96875
    ],
    "viewangles": [
        8.333330154418945,
        132.69619750976563
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 9
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Connector",
        "Connector"
    ],
    "weapon": "weapon_molotov",
    "position": [
        812.3819580078125,
        733.9366455078125,
        -91.96875
    ],
    "viewangles": [
        -15.597753524780273,
        -101.80117797851563
    ],
    "grenade": {
        "delay": 4,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Full Side/Left | Right Peek Spots",
        "Full Side/Left | Right Peek Spots"
    ],
    "weapon": "weapon_molotov",
    "position": [
        807.3504638671875,
        731.9351806640625,
        -91.96875
    ],
    "viewangles": [
        -17.910219192504883,
        -106.47989654541016
    ],
    "grenade": {
        "delay": 15,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Left | Right Peek Spots",
        "Left | Right Peek Spots"
    ],
    "weapon": "weapon_molotov",
    "position": [
        36.67168426513672,
        367.6492919921875,
        -152.96875
    ],
    "viewangles": [
        -8.01513957977295,
        -18.614198684692383
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 18
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Full Side",
        "Full Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -294.2779235839844,
        418.2619934082031,
        -152.96875
    ],
    "viewangles": [
        -13.067981719970703,
        -40.6243782043457
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 11
        },
        "recover": {
            "direction": 1
        }
    }
},
],
de_shortnuke: [
{
    "type": "grenade",
    "name": [
        "Plant [Near | R]",
        "Plant [Near | R]"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        499.1699523925781,
        68.44168853759766,
        -576.96875
    ],
    "viewangles": [
        -7.410359859466553,
        -106.89105224609375
    ],
    "grenade": {
        "run": {
            "walk": true,
            "duration": null
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1131.772705078125,
        -447.43072509765625,
        -576.96875
    ],
    "viewangles": [
        12.315020561218262,
        133.1303253173828
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 12
        },
        "recover": {
            "direction": 2
        },
        "delay": 2
    }
},
{
    "type": "grenade",
    "name": [
        "Full Ramp",
        "Full Ramp"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1241.2999267578125,
        -559.3812255859375,
        -576.96875
    ],
    "viewangles": [
        -6.668525695800781,
        149.55
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 15
        },
        "recover": {
            "direction": 2
        },
        "delay": 2
    }
},
{
    "type": "grenade",
    "name": [
        "Ramp",
        "Ramp"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1391.58740234375,
        -767.6834716796875,
        -619.420166015625
    ],
    "viewangles": [
        -9.670125961303711,
        145.11524963378906
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Left Door [Left]",
        "Left Door [Left]"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1388.1605224609375,
        -759.4415283203125,
        -613.9234619140625
    ],
    "viewangles": [
        12.925474166870117,
        146.07440185546875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 16
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Plant Center",
        "Plant Center"
    ],
    "weapon": "weapon_molotov",
    "position": [
        504.14105224609375,
        5.022028923034668,
        -576.96875
    ],
    "viewangles": [
        -9.551060676574707,
        -63.810546875
    ],
    "grenade": {
        "run": {
            "direction": 2,
            "duration": 15
        },
        "recover": {
            "direction": 1
        },
        "delay": 0,
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "description": "unsafe for rightdoor",
    "weapon": "weapon_molotov",
    "position": [
        778.7005004882813,
        -560.031005859375,
        -704.96875
    ],
    "viewangles": [
        4.369343280792236,
        113.47209167480469
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 10
        },
        "recover": {
            "direction": 2
        }
    }
},

{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1391.9769287109375,
        -804.118408203125,
        -643.7185668945313
    ],
    "viewangles": [
        -9.823001861572266,
        136.1199951171875
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 8
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "weapon": "weapon_molotov",
    "position": [
        419.2025146484375,
        -639.6663208007813,
        -704.96875
    ],
    "viewangles": [
        -33.174171447753906,
        86.9237289428711
    ]
},
{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "description": "unsafe for rightdoor",
    "weapon": "weapon_hegrenade",
    "position": [
        778.3417358398438,
        -560.4749145507813,
        -704.96875
    ],
    "viewangles": [
        5.1372833251953125,
        113.72811126708984
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 10
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Plant [Near | R]",
        "Plant [Near | R]"
    ],
    "weapon": "weapon_molotov",
    "position": [
        499.8377990722656,
        83.24891662597656,
        -576.96875
    ],
    "viewangles": [
        -6.731101989746094,
        -105.9429931640625
    ]
},
{
"type": "grenade",
    "name": [
        "Right Door",
        "Right Door"
    ],
    "weapon": "weapon_molotov",
    "position": [
        418.58135986328125,
        -634.4966430664063,
        -704.96875
    ],
    "viewangles": [
        -29.555118560791016,
        54.180606842041016
    ]
},
{
    "type": "grenade",
    "name": [
        "Left Door",
        "Left Door"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1131.772705078125,
        -447.43072509765625,
        -576.96875
    ],
    "viewangles": [
        12.315020561218262,
        133.1303253173828
    ],
    "grenade": {
        "jump": true,
        "run": {   
            "direction": 1,
            "duration": 12
        },
        "recover": {
            "direction": 2
        },
        "delay": 2
    }
},
],
de_cbble: [

{
    "type": "grenade",
    "name": [
        "Drop",
        "Drop"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -91.7198715209961,
        -75.13533782958984,
        31.03125
    ],
    "viewangles": [
        -49.072349548339844,
        -108.9902114868164
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 8
        },
        "recover": {
            "direction": 1
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Under Drop",
        "Under Drop"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        135.30068969726563,
        -82.62255859375,
        38.306251525878906
    ],
    "viewangles": [
        -49.139408111572266,
        -136.74513244628906
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 18
        },
        "recover": {
            "direction": 1
        },
        "delay": 0
    }
},

{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "description": "MOVEMENT",
    "weapon": "weapon_molotov",
    "position": [
        219.54507446289063,
        -138.2848663330078,
        45.32670974731445
    ],
    "viewangles": [
        18.21489906311035,
        -102.99600982666016
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 11
        },
        "recover": {
            "direction": 2
        }
    }
},


{
    "type": "grenade",
    "name": [
        "Chicken",
        "Chicken"
    ],
    "weapon": "weapon_molotov",
    "position": [
        184.1692352294922,
        -80.03237915039063,
        42.376569747924805
    ],
    "viewangles": [
        -7.396869659423828,
        -65.71185302734375
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 15
        },
        "recover": {
            "direction": 2
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Drop Corner",
        "Drop Corner"
    ],
    "weapon": "weapon_molotov",
    "position": [
        599.88671875,
        -69.45216369628906,
        63.03125
    ],
    "viewangles": [
        -23.664674758911133,
        -150.7505645751953
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 2
        },
        "delay": 16,
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "description": "SAFE",
    "weapon": "weapon_hegrenade",
    "position": [
        224.18191528320313,
        -92.01819610595703,
        45.70206069946289
    ],
    "viewangles": [
        7.593880653381348,
        -77.1985092163086
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Long",
        "Long"
    ],
    "weapon": "weapon_molotov",
    "position": [
        161.10508728027344,
        -1020.95703125,
        11.359909057617188
    ],
    "viewangles": [
        -26.729671478271484,
        119.54906463623047
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 3
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Long",
        "Long"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -159.43809509277344,
        -627.1902465820313,
        1.03125
    ],
    "viewangles": [
        -41.895050048828125,
        103.03885650634766
    ]
},
{
    "type": "grenade",
    "name": [
        "Long",
        "Long"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -165.47853088378906,
        -706.8801879882813,
        -43.51533508300781
    ],
    "viewangles": [
        -57.65193176269531,
        96.96205139160156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 0
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Long",
        "Long"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        157.3255615234375,
        -1017.6783447265625,
        11.359909057617188
    ],
    "viewangles": [
        -24.901288986206055,
        104.34129333496094
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 3
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        243.1579132080078,
        -356.6786193847656,
        -0.96875
    ],
    "viewangles": [
        -14.383401870727539,
        -140.71884155273438
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3,
            "walk": true
        },
        "recover": {
            "direction": 0
        },
        "delay": 19
    }
},

{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -763.1746215820313,
        -702.2718505859375,
        31.03125
    ],
    "viewangles": [
        -4.56892728805542,
        6.186849117279053
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 14
        },
        "recover": {
            "direction": 2
        },
        "delay": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -576.7101440429688,
        -703.9712524414063,
        31.03125
    ],
    "viewangles": [
        -37.84380340576172,
        74.26078033447266
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6,
            "walk": true
        },
        "recover": {
            "direction": 3
        },
        "delay": 19
    }
},

{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -111.79314422607422,
        -372.0326843261719,
        33.78303527832031
    ],
    "viewangles": [
        -21.580564498901367,
        -63.721282958984375
    ],
    "grenade": {
        "delay": 16,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Fountain/Under Fountain",
        "Fountain/Under Fountain"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -111.5682373046875,
        -371.9654846191406,
        33.756614685058594
    ],
    "viewangles": [
        -30.790019989013672,
        -65.26750183105469
    ],
    "grenade": {
        "delay": 20,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Chicken",
        "Chicken"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -3.955806016921997,
        -333.66461181640625,
        31.03125
    ],
    "viewangles": [
        -10.82498550415039,
        -68.53644561767578
    ]
},
{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "weapon": "weapon_molotov",
    "position": [
        88.88463592529297,
        -414.70526123046875,
        22.417072296142578
    ],
    "viewangles": [
        -53.37672424316406,
        -79.87157440185547
    ],
    "grenade": {
        "delay": 21,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_molotov",
    "position": [
        91.42420196533203,
        -423.2600402832031,
        23.111553192138672
    ],
    "viewangles": [
        -33.68083953857422,
        -134.33792114257813
    ],
    "grenade": {
        "delay": 20,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Drop/Peek Spot",
        "Drop/Peek Spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        452.5925598144531,
        -103.79170989990234,
        63.03125
    ],
    "viewangles": [
        -20.236387252807617,
        -136.08560180664063
    ]
},
{
    "type": "grenade",
    "name": [
        "Stivaha Spot/Drop Corner",
        "Stivaha Spot/Drop Corner"
    ],
    "weapon": "weapon_molotov",
    "position": [
        382.18408203125,
        -190.38563537597656,
        58.87981986999512
    ],
    "viewangles": [
        1.274806261062622,
        -141.144287109375
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "description": "SAFE",
    "weapon": "weapon_molotov",
    "position": [
        224.18191528320313,
        -92.01819610595703,
        45.70206069946289
    ],
    "viewangles": [
        7.593880653381348,
        -77.1985092163086
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Fountain",
        "Fountain"
    ],
    "description": "MOVEMENT",
    "weapon": "weapon_hegrenade",
    "position": [
        220.07981872558594,
        -138.73414611816406,
        45.36555862426758
    ],
    "viewangles": [
        22.65165901184082,
        -103.48368072509766
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 11
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Stivaha Spot/Pillar Spot",
        "Stivaha Spot/Pillar Spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -136.15426635742188,
        -16.328279495239258,
        31.03125
    ],
    "viewangles": [
        -11.093891143798828,
        -41.77308654785156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Stivaha Spot/Drop Corner",
        "Stivaha Spot/Drop Corner"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -279.2718811035156,
        -35.449642181396484,
        31.03125
    ],
    "viewangles": [
        -17.883344650268555,
        -34.36149597167969
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 13
        },
        "recover": {
            "direction": 2
        },
        "delay": 4
    }
},

{
    "type": "grenade",
    "name": [
        "Crack",
        "Crack"
    ],
    "weapon": "weapon_molotov",
    "position": [
        135.28514099121094,
        -136.56813049316406,
        38.302438735961914
    ],
    "viewangles": [
        26.4,
        -15.60
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 16
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Drop/Stivaha Spot",
        "Drop/Stivaha Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -303.9810485839844,
        -16.02276039123535,
        31.03125
    ],
    "viewangles": [
        -17.881284713745117,
        -34.63492965698242
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 29
        },
        "recover": {
            "direction": 1
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Drop/Corner",
        "Drop/Corner"
    ],
    "weapon": "weapon_molotov",
    "position": [
        132.8282012939453,
        -80.46054077148438,
        38.09937858581543
    ],
    "viewangles": [
        -36.36949157714844,
        -133.94004821777344
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 12
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Rock",
        "Rock"
    ],
    "weapon": "weapon_molotov",
    "position": [
        7.777020454406738,
        -17.867252349853516,
        31.03125
    ],
    "viewangles": [
        -39.52890396118164,
        -118.1687240600586
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 10
        },
        "recover": {
            "direction": 1
        }
    }
},
],
de_vertigo: [
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2050.3134765625,
        -651.6907958984375,
        11839.03125
    ],
    "viewangles": [
        -38.51621627807617,
        66.2590103149414
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 3
        },
        "delay": 25
    }
},
{
    "type": "grenade",
    "name": [
        "Middle",
        "Middle"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1490.62451171875,
        612.1972045898438,
        11937.53125
    ],
    "viewangles": [
        12.255270004272461,
        -113.26339721679688
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 11
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1636.1429443359375,
        830.643798828125,
        11839.03125
    ],
    "viewangles": [
        -36.6849365234375,
        -150.6219024658203
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 12
        },
        "delay": 2,
        "strength": 2
    }
},
{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1599.1673583984375,
        801.1947631835938,
        11839.03125
    ],
    "viewangles": [
        8.50671100616455,
        -148.647
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 2
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Test",
        "Test"
    ],
    "description": "Test",
    "weapon": "weapon_hegrenade",
    "position": [
        -1551.9691162109375,
        571.0084228515625,
        11936.53125
    ],
    "viewangles": [
        23.601242065429688,
        -124.81831359863281
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 10
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1624.0498046875,
        -111.09467315673828,
        11839.03125
    ],
    "viewangles": [
        -25.273412704467773,
        130.54701232910156
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 10
        },
        "delay": 1,
        "strength": 1
    }
},

{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2235.9541015625,
        -90.515869140625,
        11643.7919921875
    ],
    "viewangles": [
        -43.29335021972656,
        81.63432312011719
    ],
    "grenade": {
        "delay": 1,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2235.825927734375,
        -90.86797332763672,
        11643.962890625
    ],
    "viewangles": [
        -43.024452209472656,
        81.70154571533203
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 7
        },
        "delay": 2,
        "strength": 1
    }
},


{
    "type": "grenade",
    "name": [
        "Cement",
        "Cement"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2260.6650390625,
        -66.98992156982422,
        11632.0322265625
    ],
    "viewangles": [
        -30.588420867919922,
        114.15763092041016
    ],
    "grenade": {
        "delay": 12,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Plant [Box]",
        "Plant [Box]"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2234.350830078125,
        -145.42251586914063,
        11671.2421875
    ],
    "viewangles": [
        -30.933609008789063,
        85.37541198730469
    ]
},
{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2214.140625,
        -124.2696533203125,
        11660.6640625
    ],
    "viewangles": [
        -25.419139862060547,
        99.9994125366211
    ]
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2406.286376953125,
        102.88249969482422,
        11615.03125
    ],
    "viewangles": [
        -47.19233703613281,
        30.204471588134766
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 0
        },
        "delay": 13
    }
},


{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2633.518798828125,
        386.17181396484375,
        11818.8056640625
    ],
    "viewangles": [
        -23.057174682617188,
        13.205126762390137
    ]
},
{
    "type": "grenade",
    "name": [
        "Under Barrels",
        "Under Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2409.57568359375,
        318.3031921386719,
        11807.03125
    ],
    "viewangles": [
        -5.243316173553467,
        7.087751865386963
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 31,
            "walk": true
        },
        "recover": {
            "direction": 0
        },
        "delay": 10
    }
},
{
    "type": "grenade",
    "name": [
        "Mid",
        "Mid"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2368.186767578125,
        569.3917236328125,
        11807.03125
    ],
    "viewangles": [
        -14.05179500579834,
        -42.20481872558594
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 1
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Mid",
        "Mid"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2368.20703125,
        569.843994140625,
        11807.03125
    ],
    "viewangles": [
        -25.950149536132813,
        -44.624908447265625
    ]
},

{
    "type": "grenade",
    "name": [
        "Pit",
        "Pit"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2145.317626953125,
        639.6215209960938,
        11841.2939453125
    ],
    "viewangles": [
        -54.45,
        -108.37615203857422
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 0
        },
        "delay": 32
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2151.045166015625,
        377.3477783203125,
        11839.03125
    ],
    "viewangles": [
        -21.415027618408203,
        90.07621002197266
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 10
        },
        "recover": {
            "direction": 0
        },
        "delay": 23
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2151.0986328125,
        340.5555114746094,
        11839.03125
    ],
    "viewangles": [
        -16.07143211364746,
        88.58841705322266
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 1
        },
        "strength": 2
    }
},

{
    "type": "grenade",
    "name": [
        "Greenbox",
        "Greenbox"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2320.5859375,
        380.43023681640625,
        11807.03125
    ],
    "viewangles": [
        -1.5912806987762451,
        58.35206604003906
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        }
    }
},

{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1795.9766845703125,
        768.4838256835938,
        11839.03125
    ],
    "viewangles": [
        2.8600525856018066,
        158.07943725585938
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 7
        },
        "recover": {
            "direction": 1
        },
        "delay": 5
    }
},


{
    "type": "grenade",
    "name": [
        "Backside/Cement",
        "Backside/Cement"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1663.9757080078125,
        808.9077758789063,
        11839.03125
    ],
    "viewangles": [
        -43.47197723388672,
        -155.02037048339844
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 3
        },
        "delay": 27
    }
},
{
    "type": "grenade",
    "name": [
        "Full Side",
        "Full Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1728.92333984375,
        749.3604736328125,
        11839.03125
    ],
    "viewangles": [
        6.228486061096191,
        -134.3403778076172
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Greenbox",
        "Greenbox"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -944.0472412109375,
        753.3069458007813,
        11839.03125
    ],
    "viewangles": [
        3.114314317703247,
        //151.9918670654297
        152.05
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 37
        },
        "recover": {
            "direction": 1
        }
    }
},

{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -921.3076782226563,
        646.2721557617188,
        11839.03125
    ],
    "viewangles": [
        -19.93415641784668,
        167.6262664794922
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        },
        "delay": 19
    }
},

{
    "type": "grenade",
    "name": [
        "Full Side",
        "Full Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1466.828857421875,
        1000.743408203125,
        11839.03125
    ],
    "viewangles": [
        -54.97548294067383,
        -167.00875854492188
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 2
        },
        "delay": 31
    }
},


{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1430.1126708984375,
        1000.5421752929688,
        11839.03125
    ],
    "viewangles": [
        -24.51026153564453,
        -171.2107391357422
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3
        },
        "recover": {
            "direction": 0
        },
        "delay": 24
    }
},

{
    "type": "grenade",
    "name": [
        "Far Iron Pillar",
        "Far Iron Pillar"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1368.43310546875,
        974.38818359375,
        11839.03125
    ],
    "viewangles": [
        -10.71869945526123,
        179.5543670654297
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        },
        "delay": 15
    }
},




{
    "type": "grenade",
    "name": [
        "Double Box/Wall",
        "Double Box/Wall"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -921.2062377929688,
        646.0208129882813,
        11839.03125
    ],
    "viewangles": [
        -7.985729217529297,
        179.2565460205078
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 3
        },
        "delay": 10
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1049.86767578125,
        869.8828735351563,
        11839.03125
    ],
    "viewangles": [
        -13.959993362426758,
        179.46852111816406
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        },
        "delay": 18
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -2656.742431640625,
        399.61767578125,
        11841.03125
    ],
    "viewangles": [
        -8.620735168457031,
        46.49720001220703
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 2
        },
        "delay": 21
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2656.742431640625,
        399.61767578125,
        11841.03125
    ],
    "viewangles": [
        -8.620735168457031,
        46.49720001220703
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 2
        },
        "delay": 21
    }
},
{
    "type": "grenade",
    "name": [
        "Cement",
        "Cement"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1621.346435546875,
        -127.68318939208984,
        11839.03125
    ],
    "viewangles": [
        0.399009108543396,
        138.56825256347656
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 9
        },
        "recover": {
            "direction": 2
        }
    }
},

{
    "type": "grenade",
    "name": [
        "Barrels/Sandbugs",
        "Barrels/Sandbugs"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2023.3173828125,
        -595.8387451171875,
        11839.03125
    ],
    "viewangles": [
        -21.50402069091797,
        63.76
    ]
},

{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1628.05810546875,
        -216.2310028076172,
        11839.03125
    ],
    "viewangles": [
        -21.273515701293945,
        126.95800018310547
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 2
        },
        "delay": 20
    }
},




{
    "type": "grenade",
    "name": [
        "City On Box",
        "City On Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1829.0823974609375,
        358.1357727050781,
        11839.03125
    ],
    "viewangles": [
        -16.969284057617188,
        11.365525245666504
    ],
    "grenade": {
        "delay": 0,
    }
},
{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1863.331298828125,
        236.23974609375,
        11839.03125
    ],
    "viewangles": [
        0.8898288011550903,
        139.74769592285156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 10
        },
        "recover": {
            "direction": 2
        },
        "delay": 0,
        "strength": 2
    }
},,


{
    "type": "grenade",
    "name": [
        "Greenbox",
        "Greenbox"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1369.05126953125,
        257.2392272949219,
        11839.03125
    ],
    "viewangles": [
        0.6990577578544617,
        118.04886627197266
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 19
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1395.0400390625,
        445.3571472167969,
        11911.599609375
    ],
    "viewangles": [
        -52.94181442260742,
        147.98388671875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 3
        },
        "delay": 30
    }
},
{
    "type": "grenade",
    "name": [
        "Lane",
        "Lane"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1370.41650390625,
        151.81593322753906,
        11839.03125
    ],
    "viewangles": [
        -24.292659759521484,
        85.67241668701172
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 3
        },
        "delay": 17
    }
},
{
    "type": "grenade",
    "name": [
        "Lane",
        "Lane"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1332.365234375,
        322.71923828125,
        11839.03125
    ],
    "viewangles": [
        -15.739580154418945,
        127.67161560058594
    ]
},
{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1395.4945068359375,
        444.2622985839844,
        11910.982421875
    ],
    "viewangles": [
        -45.61068344116211,
        165.74124145507813
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 3
        },
        "delay": 26
    }
},

{
    "type": "grenade",
    "name": [
        "City Box",
        "City Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1846.06591796875,
        347.0621643066406,
        11839.03125
    ],
    "viewangles": [
        -16.75661277770996,
        11.915569305419922
    ],
    "grenade": {
        "delay": 0
    }
},

{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1806.7318115234375,
        -70.00330352783203,
        11839.03125
    ],
    "viewangles": [
        -23.87468719482422,
        65.07151794433594
    ]
},



{
    "type": "grenade",
    "name": [
        "Barrels/Sandbugs",
        "Barrels/Sandbugs"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1802.525634765625,
        -52.55925369262695,
        11839.03125
    ],
    "viewangles": [
        -26.925342559814453,
        57.78254318237305
    ],
    "grenade": {
        "delay": 0
    }
},,
{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1621.184814453125,
        -129.4846649169922,
        11839.03125
    ],
    "viewangles": [
        -16.790544509887695,
        129.81866455078125
    ],
    "grenade": {
        "delay": 15
    }
},

{
    "type": "grenade",
    "name": [
        "Push",
        "Push"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1976.0880126953125,
        -642.9071044921875,
        11839.03125
    ],
    "viewangles": [
        -18.898283004760742,
        61.85
    ]
},

{
    "type": "grenade",
    "name": [
        "Double Box",
        "Double Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1585.2969970703125,
        -236.67527770996094,
        11839.03125
    ],
    "viewangles": [
        -20.413227081298828,
        129.94578552246094
    ],
    "grenade": {
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "City",
        "City"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1697.04150390625,
        16.49848175048828,
        11839.03125
    ],
    "viewangles": [
        -21.290464401245117,
        43.495361328125
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 5
        },
        "recover": {
            "direction": 2
        },
        "delay": 17
    }
},
{
    "type": "grenade",
    "name": [
        "Triple Box",
        "Triple Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1646.2142333984375,
        -154.94863891601563,
        11839.03125
    ],
    "viewangles": [
        -26.56752586364746,
        110.98027801513672
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 2
        },
        "delay": 17
    }
},

{
    "type": "grenade",
    "name": [
        "Wall",
        "Wall"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1700.2589111328125,
        -513.3212890625,
        11839.03125
    ],
    "viewangles": [
        -29.575578689575195,
        115.36605834960938
    ],
    "grenade": {
        "delay": 30
    }
},
],
de_overpass: [
{
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "description": "Water",
    "weapon": "weapon_molotov",
    "position": [
        -1140.0997314453125,
        -581.4995727539063,
        137.06432342529297
    ],
    "viewangles": [
        6.933260917663574,
        108.49348449707031
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 26
        },
        "recover": {
            "direction": 1
        }
    }
},
{
                 active: true,
    "type": "grenade",
    "name": [
        "Pillar",
        "Pillar"
    ],
    "description": "SAFE",
    "weapon": "weapon_hegrenade",
    "position": [
        -1144.970458984375,
        -639.9501953125,
        137.65148162841797
    ],
    "viewangles": [
        -34.544639587402344,
        79.5704345703125
    ],
    "grenade": {
        "jump": true,
        "delay": 24
    }
},


{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "description": "",
    "weapon": "weapon_molotov",
    "position": [
        -1163.508056640625,
        -638.818359375,
        128.36901092529297
    ],
    "viewangles": [
        -21.64162826538086,
        72.61375427246094
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 2
        },
        "recover": {
            "direction": 2
        },
        "delay": 14,
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1481.09033203125,
        -924.1890258789063,
        98.41910552978516
    ],
    "viewangles": [
        -8.201221466064453,
        65.50170135498047
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 19
        },
        "recover": {
            "direction": 3
        },
        "delay": 9,
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -558.1513671875,
        -420.79608154296875,
        70.84511184692383
    ],
    "viewangles": [
        -21.861820220947266,
        118.09435272216797
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 26
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "description": "BY VIRTUAL LEGENDIG",
    "weapon": "weapon_hegrenade",
    "position": [
        -1102.7039794921875,
        -628.7923583984375,
        158.24777221679688
    ],
    "viewangles": [
        6.204055309295654,
        96.4414291381836
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 20
        },
        "recover": {
            "direction": 1
        },
        "delay": 4
    }
},
{
    "type": "grenade",
    "name": [
        "pillar",
        "pillar"
    ],
    "description": "run + jump + throw",
    "weapon": "weapon_molotov",
    "position": [
        -1246.4207763671875,
        -590.9064331054688,
        107.03610229492188
    ],
    "viewangles": [
        0.4840070605278015,
        72.375244140625
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 30
        },
        "recover": {
            "direction": 0
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Under Water",
        "Under Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -802.7581176757813,
        50.836124420166016,
        152.40988159179688
    ],
    "viewangles": [
        12.167223930358887,
        -134.5584716796875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Heaven",
        "Heaven"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -2106.4287109375,
        419.11480712890625,
        167.41458129882813
    ],
    "viewangles": [
        -20.773624420166016,
        60.80844497680664
    ]
},
{
    "type": "grenade",
    "name": [
        "Under Water/Left",
        "Under Water/Left"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -802.7581176757813,
        50.836124420166016,
        152.40988159179688
    ],
    "viewangles": [
        12.167223930358887,
        -136.26
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Water/Under Water",
        "Water/Under Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -537.0762329101563,
        348.6217956542969,
        91.21391677856445
    ],
    "viewangles": [
        -0.28116345405578613,
        -166.9292449951172
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 7
        },
        "recover": {
            "direction": 2
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Heaven",
        "Heaven"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -247.0463409423828,
        279.97161865234375,
        93.65642547607422
    ],
    "viewangles": [
        -5.622229099273682,
        169.26699829101563
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 8
        },
        "recover": {
            "direction": 2
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Heaven",
        "Heaven"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -900.4617309570313,
        -638.6920166015625,
        159.03125
    ],
    "viewangles": [
        -8.081936836242676,
        124.63648223876953
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 20
        },
        "recover": {
            "direction": 1
        },
        "delay": 6
    }
},



{
    "type": "grenade",
    "name": [
        "Short Hideshots",
        "Short Hideshots"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -799.8394165039063,
        -1628.0272216796875,
        207.91586303710938
    ],
    "viewangles": [
        -24.19723129272461,
        111.1356201171875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3
        },
        "recover": {
            "direction": 0
        },
        "delay": 17
    }
},
{
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -557.98486328125,
        -1060.58984375,
        94.6954574584961
    ],
    "viewangles": [
        -32.95468521118164,
        118.64433288574219
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 9
        },
        "recover": {
            "direction": 1
        },
        "delay": 20
    }
},
{
    "type": "grenade",
    "name": [
        "Pillar/Right side",
        "Pillar/Right"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -537.44677734375,
        -1155.7711181640625,
        127.01423645019531
    ],
    "viewangles": [
        -20.569934844970703,
        103.8547134399414
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 12
        },
        "recover": {
            "direction": 2
        },
        "delay": 17
    }
},
{
    "type": "grenade",
    "name": [
        "Backside Box",
        "Backside Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -624.9773559570313,
        -1134.432373046875,
        129.0105972290039
    ],
    "viewangles": [
        -24.33098793029785,
        122.87593841552734
    ]
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -980.35205078125,
        -33.34708023071289,
        159.03125
    ],
    "viewangles": [
        25.711170196533203,
        65.119384765625
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 12
        },
        "recover": {
            "direction": 2
        },
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -469.6809387207031,
        380.87628173828125,
        83.33428955078125
    ],
    "viewangles": [
        -2.529977560043335,
        -147.24708557128906
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 2
        },
        "delay": 6
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -469.6809387207031,
        380.87628173828125,
        83.33428955078125
    ],
    "viewangles": [
        -2.529977560043335,
        -147.24708557128906
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 2
        },
        "delay": 6
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -980.35205078125,
        -33.34708023071289,
        159.03125
    ],
    "viewangles": [
        25.711170196533203,
        65.119384765625
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 12
        },
        "recover": {
            "direction": 2
        },
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Pillar",
        "Pillar"
    ],
                description: "MOVEMENT",
    "weapon": "weapon_hegrenade",
    "position": [
        -1100.1917724609375,
        -528.8621215820313,
        154.24669647216797
    ],
    "viewangles": [
        23.030364990234375,
        102.42031860351563
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 16
        },
        "recover": {
            "direction": 1
        }
    }
},


{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -862.9799194335938,
        -575.4437255859375,
        159.03125
    ],
    "viewangles": [
        -12.97387981414795,
        88.42559051513672
    ],
    "grenade": {
        "delay": 3,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Rayzen Spot",
        "Rayzen Spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -268.4464111328125,
        -830.4052734375,
        107.22158813476563
    ],
    "viewangles": [
        -41.41463088989258,
        126.37787628173828
    ],
    "grenade": {
        "jump": true,
        "delay": 23
    }
},
{
    "type": "grenade",
    "name": [
        "Short Hideshots/Short",
        "Short Hideshots/Short"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -333.7139587402344,
        -764.7213745117188,
        107.66867065429688
    ],
    "viewangles": [
        -53.82000732421875,
        164.02716064453125
    ],
    "grenade": {
        "jump": true,
        "delay": 30
    }
},
{
    "type": "grenade",
    "name": [
        "Short",
        "Short"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -612.91796875,
        -935.8388671875,
        86.7864990234375
    ],
    "viewangles": [
        -32.21562194824219,
        128.5784454345703
    ],
    "grenade": {
        "jump": true,
        "delay": 15,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Short Hideshots",
        "Short Hideshots"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -434.1388854980469,
        -698.1571655273438,
        97.38862609863281
    ],
    "viewangles": [
        -53.8725700378418,
        175.0988006591797
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 9
        },
        "recover": {
            "direction": 0
        },
        "delay": 19,
        "strength": 1
    }
},
{
    "type": "grenade",
    "name": [
        "TT Spawn Fakeduck",
        "TT Spawn Fakeduck"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1574.1400146484375,
        -812.1095581054688,
        199.03125
    ],
    "viewangles": [
        -24.69887924194336,
        -37.80480194091797
    ]
},
{
    "type": "grenade",
    "name": [
        "Ladder",
        "Ladder"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1285.37060546875,
        -200.947265625,
        165.0498046875
    ],
    "viewangles": [
        -13.975526809692383,
        -52.72093963623047
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 4
        },
        "recover": {
            "direction": 0
        },
        "delay": 13,
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -549.4512329101563,
        -1114.4385986328125,
        112.23324584960938
    ],
    "viewangles": [
        -2.153210163116455,
        124.8218765258789
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 2
        },
        "delay": 4
    }
},
{
    "type": "grenade",
    "name": [
        "Under Water",
        "Under Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -571.2002563476563,
        -1235.1588134765625,
        172.6085968017578
    ],
    "viewangles": [
        4.474909782409668,
        108.50931549072266
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 27
        },
        "recover": {
            "direction": 2
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Backside Cement",
        "Backside Cement"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -176.09906005859375,
        -995.8305053710938,
        89.28288269042969
    ],
    "viewangles": [
        -3.777858018875122,
        161.0419464111328
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 21
        },
        "recover": {
            "direction": 2
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Cement",
        "Cement"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -218.37281799316406,
        -893.9412231445313,
        99.30256652832031
    ],
    "viewangles": [
        -3.1539881229400635,
        154.416015625
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 11
        },
        "recover": {
            "direction": 2
        },
        "delay": 1
    }
},

{
    "type": "grenade",
    "name": [
        "Pillar/Barrels",
        "Pillar/Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -520.0318603515625,
        -1098.4693603515625,
        105.60721588134766
    ],
    "viewangles": [
        -16.659421920776367,
        102.59219360351563
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 3
        },
        "delay": 13,
        "strength": 0
    }
},

{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -862.72412109375,
        -589.2939453125,
        159.03125
    ],
    "viewangles": [
        -9.09571647644043,
        88.5130386352539
    ]
},
{
    "type": "grenade",
    "name": [
        "Pillar",
        "Pillar"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -862.5198364257813,
        -566.1395874023438,
        159.03125
    ],
    "viewangles": [
        -33.85148239135742,
        87.87922668457031
    ]
},
{
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -862.3469848632813,
        -557.278564453125,
        159.03125
    ],
    "viewangles": [
        -31.027027130126953,
        109.09414672851563
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Under Water/Center",
        "Under Water/Center"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -629.2784423828125,
        -65.39813232421875,
        70.11775207519531
    ],
    "viewangles": [
        -23.462671279907227,
        171.12022399902344
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Short",
        "Short"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1559.9832763671875,
        -361.29669189453125,
        95.36310577392578
    ],
    "viewangles": [
        -39.40464401245117,
        29.878877639770508
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 2
        },
        "delay": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Backside Box",
        "Backside Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1128.1661376953125,
        -526.3523559570313,
        140.1271514892578
    ],
    "viewangles": [
        -33,
        -100.80604553222656
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 10
        },
        "recover": {
            "direction": 3
        },
        "strength": 0
    }
},
{ // 666
    "type": "grenade",
    "name": [
        "Under Water",
        "Under Water"
    ],
    "weapon": "weapon_molotov",
    "position": [
        -1119.4967041015625,
        -638.2053833007813,
        150.34825134277344
    ],
    "viewangles": [
        -41.074180603027344,
        110.448486328125
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 3
        },
        "delay": 22,
        "strength": 1
    }
},

{
    "type": "grenade",
    "name": [
        "Under Water/Right",
        "Under Water/Right"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -802.4291381835938,
        50.376914978027344,
        152.24498748779297
    ],
    "viewangles": [
        9.610669136047363,
        121.7793197631836
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 13
        },
        "recover": {
            "direction": 1
        }
    }
},


{
    "type": "grenade",
    "name": [
        "Rayzen Spot",
        "Rayzen Spot"
    ],
    "description": "",
    "weapon": "weapon_molotov",
    "position": [
        -1267.950927734375,
        -606.2687377929688,
        101.00826263427734
    ],
    "viewangles": [
        -37.03789138793945,
        45.14893341064453
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 4
        },
        "recover": {
            "direction": 0
        },
        "delay": 23,
        "strength": 0
    }
},

{
    "type": "grenade",
    "name": [
        "Ladder",
        "Ladder"
    ],
    "description": "",
    "weapon": "weapon_hegrenade",
    "position": [
        -815.964599609375,
        379.47027587890625,
        210.03125
    ],
    "viewangles": [
        9.400464057922363,
        -81.68367004394531
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 14
        },
        "recover": {
            "direction": 3
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Barrels",
        "Barrels"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -603.77783203125,
        -1269.9261474609375,
        189.99127197265625
    ],
    "viewangles": [
        -16.904375076293945,
        103.25932312011719
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 43
        },
        "recover": {
            "direction": 2
        },
        "delay": 16
    }
},
{
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -577.0045776367188,
        -1247.2232666015625,
        178.64634704589844
    ],
    "viewangles": [
        -16.85,
        120.98991394042969
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 43
        },
        "recover": {
            "direction": 2
        },
        "delay": 17
    }
},

{
    "type": "grenade",
    "name": [
        "Pillar",
        "Pillar"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -858.8850708007813,
        -577.755859375,
        159.03125
    ],
    "viewangles": [
        -37.6,
        88.7
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 3
        },
    }
},

{
    "type": "grenade",
    "name": [
        "Pillar",
        "Pillar"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1356.86962890625,
        -790.2357177734375,
        78.4253921508789
    ],
    "viewangles": [
        -6.744149208068848,
        82.63358306884766
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 30
        },
        "recover": {
            "direction": 2
        },
        "delay": 12
    }
},
{
    "type": "grenade",
    "name": [
        "Push",
        "Push"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1392.723876953125,
        -187.23452758789063,
        182.8154754638672
    ],
    "viewangles": [
        -7.3674540519714355,
        -36.784149169921875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 3
        },
        "delay": 12
    }
},
{
    "type": "grenade",
    "name": [
        "Push",
        "Push"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1875.35595703125,
        7.795431137084961,
        191.03125
    ],
    "viewangles": [
        -11.17393684387207,
        -32.810245513916016
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 25
        },
        "recover": {
            "direction": 1
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Ladder",
        "Ladder"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1874.859619140625,
        7.855689525604248,
        191.03125
    ],
    "viewangles": [
        -10.822586059570313,
        -37.795875549316406
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 30
        },
        "recover": {
            "direction": 1
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Ladder",
        "Ladder"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        -1392.3782958984375,
        -187.64419555664063,
        182.73233032226563
    ],
    "viewangles": [
        0.2995750904083252,
        -47.41744613647461
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 3
        },
        "delay": 8
    }
},
{
    "type": "grenade",
    "name": [
        "Rayzen Spot",
        "Rayzen Spot"
    ],
    "description": "MOVEMENT",
    "weapon": "weapon_hegrenade",
    "position": [
        -1129.8394775390625,
        -527.9086303710938,
        139.37017822265625
    ],
    "viewangles": [
        14.511691093444824,
        92.3847427368164
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 21
        },
        "recover": {
            "direction": 1
        },
        "strength": 0
    }
},



{
                 active: true,
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "description": "SAFE",
    "weapon": "weapon_hegrenade",
    "position": [
        -1096.8193359375,
        -594.4310913085938,
        159.0198516845703
    ],
    "viewangles": [
        -18.836620330810547,
        95.76488494873047
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3
        },
        "recover": {
            "direction": 3
        },
        "delay": 20
    }
},
{
    "type": "grenade",
    "name": [
        "Backside Box",
        "Backside Box"
    ],
    "description": "",
    "weapon": "weapon_hegrenade",
    "position": [
        -1129.529541015625,
        -526.2329711914063,
        139.43199157714844
    ],
    "viewangles": [
        -13.662925720214844,
        -102.99110412597656
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 23
        },
        "recover": {
            "direction": 3
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Water",
        "Water"
    ],
    "description": "",
    "weapon": "weapon_hegrenade",
    "position": [
        -859.2581176757813,
        -575.8092651367188,
        159.03125
    ],
    "viewangles": [
        -8.27,
        112.71846008300781
    ],
    "grenade": {
        "strength": 1
    }
},

],
de_inferno: [
{
    "type": "grenade",
    "name": [
        "Library/Peek spot",
        "Library/Peek spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1853.482421875,
        1435.500732421875,
        223.03125
    ],
    "viewangles": [
        0.3552999198436737,
        -141.01077270507813
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Library/Peek spot",
        "Library/Peek spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1853.482421875,
        1435.500732421875,
        223.03125
    ],
    "viewangles": [
        0.3552999198436737,
        -141.01077270507813
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "A Box",
        "A Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2084.9453125,
        1225.9276123046875,
        237.03125
    ],
    "viewangles": [
        -34.126617431640625,
        -89.46774291992188
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 16
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Graveyard",
        "Graveyard"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1984.2388916015625,
        1225.9154052734375,
        237.03125
    ],
    "viewangles": [
        -18.735736846923828,
        -65.9173583984375
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 3
        },
        "delay": 18
    }
},
{
    "type": "grenade",
    "name": [
        "Graveyard",
        "Graveyard"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2043.001220703125,
        1223.4326171875,
        237.03125
    ],
    "viewangles": [
        -19.790029525756836,
        -65.19926452636719
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1,
            "walk": true
        },
        "recover": {
            "direction": 0
        },
        "delay": 21
    }
},
{
    "type": "grenade",
    "name": [
        "Central Box/Both Sides",
        "Central Box/Both Sides"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1961.2913818359375,
        1123.807861328125,
        220.99343872070313
    ],
    "viewangles": [
        -41.4,
        -91.4
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Central Box/Right Side",
        "Central Box/Right Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1962.027099609375,
        1123.73046875,
        220.9476318359375
    ],
    "viewangles": [
        -51.2040901184082,
        -91.89128875732422
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 1
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Right Side",
        "Right Side"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2126.03125,
        1119.6759033203125,
        222.49961853027344
    ],
    "viewangles": [
        -63.92449951171875,
        -112.37675476074219
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 13
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Central Box",
        "Central Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1940.1502685546875,
        1188.19482421875,
        224.18772888183594
    ],
    "viewangles": [
        4.104398250579834,
        -38.580841064453125
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 48
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "A Box/Central Box",
        "A Box/Central Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2035.603759765625,
        1225.861083984375,
        237.03125
    ],
    "viewangles": [
        -41.92725372314453,
        -91.4042739868164
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 15
        },
        "recover": {
            "direction": 1
        },
        "delay": 3
    }
},
{
    "type": "grenade",
    "name": [
        "A Box",
        "A Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2486.06640625,
        973.1739501953125,
        226.59747314453125
    ],
    "viewangles": [
        -2.5014142990112305,
        -134.77406311035156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 1
        },
        "delay": 3
    }
},
{
    "type": "grenade",
    "name": [
        "A Box",
        "A Box"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2112.59130859375,
        1218.1297607421875,
        232.34242248535156
    ],
    "viewangles": [
        -7.210268974304199,
        -90.96599578857422
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3,
            "walk": true
        },
        "recover": {
            "direction": 0
        },
        "delay": 10
    }
},
{
    "type": "grenade",
    "name": [
        "Far Box",
        "Far Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1983.9481201171875,
        1225.94091796875,
        237.03125
    ],
    "viewangles": [
        -38.69463348388672,
        -92.41629791259766
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 10
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Near Box",
        "Near Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2064.03662109375,
        1120.5323486328125,
        221.80104064941406
    ],
    "viewangles": [
        -56.75608444213867,
        -93.46194458007813
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Pit",
        "Pit"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2085.75830078125,
        1225.0418701171875,
        237.03125
    ],
    "viewangles": [
        -17.611412048339844,
        -73.36219024658203
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 4
        },
        "recover": {
            "direction": 2
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Lane",
        "Lane"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1853.37109375,
        1432.3729248046875,
        223.03125
    ],
    "viewangles": [
        -54.573280334472656,
        -131.4492645263672
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 10
        },
        "recover": {
            "direction": 3
        }
    }
},

{
    "type": "grenade",
    "name": [
        "Library Lane",
        "Library Lane"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2068.938232421875,
        149.88516235351563,
        223.03125
    ],
    "viewangles": [
        -10.744037628173828,
        65.86781311035156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 4
        },
        "recover": {
            "direction": 0
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Full A Backsite",
        "Full A Backsite"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2097.340087890625,
        1156.276611328125,
        225.93113708496094
    ],
    "viewangles": [
        -1.2773255109786987,
        -49.07362365722656
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 43
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "In Apartaments",
        "In Apartaments"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2248.57470703125,
        1207.43603515625,
        231.42507934570313
    ],
    "viewangles": [
        -5.108963966369629,
        -102.71864318847656
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 3
        },
        "delay": 5
    }
},
{
    "type": "grenade",
    "name": [
        "Mid",
        "Mid"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2239.79296875,
        489.3211364746094,
        207.2701416015625
    ],
    "viewangles": [
        -53.1750373840332,
        -164.83712768554688
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 30
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Mid",
        "Mid"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2239.739990234375,
        489.3350524902344,
        207.2587432861328
    ],
    "viewangles": [
        -54.71887969970703,
        177.86392211914063
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 30
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Mid",
        "Mid"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2239.78125,
        488.8037414550781,
        207.22891235351563
    ],
    "viewangles": [
        -48.66883850097656,
        152.3865966796875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 30
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Library",
        "Library"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1370.0240478515625,
        958.1589965820313,
        211.03125
    ],
    "viewangles": [
        4.167775630950928,
        18.328327178955078
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Library Lane",
        "Library Lane"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2068.938232421875,
        149.88516235351563,
        223.03125
    ],
    "viewangles": [
        -10.744037628173828,
        65.86781311035156
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 4
        },
        "recover": {
            "direction": 0
        },
        "delay": 15
    }
},
{
    "type": "grenade",
    "name": [
        "Long",
        "Long"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2099.963623046875,
        147.42747497558594,
        223.03125
    ],
    "viewangles": [
        -3.679636240005493,
        89.15043640136719
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 3,
            "duration": 3
        },
        "recover": {
            "direction": 0
        },
        "delay": 5
    }
},
{
    "type": "grenade",
    "name": [
        "Under Balcony",
        "Under Balcony"
    ],
    "weapon": "weapon_molotov",
    "position": [
        2147.96875,
        1225.96923828125,
        235.1833953857422
    ],
    "viewangles": [
        -0.6042360067367554,
        -92.00032043457031
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 0
        },
        "delay": 5
    }
},
{
    "type": "grenade",
    "name": [
        "Under Balcony",
        "Under Balcony"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1742.147216796875,
        -108.26848602294922,
        193.3901824951172
    ],
    "viewangles": [
        -20.494890213012695,
        61.83858871459961
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 9
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Under Balcony",
        "Under Balcony"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1743.8665771484375,
        -108.45946502685547,
        193.36636352539063
    ],
    "viewangles": [
        5.6731462478637695,
        61.951881408691406
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Library/Peek spot",
        "Library/Peek spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1342.1280517578125,
        -27.08279037475586,
        335.25335693359375
    ],
    "viewangles": [
        -39.49935531616211,
        46.430057525634766
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 3
        },
        "delay": 26
    }
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1341.1981201171875,
        11.981414794921875,
        325.2374267578125
    ],
    "viewangles": [
        -25.211963653564453,
        41.43450164794922
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 5
        },
        "recover": {
            "direction": 3
        },
        "delay": 2
    }
},
{
    "type": "grenade",
    "name": [
        "Side/Far Spot",
        "Side/Far Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1834.2598876953125,
        34.07372283935547,
        191.03125
    ],
    "viewangles": [
        -15.530592918395996,
        43.72111511230469
    ],
    "grenade": {
        "run": {
            "direction": 0,
            "duration": 3
        },
        "recover": {
            "direction": 3
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Side/Near Spot",
        "Side/Near Spot"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1834.8905029296875,
        34.46489715576172,
        191.03125
    ],
    "viewangles": [
        -7.50125789642334,
        47.04848098754883
    ]
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1834.9571533203125,
        60.10941696166992,
        191.03125
    ],
    "viewangles": [
        -13.744556427001953,
        42.89031982421875
    ]
},
{
    "type": "grenade",
    "name": [
        "Long Push",
        "Long Push"
    ],
    "weapon": "weapon_molotov",
    "position": [
        899.6722412109375,
        -130.2457733154297,
        359.03125
    ],
    "viewangles": [
        8.060952186584473,
        52.4578857421875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 20,
            "walk": true
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Pit",
        "Pit"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1395.7021484375,
        239.27566528320313,
        191.22296142578125
    ],
    "viewangles": [
        11.596497535705566,
        -8.4240140914917
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 2,
            "duration": 12
        },
        "recover": {
            "direction": 1
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1085.1456298828125,
        533.529052734375,
        167.88909912109375
    ],
    "viewangles": [
        -57.099029541015625,
        -2.5369277000427246
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 65
        },
        "recover": {
            "direction": 2
        },
        "strength": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Library/Peek spot",
        "Library/Peek spot"
    ],
    "description": "MOVEMENT",
    "weapon": "weapon_hegrenade",
    "position": [
        1487.388427734375,
        980.29052734375,
        211.42877197265625
    ],
    "viewangles": [
        22.15,
        -16.47
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 10
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "A Box/Near box",
        "A Box/Near box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1440.0216064453125,
        227.40809631347656,
        193.77366638183594
    ],
    "viewangles": [
        -1.5040830373764038,
        -51.63657760620117
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "A Box",
        "A Box"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1815.532958984375,
        1375.3316650390625,
        223.03125
    ],
    "viewangles": [
        -23.786287307739258,
        -73.20293426513672
    ],
    "grenade": {
        "delay": 25
    }
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1341.03125,
        26.031238555908203,
        196.54188537597656
    ],
    "viewangles": [
        -36.245704650878906,
        39.509735107421875
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "A Box/Left side",
        "A Box/Left side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1330.7042236328125,
        256.29315185546875,
        195.4660186767578
    ],
    "viewangles": [
        -43.515625,
        4.356857776641846
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Graveyard",
        "Graveyard"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1336.8203125,
        251.40513610839844,
        194.82408142089844
    ],
    "viewangles": [
        0.38815033435821533,
        -32.4769287109375
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 18
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Graveyard",
        "Graveyard"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1763.140869140625,
        1415.3763427734375,
        223.03125
    ],
    "viewangles": [
        4.9108781814575195,
        -58.66627883911133
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 2
        },
        "recover": {
            "direction": 1
        },
        "delay": 0
    }
},
{
    "type": "grenade",
    "name": [
        "Under Balcony",
        "Under Balcony"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1288.1351318359375,
        324.4903869628906,
        192.03125
    ],
    "viewangles": [
        -43.231361389160156,
        -30.4737548828125
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 11
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Hay Cart Back",
        "Hay Cart Back"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1185.03125,
        359.9686584472656,
        191.03125
    ],
    "viewangles": [
        -52.235774993896484,
        -23.88720703125
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 40
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Graveyard",
        "Graveyard"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1078.807373046875,
        588.843505859375,
        170.33428955078125
    ],
    "viewangles": [
        -35.22151565551758,
        -8.11115837097168
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 50
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Long Push",
        "Long Push"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        1119.7835693359375,
        434.36163330078125,
        169.886474609375
    ],
    "viewangles": [
        -55.76872253417969,
        54.448116302490234
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 22
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Short Push",
        "Short Push"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1117.1556396484375,
        587.922607421875,
        177.6070556640625
    ],
    "viewangles": [
        -50.9928092956543,
        -47.908287048339844
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 8
        },
        "recover": {
            "direction": 2
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Archade",
        "Archade"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1102.4599609375,
        461.03436279296875,
        166.3852996826172
    ],
    "viewangles": [
        -38.85353088378906,
        47.676002502441406
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 17
        },
        "recover": {
            "direction": 1
        }
    }
},
{
    "type": "grenade",
    "name": [
        "Side",
        "Side"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1303.8048095703125,
        528.0307006835938,
        186.60028076171875
    ],
    "viewangles": [
        -51.588722229003906,
        4.444694519042969
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "recover": {
            "direction": 2
        },
        "delay": 7
    }
},
{
    "type": "grenade",
    "name": [
        "Library/Peek spot",
        "Library/Peek spot"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1314.7420654296875,
        797.1519165039063,
        209.4739227294922
    ],
    "viewangles": [
        -36.56919479370117,
        5.570029258728027
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 7
        },
        "delay": 1
    }
},
{
    "type": "grenade",
    "name": [
        "Box A",
        "Box A"
    ],
    "weapon": "weapon_hegrenade",
    "position": [
        2153.304443359375,
        1010.8685913085938,
        222.8515625
    ],
    "viewangles": [
        15.660511016845703,
        -107.587890625
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 1,
            "duration": 11
        },
        "recover": {
            "direction": 2
        },
        "delay": 3
    }
},
{
    "type": "grenade",
    "name": [
        "Archade",
        "Archade"
    ],
    "weapon": "weapon_molotov",
    "position": [
        1412.0421142578125,
        708.988037109375,
        198.11587524414063
    ],
    "viewangles": [
        -43.49305725097656,
        57.978214263916016
    ],
    "grenade": {
        "jump": true,
        "run": {
            "direction": 0,
            "duration": 6
        },
        "delay": 0
    }
},
]
}
exports.locations = locations;
 
Забаненный
Статус
Оффлайн
Регистрация
8 Июл 2021
Сообщения
45
Реакции[?]
26
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Забаненный
Статус
Оффлайн
Регистрация
19 Сен 2020
Сообщения
318
Реакции[?]
97
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Сверху Снизу