Fake Wraith Paste NL - Lua

--[[
* scammed his lua dev ;w;

* also retard stealing names from other luas, it was called "wraith" lmao nice
raz fan :joy:
* scammer discord: Naz1#2676
* scammer discord id: 752972533933932676
--]]
-- ? AJUDA
-- TODO: Renderizar Um Texto Com WRAITH no tab se existe algum usuario de wraith.
Código de exemplo:
render.texture(render.load_image(network.get("https://c.tenor.com/
cDX6Hvr5IYMAAAAC/pornhub-community-logo.gif")), vector(465, 435), vector(15, 15))
-- * gradiente = function(vermelho1, verde1, azul1, transparencia1; vermelho2,
verde2, azul2, transparencia2, "texto")
-- * Preto: 0, 0, 0, 255
-- * Branco: 255, 255, 255, 255
-- * Cor da lua: 255, 100, 100, 255; 255, 100, 100, 100
-- ! local dt = not cheat.ref.doubletap:get(); Essa funcao checa se o doubletap ta
ativado
-- ? AJUDA
_DEBUG = true
local enc = require("neverlose/crc32")
local b_render = require("neverlose/b_renderer")
-- *Relacionado ao Cheat*
local cheat = {
-- *Referencias*
ref = {
doubletap = ui.find("aimbot", "ragebot", "main", "double tap"),

hideshots = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
fakeduck = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck") ,
dynamic = ui.find("Aimbot", "Ragebot", "Accuracy", "Auto Stop", "Dynamic
Mode"),
accuracy = ui.find("Aimbot", "Ragebot", "Accuracy", "Auto Stop", "Force
Accuracy"),
delayshot = ui.find("Aimbot", "Ragebot", "Selection", "Minimum Damage",
"Delay Shot"),
stricthc = ui.find("Aimbot", "Ragebot", "Selection", "Hit Chance", "Strict
Hit Chance"),
pitch = ui.find("Aimbot", "Anti Aim", "Angles", "Pitch"),
offset = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset"),
yaw = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw"),
modifier = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier"),
moffset = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier",
"Offset"),
limit1 = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Left Limit"),
limit2 = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Right
Limit"),
freestand = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"),
antistab = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Avoid
Backstab"),
bodyyaw = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw"),
roll = ui.find("Aimbot", "Anti Aim", "Angles", "Extended Angles"),
rollval = ui.find("Aimbot", "Anti Aim", "Angles", "Extended Angles",
"Extended Roll"),
airstrafe = ui.find("Miscellaneous", "Main", "Movement", "Air Strafe"),
legmov = ui.find("Aimbot", "Anti Aim", "Misc", "Leg Movement"),
slowwalk = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
lagoptions = ui.find("Aimbot", "Ragebot", "Main", "Double Tap", "Lag
Options"),
fakelag = ui.find("Aimbot", "Anti Aim", "Fake Lag", "Limit"),
asoptions = ui.find("Aimbot", "Ragebot", "Accuracy", "Auto Stop",
"Options"),
asdtoptions = ui.find("Aimbot", "Ragebot", "Accuracy", "Auto Stop", "Double
Tap")
-- *Utilidades*
local utils = {
-- *Frases da killsay*
killsay_phrases = {
"get resolved by wraith",
"buy now en.neverlose.cc/market/item?id=p6dLNl",
"destroyed by wraith",
"luckzera faliu o zurmely KKKKJ"
},
-- *Animação*
animation = {
["lerp"] = nil,
["new"] = nil,
["data"] = { }
},
-- *Fontes*
fonts = {
["small_pixel"] = render.load_font("Smallest Pixel-7", 10, "o"),
},
-- *Gradiente*
gradient = function(r1, g1, b1, a1, r2, g2, b2, a2, text)
local output = ''

local len = #text-1
local rinc = (r2 - r1) / len
local ginc = (g2 - g1) / len
local binc = (b2 - b1) / len
local ainc = (a2 - a1) / len
for i=1, len+1 do

output = output .. ('\a%02x%02x%02x%02x%s'):format(r1, g1, b1, a1,
text:sub(i, i))
r1 = r1 + rinc
g1 = g1 + ginc
b1 = b1 + binc
a1 = a1 + ainc
end
return output
end,
-- *Grupos (Tabs)*
groups = {
main = ui.create("Main", "Main"),

ragebot = ui.create("Aimbot", "Rage-Bot"),
antiaim = ui.create("Aimbot", "Anti-Aim"),
visuals = ui.create("Visuals", "Indicators"),
other = ui.create("Other", "Main")
},
-- *Callbacks (Usados para executar o codigo)*

callbacks = {
draw = function(to_register)
if to_register == nil then

if _DEBUG == true then
print("Forgot to type-in function name when calling the
callback!")
return
else
common.add_notify("ERROR", "Check console for more info!")
return print_raw("Please Send the following code \afa7373" ..
enc.crc32("draw_error") .. "\aFFFFFF in this dm\afa7373 $omeone#4103")
end
end
events.render:set(to_register)
end,
aim_ack = function(to_register)

callback!")
return
else
enc.crc32("aim_ack_error") .. "\aFFFFFF in this dm\afa7373 $omeone#4103")
end
end
events.aim_ack:set(function(e) to_register(e) end)
end,
createmove = function(to_register)

callback!")
return
else
enc.crc32("createmove_error") .. "\aFFFFFF in this dm\afa7373 $omeone#4103")
end
end
events.createmove:set(to_register)
end,
player_death = function(to_register)

callback!")
return
else
enc.crc32("player_death_error") .. "\aFFFFFF in this dm\afa7373 $omeone#4103")
end
end
events.player_death:set(function(e) to_register(e) end)
end
},
console_exec = function(to_execute)
utils.console_exec(to_execute)
end
-- *Sla lol*
local text_color = utils.gradient(150, 170, 255, 255, 150, 170, 255, 100, "[+] ")
-- *Menu da lua*
local menu = {
main = { ["button_discord"] = nil },

ragebot = { ["switch_rage"] = nil, ["switch_resolver"] = nil,
["switch_jumpscout"] = nil, ["switch_accuracy"] = nil, ["combo_accuracy"] = nil,
["switch_idealtick"] = nil },
antiaim = { ["switch_aa"] = nil, ["combo_presets"] = nil, builder
= { } },
visuals = { ["switch_watermark"] = nil, ["switch_indicators"] = nil,
["cpicker_menu"] = nil },
other = { ["switch_leg_break"] = nil, ["switch_killsay"] = nil,
["switch_antistab"] = nil, ["switch_logs"] = nil },
utils.animation["lerp"] = function(start, end_pos, time)
if type(start) == 'userdata' then
local color_data = {0, 0, 0, 0}
for i, color_key in ipairs({'r', 'g', 'b', 'a'}) do

color_data[i] = utils.animation["lerp"](start[color_key],
end_pos[color_key], time)
end
return color(unpack(color_data))
end
return (end_pos - start) * (globals.frametime * time * 175) + start
end
utils.animation["new"] = function(name, value, time)
if utils.animation["data"][name] == nil then
utils.animation["data"][name] = value
end
utils.animation["data"][name] = utils.animation["lerp"](utils.animation["data"]
[name], value, time)
return utils.animation["data"][name]
end
-- *Sidebar da lua*
ui.sidebar(utils.gradient(150, 170, 255, 255, 150, 170, 255, 100, 'wraith.sys'),
'shield-alt')
-- ! Se A fonte nao estiver baixada
if not files.read("nl/wraith/font.ttf") then
-- *Cria um botao chamado "Download Font" no grupo "MAIN" que ao clicar baixa
uma fonte no diretório "nl/wraith/"*
utils.groups.main:button("Download Font", function()
files.create_folder("nl/wraith")
files.write("nl/wraith/font.ttf", network.get("https://cdn-
104.anonfiles.com/56A7C08ey0/ea9db6eb-1663531785/font.ttf"))
end)
-- *Cria um text no grupo "MAIN"*

utils.groups.main:label("1. Click on the button to Download the font\n2.
Download the in the folder 'nl/wraith'\n3. Reload the script and Enjoy!")
return
end
-- *Main*
-- *Ragebot*
menu.ragebot["switch_rage"] = utils.groups.ragebot:switch(text_color .. "\

aFFFFFFFFEnable Ragebot", false)
menu.ragebot["switch_resolver"] = utils.groups.ragebot:switch(text_color .. "\
aFFFFFFFFEnable Calculate Angle", false)
menu.ragebot["switch_jumpscout"] = utils.groups.ragebot:switch(text_color .. "\
aFFFFFFFFEnable JumpScout Fix", false)
menu.ragebot["switch_accuracy"] = utils.groups.ragebot:switch(text_color .. "\
aFFFFFFFFEnable Accuracy Fix", false)
menu.ragebot["combo_accuracy"] =
menu.ragebot["switch_accuracy"]:create():combo("Accuracy Mode", "Safest", "Safe",
"Unsafe")
menu.ragebot["switch_idealtick"] = utils.groups.ragebot:switch(text_color .. "\
aFFFFFFFFEnable Ideal Tick", false)
-- *AntiAim*
menu.antiaim["switch_aa"] =
utils.groups.antiaim:switch(text_color .. "\aFFFFFFFFEnable AntiAim", false)
menu.antiaim["combo_presets"] = utils.groups.antiaim:combo
(text_color .. "\aFFFFFFFFPresets", "Jitter High", "Jitter Low", "Low Delta",
"Custom")
menu.antiaim.builder["combo_state"] = utils.groups.antiaim:combo
(text_color .. "\aFFFFFFFFState", "Standing", "Walking", "Running", "Air")
menu.antiaim.builder["combo_jitter_mode#standing"] = utils.groups.antiaim:combo
(text_color .. "\aFFFFFFFFJitter Mode", "Disabled", "Center")
menu.antiaim.builder["slider_yaw_offset#standing"] =
utils.groups.antiaim:slider(text_color .. "\aFFFFFFFFYaw Offset", -180, 180, 0)
menu.antiaim.builder["slider_jitter_offset#standing"] =
utils.groups.antiaim:slider(text_color .. "\aFFFFFFFFJitter Offset", -180, 180, 0)
menu.antiaim.builder["slider_left_limit#standing"] =
utils.groups.antiaim:slider(text_color .. "\aFFFFFFFFLeft Limit", 0, 60, 60)
menu.antiaim.builder["slider_right_limit#standing"] =
utils.groups.antiaim:slider(text_color .. "\aFFFFFFFFRight Limit", 0, 60, 60)
menu.antiaim.builder["combo_jitter_mode#walking"] = utils.groups.antiaim:combo
menu.antiaim.builder["slider_yaw_offset#walking"] =
menu.antiaim.builder["slider_jitter_offset#walking"] =
menu.antiaim.builder["slider_left_limit#walking"] =
menu.antiaim.builder["slider_right_limit#walking"] =
menu.antiaim.builder["combo_jitter_mode#running"] = utils.groups.antiaim:combo
menu.antiaim.builder["slider_yaw_offset#running"] =
menu.antiaim.builder["slider_jitter_offset#running"] =
menu.antiaim.builder["slider_left_limit#running"] =
menu.antiaim.builder["slider_right_limit#running"] =
menu.antiaim.builder["combo_jitter_mode#air"] = utils.groups.antiaim:combo
menu.antiaim.builder["slider_yaw_offset#air"] =
menu.antiaim.builder["slider_jitter_offset#air"] =
menu.antiaim.builder["slider_left_limit#air"] =
menu.antiaim.builder["slider_right_limit#air"] =
-- *Visuals*
menu.visuals["switch_watermark"] = utils.groups.visuals:switch (text_color ..

"\aFFFFFFFFEnable Watermark", false)
menu.visuals["switch_indicators"] = utils.groups.visuals:switch (text_color ..
"\aFFFFFFFFEnable Indicators", false)
menu.visuals["cpicker_menu"] = utils.groups.visuals:color_picker(text_color ..
"\aFFFFFFFFEnable Menu Color", color(150, 170, 255, 255))
-- *Misc*
menu.other["switch_leg_break"] = utils.groups.other:switch(text_color .. "\

aFFFFFFFFEnable Leg Breaker", false)
menu.other["switch_antistab"] = utils.groups.other:switch(text_color .. "\
aFFFFFFFFEnable Anti Backstab", false)
menu.other["switch_killsay"] = utils.groups.other:switch(text_color .. "\
aFFFFFFFFEnable Killsay", false)
menu.other["switch_logs"] = utils.groups.other:switch(text_color .. "\
aFFFFFFFFEnable Logs", false)
-- *Funçoes*
hitgroups = { [0] = 'generic', 'head', 'chest', 'stomach', 'left arm', 'right arm',
'left leg', 'right leg', 'neck', 'generic', 'gear' }
logs = function(e)
local target, damage, wanted_damage, wanted_hitgroup, hc, state, bt

= entity.get(e.target), e.damage, e.wanted_damage,
hitgroups[e.wanted_hitgroup], e.hitchance, e.state, e.backtrack
if not target then return end
local hp = target["m_iHealth"]
local hitgroup = hitgroups[e.hitgroup]
if state == "spread" then state = "\aFEEA7Dspread"end

if state == "prediction error" then state = "\aFEEA7Dpred. error"
end
if state == "correction" then state = "\aFF5959resolver"
end
if state == "jitter correction" then state = "\aFF5959jitter
correction \aa2a0ff(angle: " .. string.format("%.3f", e.spread * 12) .. ")" end
if state == "lagcomp failure" then state = "\aFF5959backtrack"
end
if state == "unregistered shot" then state = "\a999999unregistered
shot" end
if state ~= nil then print_raw(("\aFF6464[wraith] \aD5D5D5Missed shot at \

aFF6464%s\aFFFFFF's \aFF6464%s \aFFFFFFdue to "..state..'\aFF6464 (hc:
'..string.format("%.f", hc)..') (damage: '..string.format("%.f",
wanted_damage)..')'):format(target:get_name(), wanted_hitgroup)) return end
print_raw(("\aFF6464[wraith] \aD5D5D5Registered shot at \aFF6464%s\aFFFFFF's \

aFF6464%s \aFFFFFFfor \aFF6464".. damage .." \aFFFFFFdamage\aFF6464 (hp: "..hp..")
(aimed: "..wanted_hitgroup..") (bt: %s)"):format(target:get_name(), hitgroup,
e.damage, bt))
end
jumpscout = function()
cheat.ref.airstrafe:set( not menu.ragebot["switch_jumpscout"]:get())
end
antibackstab = function()
cheat.ref.antistab:set(menu.other["switch_antistab"]:get())
end
antiaim = function()
tick = globals.client_tick % 30 > 15
cheat.ref.pitch:set("Down")
cheat.ref.yaw:set("Backward")
for _, menu_items in pairs(menu.antiaim.builder) do
menu_items:set_visible(menu.antiaim["combo_presets"]:get() == "Custom")
end
if menu.antiaim["combo_presets"]:get() == "Jitter High" then
cheat.ref.modifier:set("Center")
cheat.ref.moffset:set(tick and -37 or 37)
cheat.ref.offset:set(tick and -2 or 2)
cheat.ref.limit1:set(tick and math.random(10, 30) or 60)
return
elseif menu.antiaim["combo_presets"]:get() == "Jitter Low" then
return
elseif menu.antiaim["combo_presets"]:get() == "Low Delta" then
return
elseif menu.antiaim["combo_presets"]:get() == "Custom" then
local standing = { yaw_offset =

menu.antiaim.builder["slider_yaw_offset#standing"], jitter_mode =
menu.antiaim.builder["combo_jitter_mode#standing"], jitter_offset =
menu.antiaim.builder["slider_jitter_offset#standing"], limit1 =
menu.antiaim.builder["slider_left_limit#standing"], limit2 =
menu.antiaim.builder["slider_right_limit#standing"] }
local walking = { yaw_offset =
menu.antiaim.builder["slider_yaw_offset#walking"] , jitter_mode =
menu.antiaim.builder["combo_jitter_mode#walking"] , jitter_offset =
menu.antiaim.builder["slider_jitter_offset#walking"] , limit1 =
menu.antiaim.builder["slider_left_limit#walking"] , limit2 =
menu.antiaim.builder["slider_right_limit#walking"] }
local running = { yaw_offset =
menu.antiaim.builder["slider_yaw_offset#running"] , jitter_mode =
menu.antiaim.builder["combo_jitter_mode#running"] , jitter_offset =
menu.antiaim.builder["slider_jitter_offset#running"] , limit1 =
menu.antiaim.builder["slider_left_limit#running"] , limit2 =
menu.antiaim.builder["slider_right_limit#running"] }
local air = { yaw_offset =
menu.antiaim.builder["slider_yaw_offset#air"] , jitter_mode =
menu.antiaim.builder["combo_jitter_mode#air"] , jitter_offset =
menu.antiaim.builder["slider_jitter_offset#air"] , limit1 =
menu.antiaim.builder["slider_left_limit#air"] , limit2 =
menu.antiaim.builder["slider_right_limit#air"]}
--standing.yaw_offset:set_visible(false)
--standing.jitter_mode:set_visible(false)
--standing.jitter_offset:set_visible(false)
--walking.yaw_offset:set_visible(false)
--walking.jitter_mode:set_visible(false)
--walking.jitter_offset:set_visible(false)
--running.yaw_offset:set_visible(false)
--running.jitter_mode:set_visible(false)
--running.jitter_offset:set_visible(false)
--air.yaw_offset:set_visible(false)
--air.jitter_mode:set_visible(false)
--air.jitter_offset:set_visible(false)
if menu.antiaim["combo_presets"]:get() ~= "Custom" then return end
if menu.antiaim.builder["combo_state"]:get() == "Standing"then
for _, standing in pairs(standing) do standing:set_visible(true) end

for _, walking in pairs(walking) do walking:set_visible(false) end
for _, running in pairs(running) do running:set_visible(false) end
for _, air in pairs(air) do air:set_visible(false) end
elseif menu.antiaim.builder["combo_state"]:get() == "Walking" then
for _, standing in pairs(standing) do standing:set_visible(false) end

for _, walking in pairs(walking) do walking:set_visible(true) end
elseif menu.antiaim.builder["combo_state"]:get() == "Running" then

for _, running in pairs(running) do running:set_visible(true) end
elseif menu.antiaim.builder["combo_state"]:get() == "Air" then

for _, air in pairs(air) do air:set_visible(true) end
end
--for _, state in pairs(menu.antiaim.builder) do

-- state:set_visible(menu.antiaim["combo_presets"]:get() == "Custom")
--end
local speed = entity.get_local_player().m_vecVelocity:length()
if speed < 2 then
cheat.ref.offset:set
(menu.antiaim.builder["slider_yaw_offset#standing"] :get())
cheat.ref.modifier:set(menu.antiaim.builder["combo_jitter_mode#standing"] :get())
cheat.ref.moffset:set
(menu.antiaim.builder["slider_jitter_offset#standing"]:get())
cheat.ref.limit1:set
(menu.antiaim.builder["slider_left_limit#standing"] :get())
(menu.antiaim.builder["slider_right_limit#standing"] :get())
end
if cheat.ref.slowwalk:get() then
(menu.antiaim.builder["slider_yaw_offset#walking"] :get())
cheat.ref.modifier:set(menu.antiaim.builder["combo_jitter_mode#walking"] :get())
(menu.antiaim.builder["slider_jitter_offset#walking"]:get())
(menu.antiaim.builder["slider_left_limit#walking"] :get())
(menu.antiaim.builder["slider_right_limit#walking"] :get())
end
if not cheat.ref.slowwalk:get() and speed > 2 then
(menu.antiaim.builder["slider_yaw_offset#running"] :get())
cheat.ref.modifier:set(menu.antiaim.builder["combo_jitter_mode#running"] :get())
(menu.antiaim.builder["slider_jitter_offset#running"]:get())
(menu.antiaim.builder["slider_left_limit#running"] :get())
(menu.antiaim.builder["slider_right_limit#running"] :get())
end
if bit.band(entity.get_local_player().m_fFlags, 1) == 0 then
(menu.antiaim.builder["slider_yaw_offset#air"] :get())
cheat.ref.modifier:set(menu.antiaim.builder["combo_jitter_mode#air"] :get())
(menu.antiaim.builder["slider_jitter_offset#air"]:get())
(menu.antiaim.builder["slider_left_limit#air"] :get())
(menu.antiaim.builder["slider_right_limit#air"] :get())
end
end
end
watermark = function()
if not menu.visuals["switch_watermark"]:get() then return end
local screen_x, screen_y = render.screen_size().x, render.screen_size().y

local watermark_text = 'wraith.sys | ' .. common.get_username() .. ' | ' ..
common.get_date("%m/%d")
local text_size = render.measure_text(utils.fonts["small_pixel"], "",
watermark_text)
local val = globals.realtime % 4 > 2

local val2 = globals.realtime % 4 > 2
local pos_x = utils.animation["new"]('teste pos', val2 and text_size.x + 10 or

30, 0.015)
--local color = menu.visuals["cpicker_menu"].r():get()
local col = menu.visuals["cpicker_menu"]:get()
b_render.rectangle(screen_x - text_size.x - 10, 10, 125, 1.5, 100, 100, 100,

255)
b_render.rectangle(screen_x - pos_x, 10, 20, 1.5, col.r, col.g, col.b, 255)
render.blur(vector(screen_x - text_size.x - 10, text_size.y), vector(screen_x -

text_size.x + 130, text_size.y + text_size.y), 2, 255)
render.text(utils.fonts["small_pixel"], vector(screen_x - text_size.x - 10,
10), color(255, 255, 255, 255), "nil", watermark_text)
end
indicator = function()
if not menu.visuals["switch_indicators"]:get() then return end

local exploit_charge = rage.exploit:get() < 1
local itick = menu.ragebot["switch_idealtick"]:get()
local col = menu.visuals["cpicker_menu"]:get()

local font = utils.fonts["small_pixel"]
local dt = not cheat.ref.doubletap:get()

local hs = not cheat.ref.hideshots:get()
local dt_col = utils.animation["new"]('doubletap color', dt and
color(155,155,155, 200) or col , 0.07)
local hs_col = utils.animation["new"]('hideshots color', hs and
color(155,155,155, 200) or col , 0.07)
local itick_col = utils.animation["new"]('ideal tick color', exploit_charge and
color(155,155,155, 200) or col , 0.07)
local bar_color = utils.animation["new"]('test color', exploit_charge and
color(155,155,155, 200) or col, 0.07)
local screen_x, screen_y = render.screen_size().x, render.screen_size().y

local text_size = render.measure_text(font, "", 'wraith.sys')
local x = utils.animation["new"]('test x', val and -20 or 26.5, 0.07)
render.rect(vector(screen_x / 2 - 25.5, screen_y / 2 + 16), vector(screen_x / 2

+ 26.5, screen_y / 2 + 18), color(20, 20, 20, 255))
render.rect(vector(screen_x / 2 - 25.5, screen_y / 2 + 16), vector(screen_x / 2
+ x, screen_y / 2 + 18), bar_color)
render.rect_outline(vector(screen_x / 2 - 26.5, screen_y / 2 + 15),
vector(screen_x / 2 + 27.5, screen_y / 2 + 19), color(20, 20, 20, 255))
render.text(font, vector(screen_x / 2 - text_size.x / 2, screen_y / 2 + 18),
color(255, 255, 255, 255), "nil", 'wraith')
render.text(font, vector(screen_x / 2 + text_size.x / 2 - 18, screen_y / 2 +
18), bar_color, "nil", '.sys')
render.text(font, vector(screen_x / 2 - render.measure_text(font, "",
'doubletap').x / 2 - 3, screen_y / 2 + render.measure_text(font, "",
'doubletap').y + 14.5), dt_col, "nil", 'doubletap')
render.text(font, vector(screen_x / 2 - render.measure_text(font, "",
'hideshots').x / 2 - 3, screen_y / 2 + render.measure_text(font, "",
'hideshots').y + 22), hs_col, "nil", 'hideshots')
if itick and hs then render.text(font, vector(screen_x / 2 -

render.measure_text(font, "", 'ideal tick').x / 2 - 1, screen_y / 2 +
render.measure_text(font, "", 'ideal tick').y + 30.5), itick_col, "nil", 'ideal
tick') end
end
better_accuracy = function()
if not menu.ragebot["switch_accuracy"]:get() then return end
if menu.ragebot["combo_accuracy"]:get() == "Unsafe" then

cheat.ref.dynamic:set(true)
cheat.ref.stricthc:set(false)
cheat.ref.delayshot:set(false)
cheat.ref.accuracy:set(false)
cheat.ref.asoptions:set("Early", "Move Btw. Shots")
cheat.ref.asdtoptions:set("Early", "Move Btw. Shots")
elseif menu.ragebot["combo_accuracy"]:get() == "Safe" then
cheat.ref.dynamic:set(false)
cheat.ref.stricthc:set(false)
cheat.ref.delayshot:set(true)
cheat.ref.accuracy:set(false)
cheat.ref.asoptions:set("Early", "Full Stop", "Move Btw. Shots")
cheat.ref.asdtoptions:set("Early", "Move Btw. Shots")
elseif menu.ragebot["combo_accuracy"]:get() == "Safest" then
cheat.ref.dynamic:set(false)
cheat.ref.stricthc:set(true)
cheat.ref.delayshot:set(true)
cheat.ref.accuracy:set(true)
cheat.ref.fakelag:set(1)
cheat.ref.asoptions:set("Full Stop", "Move Btw. Shots")
cheat.ref.asdtoptions:set("Move Btw. Shots", "Full Stop")
end
end
idealtick = function()
if menu.ragebot["switch_idealtick"]:get() then
cheat.ref.lagoptions:set("Disabled")
else
cheat.ref.lagoptions:set("On Peek")
end
end
legbreaker = function()
if not globals.is_in_game then return end
local tick1 = globals.client_tick % 20 > 10
if menu.other["switch_leg_break"]:get() then
cheat.ref.legmov:set(tick1 and "Sliding" or "Walking")
end
end
killsay = function(e)
local lPlayer = entity.get_local_player()

local attacker = entity.get(e.attacker, true)
local text =
tostring(utils.killsay_phrases[math.random(#utils.killsay_phrases)])
if lPlayer == attacker and menu.other["switch_killsay"]:get() then
utils.console_exec("say " .. text)
end
end
-- *Callbacks*
utils.callbacks.draw(function()
watermark()
indicator()
end)
utils.callbacks.createmove(function()
if menu.antiaim["switch_aa"]:get() then cheat.ref.bodyyaw:set(true) antiaim()

end
if menu.ragebot["switch_rage"]:get() then jumpscout() better_accuracy()

idealtick() end
antibackstab()
legbreaker()
end)
utils.callbacks.aim_ack(function(e)
if not menu.other["switch_logs"]:get() then return end

logs(e)
end)
utils.callbacks.player_death(function(e)
killsay(e)
end)

Fake Wraith Paste NL - Lua

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fake Wraith Paste NL - Lua

Uploaded by

Copyright:

Available Formats

--[[

* scammed his lua dev ;w;

doubletap = ui.find("aimbot", "ragebot", "main", "double tap"),

["small_pixel"] = render.load_font("Smallest Pixel-7", 10, "o"),

local output = ''

for i=1, len+1 do

main = ui.create("Main", "Main"),

-- *Callbacks (Usados para executar o codigo)*

if to_register == nil then

if to_register == nil then

if _DEBUG == true then

events.aim_ack:set(function(e) to_register(e) end)

if to_register == nil then

if _DEBUG == true then

if to_register == nil then

if _DEBUG == true then

events.player_death:set(function(e) to_register(e) end)

main = { ["button_discord"] = nil },

utils.animation["lerp"] = function(start, end_pos, time)

if type(start) == 'userdata' then

local color_data = {0, 0, 0, 0}

for i, color_key in ipairs({'r', 'g', 'b', 'a'}) do

return (end_pos - start) * (globals.frametime * time * 175) + start

utils.animation["new"] = function(name, value, time)

if utils.animation["data"][name] == nil then

-- ! Se A fonte nao estiver baixada

if not files.read("nl/wraith/font.ttf") then

-- *Cria um text no grupo "MAIN"*

menu.ragebot["switch_rage"] = utils.groups.ragebot:switch(text_color .. "\

menu.visuals["switch_watermark"] = utils.groups.visuals:switch (text_color ..

menu.other["switch_leg_break"] = utils.groups.other:switch(text_color .. "\

local target, damage, wanted_damage, wanted_hitgroup, hc, state, bt

if not target then return end

if state == "spread" then state = "\aFEEA7Dspread"end

if state ~= nil then print_raw(("\aFF6464[wraith] \aD5D5D5Missed shot at \

print_raw(("\aFF6464[wraith] \aD5D5D5Registered shot at \aFF6464%s\aFFFFFF's \

cheat.ref.airstrafe:set( not menu.ragebot["switch_jumpscout"]:get())

tick = globals.client_tick % 30 > 15

for _, menu_items in pairs(menu.antiaim.builder) do

if menu.antiaim["combo_presets"]:get() == "Jitter High" then

elseif menu.antiaim["combo_presets"]:get() == "Jitter Low" then

elseif menu.antiaim["combo_presets"]:get() == "Low Delta" then

elseif menu.antiaim["combo_presets"]:get() == "Custom" then

local standing = { yaw_offset =

if menu.antiaim["combo_presets"]:get() ~= "Custom" then return end

for _, standing in pairs(standing) do standing:set_visible(true) end

elseif menu.antiaim.builder["combo_state"]:get() == "Walking" then

for _, standing in pairs(standing) do standing:set_visible(false) end

elseif menu.antiaim.builder["combo_state"]:get() == "Running" then

for _, standing in pairs(standing) do standing:set_visible(false) end

elseif menu.antiaim.builder["combo_state"]:get() == "Air" then

for _, standing in pairs(standing) do standing:set_visible(false) end

--for _, state in pairs(menu.antiaim.builder) do

local speed = entity.get_local_player().m_vecVelocity:length()

if speed < 2 then

if not cheat.ref.slowwalk:get() and speed > 2 then

if not menu.visuals["switch_watermark"]:get() then return end

local screen_x, screen_y = render.screen_size().x, render.screen_size().y

local val = globals.realtime % 4 > 2

local pos_x = utils.animation["new"]('teste pos', val2 and text_size.x + 10 or

--local color = menu.visuals["cpicker_menu"].r():get()

local col = menu.visuals["cpicker_menu"]:get()

b_render.rectangle(screen_x - text_size.x - 10, 10, 125, 1.5, 100, 100, 100,

-- Callbacks (Usados para executar o codigo)

-- Cria um text no grupo "MAIN"