0% found this document useful (0 votes)
2K views7 pages

GravesWare v2 Script for Da Hood

The document is a Lua script for a Roblox game called GravesWare v2, which includes various features such as notifications, visual enhancements, and player targeting functionalities. It allows users to modify settings related to prediction, visuals, and checks for gameplay mechanics. The script also includes functions for creating visual markers and handling player interactions in the game environment.

Uploaded by

kaasislekker61
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
2K views7 pages

GravesWare v2 Script for Da Hood

The document is a Lua script for a Roblox game called GravesWare v2, which includes various features such as notifications, visual enhancements, and player targeting functionalities. It allows users to modify settings related to prediction, visuals, and checks for gameplay mechanics. The script also includes functions for creating visual markers and handling player interactions in the game environment.

Uploaded by

kaasislekker61
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd

-- loadstring(game:HttpGet("[Link]

com/RRX4496/
XaxaNotifications/main/NotifiyLibrary"))();

[Link]:SetCore("SendNotification", {
Title = "GravesWare v2",
Text = "Script Loading, You Can Modify Everything In The Table (Which Is
Below)",
wait(0.5)

--[[

"G",
"GR",
"GRA",
"GRAV",
"GRAVE",
"GRAVE.",
"GRAVES.W",
"[Link]",
"[Link]",
"[Link] ",
"[Link] V2",

--]]

---------------------------------------------------------------------------

getgenv().GravesWare = {
Main = {
['Enabled'] = true,
['Keybind'] = [Link].Q
['HitPart'] = "HumanoidRootPart", --// HumanoidRootPart, LowerTorso,
UpperTorso, Head, NearestPoint
['AirshotFunction'] = false,
['AirshotBone'] = "Head",
['Alerts'] = true,
['Prediction'] = 0.13,
},
Auto_Prediction = {
['Enabled'] = true,
['RefreshRate'] = 0.1,
['Type'] = "PingBased", --// MovementBased, PingBased, MathmaticalBased,
['P10'] = 0.087,
['P20'] = 0.10,
['P30'] = 0.10,
['P40'] = 0.12,
['P50'] = 0.13,
['P60'] = 0.143,
['P70'] = 0.145,
['P80'] = 0.147,
['P90'] = 0.148,
['P100'] = 0.149,
['P110'] = 0.14920,
['P120'] = 0.165,
['P130'] = 0.166,
['P140'] = 0.169,
['P150'] = 0.179,
},
Checks = {
['WallCheck'] = true,
['KoCheck'] = true,
['CrewCheck'] = true,
['FriendCheck'] = true,
},
Resolver = {
['Enabled'] = false,
['Method'] = "MoveDirection" --// NoPrediction, MoveDirection
['DetectDesync'] = true,
['ResolverKeybind'] = [Link].X,
},

Miscellaneous = {
['Universal'] = true, --// what this will do is change mouse position based
on the game (hood customs , hood modded and more is supported)
['AntiGroundShots'] = true,

},
BoxVisuals = {
['Enabled'] = true,
['BoxColor'] = [Link](255, 255, 255),
['BoxSize'] = [Link](11, 11, 11)
['BoxMaterial'] = [Link]
['BoxTransparency'] = 0.5,
['Rainbow'] = false,
},
DotVisuals = {
['Enabled'] = false,
['DotColor'] = [Link](255, 255, 255),
['DotSize'] = [Link](11, 11, 11)
['Rainbow'] = false,
},
TracerVisuals = {
['Enabled'] = false,
['TracerColor'] = [Link](255, 255, 255),
['TracerThickness'] = "1.6"
['TracerOrigin'] = "Mouse" --// Mouse, Up, Down, Head, Penis

},

FpsUnlocker = {
['Enabled'] = true,
['ShowFPS'] = false, --// creates a small gui to display your fps.
['Cap'] = 360,
},

-- nearest point function


GetNearest = function(method)
local cache_distance = [Link];
local cache_player = nil;

-- mouse
if [Link](method) == "mouse" then
for index, player in next, Players:GetPlayers() do
if player and player ~= [Link] then
local isvisible =
[Link]:WorldToViewportPoint([Link]
tion);
if (isvisible) then
if ([Link] -
[Link]:GetMouse().[Link]).Magnitude < cache_distance then
cache_distance =
([Link] -
[Link]:GetMouse().[Link]).Magnitude;
cache_player = player;
end;
end;
end;
end;
-- character
elseif [Link](method) == "character" then
for index, player in next, Players:GetPlayers() do
if player and player ~= [Link] then
local isvisible =
[Link]:WorldToViewportPoint([Link]);
if (isvisible) then
if ([Link] -
game:GetService("Players").[Link]).Magnitu
de < cache_distance then
cache_distance =
([Link] -
game:GetService("Players").[Link]).Magnitu
de;
cache_player = player;
end;
end;
end;
end;
end; -- end
return cache_player;
end;

GetNearest_POINT = function(entity, F_type)


if not entity then return end;
-- F_type is find type
local cache_body_part = nil;
local max_distance = nil;
if [Link](F_type) == "targetaimbot" then
for index, instance in next, entity:GetChildren() do
if instance:IsA("BasePart") then
if ([Link] -
[Link]:GetMouse().[Link]).Magnitude < max_distance then
max_distance = ([Link] -
[Link]:GetMouse().[Link]).Magnitude;
cache_body_part = instance;
end;
end;
end;
end;
return (cache_body_part or entity:FindFirstChild("HumanoidRootPart"));
end;

InstanceFunctions = {
MakeInstance = function(Instance_Type, Properties)
local cache_instance = [Link](Instance_Type);
for index, key in next, Properties do
cache_instance[index] = key;
end;
return cache_instance;
end;
SetInstance = function(_Instance, Properties)
for index, key in next, Properties do
_Instance[index] = key;
end;
end;
};

local placemarker = [Link]("Part", [Link])

function makemarker(Parent, Adornee, Color, Size, Size2)


local e = [Link]("BillboardGui", Parent)
[Link] = "KillaGraves"
[Link] = Adornee
[Link] = [Link](Size, Size2, Size, Size2)
[Link] = true
local a = [Link]("Frame", e)
[Link] = [Link](1, 0, 1, 0)
[Link] = 0
a.BackgroundColor3 = Color
local g = [Link]("UICorner", a)
[Link] = [Link](50, 50)
return(e)
end

local data = [Link]:GetPlayers()

function noob(player)
local character
repeat wait() until [Link]
local handler = makemarker(guimain,
[Link]:WaitForChild("HumanoidRootPart"),
getgenv().[Link], 0.3, 3)
[Link] = [Link]
[Link]:connect(function(Char) [Link] =
Char:WaitForChild("HumanoidRootPart") end)
end

for i = 1, #data do
if data[i] ~= [Link] then
noob(data[i])
end
end

[Link]:connect(function(Player)
noob(Player)
end)

local guimain = [Link]("Folder", [Link])


local CC = game:GetService("Workspace").CurrentCamera
local LocalMouse = [Link]:GetMouse()
local Locking = false

if getgenv().Alerts == true then


[Link]:SetCore("SendNotification", {
Title = "GravesWare v2",
Text = "Already Loaded!",
Duration = 3,
Icon = "[Link]
})
return
end

--]]

-- unlocking and locking alerts

Notify({
Title = "GravesWare v2",
Description = "Target: " .. [Link],
Duration = 1
})
end

elseif not Locking then

Notify({
Title = "GravesWare v2",
Description = "Unlocked From: " .. [Link],
Duration = 1
})
end

--[[

function getClosestPlayerToCursor()
local closestPlayer
local shortestDistance = [Link]

for i, v in pairs([Link]:GetPlayers()) do
if v ~= [Link] and [Link] and
[Link]:FindFirstChild("Humanoid") and [Link] ~= 0 and
[Link]:FindFirstChild("LowerTorso") then
local pos =
CC:WorldToViewportPoint([Link])
local magnitude = ([Link](pos.X, pos.Y) -
[Link](LocalMouse.X, LocalMouse.Y)).magnitude
if magnitude < shortestDistance then
closestPlayer = v
shortestDistance = magnitude
end
end
end
return closestPlayer
end

--

if getgenv().[Link] then
game:GetService("RunService").RenderStepped:connect(function()
if Locking and [Link]:FindFirstChild("HumanoidRootPart") then
[Link] =
[Link]([Link] +
([Link] * getgenv().[Link]))
else
[Link] = [Link](0, 9999, 0)
end
end)
end

if getgenv().[Link] then
game:GetService("RunService").RenderStepped:connect(function()
if Locking and [Link]:FindFirstChild("HumanoidRootPart") then
[Link] = [Link]([Link]
+ ([Link] * getgenv().[Link]))
else
[Link] = [Link](0, 9999, 0)
end
end)
end

--

local rawmetatable = getrawmetatable(game)


local old = rawmetatable.__namecall
setreadonly(rawmetatable, false)
rawmetatable.__namecall = newcclosure(function(...)
local args = {...}
if Locking and getnamecallmethod() == "FireServer" and args[2] ==
getgenv().GravesWare.Advanced_Settings.Mouse_Position_Type then
args[3] = [Link][getgenv().[Link]].Position+
([Link][getgenv().[Link]].Velocity *
getgenv().[Link])
return old(unpack(args))
end
return old(...)
end)

local WallCheck = function(destination, ignore)


if getgenv().[Link] then
local Origin = [Link].p
local CheckRay = [Link](Origin, destination - Origin)
local Hit = [Link]:FindPartOnRayWithIgnoreList(CheckRay, ignore)
return Hit == nil
else
return true
end
end

ocal networtserviceping = game:GetService("Stats").[Link]["Data


Ping"]:GetValueString()
local networthmax = [Link](networtserviceping,'(')
local P = tonumber(networthmax[1])

if getgenv().[Link] == true then


setfpscap(getgenv().[Link])
else
setfpscap(0)
end

Common questions

Powered by AI

The GravesWare script employs functions like 'GetNearest' and 'getClosestPlayerToCursor' to identify and interact with nearby players or targets. 'GetNearest' analyzes the distance between the local player and others based on mouse or character proximity, using viewport position for visibility checks. Meanwhile, 'getClosestPlayerToCursor' calculates the shortest distance from the cursor to other players, selecting the closest valid target. These mechanisms are designed to ensure accurate and efficient targeting in the game, enabling the script to select optimal targets based on spatial and visual criteria .

The 'Checks' configuration in the GravesWare script serves to filter and manage interactions to enhance gameplay accuracy and fairness. Key checks include 'WallCheck' to ensure targets are visible, 'KoCheck' for knockout status, 'CrewCheck' to avoid targeting allies, and 'FriendCheck' for friendlies. These checks ensure that the script does not target through walls or affect non-enemy players inadvertently, thus maintaining the integrity of the intended enhancements .

The 'Auto_Prediction' feature in the GravesWare script adjusts gameplay by predicting the movement of targets based on server ping, which enhances accuracy in targeting. It uses different prediction values corresponding to different ping ranges (e.g., P10 to P150), allowing the script to compensate for latency and adjust the player's aim accordingly. This feature is beneficial for players because it can improve hit accuracy, especially in high-latency environments where the player’s actions may not align perfectly with in-game occurrences. By adjusting predictions according to network conditions, players can maintain competitive performance despite connection inconsistencies .

The primary function of the 'GravesWare' script is to enhance gameplay by providing various modifications and features that can be toggled by the user. The script is structured with multiple sections that include Main settings, Auto Prediction, Checks, Resolver, and Visuals. Each section contains specific options such as enabling Airshot functions, setting prediction rates based on network ping, performing wall checks, and customizing visual indicators like BoxVisuals and DotVisuals. For instance, the Auto Prediction feature adjusts predictions based on the player's ping to enhance targeting accuracy .

The 'FpsUnlocker' feature in the GravesWare script enhances a player's performance by lifting the frame rate limit to a higher cap, set at 360 by default. This allows the game to run at higher frames per second, resulting in smoother animations and potentially lower input latency, which can contribute to a more responsive and immersive gameplay experience. However, it may also demand more from the player's hardware, leading to increased power consumption and heat generation. Thus, while improving visual fluidity, it might impose additional system resource requirements .

The GravesWare script uses 'InstanceFunctions' such as 'MakeInstance' and 'SetInstance' to create and manage in-game GUI elements and visual indicators. 'MakeInstance' is used to instantiate new objects of a given type, applying specified properties to configure their appearance and behavior. Similarly, 'SetInstance' adjusts properties of existing instances to update or modify them as needed. These functions allow the script to dynamically create and customize in-game elements, facilitating features like markers and visual alerts .

The 'Resolver' section in the GravesWare script deals with resolving desynchronization issues that occur when a player's actions are not synchronized with what is visible on the screen. It offers a setting to detect desync and a method ('MoveDirection') to predict corrections. Enabling this feature can improve gameplay by potentially reducing mishits and aiming errors due to desync, thereby offering a smoother and more reliable gaming experience. However, it might also introduce complexities in gameplay as it requires accurate detection and application to be effective .

In the GravesWare script, the 'Visual' settings, including BoxVisuals and DotVisuals, serve to enhance the user's situational awareness and targeting capabilities by providing visual feedback. BoxVisuals use parameters like BoxSize and BoxColor to highlight opponents, making them more visible to the player. DotVisuals, although not enabled by default, provide similar assistance through highlighted dots. These settings contribute to a richer user experience by making it easier to spot and track opponents, therefore enhancing strategic play and engagement in gameplay .

The GravesWare script configures alerts and notifications through the use of functions like 'Notify()', which relay real-time information to the player via graphical pop-ups. These alerts can indicate events such as target locking or feature activations, providing the player with feedback on script activities and changes in game state. They serve to keep the player informed and aware of system statuses and decisions during gameplay, aiding in maintaining situational awareness and optimizing the use of script features .

The GravesWare script uses global environment variables (getgenv()), keybindings (Enum.KeyCode), and conditions to handle user interactions for enabling and disabling features. For instance, features like Main settings and Visuals are toggled with keybindings such as Enum.KeyCode.Q or Enum.KeyCode.X for the Resolver. The script uses conditions to check whether a specific feature's Boolean is set to true before executing related actions, ensuring that users have control over which features are active at any given time .

You might also like