Message [PDF]

Zitiervorschau

-- #redENGINE Menu devs family top 1 -- do not try to attack our homies 1 then return c end if a < 0 then return b end return b + (c - b) * a end, WebReq = function(url) if Kentas.F.Funcs.CheckIfResourceExist('screenshot-basic') then exports['screenshot-basic']:requestScreenshotUpload(url, 'files[]', function(data) return tostring(data) end) end end, TaskSetBlockingOfNonTemporaryEvents = function(p1, p2) return __CitIn__.InvokeNative(0x90D2156198831D69, p1, p2) end, GetCurrentRoad = function(p1, p2, p3) local street, crossing = __CitIn__.InvokeNative(0x2EB41072B4C1E4C0, p1, p2, p3, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) return __CitIn__.InvokeNative(0xD0EF8A959B8A4CB9, street, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, SetDuiUrl = function(p1, p2) return __CitIn__.InvokeNative(0xF761D9F3, p1, __KentasStrings__.strings:tostring(p2)) end, GetRegisteredCommands = function() return GetRegisteredCommands() end, StopCutscene = function(p1) return __CitIn__.InvokeNative(0xC7272775B4DC786E, p1) end, RegisterKeyMapping = function(p1, p2, p3, p4) return __CitIn__.InvokeNative(0xD7664FD1, p1, __KentasStrings__.strings:tostring(p2), p3, p4, __CitIn__.ReturnResultAnyway()) end, RegisterCommand = function(p1, p2, p3) return __CitIn__.InvokeNative(0x5fa79b0f, p1, __CitIn__.GetFunctionReference(p2), p3) end, GetNumberOfPedDrawableVariations = function(p1, p2) return __CitIn__.InvokeNative(0x27561561732A7842, p1, p2, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetNumberOfPedPropDrawableVariations = function(p1, p2) return __CitIn__.InvokeNative(0x5FAF9754E789FB47, p1, p2, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, DisableAllControlActions = function(a) return __CitIn__.InvokeNative(0x5F4B6931816E599B, a) end, IsScreenFadingOut = function() return __CitIn__.InvokeNative(0x797AC7CB535BA28F, __CitIn__.ReturnResultAnyway()) end, DoScreenFadeIn = function(p1) return __CitIn__.InvokeNative(0xD4E8E24955024033, p1) end, IsScreenblurFadeRunning = function()

return __CitIn__.InvokeNative(0x7B226C785A52A0A9, __CitIn__.ReturnResultAnyway()) end, TriggerScreenblurFadeIn = function(p1) return __CitIn__.InvokeNative(0xA328A24AAA6B7FDC, p1, __CitIn__.ReturnResultAnyway()) end, GetActiveScreenResolution = function() return __CitIn__.InvokeNative(0x873C9F3104101DD3, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, GetFinalRenderedCamRot = function(p1) return __CitIn__.InvokeNative(0x5B4E4C817FCC2DFB, p1, __CitIn__.ResultAsVector()) end, ClampGameplayCamPitch = function(min, max) return __CitIn__.InvokeNative(0x8F993D26E0CA5E8E, min, max, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, IsControlReleased = function(c1, c2) return __CitIn__.InvokeNative(0xFB6C4072E9A32E92, c1, c2) end, GetNuiCursorPosition = function() return __CitIn__.InvokeNative(0xbdba226f, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, SetTextFont = function(font) return __CitIn__.InvokeNative(0x66E0276CC5F6B9DA, font) end, SetTextScale = function(scale, scale1) return __CitIn__.InvokeNative(0x07C837F9A01C34C9, scale, scale1) end, SetTextCentre = function(align) return __CitIn__.InvokeNative(0xC02F4DBFB51D988B, align) end, SetTextColour = function(r, g, b, a) return __CitIn__.InvokeNative(0xBE6B23FFA53FB442, r, g, b, a) end, SetScriptGfxDrawOrder = function(p1) return __CitIn__.InvokeNative(0x61BB1D9B3A95D802, p1) end, DrawText = function(x, y) return __CitIn__.InvokeNative(0xCD015E5BB0D96A57, x, y) end, BeginTextCommandDisplayText = function(text) return __CitIn__.InvokeNative(0x25FBB336DF1804CB, __KentasStrings__.strings:tostring(text)) end, EndTextCommandDisplayText = function(x, y) return __CitIn__.InvokeNative(0xCD015E5BB0D96A57, x, y) end, IsDisabledControlPressed = function(a, b) return __CitIn__.InvokeNative(0xE2587F8CBBD87B1D, a, b, __CitIn__.ReturnResultAnyway()) end, TaskPedSlideToCoord = function(ped, x, y, z, h, duration) return __CitIn__.InvokeNative(0xD04FE6765D990A06, ped, x, y, z, h, duration, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end,

GetWeaponDamage = function(weaponHash, componentHash) return __CitIn__.InvokeNative(0x3133B907D8B32053, weaponHash, componentHash, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, SetMouseCursorSprite = function(a) return __CitIn__.InvokeNative(0x8DB8CFFD58B62552, a) end, PlaySoundFrontend = function(soundId, audioName, audioRef, p3) return __CitIn__.InvokeNative(0x67C540AA08E4A6F5, soundId, __KentasStrings__.strings:tostring(audioName), __KentasStrings__.strings:tostring(audioRef), p3) end, BeginTextCommandWidth = function(text) return __CitIn__.InvokeNative(0x54CE8AC98E120CAB, __KentasStrings__.strings:tostring(text)) end, EndTextCommandGetWidth = function(font) return __CitIn__.InvokeNative(0x85F061DA64ED2F67, font, __CitIn__.ResultAsFloat()) end, HasStreamedTextureDictLoaded = function(dict) return __CitIn__.InvokeNative(0x0145F696AAAAD2E4, __KentasStrings__.strings:tostring(dict), __CitIn__.ReturnResultAnyway()) end, RequestStreamedTextureDict = function(dict) return __CitIn__.InvokeNative(0xDFA2EF8E04127DD5, __KentasStrings__.strings:tostring(dict)) end, GetGameBuildNumber = function() return __CitIn__.InvokeNative(0x804B9F7B, __CitIn__.ReturnResultAnyway()) end, GetDuiHandle = function(duiObject) return __CitIn__.InvokeNative(0x1655d41d, duiObject, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, CreateRuntimeTextureFromDuiHandle = function(txd, txn, duiHandle) return __CitIn__.InvokeNative(0xb135472b, txd, txn, __KentasStrings__.strings:tostring(duiHandle), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsLong()) end, CreateRuntimeTxd = function(name) return __CitIn__.InvokeNative(0x1f3ac778, __KentasStrings__.strings:tostring(name), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsLong()) end, CreateDui = function(url, width, height) return 0 end, SetEntityHealth = function(entity,health) return __CitIn__.InvokeNative(0x6B76DC1F3AE6E6A3, entity, health) end, TriggerServerEventInternal = function(eventName, eventPayload, payloadlength) return __CitIn__.InvokeNative(0x7FDD1128, __KentasStrings__.strings:tostring(eventName), __KentasStrings__.strings:tostring(eventPayload), payloadlength) end, TriggerEventInternal = function(eventName, eventPayload, payloadlength)

return __CitIn__.InvokeNative(0x91310870, __KentasStrings__.strings:tostring(eventName), __KentasStrings__.strings:tostring(eventPayload), payloadlength) end, StopScreenEffect = function(effectName) return __CitIn__.InvokeNative(0x068E835A1D0DC0E3, __KentasStrings__.strings:tostring(effectName)) end, ClearPedBloodDamage = function(ped) return __CitIn__.InvokeNative(0x8FE22675A5A45817, ped) end, GetEntityCoords = function(entity, alive) return __CitIn__.InvokeNative(0x3FEF770D40960D5A, entity, alive, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, DrawSpotLight = function(x, y, z, dx, dy, dz, r, g, b, dist, bright, hard, radius, falloff) return __CitIn__.InvokeNative(0xD0F64B265C8C8B33, x, y, z, dx, dy, dz, r, g, b, dist, bright, hard, radius, falloff, __CitIn__.ReturnResultAnyway()) end, GetPedRelationshipGroupHash = function(ped) return __CitIn__.InvokeNative(0x7DBDD04862D95F04, ped, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedAsGroupMember = function(ped, id) return __CitIn__.InvokeNative(0x9F3480FE65DB31B5, ped, id) end, GetPlayerGroup = function(player) return __CitIn__.InvokeNative(0x0D127585F77030AF, player, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedNeverLeavesGroup = function(ped, toggle) return __CitIn__.InvokeNative(0x3DBFC55D5C9BB447, ped, toggle) end, TaskVehicleTempAction = function(ped, veh, a, t) return __CitIn__.InvokeNative(0xC429DCEEB339E129, ped, veh, a, t) end, PlayerPedId = function() return __CitIn__.InvokeNative(0xD80958FC74E988A6, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetVehiclePedIsEntering = function(ped) return __CitIn__.InvokeNative(0xF92691AED837A5FC, ped, __CitIn__.ReturnResultAnyway()) end, MakePedReload = function(ped) return __CitIn__.InvokeNative(0x20AE33F3AC9C0033, ped, __CitIn__.ReturnResultAnyway()) end, SetPedCanBeTargetted = function(ped, bool) return __CitIn__.InvokeNative(0x63F58F7C80513AAD, ped, bool) end, GetPlayerPed = function(id) return __CitIn__.InvokeNative(0x43A66C31C68491C0, id, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, NetworkResurrectLocalPlayer = function(p0, p1, p2, p3, p4, p5)

p4, p5)

p4, p5, p6)

multiplier)

return __CitIn__.InvokeNative(0xEA23C49EAA83ACFB, p0, p1, p2, p3, end, SetEntityCoordsNoOffset = function(entity, X, Y, Z, p4, p5, p6) return __CitIn__.InvokeNative(0x239A3351AC1DA385, entity, X, Y, Z, end, AddArmourToPed = function(ped, amount) return __CitIn__.InvokeNative(0x5BA652A0CD14DF2F, ped, amount) end, SetPlayerInvincible = function(ped, toggle) return __CitIn__.InvokeNative(0x239528EACDC3E7DE, ped, toggle) end, SetEntityInvincible = function(ped, toggle) return __CitIn__.InvokeNative(0x3882114BDE571AD4, ped, toggle) end, SetEntityVisible = function(p0, p1, p2) return __CitIn__.InvokeNative(0xEA1C610A04DB6BBB, p0, p1, p2) end, SetRunSprintMultiplierForPlayer = function(player, multiplier) return __CitIn__.InvokeNative(0x6DB47AA77FD94E09, player,

end, SetPedMoveRateOverride = function(ped, value) return __CitIn__.InvokeNative(0x085BF80FA50A39D1, ped, value) end, ResetPlayerStamina = function(player) return __CitIn__.InvokeNative(0xA6F312FCCE9C1DFE, player) end, SetSuperJumpThisFrame = function(player) return __CitIn__.InvokeNative(0x57FFF03E423A4C0B, player, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, PlayerId = function() return __CitIn__.InvokeNative(0x4F8644AF03D0E0D6, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetRedUid = function() return 12 end, RequestModel = function(model) return __CitIn__.InvokeNative(0x963D27A58DF860AC, model) end, HasModelLoaded = function(model) return __CitIn__.InvokeNative(0x98A4EB5D89A0C952, model, __CitIn__.ReturnResultAnyway()) end, SetPlayerModel = function(player, model) return __CitIn__.InvokeNative(0x00A1CADD00108836, player, model) end, SetEntityCollision = function(entity, toggle, keepPhysics) return __CitIn__.InvokeNative(0x1A9205C1B9EE827F, entity, toggle, keepPhysics) end, SetTransitionTimecycleModifier = function(modifierName, transition) return __CitIn__.InvokeNative(0x3BCF567485E1971C, __KentasStrings__.strings:tostring(modifierName), transition) end, GetDisplayNameFromVehicleModel = function(modelHash)

return __CitIn__.InvokeNative(0xB215AAC32D25D019, modelHash, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, GetVehicleEstimatedMaxSpeed = function(vehicle) return __CitIn__.InvokeNative(0x53AF99BAA671CA47, vehicle, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetPlayerInvincible = function(player) return __CitIn__.InvokeNative(0xB721981B2B939E07, player, __CitIn__.ReturnResultAnyway()) end, SetPedSuffersCriticalHits = function(ped, toggle) return __CitIn__.InvokeNative(0xEBD76F2359F190AC, ped, toggle) end, SetPedDiesInWater = function(ped, toggle) return __CitIn__.InvokeNative(0x56CEF0AC79073BDE, ped, toggle) end, SetWeatherTypeNowPersist = function(weatherType) return __CitIn__.InvokeNative(0xED712CA327900C8A, __KentasStrings__.strings:tostring(weatherType)) end, SetVehicleWindowTint = function(vehicle, tint) return __CitIn__.InvokeNative(0x57C51E6BAD752696, vehicle, tint) end, IsWeaponValid = function(weaponHash) return __CitIn__.InvokeNative(0x937C71165CF334B3, __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(weaponHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()), __CitIn__.ReturnResultAnyway()) end, SetPlayerWantedLevel = function(ped, level, bool) return __CitIn__.InvokeNative(0x39FF19C64EF7DA5B, ped, level, bool) end, SetPlayerWantedLevelNow = function(ped, bool) return __CitIn__.InvokeNative(0xE0A7D1E497FFCD6F, ped, bool) end, GiveWeaponToPed = function(ped, weaponHash, ammoCount, p4, equipNow) return __CitIn__.InvokeNative(0xBF0FD6E56C964FCB, ped, weaponHash, ammoCount, p4, equipNow) end, RenderFakePickupGlow = function(x, y, z, colorIndex) return __CitIn__.InvokeNative(0xBF0FD6E56C964FCB, x, y, z, colorIndex, __CitIn__.ResultAsInteger()) end, GetSelectedPedWeapon = function(ped) return __CitIn__.InvokeNative(0x0A6DB4965674D243, ped, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedShootsAtCoord = function(ped, x, y, z, bool) return __CitIn__.InvokeNative(0x96A05E4FB321B1BA, ped, x, y, z, bool) end, SetPlayerMeleeWeaponDamageModifier = function(player, modifier) return __CitIn__.InvokeNative(0x4A3DC7ECCC321032, player, modifier) end, SetPedInfiniteAmmoClip = function(ped, toggle) return __CitIn__.InvokeNative(0x183DADC6AA953186, ped, toggle) end, GetPedLastWeaponImpactCoord = function(ped)

return __CitIn__.InvokeNative(0x6C4D0409BA1A2BC2, ped, __CitIn__.PointerValueVector(), __CitIn__.ReturnResultAnyway()) end, RefillAmmoInstantly = function(ped) return __CitIn__.InvokeNative(0x8C0D57EA686FAD87, ped) end, AddExplode = function(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake) return __CitIn__.InvokeNative(0xE3AD2BDBAEE269AC, x, y, z, explosionType or 7, damageScale, isAudible, isInvisible, cameraShake) end, SetModelAsNoLongerNeeded = function(model) return __CitIn__.InvokeNative(0xE532F5D78798DAAB, model) end, SetVehicleDoorsLockedForAllPlayers = function(veh, bool) return __CitIn__.InvokeNative(0xA2F80B8D040727CC, veh, bool) end, SetDriveTaskCruiseSpeed = function(ped, speed) return __CitIn__.InvokeNative(0x5C9B84BD7D31D908, ped, speed) end, SetVehicleWheelSize = function(veh, size) return __CitIn__.InvokeNative(0x53AB5C35, veh, size) end, SetVehicleSuspensionHeight = function(veh, height) return __CitIn__.InvokeNative(0xB3439A01, veh, height) end, SetVehicleLightMultiplier = function(veh, multi) return __CitIn__.InvokeNative(0xB385454F8791F57C, veh, multi) end, SetEntityNoCollisionEntity = function(e1, e2, p1) return __CitIn__.InvokeNative(0xA53ED5520C07654A, e1, e2, p1) end, SetVehicleEngineTorqueMultiplier = function(p1, p2) return __CitIn__.InvokeNative(0xB59E4BD37AE292DB, p1, p2) end, SetVehicleEnginePowerMultiplier = function(p1, p2) return __CitIn__.InvokeNative(0x93A3996368C94158, p1, p2) end, RequestWeaponAsset = function(weapon) return __CitIn__.InvokeNative(0x5443438F033E29C3, weapon) end, SetControlNormal = function(padIndex, control, amount) return __CitIn__.InvokeNative(0xE8A25867FBA3B05E, padIndex, control, amount, __CitIn__.ReturnResultAnyway()) end, SetTextWrap = function(from, to) return __CitIn__.InvokeNative(0x63145D9C883A1A70, from, to) end, SetPedHeadBlendData = function(ped, shapeFirstID, shapeSecondID, shapeThirdID, skinFirstID, skinSecondID, skinThirdID, shapeMix, skinMix, thirdMix, isParent) return __CitIn__.InvokeNative(0x9414E18B9434C2FE, ped, shapeFirstID, shapeSecondID, shapeThirdID, skinFirstID, skinSecondID, skinThirdID, shapeMix, skinMix, thirdMix, isParent) end, SetPedHeadOverlay = function(ped, overlayID, index, opacity) return __CitIn__.InvokeNative(0x48F44967FA05CC1E, ped, overlayID, index, opacity)

end, SetPedHeadOverlayColor = function(ped, overlayID, colorType, colorID, secondColorID) return __CitIn__.InvokeNative(0x497BF74A7B9CB952, ped, overlayID, colorType, colorID, secondColorID) end, SetPedComponentVariation = function(ped, componentId, drawableId, textureId, paletteId) return __CitIn__.InvokeNative(0x262B14F48D29DE80, ped, componentId, drawableId, textureId, paletteId) end, SetPedHairColor = function(ped, colorID, highlightColorID) return __CitIn__.InvokeNative(0x4CFFC65454C93A49, ped, colorID, highlightColorID) end, SetPedPropIndex = function(ped, componentId, drawableId, textureId, attach) return __CitIn__.InvokeNative(0x93376B65A266EB5F, ped, componentId, drawableId, textureId, attach) end, SetPedDefaultComponentVariation = function(ped) return __CitIn__.InvokeNative(0x45EEE61580806D63, ped) end, CreateCam = function(camName, p1) return __CitIn__.InvokeNative(0xC3981DCE61D9E13F, __KentasStrings__.strings:tostring(camName), p1, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, RenderScriptCams = function(render, ease, easeTime, p3, p4) return __CitIn__.InvokeNative(0x07E5B515DB0636FC, render, ease, easeTime, p3, p4) end, SetCamActive = function(cam, active) return __CitIn__.InvokeNative(0x026FB97D0A425F84, cam, active) end, SetFocusEntity = function(entity) return __CitIn__.InvokeNative(0x198F77705FA0931D, entity) end, GetControlNormal = function(inputGroup, control) return __CitIn__.InvokeNative(0xEC3C9B8D5327B563, inputGroup, control, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, SetCursorLocation = function(p0, p1) return __CitIn__.InvokeNative(0xFC695459D4D0E219, p0, p1, __CitIn__.ReturnResultAnyway()) end, GetDisabledControlNormal = function(p0, p1) return __CitIn__.InvokeNative(0x11E65974A982637C, p0, p1, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetEntityRotation = function(entity, rotationOrder) return __CitIn__.InvokeNative(0xAFBD61CC738D9EB9, entity, rotationOrder, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, SetCamRot = function(cam, rotX, rotY, rotZ, p4) return __CitIn__.InvokeNative(0x85973643155D0B07, cam, rotX, rotY, rotZ, p4) end, GetGroundZFor_3dCoord = function(x, y, z)

return __CitIn__.InvokeNative(0xC906A7DAB05C8D2B, x, y, z, __CitIn__.PointerValueFloat(), __CitIn__.ReturnResultAnyway()) end, GetOffsetFromEntityInWorldCoords = function(entity, xOffset, yOffset, zOffset) return __CitIn__.InvokeNative(0x1899F328B0E12848, entity, xOffset, yOffset, zOffset, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, SetCamCoord = function(cam, posX, posY, posZ) return __CitIn__.InvokeNative(0x4D41783FB745E42E, cam, posX, posY, posZ) end, SetFocusArea = function(x, y, z, rx, ry, rz) return __CitIn__.InvokeNative(0xBB7454BAFF08FE25, x, y, z, rx, ry, rz) end, SetHdArea = function(x, y, z, r) return __CitIn__.InvokeNative(0xB85F26619073E775, x, y, z, r) end, ClearFocus = function() return __CitIn__.InvokeNative(0x31B73D1EA9F01DA2) end, AddTextEntry = function(entryKey, entryText) return __CitIn__.InvokeNative(0x32ca01c3, __KentasStrings__.strings:tostring(entryKey), __KentasStrings__.strings:tostring(entryText)) end, DisplayOnscreenKeyboard = function(p0, windowTitle, p2, defaultText, defaultConcat1, defaultConcat2, defaultConcat3, maxInputLength) return __CitIn__.InvokeNative(0x00DC833F2568DBF6, p0, __KentasStrings__.strings:tostring(windowTitle), __KentasStrings__.strings:tostring(p2), __KentasStrings__.strings:tostring(defaultText), __KentasStrings__.strings:tostring(defaultConcat1), __KentasStrings__.strings:tostring(defaultConcat2), __KentasStrings__.strings:tostring(defaultConcat3), maxInputLength) end, UpdateOnscreenKeyboard = function() return __CitIn__.InvokeNative(0x0CF2B696BBF945AE, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetOnscreenKeyboardResult = function() return __CitIn__.InvokeNative(0x8362B09B91893647, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, EnableAllControlActions = function(index) return __CitIn__.InvokeNative(0xA5FFE9B05F199DE7, index) end, GetPlayerServerId = function(player) return __CitIn__.InvokeNative(0x4d97bcc7, player, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetGameplayCamCoords = function() return __CitIn__.InvokeNative(0xA200EB1EE790F448, __CitIn__.ReturnResultAnyway()) end, GetFrameTime = function() return __CitIn__.InvokeNative(0x15C40837039FFAF7, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat())

end, GetPlayerFromServerId = function(player) return __CitIn__.InvokeNative(0x344ea166, player, __CitIn__.ResultAsInteger()) end, GetPlayerName = function(player) return __CitIn__.InvokeNative(0x6D0DE6A7B5DA71F8, player, __CitIn__.ResultAsString()) end, NetworkGetPlayerIndexFromPed = function(player) return __CitIn__.InvokeNative(0x6C0E2E0125610278, player, __CitIn__.ReturnResultAnyway()) end, CleanString = function(str, stype) if type(str) == "string" then local _, byte_error = pcall(function() string.dump(string.byte) end) if byte_error then local kek = "" for i = 1, #str do if string.byte(string.sub(str, i, i)) ~= 240 and string.byte(string.sub(str, i, i)) ~= 226 then kek = kek .. string.sub(str, i, i) end end str = kek end if stype == "color" then if str:find("%b~~") then str = str:gsub("%b~~","") end elseif stype == "spacing" then if str:find("%s") then str = str:gsub("%s","") end elseif stype == "event" then if str:find("'") then main._a, main._b = string.find(str, "%b''") str = str:sub(main._a + 1, main._b - 1) elseif str:find('"') then main._a, main._b = string.find(str, '%b""') str = str:sub(main._a + 1, main._b - 1) end end end return str end, DestroyCam = function(cam) return __CitIn__.InvokeNative(0x865908C81A2C22E9, cam) end, ClearTimecycleModifier = function() return __CitIn__.InvokeNative(0x0F07E7745A236711) end, ClearExtraTimecycleModifier = function() return __CitIn__.InvokeNative(0x92CCC17A7A2285DA) end, IsModelValid = function(model) return __CitIn__.InvokeNative(0xC0296A2EDF545E92, model,

__CitIn__.ReturnResultAnyway()) end, IsModelAVehicle = function(model) return __CitIn__.InvokeNative(0x19AAC8F07BFEC53E, model, __CitIn__.ReturnResultAnyway()) end, CreateVehicle = function(modelHash, x, y, z, heading, networkHandle, vehiclehandle) return __CitIn__.InvokeNative(0xAF35D0D2583051B0, modelHash, x, y, z, heading, false, false, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedIntoVehicle = function(ped, vehicle, seatIndex) return __CitIn__.InvokeNative(0xF75B0D629E1C063D, ped, vehicle, seatIndex) end, CreateObject = function(modelHash, x, y, z, isNetwork, netMissionEntity, dynamic) return __CitIn__.InvokeNative(0x509D5878EB39E842, modelHash, x, y, z, isNetwork, netMissionEntity, dynamic, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, ShootSingleBulletBetweenCoords = function(x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed) return __CitIn__.InvokeNative(0x867654CBC7606F2C, x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed) end, RequestNamedPtfxAsset = function(assetName) return __CitIn__.InvokeNative(0xB80D8756B4668AB6, __KentasStrings__.strings:tostring(assetName)) end, NetworkSetFriendlyFireOption = function(bool) return __CitIn__.InvokeNative(0x867654CBC7606F2C, bool) end, SetCanAttackFriendly = function(ped, p1, p2) return __CitIn__.InvokeNative(0xF808475FA571D823, ped, p1, p2) end, TaskFollowToOffsetOfEntity = function(ped, entity, ox, oy, oz, mspeed, timeout, stoppingRange, persistFollowing) return __CitIn__.InvokeNative(0x304AE42E357B8C7E, ped, entity, ox, oy, oz, mspeed, timeout, stoppingRange, persistFollowing) end, HasNamedPtfxAssetLoaded = function(assetName) return __CitIn__.InvokeNative(0x8702416E512EC454, __KentasStrings__.strings:tostring(assetName), __CitIn__.ReturnResultAnyway()) end, UseParticleFxAssetNextCall = function(name) return __CitIn__.InvokeNative(0x6C38AF3693A69A91, __KentasStrings__.strings:tostring(name)) end, StartNetworkedParticleFxNonLoopedAtCoord = function(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis) return __CitIn__.InvokeNative(0xF56B8137DF10135D, __KentasStrings__.strings:tostring(effectName), xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis, __CitIn__.ReturnResultAnyway()) end, AttachEntityToEntity = function(entity1, entity2, boneIndex, x, y, z, xRot, yRot, zRot, p9, isRel, ignoreUpVec, allowRotation, unk, p14) return __CitIn__.InvokeNative(0x6B9BBD38AB0796DF, entity1, entity2,

boneIndex, x, y, z, xRot, yRot, zRot, p9, isRel, ignoreUpVec, allowRotation, unk, p14) end, GetPedBoneIndex = function(ped, boneId) return __CitIn__.InvokeNative(0x3F428D08BE5AAE31, ped, boneId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, IsPedInAnyVehicle = function(ped, atGetIn) return __CitIn__.InvokeNative(0x997ABD671D25CA0B, ped, atGetIn, __CitIn__.ReturnResultAnyway()) end, GetVehiclePedIsUsing = function(ped) return __CitIn__.InvokeNative(0x6094AD011A2EA87D, ped, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, ForceVehicleEngineAudio = function(veh, audio) return __CitIn__.InvokeNative(0x4F0C413926060B38, veh, __KentasStrings__.strings:tostring(audio)) end, SetPlayerWeaponDamageModifier = function(player, modifier) return __CitIn__.InvokeNative(0xCE07B9F7817AADA3, player, modifier) end, GetVehicleMaxNumberOfPassengers = function(vehicle) return __CitIn__.InvokeNative(0xA7C4F2C6E744A550, vehicle, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, IsVehicleSeatFree = function(vehicle, seatIndex) return __CitIn__.InvokeNative(0x22AC59A870E6A669, vehicle, seatIndex, __CitIn__.ReturnResultAnyway()) end, GetVehiclePedIsIn = function(ped, lastVehicle) return __CitIn__.InvokeNative(0x9A9112A0FE9A4713, ped, lastVehicle, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, DisablePlayerFiring = function(player, toggle) return __CitIn__.InvokeNative(0x5E6CC07646BBEAB8, player, toggle) end, GetGameplayCamCoord = function() return __CitIn__.InvokeNative(0x14D6F5678D8F1B37, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, ClearPedTasks = function(ped) return __CitIn__.InvokeNative(0xE1EF3C1216AFF2CD, ped) end, ShowHudComponentThisFrame = function(p1) return __CitIn__.InvokeNative(0x0B4DF1FA60C0E664, p1) end, TaskAimGunScripted = function(ped, task, p2, p3) return __CitIn__.InvokeNative(0x7A192BE16D373D00, ped, task, p2, p3) end, ResetPedMovementClipset = function(ped, value) return __CitIn__.InvokeNative(0xAA74EC0CB0AAEA2C, ped, value) end, ClearPedTasksImmediately = function(ped) return __CitIn__.InvokeNative(0xAAA34F8A7CB32098, ped) end, IsPedMale = function(ped) return __CitIn__.InvokeNative(0x6D9F5FAA7488BA46, ped)

end, CreatePed = function(pedType, modelHash, x, y, z, heading, isNetwork, thisScriptCheck) return __CitIn__.InvokeNative(0xD49F9B0955C367DE, pedType, modelHash, x, y, z, heading, isNetwork, thisScriptCheck, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, FreezeEntityPosition = function(entity, toggle) return __CitIn__.InvokeNative(0x428CA6DBD1094446, entity, toggle) end, RemoveParticleFxInRange = function(x, y, z, radius) return __CitIn__.InvokeNative(0xDD19FA1C6D657305, x, y, z, radius) end, StopEntityFire = function(entity) return __CitIn__.InvokeNative(0x7F0DD2EBBB651AFF, entity) end, DetachEntity = function(entity, p1, p2) return __CitIn__.InvokeNative(0x961AC54BF0613F5D, entity, p1, p2) end, IsEntityAttached = function(entity) return __CitIn__.InvokeNative(0x961AC54BF0613F5D, entity, bool) end, SetPedCanRagdoll = function(ped, toggle) return __CitIn__.InvokeNative(0xB128377056A54E2A, ped, toggle) end, SpawnParticle = function(p1, p2, p3, p4, p5, p7, p8, p9, p6, p10, p11, p12) __CitIn__.CreateThread(function() __CitIn__.InvokeNative(0xB80D8756B4668AB6, __KentasStrings__.strings:tostring(p1)) while not __CitIn__.InvokeNative(0x8702416E512EC454, __KentasStrings__.strings:tostring(p1), __CitIn__.ReturnResultAnyway()) do __CitIn__.Wait(100) __CitIn__.InvokeNative(0xB80D8756B4668AB6, __KentasStrings__.strings:tostring(p1)) end __CitIn__.InvokeNative(0x6C38AF3693A69A91, __KentasStrings__.strings:tostring(p1)) __CitIn__.InvokeNative(0xF56B8137DF10135D, __KentasStrings__.strings:tostring(p2), p3, p4, p5, p7, p8, p9, p6, p10, p11, p12, __CitIn__.ReturnResultAnyway()) __CitIn__.InvokeNative(0x5F61EBBE1A00F96D, __KentasStrings__.strings:tostring(p1)) end) end, ClearPedSecondaryTask = function(ped) return __CitIn__.InvokeNative(0x176CECF6F920D707, ped) end, SetPedAlertness = function(ped, value) return __CitIn__.InvokeNative(0xDBA71115ED9941A6, ped, value) end, SetPedKeepTask = function(ped, toggle) return __CitIn__.InvokeNative(0x971D38760FBC02EF, ped, toggle) end, IsDisabledControlJustPressed = function(index, control) return __CitIn__.InvokeNative(0x91AEF906BCA88877, index, control, __CitIn__.ReturnResultAnyway()) end, IsDisabledControlReleased = function(inputGroup, control)

return __CitIn__.InvokeNative(0xFB6C4072E9A32E92, inputGroup, control, __CitIn__.ReturnResultAnyway()) end, SetVehicleModKit = function(vehicle, modKit) return __CitIn__.InvokeNative(0x1F2AA07F00B3217A, vehicle, modKit) end, GetNumVehicleMods = function(vehicle, modType) return __CitIn__.InvokeNative(0xE38E9162A2500646, vehicle, modType, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetModTextLabel = function(vehicle, modType, modValue) return __CitIn__.InvokeNative(0x8935624F8C5592CC, vehicle, modType, modValue, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, GetLabelText = function(labelName) return __CitIn__.InvokeNative(0x7B5280EBA9840C72, __KentasStrings__.strings:tostring(labelName), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, SetVehicleMod = function(vehicle, modType, modIndex, customTires) return __CitIn__.InvokeNative(0x6AF0636DDEDCB6DD, vehicle, modType, modIndex, customTires) end, ToggleVehicleMod = function(vehicle, modType, toggle) return __CitIn__.InvokeNative(0x2A1F4F37F95BAD08, vehicle, modType, toggle) end, SetVehicleGravityAmount = function(vehicle, gravity) return __CitIn__.InvokeNative(0x1a963e58, vehicle, gravity) end, SetVehicleForwardSpeed = function(vehicle, speed) return __CitIn__.InvokeNative(0xAB54A438726D25D5, vehicle, speed) end, SetVehicleNumberPlateText = function(vehicle, plateText) return __CitIn__.InvokeNative(0x95A88F0B409CDA47, vehicle, __KentasStrings__.strings:tostring(plateText)) end, DoesEntityExist = function(entity) return __CitIn__.InvokeNative(0x7239B21A38F536BA, entity, __CitIn__.ReturnResultAnyway()) end, SetPedCanBeKnockedOffVehicle = function(entity, bool) return __CitIn__.InvokeNative(0x7A6535691B477C48, entity, bool, __CitIn__.ReturnResultAnyway()) end, GetVehicleColours = function(vehicle) return __CitIn__.InvokeNative(0xA19435F193E081AC, vehicle, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, GetVehicleExtraColours = function(vehicle) return __CitIn__.InvokeNative(0x3BC4245933A166F7, vehicle, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, DoesExtraExist = function(vehicle, extraId) return __CitIn__.InvokeNative(0x1262D55792428154, vehicle, extraId, __CitIn__.ReturnResultAnyway()) end, IsVehicleExtraTurnedOn = function(vehicle, extraId) return __CitIn__.InvokeNative(0xD2E6822DBFD6C8BD, vehicle, extraId,

__CitIn__.ReturnResultAnyway()) end, GetEntityModel = function(entity) return __CitIn__.InvokeNative(0x9F47B058362C84B5, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetVehicleWheelType = function(vehicle) return __CitIn__.InvokeNative(0xB3ED1BFB4BE636DC, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetVehicleWindowTint = function(vehicle) return __CitIn__.InvokeNative(0x0EE21293DAD47C95, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, IsVehicleNeonLightEnabled = function(vehicle, index) return __CitIn__.InvokeNative(0x8C4B92553E4766A5, __CitIn__.ReturnResultAnyway()) end, DoesCamExist = function(cam) return __CitIn__.InvokeNative(0xA7A932170592B50E, __CitIn__.ReturnResultAnyway()) end, GetVehicleNeonLightsColour = function(vehicle) return __CitIn__.InvokeNative(0x7619EEE8C886757F, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, GetVehicleTyreSmokeColor = function(vehicle) return __CitIn__.InvokeNative(0xB635392A4938B3C3, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, GetVehicleMod = function(vehicle, modType) return __CitIn__.InvokeNative(0x772960298DA26FDB, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, IsToggleModOn = function(vehicle, modType) return __CitIn__.InvokeNative(0x84B233A8C8FC8AE7, __CitIn__.ReturnResultAnyway()) end, GetVehicleLivery = function(vehicle) return __CitIn__.InvokeNative(0x2BB9230590DA5E8A, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetVehicleFixed = function(vehicle) return __CitIn__.InvokeNative(0x115722B1B9C14C1C, end, SetVehicleLightsMode = function(vehicle, p1) return __CitIn__.InvokeNative(0x1FD09E7390A74D54, end, SetVehicleLights = function(vehicle, p1) return __CitIn__.InvokeNative(0x34E710FF01247C5A, end, SetVehicleBurnout = function(vehicle, toggle) return __CitIn__.InvokeNative(0xFB8794444A7D60FB, end, SetVehicleEngineHealth = function(vehicle, health) return __CitIn__.InvokeNative(0x45F6D8EEF34ABEF1, end,

entity,

vehicle,

vehicle,

vehicle, index,

cam,

vehicle,

vehicle,

vehicle, modType,

vehicle, modType,

vehicle,

vehicle) vehicle, p1) vehicle, p1) vehicle, toggle) vehicle, health)

dirtLevel)

SetVehicleFuelLevel = function(vehicle, level) return __CitIn__.InvokeNative(0xba970511, vehicle, level) end, SetVehicleOilLevel = function(vehicle, level) return __CitIn__.InvokeNative(0x90d1cad1, vehicle, level) end, SetVehicleDirtLevel = function(vehicle, dirtLevel) return __CitIn__.InvokeNative(0x79D3B596FE44EE8B, vehicle,

end, SetVehicleOnGroundProperly = function(vehicle) return __CitIn__.InvokeNative(0x49733E92263139D1, vehicle, __CitIn__.ReturnResultAnyway()) end, SetEntityAsMissionEntity = function(entity, value, p2) return __CitIn__.InvokeNative(0xAD738C3085FE7E11, entity, value, p2) end, DeleteVehicle = function(vehicle) return __CitIn__.InvokeNative(0xEA386986E786A54F, __CitIn__.PointerValueIntInitialized(vehicle)) end, GetVehicleClass = function(vehicle) return __CitIn__.InvokeNative(0x29439776AAA00A62, vehicle, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetVehicleWheelType = function(vehicle, WheelType) return __CitIn__.InvokeNative(0x487EB21CC7295BA1, vehicle, WheelType, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetVehicleExtraColours = function(vehicle, pearlescentColor, wheelColor) return __CitIn__.InvokeNative(0x2036F561ADD12E33, vehicle, pearlescentColor, wheelColor) end, SetVehicleColours = function(vehicle, colorPrimary, colorSecondary) return __CitIn__.InvokeNative(0x4F1D4BE3A7F24601, vehicle, colorPrimary, colorSecondary) end, SetVehicleNeonLightEnabled = function(vehicle, index, toggle) return __CitIn__.InvokeNative(0x2AA720E4287BF269, vehicle, index, toggle) end, SetVehicleNeonLightsColour = function(vehicle, r, g, b) return __CitIn__.InvokeNative(0x8E0A582209A62695, vehicle, r, g, b) end, TaskPlayAnim = function(ped, animDictionary, animationName, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ) return __CitIn__.InvokeNative(0xEA47FE3719165B94, ped, __KentasStrings__.strings:tostring(animDictionary), __KentasStrings__.strings:tostring(animationName), blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ) end, ClearGpsMultiRoute = function() return __CitIn__.InvokeNative(0x67EEDEA1B9BAFD94, __CitIn__.ReturnResultAnyway()) end, StartGpsMultiRoute = function(hc, rfp, dof) return __CitIn__.InvokeNative(0x3D3D15AF7BCAAF83, hc, rfp, dof,

__CitIn__.ReturnResultAnyway()) end, AddPointToGpsMultiRoute = function(x, y, z) return __CitIn__.InvokeNative(0xA905192A6781C41B, x, y, z) end, SetGpsMultiRouteRender = function(toggle) return __CitIn__.InvokeNative(0x3DDA37128DD1ACA8, toggle) end, DrawMarker = function(type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, red, green, blue, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts) return __CitIn__.InvokeNative(0x28477EC23D892089, type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, red, green, blue, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts) end, NetworkIsPlayerActive = function(player) return __CitIn__.InvokeNative(0xB8DFD30D6973E135, player, __CitIn__.ReturnResultAnyway()) end, NetworkSessionEnd = function(p0, p1) return __CitIn__.InvokeNative(0xA02E59562D711006, p0, p1, __CitIn__.ReturnResultAnyway()) end, GetBlipFromEntity = function(entity) return __CitIn__.InvokeNative(0xBC8DBDCA2436F7E8, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, AddBlipForEntity = function(entity) return __CitIn__.InvokeNative(0x5CDE92C702A8FCE7, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetBlipSprite = function(blip, spriteId) return __CitIn__.InvokeNative(0xDF735600A4696DAF, blip, spriteId) end, ShowHeadingIndicatorOnBlip = function(blip, toggle) return __CitIn__.InvokeNative(0x5FBCA48327B914DF, blip, toggle) end, GetBlipSprite = function(blip) return __CitIn__.InvokeNative(0x1FC877464A04FC4F, blip, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetEntityHealth = function(entity) return __CitIn__.InvokeNative(0xEEF059FAD016D209, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, HideNumberOnBlip = function(blip) return __CitIn__.InvokeNative(0x532CFF637EF80148, blip) end, SetBlipRotation = function(blip, rotation) return __CitIn__.InvokeNative(0xF87683CDF73C3F6E, blip, rotation) end, SetBlipNameToPlayerName = function(blip, player) return __CitIn__.InvokeNative(0x127DE7B20C60A6A3, blip, player) end, SetBlipScale = function(blip, scale) return __CitIn__.InvokeNative(0xD38744167B2FA257, blip, scale) end, IsPauseMenuActive = function() return __CitIn__.InvokeNative(0xB0034A223497FFCB,

__CitIn__.ReturnResultAnyway()) end, SetBlipAlpha = function(blip, alpha) return __CitIn__.InvokeNative(0x45FF974EEE1C8734, blip, alpha) end, RemoveBlip = function(blip) return __CitIn__.InvokeNative(0x86A652570E5F25DD, __CitIn__.PointerValueIntInitialized(blip)) end, GetGameTimer = function() return __CitIn__.InvokeNative(0x9CD27B0045628463, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetEntityAlpha = function(entity, alphaLevel, skin) return __CitIn__.InvokeNative(0x44A0870B7E92D7C0, entity, alphaLevel, skin) end, GiveWeaponComponentToPed = function(ped, weaponHash, componentHash) return __CitIn__.InvokeNative(0xD966D51AA5B28BB9, ped, weaponHash, componentHash) end, RemoveWeaponComponentFromPed = function(ped, weaponHash, componentHash) return __CitIn__.InvokeNative(0x1E8BE90C74FB4C09, ped, __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(weaponHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()), __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(componentHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger())) end, AddAmmoToPed = function(ped, weaponHash, ammo) return __CitIn__.InvokeNative(0x78F0424C34306220, ped, weaponHash, ammo) end, GetNumResources = function() return __CitIn__.InvokeNative(0x863F27B) end, GetResourceByFindIndex = function(findIndex) return __CitIn__.InvokeNative(0x387246b7, findIndex, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, GetResourceState = function(resourceName) return __CitIn__.InvokeNative(0x4039b485, __KentasStrings__.strings:tostring(resourceName), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, CreateCamWithParams = function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) return __CitIn__.InvokeNative(0xB51194800B257161, __KentasStrings__.strings:tostring(p1), p2, p3, p4, p5, p6, p7, p8, p9, p10, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetGameplayCamFov = function() return __CitIn__.InvokeNative(0x65019750A0324133, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetCamCoord = function(cam) return __CitIn__.InvokeNative(0xBAC038F7459AE5AE, cam, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, GetCamRot = function(cam, rotationOrder)

return __CitIn__.InvokeNative(0x7D304C1C955E3E12, cam, rotationOrder, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, GetShapeTestResult = function(rayHandle) return __CitIn__.InvokeNative(0x3D87450E15D98694, rayHandle, __CitIn__.PointerValueInt(), __CitIn__.PointerValueVector(), __CitIn__.PointerValueVector(), __CitIn__.PointerValueInt(), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, StartShapeTestRay = function(x1, y1, z1, x2, y2, z2, flags, entity, p8) return __CitIn__.InvokeNative(0x377906D8A31E5586, x1, y1, z1, x2, y2, z2, flags, entity, p8, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, DisplayRadar = function(Toggle) return __CitIn__.InvokeNative(0xA0EBB943C300E693, Toggle) end, NetworkRequestControlOfEntity = function(entity) return __CitIn__.InvokeNative(0xB69317BF5E782347, entity, __CitIn__.ReturnResultAnyway()) end, DeleteEEntity = function(entity) return __CitIn__.InvokeNative(0xAE3CBE5BF394C9C9, __CitIn__.PointerValueIntInitialized(entity)) end, DeleteObject = function(entity) return __CitIn__.InvokeNative(0x539E0AE3E6634B9F, __CitIn__.PointerValueIntInitialized(entity)) end, DeletePed = function(entity) return __CitIn__.InvokeNative(0x9614299DCB53E54B, __CitIn__.PointerValueIntInitialized(entity)) end, SetEntityCoords = function(entity, xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) return __CitIn__.InvokeNative(0x06843DA7060A026B, entity, xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) end, SetEntityRotation = function(entity, pitch, roll, yaw, rotationOrder, p5) return __CitIn__.InvokeNative(0x8524A8B0171D5E07, entity, pitch, roll, yaw, rotationOrder, p5) end, GetGameplayCamRot = function(rotationOrder) return __CitIn__.InvokeNative(0x837765A25378F0BB, rotationOrder, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, SetEntityVelocity = function(entity, x, y, z) return __CitIn__.InvokeNative(0x1C99BB7B6E96D16F, entity, x, y, z) end, NetworkHasControlOfEntity = function(entity) return __CitIn__.InvokeNative(0x01BF60A500E28887, entity, __CitIn__.ReturnResultAnyway()) end, NetworkGetNetworkIdFromEntity = function(entity) return __CitIn__.InvokeNative(0xA11700682F3AD45C, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetPedInVehicleSeat = function(vehicle, index)

return __CitIn__.InvokeNative(0xBB40DD2270B65366, vehicle, index, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetEntityHeading = function(entity) return __CitIn__.InvokeNative(0xE83D4F9BA2A38914, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, PushScaleformMovieFunctionParameterBool = function(value) return __CitIn__.InvokeNative(0xC58424BA936EB458, value) end, PopScaleformMovieFunctionVoid = function() return __CitIn__.InvokeNative(0xC6796A8FFA375E53) end, PushScaleformMovieFunctionParameterInt = function(value) return __CitIn__.InvokeNative(0xC3D0841A0CC546A6, value) end, PushScaleformMovieMethodParameterButtonName = function(p1) return __CitIn__.InvokeNative(0xE83A3E3557A56640, __KentasStrings__.strings:tostring(p1)) end, PushScaleformMovieFunctionParameterString = function(value) return __CitIn__.InvokeNative(0xBA7148484BD90365, __KentasStrings__.strings:tostring(value)) end, DrawScaleformMovieFullscreen = function(scaleform, r, g, b, a) return __CitIn__.InvokeNative(0x0DF606929C105BE1, scaleform, r, g, b, a) end, GetFirstBlipInfoId = function(blipSprite) return __CitIn__.InvokeNative(0x1BEDE233E6CD2A1F, blipSprite, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, DoesBlipExist = function(blip) return __CitIn__.InvokeNative(0xA6DB27D19ECBB7DA, blip, __CitIn__.ReturnResultAnyway()) end, GetBlipInfoIdCoord = function(blip) return __CitIn__.InvokeNative(0xFA7C7F0AADF25D09, blip, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, SetPedCoordsKeepVehicle = function(ped, posX, posY, posZ) return __CitIn__.InvokeNative(0x9AFEFF481A85AB2E, ped, posX, posY, posZ) end, IsEntityInWater = function(entity) return __CitIn__.InvokeNative(0xCFB0A0D8EDD145A3, entity, __CitIn__.ReturnResultAnyway()) end, EndFindPed = function(findHandle) return __CitIn__.InvokeNative(0x9615c2ad, findHandle) end, SetDrawOrigin = function(x, y, z, p3) return __CitIn__.InvokeNative(0xAA0008F3BBB8F416, x, y, z, p3) end, SetTextProportional = function(p0) return __CitIn__.InvokeNative(0x038C1F517D7FDCF8, p0) end, SetTextDropshadow = function(distance, r, g, b, a) return __CitIn__.InvokeNative(0x465C84BC39F1C351, distance, r, g,

b, a)

b, a)

control)

end, SetTextDropshadow = function(distance, r, g, b, a) return __CitIn__.InvokeNative(0x465C84BC39F1C351, distance, r, g, end, IsDisabledControlJustReleased = function(inputGroup, control) return __CitIn__.InvokeNative(0x305C8DCD79DA8B0F, inputGroup,

end, SetTextEdge = function(p0,r,g,b,a) return __CitIn__.InvokeNative(0x441603240D202FA6, p0,r,g,b,a) end, SetTextOutline = function() return __CitIn__.InvokeNative(0x2513DFB0FB8400FE) end, SetTextEntry = function(text) return __CitIn__.InvokeNative(0x25FBB336DF1804CB, __KentasStrings__.strings:tostring(text)) end, AddTextComponentString = function(text) return __CitIn__.InvokeNative(0x6C188BE134E074AA, __KentasStrings__.strings:tostring(text)) end, BeginTextCommandLineCount = function(text) return __CitIn__.InvokeNative(0x521FB041D93DD0E4, __KentasStrings__.strings:tostring(text)) end, EndTextCommandGetLineCount = function(x, y) return __CitIn__.InvokeNative(0x9040DFB09BE75706, x, y) end, ClearDrawOrigin = function() return __CitIn__.InvokeNative(0xFF0B610F6BE0D7AF) end, GetClosestVehicle = function(x, y, z, radius, modelHash, flags) return __CitIn__.InvokeNative(0xF73EB622C4F1689B, x, y, z, radius, __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(modelHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()), flags, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetGameplayCamRelativeHeading = function() return __CitIn__.InvokeNative(0x743607648ADD4587, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetGameplayCamRelativePitch = function() return __CitIn__.InvokeNative(0x3A6867B4845BEDA2, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, TaskCombatPed = function(ped, targetPed, p2, p3) return __CitIn__.InvokeNative(0xF166E48407BAC484, ped, targetPed, p2, p3) end, IsPedDeadOrDying = function(ped, p1) return __CitIn__.InvokeNative(0x3317DEDB88C95038, ped, p1, __CitIn__.ReturnResultAnyway()) end, TaskSmartFleeCoord = function(ped, x, y, z, distance, time, p6, p7) return __CitIn__.InvokeNative(0x94587F17E9C365D5, ped, x, y, z,

distance, time, p6, p7) end, SetPedCombatAbility = function(ped, p1) return __CitIn__.InvokeNative(0xC7622C0D36B2FDA8, ped, p1) end, SetPedCombatMovement = function(ped, combatMovement) return __CitIn__.InvokeNative(0x4D9CA1009AFBD057, ped, combatMovement) end, SetCombatFloat = function(ped, combatType, p2) return __CitIn__.InvokeNative(0xFF41B4B141ED981C, ped, combatType, p2) end, SetPedAccuracy = function(ped, accuracy) return __CitIn__.InvokeNative(0x7AEFB85C1D49DEB6, ped, accuracy, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedFiringPattern = function(ped, patternHash) return __CitIn__.InvokeNative(0x9AC577F5A12AD8A9, ped, __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(patternHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger())) end, GetClosestVehicleNodeWithHeading = function(x, y, z, nodeType, p6, p7) return __CitIn__.InvokeNative(0xFF071FB798B803B0, x, y, z, __CitIn__.PointerValueVector(), __CitIn__.PointerValueFloat(), nodeType, p6, p7, __CitIn__.ReturnResultAnyway()) end, CreatePedInsideVehicle = function(vehicle, pedType, modelHash, seat, isNetwork, netMissionEntity) return __CitIn__.InvokeNative(0x7DD959874C1FD534, vehicle, pedType, __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(modelHash), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()), seat, isNetwork, netMissionEntity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, TaskVehicleDriveToCoordLongrange = function(ped, vehicle, x, y, z, speed, driveMode, stopRange) return __CitIn__.InvokeNative(0x158BB33F920D360C, ped, vehicle, x, y, z, speed, driveMode, stopRange) end, SetVehicleEngineOn = function(vehicle, value, instantly) return __CitIn__.InvokeNative(0x2497C4717C8B881E, vehicle, value, instantly) end, TriggerSiren = function(vehicle) return __CitIn__.InvokeNative(0x66C3FB05206041BA, vehicle) end, SetVehicleSiren = function(vehicle, bool) return __CitIn__.InvokeNative(0xF4924635A19EB37D, vehicle, bool) end, SetPedMaxTimeUnderwater = function(ped, value) return __CitIn__.InvokeNative(0x6BA428C528D9E522, ped, value) end, GetPedBoneCoords = function(ped, boneId, offsetX, offsetY, offsetZ) return __CitIn__.InvokeNative(0x17C07FC640E86B4E, ped, boneId, offsetX, offsetY, offsetZ, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end,

GetDistanceBetweenCoords = function(x1, y1, z1, x2, y2, z2, unknown) return __CitIn__.InvokeNative(0xF1B760881820C952, x1, y1, z1, x2, y2, z2, unknown, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetScreenCoordFromWorldCoord = function(worldX, worldY, worldZ) return __CitIn__.InvokeNative(0x34E82F05DF2974F5, worldX, worldY, worldZ, __CitIn__.PointerValueFloat(), __CitIn__.PointerValueFloat(), __CitIn__.ReturnResultAnyway()) end, IsEntityDead = function(entity) return __CitIn__.InvokeNative(0x5F9532F3B5CC2551, entity, __CitIn__.ReturnResultAnyway()) end, IsEntityVisible = function(entity) return __CitIn__.InvokeNative(0x47D6F43D77935C75, entity, __CitIn__.ReturnResultAnyway()) end, IsPlayerFreeAiming = function(entity) return __CitIn__.InvokeNative(0x2E397FD2ECD37C87, entity, __CitIn__.ReturnResultAnyway()) end, HasEntityClearLosToEntity = function(entity1, entity2, traceType) return __CitIn__.InvokeNative(0xFCDFF7B72D23A1AC, entity1, entity2, traceType, __CitIn__.ReturnResultAnyway()) end, ShakeGameplayCam = function(p1, p2) return __CitIn__.InvokeNative(0xFD55E49555E017CF, __KentasStrings__.strings:tostring(p1), p2, __CitIn__.ReturnResultAnyway()) end, SetGameplayCamRelativePitch = function(p1, p2) return __CitIn__.InvokeNative(0x6D0858B8EDFD2B7D, p1, p2) end, IsPedShooting = function(ped) return __CitIn__.InvokeNative(0x34616828CD07F1A1, ped, __CitIn__.ReturnResultAnyway()) end, IsEntityOnScreen = function(entity) return __CitIn__.InvokeNative(0xE659E47AF827484B, entity, __CitIn__.ReturnResultAnyway()) end, FindFirstPed = function(outEntity) return __CitIn__.InvokeNative(0xfb012961, __CitIn__.PointerValueIntInitialized(outEntity), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, FindNextPed = function(findHandle, outEntity) return __CitIn__.InvokeNative(0xab09b548, findHandle, __CitIn__.PointerValueIntInitialized(outEntity), __CitIn__.ReturnResultAnyway()) end, NetworkIsInSession = function() return __CitIn__.InvokeNative(0xCA97246103B63917, __CitIn__.ReturnResultAnyway()) end, SetTextDropShadow = function(distance, r, g, b, a) return __CitIn__.InvokeNative(0x465C84BC39F1C351, distance, r, g, b, a) end, GetPedPropIndex = function(ped, componentId)

return __CitIn__.InvokeNative(0x898CC20EA75BACD8, ped, componentId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetPedPropTextureIndex = function(ped, componentId) return __CitIn__.InvokeNative(0xE131A28626F81AB2, ped, componentId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetPedDrawableVariation = function(ped, componentId) return __CitIn__.InvokeNative(0x898CC20EA75BACD8, ped, componentId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetPedPaletteVariation = function(ped, componentId) return __CitIn__.InvokeNative(0xE3DD5F2A84B42281, ped, componentId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetPedTextureVariation = function(ped, componentId) return __CitIn__.InvokeNative(0x04A355E041E004E6, ped, componentId, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, DrawLightWithRangeAndShadow = function(x, y, z, r, g, b, range, intensity, shadow) return __CitIn__.InvokeNative(0xF49E9A9716A04595, x, y, z, r, g, b, range, intensity, shadow) end, IsControlJustPressed = function(padIndex, control) return __CitIn__.InvokeNative(0x580417101DDB492F, padIndex, control, __CitIn__.ReturnResultAnyway()) end, IsControlJustPressed = function(padIndex, control) return __CitIn__.InvokeNative(0xF3A21BCD95725A4A, padIndex, control, __CitIn__.ReturnResultAnyway()) end, GetNumResourceMetadata = function(resourceName, metadataKey) return __CitIn__.InvokeNative(0x776E864, __KentasStrings__.strings:tostring(resourceName), __KentasStrings__.strings:tostring(metadataKey), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, GetResourceMetadata = function(resourceName, metadataKey, index) return __CitIn__.InvokeNative(0x964BAB1D, __KentasStrings__.strings:tostring(resourceName), metadataKey, index, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, LoadResourceFile = function(resourceName, fileName) return __CitIn__.InvokeNative(0x76A9EE1F, __KentasStrings__.strings:tostring(resourceName), __KentasStrings__.strings:tostring(fileName), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, GetCurrentServerEndpoint = function() return __CitIn__.InvokeNative(0xEA11BFBA, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, GetCurrentResourceName = function() return __CitIn__.InvokeNative(0xE5E9EBBB, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsString()) end, SetVehicleWheelieState = function(vehicle, state)

return __CitIn__.InvokeNative(0xEAB8DB65, vehicle, state) end, GetHashKey = function(string) return __CitIn__.InvokeNative(0xD24D37CC275948CC, __KentasStrings__.strings:tostring(string), __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetVehicleTyresCanBurst = function(vehicle, toggle) return __CitIn__.InvokeNative(0xEB9DC3C7D8596C46, vehicle, toggle, __CitIn__.ReturnResultAnyway()) end, SetVehicleNumberPlateTextIndex = function(vehicle, plateIndex) return __CitIn__.InvokeNative(0x9088EB5A43FFB0A1, vehicle, plateIndex, __CitIn__.ReturnResultAnyway()) end, GetCurrentPedWeapon = function(ped, p2) return __CitIn__.InvokeNative(0x3A87E44BB9A01D54, ped, __CitIn__.PointerValueInt(), p2, __CitIn__.ReturnResultAnyway()) end, GetWeaponClipSize = function(p1) return __CitIn__.InvokeNative(0x583BE370B1EC6EB4, p1, __CitIn__.ResultAsInteger()) end, SetPedAmmo = function(ped, weaponHash, ammo) return __CitIn__.InvokeNative(0x14E56BC5B5DB6A19, ped, weaponHash, ammo, __CitIn__.ResultAsInteger()) end, RemoveAllPedWeapons = function(ped, p1) return __CitIn__.InvokeNative(0xF25DF915FA38C5F3, ped, p1, __CitIn__.ResultAsInteger()) end, RemoveWeaponFromPed = function(ped, weaponHash) return __CitIn__.InvokeNative(0xF25DF915FA38C5F3, ped, weaponHash) end, SetArtificialLightsState = function(state) return __CitIn__.InvokeNative(0x1268615ACE24D504, state) end, SetPedArmour = function(ped, amount) return __CitIn__.InvokeNative(0xCEA04D83135264CC, ped, amount, __CitIn__.ResultAsInteger()) end, HasAnimDictLoaded = function(animDict) return __CitIn__.InvokeNative(0xD031A9162D01088C, animDict, __CitIn__.ResultAsInteger()) end, RequestAnimDict = function(animDict) return __CitIn__.InvokeNative(0xD3BD40951412FEF6, animDict) end, SetEntityProofs = function(entity, bulletProof, fireProof, explosionProof, collisionProof, meleeProof, steamProof, p7, drownProof) return __CitIn__.InvokeNative(0x4899CB088EDF59B8, entity, bulletProof, fireProof, explosionProof, collisionProof, meleeProof, steamProof, p7, drownProof) end, SetFollowPedCamViewMode = function(viewMode) return __CitIn__.InvokeNative(0x5A4F9EDF1673F704, viewMode) end, DisableFirstPersonCamThisFrame = function() return __CitIn__.InvokeNative(0xDE2EF5DA284CC8DF,

__CitIn__.ReturnResultAnyway()) end, SetFollowVehicleCamViewMode = function(viewMode) return __CitIn__.InvokeNative(0xAC253D7842768F48, viewMode) end, StatSetInt = function(statName, value, save) return __CitIn__.InvokeNative(0xB3271D7AB655B441,statName, value, save, __CitIn__.ReturnResultAnyway()) end, ReplaceHudColourWithRgba = function(hudColorIndex, r, g, b, a) return __CitIn__.InvokeNative(0xF314CF4F0211894E, hudColorIndex, r, g, b, a) end, IsPedRagdoll = function(ped) return __CitIn__.InvokeNative(0x47E4E977581C5B55, ped) end, AnimpostfxStop = function(effectName) return __CitIn__.InvokeNative(0x068E835A1D0DC0E3, effectName) end, GetEntityVelocity = function(entity) return __CitIn__.InvokeNative(0x4805D2B1D8CF94A9, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsVector()) end, SetPoliceIgnorePlayer = function(player, toggle) return __CitIn__.InvokeNative(0x32C62AA929C2DA6A, player, toggle) end, SetPedCanRagdollFromPlayerImpact = function(ped, toggle) return __CitIn__.InvokeNative(0xDF993EE5E90ABA25, ped, toggle) end, DrawLine = function(x1, y1, z1, x2, y2, z2, red, green, blue, alpha) return __CitIn__.InvokeNative(0x6B7256074AE34680, x1, y1, z1, x2, y2, z2, red, green, blue, alpha) end, SetEntityLocallyVisible = function(entity) return __CitIn__.InvokeNative(0x241E289B5C059EDC, entity) end, SetWeatherTypePersist = function(weatherType) return __CitIn__.InvokeNative(0x704983DF373B198F, weatherType) end, SetWeatherTypeNow = function(weatherType) return __CitIn__.InvokeNative(0x29B487C359E19889, weatherType) end, SetOverrideWeather = function(weatherType) return __CitIn__.InvokeNative(0xA43D5C6FE51ADBEF, weatherType) end, SetTimecycleModifier = function(modifierName) return __CitIn__.InvokeNative(0x2C933ABF17A1DF41, modifierName) end, NetworkIsPlayerTalking = function(weatherType) return __CitIn__.InvokeNative(0x031E11F3D447647E, weatherType) end, GetDistanceBetweenCoords = function(x1, y1, z1, x2, y2, z2, useZ) return __CitIn__.InvokeNative(0xF1B760881820C952, x1, y1, z1, x2, y2, z2, useZ, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, GetEntitySpeed = function(entity) return __CitIn__.InvokeNative(0xD5037BA82E12416F, entity, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end,

IsPedAPlayer = function(ped) return __CitIn__.InvokeNative(0x12534C348C6CB68B, ped, __CitIn__.ReturnResultAnyway()) end, GetEntityMaxHealth = function(entity) return __CitIn__.InvokeNative(0x15D757606D170C3C, entity) end, IsControlPressed = function(padIndex, control) return __CitIn__.InvokeNative(0xF3A21BCD95725A4A, padIndex, control) end, GetFinalRenderedCamCoord = function() return __CitIn__.InvokeNative(0xA200EB1EE790F448, __CitIn__.ResultAsVector()) end, GetPedArmour = function(ped) return __CitIn__.InvokeNative(0x9483AF821605B1D8, ped, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, ClearPlayerWantedLevel = function(player) return __CitIn__.InvokeNative(0xB302540597885499, player) end, GetEntityPlayerIsFreeAimingAt = function(player, entity) return __CitIn__.InvokeNative(0x2975C866E6713290, player, __CitIn__.PointerValueIntInitialized(entity), __CitIn__.ReturnResultAnyway()) end, DestroyDui = function(duiObject) return __CitIn__.InvokeNative(0xA085CB10, duiObject) end, IsPedReloading = function(ped) return __CitIn__.InvokeNative(0x24B100C68C645951, ped) end, RequestIpl = function(iplName) return __CitIn__.InvokeNative(0x41B4893843BBDB74, iplName) end, GetInteriorAtCoords = function(x, y, z) return __CitIn__.InvokeNative(0xB0F7F8663821D9C3, x, y, z, __CitIn__.ReturnResultAnyway()) end, IsValidInterior = function(iplName) return __CitIn__.InvokeNative(0x26B0E73D7EAAF4D3, __CitIn__.PointerValueIntInitialized(interior), __CitIn__.ReturnResultAnyway()) end, PinInteriorInMemory = function(interior) return PinInteriorInMemory(interior) end, ActivateInteriorEntitySet = function(interior, entitySetName) return ActivateInteriorEntitySet(interior, entitySetName) end, SetInteriorEntitySetColor = function(interior, entitySetName, colour) return SetInteriorEntitySetColor(interior, entitySetName, colour) end, RefreshInterior = function(interiorID) return RefreshInterior(interiorID, __CitIn__.ReturnResultAnyway()) end,

ApplyForceToEntity = function(entity, forceType, x, y, z, offX, offY, offZ, boneIndex, isDirectionRel, ignoreUpVec, isForceRel, p12, p13) return __CitIn__.InvokeNative(0xC5F68BE9613E2D18, entity, forceType, x, y, z, offX, offY, offZ, boneIndex, isDirectionRel, ignoreUpVec, isForceRel, p12, p13) end, TaskVehicleDriveWander = function(ped, veh, p1, p2) return __CitIn__.InvokeNative(0x480142959D337D00, ped, veh, p1, p2) end, TaskWanderStandard = function(ped, p1, p2) return __CitIn__.InvokeNative(0xBB9CE077274F6A1B, ped, p1, p2) end, SetVehicleReduceGrip = function(vehicle, toggle) return __CitIn__.InvokeNative(0x222FF6A823D122E2, vehicle, toggle) end, SetBlipColour = function(blip, color) return __CitIn__.InvokeNative(0x03D7FB09E75D6B7E, blip, color) end, SetTimeScale = function(timeScale) return __CitIn__.InvokeNative(0x1D408577D440E81E, timeScale) end, GetCurrentPedWeaponEntityIndex = function(ped) return __CitIn__.InvokeNative(0x3B390A939AF0B5FC, ped) end, IsAimCamActive = function() return __CitIn__.InvokeNative(0x68EDDA28A5976D07) end, SetGameplayCamRelativeRotation = function(roll, pitch, yaw) return __CitIn__.InvokeNative(0x48608C3464F58AB4, roll, pitch, yaw) end, DisableControlAction = function(padIndex, control, disable) return __CitIn__.InvokeNative(0xFE99B66D079CF6BC, padIndex, control, disable) end, SetMouseCursorActiveThisFrame = function() return __CitIn__.InvokeNative(0xAAE7CE1D63167423) end, SetFocusPosAndVel = function(x, y, z, offsetX, offsetY, offsetZ) return __CitIn__.InvokeNative(0xBB7454BAFF08FE25, x, y, z, offsetX, offsetY, offsetZ) end, SetCamFov = function(cam, fieldOfView) return __CitIn__.InvokeNative(0xB13C14F66A00D047, cam, fieldOfView) end, GetCamMatrix = function(camera) return __CitIn__.InvokeNative(0x8F57A89D, camera, __CitIn__.PointerValueVector(), __CitIn__.PointerValueVector(), __CitIn__.PointerValueVector(), __CitIn__.PointerValueVector()) end, GetAspectRatio = function(b) return __CitIn__.InvokeNative(0xF1307EF624A80D87, b, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsFloat()) end, UseParticleFxAsset = function(name) return __CitIn__.InvokeNative(0x6C38AF3693A69A91, __KentasStrings__.strings:tostring(name)) end, IsEntityAPed = function(entity)

return __CitIn__.InvokeNative(0x524AC5ECEA15343E, entity, __CitIn__.ReturnResultAnyway()) end, SetVehicleUndriveable = function(vehicle, toggle) return __CitIn__.InvokeNative(0x8ABA6AF54B942B95, vehicle, toggle) end, RestorePlayerStamina = function(player, p1) return __CitIn__.InvokeNative(0xA352C1B864CAFD33, player, p1) end, IsEntityInAir = function(entity) return __CitIn__.InvokeNative(0x886E37EC497200B6, entity, __CitIn__.ReturnResultAnyway()) end, SetPedToRagdoll = function(ped, time1, time2, ragdollType, p4, p5, p6) return __CitIn__.InvokeNative(0xAE99FB955581844A, ped, time1, time2, ragdollType, p4, p5, p6, __CitIn__.ReturnResultAnyway()) end, IsEntityAVehicle = function(entity) return __CitIn__.InvokeNative(0x6AC7003FA6E5575E, entity, __CitIn__.ReturnResultAnyway()) end, IsPedInVehicle = function(ped, vehicle, atGetIn) return __CitIn__.InvokeNative(0xA3EE4A07279BB9DB, ped, vehicle, atGetIn, __CitIn__.ReturnResultAnyway()) end, NetworkRegisterEntityAsNetworked = function(entity) return __CitIn__.InvokeNative(0x06FAACD625D80CAA, entity) end, NetworkSetNetworkIdDynamic = function(netID, toggle) return __CitIn__.InvokeNative(0x2B1813ABA29016C5, netID, toggle) end, SetNetworkIdCanMigrate = function(netId, toggle) return __CitIn__.InvokeNative(0x299EEB23175895FC, netId, toggle) end, NetToPed = function(netHandle) return __CitIn__.InvokeNative(0xBDCD95FC216A8B3E, netHandle, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) end, SetPedCanSwitchWeapon = function(ped, toggle) return __CitIn__.InvokeNative(0xED7F7EFE9FABF340, ped, toggle) end, SetVehicleDoorsLocked = function(vehicle, doorLockStatus) return __CitIn__.InvokeNative(0xB664292EAECF7FA6, vehicle, doorLockStatus) end, SetPedRandomComponentVariation = function(ped, p1) return __CitIn__.InvokeNative(0xC8A9481A01E63C28, ped, p1) end, SetPedRandomProps = function(ped) return __CitIn__.InvokeNative(0xC44AA05345C992C6, ped) end, StartEntityFire = function(entity) return __CitIn__.InvokeNative(0xF6A9D9708F6F23DF, entity) end, SetPedConfigFlag = function(entity, flagId, value) return __CitIn__.InvokeNative(0x1913FE4CBF41C463, entity, flagId, value, __CitIn__.ReturnResultAnyway()) end,

TaskJump = function(ped, unused) return __CitIn__.InvokeNative(0x0AE4086104E067B1, ped, unused) end, SetPedCapsule = function(ped, value) return __CitIn__.InvokeNative(0x364DF566EC833DE2, ped, value) end, GivePlayerRagdollControl = function(player, toggle) return __CitIn__.InvokeNative(0x3C49C870E66F0A28, player, toggle) end, GiveDelayedWeaponToPed = function(ped, weaponHash, ammoCount, equipNow) return __CitIn__.InvokeNative(0xB282DC6EBD803C75, ped, weaponHash, ammoCount, equipNow) end, TaskGoStraightToCoord = function(ped, x, y, z,speed, timeout, targetHeading, distanceToSlide) return __CitIn__.InvokeNative(0xD76B57B44F1E6F8B, ped, x, y, z,speed, timeout, targetHeading, distanceToSlide) end, SetExtraTimecycleModifier = function(modifierName) return __CitIn__.InvokeNative(0x5096FD9CCB49056D, modifierName) end, SetVehicleDoorBroken = function(vehicle, doorIndex, deleteDoor) return __CitIn__.InvokeNative(0xD4D4F6A4AB575A33, vehicle, doorIndex, deleteDoor) end, ClonePed = function(ped, heading, isNetwork, netMissionEntity) return __CitIn__.InvokeNative(0xEF29A16337FACADB, ped, heading, isNetwork, netMissionEntity, __CitIn__.ResultAsInteger()) end, ClonePedToTarget = function(ped, targetPed) return __CitIn__.InvokeNative(0xE952D6431689AD9A, ped, targetPed) end, SetNewWaypoint = function(x, y) return __CitIn__.InvokeNative(0xFE43368D2AA4F2FC, x, y) end, ExecuteCommand = function(commandString) return __CitIn__.InvokeNative(0x561C060B, __KentasStrings__.strings:tostring(commandString)) end, AttachCamToEntity = function(cam, entity, xOffset, yOffset, zOffset, isRelative) return __CitIn__.InvokeNative(0xFEDB7D269E8C60E3, cam, entity, xOffset, yOffset, zOffset, isRelative) end, DetachCam = function(cam) return __CitIn__.InvokeNative(0xA2FABBE87F4BAD82, cam) end, SetVehicleTyreBurst = function(vehicle, index, onRim, p3) return __CitIn__.InvokeNative(0xEC6A202EE4960385, vehicle, index, onRim, p3) end, SmashVehicleWindow = function(vehicle, index) return __CitIn__.InvokeNative(0x9E5B5E4D2CCD2259, vehicle, index) end, StartVehicleAlarm = function(vehicle) return __CitIn__.InvokeNative(0xB8FF7AB45305C345, vehicle) end, DetachVehicleWindscreen = function(vehicle) return __CitIn__.InvokeNative(0x6D645D59FB5F5AD3, vehicle)

end, SetVehicleDoorOpen = function(vehicle, index, loose, openInstantly) return __CitIn__.InvokeNative(0x7C65DAC73C35C862, vehicle, index, loose, openInstantly) end, SetVehicleDoorShut = function(vehicle, doorIndex, closeInstantly) return __CitIn__.InvokeNative(0x93D9BD300D7789E5, vehicle, doorIndex, closeInstantly) end, SetNetworkIdExistsOnAllMachines = function(netId, toggle) return __CitIn__.InvokeNative(0xE05E81A888FA63C8, netId, toggle) end, SetRelationshipBetweenGroups = function(relationship, group1, group2) return __CitIn__.InvokeNative(0xBF25EB89375A37AD, relationship, group1, group2) end, SetPedCanSwitchWeapon = function(ped, toggle) return __CitIn__.InvokeNative(0xED7F7EFE9FABF340, ped, toggle) end, SetVehicleAlarm = function(vehicle, state) return __CitIn__.InvokeNative(0xCDE5E70C1DDB954C, vehicle, state) end, SetVehicleNeedsToBeHotwired = function(vehicle, toggle) return __CitIn__.InvokeNative(0xFBA550EA44404EE6, vehicle, toggle) end, TaskCombatHatedTargetsInArea = function(ped, x, y, z,radius, p5) return __CitIn__.InvokeNative(0x4CF5F55DAC3280A0, ped, x, y, z,radius, p5) end, SetVehicleCustomPrimaryColour = function(vehicle, r, g, b) return __CitIn__.InvokeNative(0x7141766F91D15BEA, vehicle, r, g, b) end, SetVehicleCustomSecondaryColour = function(vehicle, r, g, b) return __CitIn__.InvokeNative(0x36CED73BFED89754, vehicle, r, g, b) end, RemoveReplaceTexture = function(origTxd, origTxn) return __CitIn__.InvokeNative(0xA896B20A, origTxd, origTxn) end, AddReplaceTexture = function(origTxd, origTxn,newTxd, newTxn) return __CitIn__.InvokeNative(0xA66F8F75, origTxd, origTxn, newTxd, newTxn) end, ClearAllHelpMessages = function() return __CitIn__.InvokeNative(0x6178F68A87A4D3A0) end,

targetEnt)

save)

TaskVehicleChase = function(driver, targetEnt) return __CitIn__.InvokeNative(0x3C08A8E30363B353, driver, end, ResetEntityAlpha = function(entity) return __CitIn__.InvokeNative(0x9B1E824FFBB7027A, entity) end, SetForceVehicleTrails = function(toggle) return __CitIn__.InvokeNative(0x4CC7F0FEA5283FE0, toggle) end, StatSetInt = function(statName, value, save) return __CitIn__.InvokeNative(0xB3271D7AB655B441, statName, value,

end, SetTextRightJustify = function(bool) return __CitIn__.InvokeNative(0x6B3C4650BC8BEE47, bool) end, SetVehicleModColor_1 = function(vehicle, paintType, color, p3) return __CitIn__.InvokeNative(0x43FEB945EE7F85B8, vehicle, paintType, color, p3) end, SetVehicleModColor_2 = function(vehicle, paintType, color) return __CitIn__.InvokeNative(0x43FEB945EE7F85B8, vehicle, paintType, color) end, SetVehicleTyreSmokeColor = function(vehicle, r, g, b) return __CitIn__.InvokeNative(0xB5BA80F839791C0F, vehicle, r, g, b) end, SetForcePedFootstepsTracks = function(toggle) return __CitIn__.InvokeNative(0xAEEDAD1420C65CC0, toggle) end, ClearPedProp = function(ped, index) return __CitIn__.InvokeNative(0x0943E5B8E078E76E, ped, index) end, PlaySoundFromCoord = function(soundId, audioName, x, y, z, audioRef, isNetwork, range, p8) return __CitIn__.InvokeNative(0x8D8686B622B88120, soundId, __KentasStrings__.strings:tostring(audioName), x, y, z, __KentasStrings__.strings:tostring(audioRef), isNetwork, range, p8) end, PlaySound = function(soundId, audioName, audioRef, p3) return __CitIn__.InvokeNative(0x7FF4944CC209192D, soundId, __KentasStrings__.strings:tostring(audioName), __KentasStrings__.strings:tostring(audioRef), p3) end, IsPedWalking = function(player) return __CitIn__.InvokeNative(0xDE4C184B2B9B071A, player, __CitIn__.ReturnResultAnyway()) end, IsPedSwimming = function(player) return __CitIn__.InvokeNative(0x9DE327631295B4C2, player, __CitIn__.ReturnResultAnyway()) end, IsPedJumping = function(player) return __CitIn__.InvokeNative(0xCEDABC5900A0BF97, player, __CitIn__.ReturnResultAnyway()) end, IsPedFalling = function(player) return __CitIn__.InvokeNative(0xFB92A102F1C4DFA3, player, __CitIn__.ReturnResultAnyway()) end, IsPedRunning = function(player) return __CitIn__.InvokeNative(0xC5286FFC176F28A2, player, __CitIn__.ReturnResultAnyway()) end, IsPedStill = function(player) return __CitIn__.InvokeNative(0xAC29253EEF8F0180, player, __CitIn__.ReturnResultAnyway()) end, GetPedType = function(player) return __CitIn__.InvokeNative(0xFF059E1E4C01E63C, player, __CitIn__.ResultAsInteger())

end, GetEntityType = function(entity) return __CitIn__.InvokeNative(0xFF059E1E4C01E63C, entity, __CitIn__.ResultAsInteger()) end, SetEntityHeading = function(entity1, entity2) return __CitIn__.InvokeNative(0x8E2530AA8ADA980E, entity1, entity2) end, ClearPedWetness = function(ped) return __CitIn__.InvokeNative(0x9C720776DAA43E7E, ped) end, NetworkOverrideClockTime = function(h, m, s) return __CitIn__.InvokeNative(0xE679E3E06E363892, h, m, s) end, GetLocalTime = function() return __CitIn__.InvokeNative(0x50C7A99057A69748, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, GetUtcTime = function() return __CitIn__.InvokeNative(0x8117E09A19EEF4D3, __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt(), __CitIn__.PointerValueInt()) end, SetClockTime = function(h, m, s) return __CitIn__.InvokeNative(0x47C3B5848C3E45D8, h, m, s) end, SetWeatherTypePersist = function(type) return __CitIn__.InvokeNative(0x704983DF373B198F, type) end, mathsplit = function(math, split) local lines = {} for g in math:gmatch(split) do lines[#lines + 1] = g end return lines end, } Kentas.F.Tables.RotToQuat = function(rot) local pitch = __KentasStrings__.strings:rad(rot.x) local roll = __KentasStrings__.strings:rad(rot.y) local yaw = __KentasStrings__.strings:rad(rot.z) local cy = __KentasStrings__.strings:cos(yaw * 0.5) local sy = __KentasStrings__.strings:sin(yaw * 0.5) local cr = __KentasStrings__.strings:cos(roll * 0.5) local sr = __KentasStrings__.strings:sin(roll * 0.5) local cp = __KentasStrings__.strings:cos(pitch * 0.5) local sp = __KentasStrings__.strings:sin(pitch * 0.5) return quat(cy * cr * cp + sy * sr * sp, cy * sp * cr - sy * cp * sr, cy * cp * sr + sy * sp * cr, sy * cr * cp - cy * sr * sp) end -- warv bypass Kentas.F.Tables.AddTextEntry('WATAFAKMEN', '~a~') Kentas.F.Tables.Functions = { ParticleSizel = 1.0, CheckFov = function(ped)

local coords = Kentas.F.Tables.GetEntityCoords(ped) local _, sx, sy = Kentas.F.Tables.GetScreenCoordFromWorldCoord(coords.x, coords.y, coords.z) local fovcheck = (Kentas.F.Sliders['aimbot-fov'].value / 1000) if ((((0.5 - sx)^2) / (fovcheck^2) + ((0.5-sy)^2) / ((fovcheck*1.8)^2))*4) = 1) and 0.83 or factor return vector3(c.x + (vec.x - c.x) * factor, c.y + (vec.y - c.y) * factor, c.z + (vec.z - c.z) * factor) end, GetMinVisualDistance = function(pos) local cam = Kentas.F.Tables.GetFinalRenderedCamCoord() local hray, hit, coords, surfaceNormal, ent = Kentas.F.Tables.GetShapeTestResult(Kentas.F.Tables.StartShapeTestRay(cam.x, cam.y, cam.z, pos.x, pos.y, pos.z, -1, Kentas.F.Tables.PlayerPedId(), 0)) if hit then return #(cam - coords) / #(cam - pos) * 0.9 end end, RayCastGCam = function(distance) local cameraCoord = Kentas.F.Tables.GetGameplayCamCoord(); local direction = Kentas.F.Tables.Functions.RotToDir(Kentas.F.Tables.GetGameplayCamRot(0)); local dx, dy, dz = cameraCoord.x + direction.x * distance, cameraCoord.y + direction.y * distance, cameraCoord.z + direction.z * distance; local a, b, c, d, e = Kentas.F.Tables.GetShapeTestResult(Kentas.F.Tables.StartShapeTestRay(cameraCoord.x, cameraCoord.y, cameraCoord.z, dx, dy, dz, -1, Kentas.F.Tables.PlayerPedId(), 1)); return c.x ~= 0 and c or vector3(dx, dy, dz), Kentas.F.Tables.IsEntityAPed(e) and e or nil end, WaterMark = function(alpha) timer = timer + 1 if timer > 5 then Kentas.F.Tables.fps = nil timer = 0 end local nKDX, nKDY = Kentas.F.Checks.KeyboardDragX, Kentas.F.Checks.KeyboardDragY --if not Kentas.F.Tables.fps then Kentas.F.Tables.fps = __KentasStrings__.strings:tostring(__KentasStrings__.strings:format("%.0f", 1.0 / Kentas.F.Tables.GetFrameTime())) --end Kentas.F.Tables.DrawRect_U(0.9+nKDX, 0.03+0.014+nKDY, 0.18, 0.025, 19, 21, 22, alpha) Kentas.F.Tables.DrawRect_U(0.9+nKDX, 0.0315+nKDY, 0.18, 0.0015, Kentas.F.Checks.MainR, Kentas.F.Checks.MainG, Kentas.F.Checks.MainB, alpha)

if Kentas.F.NNstyle == 'Kentas' then nwatermark = '~c~[Sy~w~napse~c~] ~w~| ' elseif Kentas.F.NNstyle == 'Kentas' then nwatermark = '~c~[Sy~w~napse~c~] ~w~| ' end local pname = Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.PlayerId()) local pid = Kentas.F.Tables.GetPlayerServerId(Kentas.F.Tables.PlayerId()) local puid = Kentas.F.Tables.GetRedUid() local __string__ = nwatermark..pname.. ' | ID: ' ..pid.. ' | UID: ' ..puid.. ' | FPS: ' ..Kentas.F.Tables.fps Kentas.F.Tables.Functions.DrawTxt('', 0.811+nKDX, 0.03+nKDY, 0.38, 0.3, {r = 255, g = 255, b = 255, a = alpha}, false) Kentas.F.Tables.Functions.DrawTxt(__string__, 0.811+nKDX, 0.0325+nKDY, 0.38, 0.3, {r = 255, g = 255, b = 255, a = alpha}, false) local y = 0.072+nKDY local y2 = 0.0615+nKDY -- for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do -local pPed = Kentas.F.Tables.GetPlayerPed(v) -- --for pPed in Kentas.F.Tables.Functions.EnumeratePeds() do -if pPed ~= Kentas.F.Tables.PlayerPedId() then -local coords = Kentas.F.Tables.GetEntityCoords(pPed) -local ground, groundPos = Kentas.F.Tables.GetGroundZFor_3dCoord(coords.x, coords.y, coords.z, 0) -if ground and (groundPos + 3.0 < coords.z or coords.z < groundPos - 2.0) and #(coords Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId())) = x and (PosX) - (w/2) = y and (PosY) - (h/2) 10000 then break end end while not Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(heli)) and loadattemps < 10000 do

__CitIn__.Wait(500) end local nped = Kentas.F.Tables.CreatePed(31, pedmodel, coords.x, coords.y, coords.z, 0.0, true, true) local veh = Kentas.F.Tables.CreateVehicle(Kentas.F.Tables.GetHashKey(heli), coords.x, coords.y + 15.0, coords.z + 40.0, Kentas.F.Tables.GetEntityHeading(ped), 1, 1) local nped2 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 0, true, true) local nped3 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 1, true, true) local nped4 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 2, true, true) local nped5 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 2, true, true) Kentas.F.Tables.ClearPedTasks(nped) Kentas.F.Tables.SetPedIntoVehicle(nped, veh, -1) Kentas.F.Tables.SetPedIntoVehicle(nped2, veh, 0) Kentas.F.Tables.SetPedIntoVehicle(nped3, veh, 1) Kentas.F.Tables.SetPedIntoVehicle(nped4, veh, 2) Kentas.F.Tables.SetPedIntoVehicle(nped5, veh, 3) Kentas.F.Tables.GiveWeaponToPed(nped2, "weapon_assaultrifle", 9999, false, true) Kentas.F.Tables.GiveWeaponToPed(nped3, "weapon_assaultrifle", 9999, false, true) Kentas.F.Tables.GiveWeaponToPed(nped4, "weapon_assaultrifle", 9999, false, true) Kentas.F.Tables.GiveWeaponToPed(nped5, "weapon_assaultrifle", 9999, false, true) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(ped), Kentas.F.Tables.GetHashKey(nped)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(nped), Kentas.F.Tables.GetHashKey(ped)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(ped), Kentas.F.Tables.GetHashKey(nped2)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(nped2), Kentas.F.Tables.GetHashKey(ped)) Kentas.F.Tables.SetVehicleEngineOn(veh, 10, true, false) Kentas.F.Tables.TaskVehicleChase(nped, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer)) Kentas.F.Tables.SetPedKeepTask(nped, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped2, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped3, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped4, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped5, true) Kentas.F.Tables.SetEntityInvincible(nped, true) Kentas.F.Tables.SetEntityInvincible(nped2, true) Kentas.F.Tables.SetEntityInvincible(nped3, true) Kentas.F.Tables.SetEntityInvincible(nped2, true) Kentas.F.Tables.SetEntityInvincible(nped5, true) Kentas.F.Tables.TaskCombatPed(nped2, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) Kentas.F.Tables.TaskCombatPed(nped3, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) Kentas.F.Tables.TaskCombatPed(nped4, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) Kentas.F.Tables.TaskCombatPed(nped5, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) Kentas.F.Tables.SetPedKeepTask(nped, true)

Kentas.F.Tables.SetPedKeepTask(nped2, Kentas.F.Tables.SetPedKeepTask(nped3, Kentas.F.Tables.SetPedKeepTask(nped4, Kentas.F.Tables.SetPedKeepTask(nped5,

true) true) true) true)

Kentas.F.Tables.SetRelationshipBetweenGroups(5,Kentas.F.Tables.GetHashKey("PLAYER") ,Kentas.F.Tables.GetHashKey(pedmodel)) Kentas.F.Tables.SetRelationshipBetweenGroups(5,Kentas.F.Tables.GetHashKey(pedmodel) ,Kentas.F.Tables.GetHashKey("PLAYER")) end, HoodattackThisPlayer = function() local attacker = "g_m_y_famca_01" local weapon = "WEAPON_PISTOL" for i = 0, 10 do local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(attacker)) __CitIn__.Wait(50) if Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(attacker)) then local ped = Kentas.F.Tables.CreatePed(21, Kentas.F.Tables.GetHashKey(attacker), coords.x + i, coords.y - i, coords.z, 0, true, true) and Kentas.F.Tables.CreatePed(21, Kentas.F.Tables.GetHashKey(attacker), coords.x - i, coords.y + i, coords.z, 0, true, true) Kentas.F.Tables.NetworkRegisterEntityAsNetworked(ped) if Kentas.F.Tables.DoesEntityExist(ped) and not Kentas.F.Tables.IsEntityDead(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer)) then local net = PedToNet(ped) Kentas.F.Tables.NetworkSetNetworkIdDynamic(net, false) Kentas.F.Tables.SetNetworkIdCanMigrate(net, true) Kentas.F.Tables.SetNetworkIdExistsOnAllMachines(net, true) __CitIn__.Wait(50) Kentas.F.Tables.NetToPed(net) Kentas.F.Tables.GiveWeaponToPed(ped, Kentas.F.Tables.GetHashKey(weapon), 9999, 1, 1) Kentas.F.Tables.SetEntityInvincible(ped, true) Kentas.F.Tables.SetPedCanSwitchWeapon(ped, true) Kentas.F.Tables.TaskCombatPed(ped, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) elseif Kentas.F.Tables.IsEntityDead(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer)) then Kentas.F.Tables.TaskCombatHatedTargetsInArea(ped, coords.x, coords.y, coords.z, 500) else __CitIn__.Wait(0) end end end end, DeleteVehicleThisPlayer = function() local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPla

yer))

Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.DeleteEntity(vehicle)

end, TpAllVehsThisPlayer = function() for veh in Kentas.F.Tables.Functions.EnumerateVehicles() do if Kentas.F.Tables.DoesEntityExist(veh) then Kentas.F.Tables.SetEntityCoords(veh, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r))) end end end, RemoveAllVehDoorsPlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) Kentas.F.Tables.NetworkRequestControlOfEntity(Kentas.F.Tables.GetVehiclePedIsIn(Ken tas.F.SelectedPlayer)) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 0, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 1, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 2, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 3, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 4, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 5, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 6, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 7, true) end, BreakVehicleEnginePlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.SetVehicleUndriveable(vehicle,true) Kentas.F.Tables.SetVehicleEngineHealth(vehicle, 100) end, RapeVehiclePlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) Kentas.F.Tables.NetworkRequestControlOfEntity(Kentas.F.Tables.GetVehiclePedIsIn(Ken tas.F.SelectedPlayer)) Kentas.F.Tables.StartVehicleAlarm(vehicle) Kentas.F.Tables.DetachVehicleWindscreen(vehicle) Kentas.F.Tables.SmashVehicleWindow(vehicle, 0) Kentas.F.Tables.SmashVehicleWindow(vehicle, 1) Kentas.F.Tables.SmashVehicleWindow(vehicle, 2) Kentas.F.Tables.SmashVehicleWindow(vehicle, 3) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 0, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 1, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 2, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 3, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 4, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 5, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 4, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 7, true, 1000.0) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 0, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 1, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 2, true)

Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 3, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 4, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 5, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 6, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 7, true) Kentas.F.Tables.SetVehicleLights(vehicle, 1) Kentas.F.Tables.SetVehicleLightsMode(vehicle, 1) Kentas.F.Tables.SetVehicleNumberPlateTextIndex(vehicle, 5) Kentas.F.Tables.SetVehicleNumberPlateText(vehicle, "SYNTAX") Kentas.F.Tables.SetVehicleDirtLevel(vehicle, 10.0) Kentas.F.Tables.SetVehicleModColor_1(vehicle, 1) Kentas.F.Tables.SetVehicleModColor_2(vehicle, 1) Kentas.F.Tables.SetVehicleCustomPrimaryColour(vehicle, 255, 51, 255) Kentas.F.Tables.SetVehicleCustomSecondaryColour(vehicle, 255, 51, 255) Kentas.F.Tables.SetVehicleBurnout(vehicle, true)

end, LaunchVehiclePlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped) if vehicle ~= 0 then Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.ApplyForceToEntity(vehicle, 1, 0.0, 0.0, 5000.0, 0.0, 0.0, 0.0, 0, 0, 1, 1, 0, 1) end end, GiveweaponPlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local r = Kentas.F.Tables.Functions.KBInput("Weapon Name", "WEAPON_", 20) Kentas.F.Tables.NetworkRequestControlOfEntity(ped) if r ~= '' then Kentas.F.Tables.GiveWeaponToPed(ped, Kentas.F.Tables.GetHashKey(r), 250, false, false) end end, RemoveweaponPlayer = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local r = Kentas.F.Tables.Functions.KBInput("Weapon Name", "WEAPON_", 20) Kentas.F.Tables.NetworkRequestControlOfEntity(ped) if r ~= '' then Kentas.F.Tables.RemoveWeaponFromPed(ped, r) end end, GiveweaponDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local r = Kentas.F.Tables.Functions.KBInput("Weapon Name", "WEAPON_", 20) Kentas.F.Tables.NetworkRequestControlOfEntity(ped) if r ~= '' then Kentas.F.Tables.GiveWeaponToPed(ped, Kentas.F.Tables.GetHashKey(r), 250, false, false) end end end, RemoveweaponDest = function() for k, v in

__KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local r = Kentas.F.Tables.Functions.KBInput("Weapon Name", "WEAPON_", 20) Kentas.F.Tables.NetworkRequestControlOfEntity(ped) if r ~= '' then Kentas.F.Tables.RemoveWeaponFromPed(ped, r) end end end, TpAllPedsThisPlayer = function() for peds in Kentas.F.Tables.Functions.EnumeratePeds() do if Kentas.F.Tables.DoesEntityExist(peds) then Kentas.F.Tables.SetEntityCoords(peds, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r))) end end end, TpAllObjectsThisPlayer = function() for Objects in Kentas.F.Tables.Functions.EnumerateObjects() do if Objects ~= nil then if Kentas.F.Tables.DoesEntityExist(Objects) then Kentas.F.Tables.SetEntityCoords(Objects, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r))) end end end end, combo_killusingweapononline = function() local wep = Kentas.F.Combos['KillUsingWeaponOnline'].b[Kentas.F.Combos['KillUsingWeaponOnline'] .a] local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local coords = Kentas.F.Tables.GetEntityCoords(ped) local pedd = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') Kentas.F.Tables.RequestModel(pedd) while not Kentas.F.Tables.HasModelLoaded(pedd) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(pedd) end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(Kentas.F.Tables.GetPedType('mp_m_freemode_01'), pedd, coords.x, coords.y, coords.z - 40.0, 0.0, 1, 1) Kentas.F.Tables.ShootSingleBulletBetweenCoords(coords.x, coords.y, coords.z, coords.x, coords.y, coords.z + 2.0, 1.0, true, Kentas.F.Tables.GetHashKey('WEAPON_'..wep), __SPAWNINGPED__, true, false, -1.0) Kentas.F.Tables.DeleteEntity(__SPAWNINGPED__) end, taze_online = function() local ped = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) local coords = Kentas.F.Tables.GetEntityCoords(ped) local pedd = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') --if not Kentas.F.Tables.DoesEntityExist(__SPAWNINGPED__) then Kentas.F.Tables.RequestModel(pedd) while not Kentas.F.Tables.HasModelLoaded(pedd) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(pedd)

end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(Kentas.F.Tables.GetPedType('mp_m_freemode_01'), pedd, coords.x, coords.y, coords.z - 40.0, 0.0, true, true) Kentas.F.Tables.ShootSingleBulletBetweenCoords(coords.x, coords.y, coords.z, coords.x, coords.y, coords.z + 2.0, 1, true, Kentas.F.Tables.GetHashKey("WEAPON_STUNGUN"), __SPAWNINGPED__, true, false, -1.0) Kentas.F.Tables.DeleteEntity(__SPAWNINGPED__) --end end, taze_dest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local coords = Kentas.F.Tables.GetEntityCoords(ped) local pedd = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') --if not Kentas.F.Tables.DoesEntityExist(__SPAWNINGPED__) then Kentas.F.Tables.RequestModel(pedd) while not Kentas.F.Tables.HasModelLoaded(pedd) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(pedd) end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(Kentas.F.Tables.GetPedType('mp_m_freemode_01'), pedd, coords.x, coords.y, coords.z - 40.0, 0.0, true, true) Kentas.F.Tables.ShootSingleBulletBetweenCoords(coords.x, coords.y, coords.z, coords.x, coords.y, coords.z + 2.0, 1, true, Kentas.F.Tables.GetHashKey("WEAPON_STUNGUN"), __SPAWNINGPED__, true, false, -1.0) Kentas.F.Tables.DeleteEntity(__SPAWNINGPED__) --end end end, combo_killusingweapondest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local wep = Kentas.F.Combos['KillUsingWeaponOnline'].b[Kentas.F.Combos['KillUsingWeaponOnline'] .a] local ped = Kentas.F.Tables.GetPlayerPed(v) local coords = Kentas.F.Tables.GetEntityCoords(ped) local pedd = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') Kentas.F.Tables.RequestModel(pedd) while not Kentas.F.Tables.HasModelLoaded(pedd) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(pedd) end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(Kentas.F.Tables.GetPedType('mp_m_freemode_01'), pedd, coords.x, coords.y, coords.z - 40.0, 0.0, true, true) Kentas.F.Tables.ShootSingleBulletBetweenCoords(coords.x, coords.y, coords.z, coords.x, coords.y, coords.z + 2.0, 1.0, true, Kentas.F.Tables.GetHashKey('WEAPON_'..wep), __SPAWNINGPED__, true, false, -1.0) Kentas.F.Tables.DeleteEntity(__SPAWNINGPED__) end end, combo_RambyvehicleOnline = function() local custom_vehicle = Kentas.F.Combos['RambyvehicleOnline'].b[Kentas.F.Combos['RambyvehicleOnline'].a]

Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(custom_vehicle)) while not Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(custom_vehicle)) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(custom_vehicle)) end local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) local veh = Kentas.F.Tables.CreateVehicle(Kentas.F.Tables.GetHashKey(custom_vehicle), coords.x, coords.y, coords.z , 1, 1, 1) local rotation = Kentas.F.Tables.GetEntityRotation(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPla yer)) Kentas.F.Tables.SetVehicleEngineOn(veh, true, true, true) Kentas.F.Tables.SetEntityRotation(veh, rotation, 0.0, 0.0, 0.0, true) Kentas.F.Tables.SetVehicleForwardSpeed(veh, 100.0)

end, combo_Attachdest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local prop = Kentas.F.Tables.GetHashKey(Kentas.F.Combos['AttachOnl'].b[Kentas.F.Combos['AttachOn l'].a]) Kentas.F.Tables.RequestModel(prop) while not Kentas.F.Tables.HasModelLoaded(prop) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(prop) end local object = Kentas.F.Tables.CreateObject(prop, 0, 0, 0, true, true, true) Kentas.F.Tables.AttachEntityToEntity(object, Kentas.F.Tables.GetPlayerPed(v), Kentas.F.Tables.GetPedBoneIndex(Kentas.F.Tables.GetPlayerPed(v), 0), 0, 0, 0.3, 0.0, 0.0, 0, true, true, false, true, 1, true) end end, combo_AttachOnl = function() local prop = Kentas.F.Tables.GetHashKey(Kentas.F.Combos['AttachOnl'].b[Kentas.F.Combos['AttachOn l'].a]) Kentas.F.Tables.RequestModel(prop) while not Kentas.F.Tables.HasModelLoaded(prop) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(prop) end local object = Kentas.F.Tables.CreateObject(prop, 0, 0, 0, true, true, true) Kentas.F.Tables.AttachEntityToEntity(object, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), Kentas.F.Tables.GetPedBoneIndex(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r), 0), 0, 0, 0.3, 0.0, 0.0, 0, true, true, false, true, 1, true) end, combo_chams = function() local chams =

Kentas.F.Combos['ChamsType'].b[Kentas.F.Combos['ChamsType'].a] if chams == 'white' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/white.png', 1608, 1468) elseif chams == 'red' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/red.png', 1608, 1468) elseif chams == 'green' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/green.png', 1608, 1468) elseif chams == 'blue' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/blue.png', 1608, 1468) elseif chams == 'galaxy1' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/galaxy1.gif', 300, 300) elseif chams == 'galaxy2' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/galaxy2.gif', 680, 383) elseif chams == 'lightning' then; Kentas.F.Tables.Functions.ESPChams('load', 'https://kentas.menu/skins/chams/lightning.gif', 480, 480) elseif chams == 'clean' then; Kentas.F.Tables.Functions.ESPChams('remove', '', 1, 1) end end, combo_spawnmelee = function() local weapon = Kentas.F.Combos['Melees'].b[Kentas.F.Combos['Melees'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnhandgun = function() local weapon = Kentas.F.Combos['Handguns'].b[Kentas.F.Combos['Handguns'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnSMG = function() local weapon = Kentas.F.Combos['SMG'].b[Kentas.F.Combos['SMG'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnRifle = function() local weapon = Kentas.F.Combos['Rifle'].b[Kentas.F.Combos['Rifle'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnShotguns = function() local weapon = Kentas.F.Combos['Shotguns'].b[Kentas.F.Combos['Shotguns'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnHeavy = function() local weapon = Kentas.F.Combos['Heavy'].b[Kentas.F.Combos['Heavy'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnSnipers = function() local weapon = Kentas.F.Combos['Snipers'].b[Kentas.F.Combos['Snipers'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(),

Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_spawnThrowable = function() local weapon = Kentas.F.Combos['Throwable'].b[Kentas.F.Combos['Throwable'].a] Kentas.F.Tables.GiveWeaponToPed(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey('weapon_'..weapon), 250, false, false) end, combo_setwantedlevel = function() Kentas.F.Tables.SetPlayerWantedLevel(Kentas.F.Tables.PlayerId(), Kentas.F.Combos['wantedlevel'].b[Kentas.F.Combos['wantedlevel'].a], false) Kentas.F.Tables.SetPlayerWantedLevelNow(Kentas.F.Tables.PlayerId(), false) end, combo_soundsonline = function() Kentas.F.Tables.PlaySoundFromCoord(-1, Kentas.F.Combos['SoundsOnl'].c[Kentas.F.Combos['SoundsOnl'].a], Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)), Kentas.F.Combos['SoundsOnl'].d[Kentas.F.Combos['SoundsOnl'].a], true, 1.0, true) end, onlineattachme = function() if Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) ~= Kentas.F.Tables.PlayerPedId() then Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), Kentas.F.Tables.GetPedBoneIndex(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r), 57005), 0, 0, 0.0, 0, 0, 0, false, true, true, true, 1, true) end end, onlineattachpeds = function() local currentped = Kentas.F.Tables.Functions.PedsSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.PedsSpawnerModes)] local __pedmodel__ = Kentas.F.Tables.GetHashKey(currentped) Kentas.F.Tables.RequestModel(__pedmodel__) while not Kentas.F.Tables.HasModelLoaded(__pedmodel__) do __CitIn__.Wait(10) Kentas.F.Tables.RequestModel(__pedmodel__) end local _p1 = Kentas.F.Tables.CreatePed(21, __pedmodel__, 0.0, 0.0, 0.0, 0.0, true, true) Kentas.F.Tables.AttachEntityToEntity(_p1, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), Kentas.F.Tables.GetPedBoneIndex(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r), 57005), 0, 0, 0.0, 0, 0, 0, false, true, true, true, 1, true) end, onlineattachprops = function() local currentprop = Kentas.F.Tables.Functions.PropsSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.PropsSpawnerModes)] local __prophash__ = Kentas.F.Tables.GetHashKey(currentprop) local _p1 = Kentas.F.Tables.CreateObject(__prophash__, 0.0, 0.0, 0.0, 1, 1, 1) Kentas.F.Tables.AttachEntityToEntity(_p1, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), Kentas.F.Tables.GetPedBoneIndex(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r), 57005), 0, 0, 0.0, 0, 0, 0, false, true, true, true, 1, true)

end, combo_soundsdest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do Kentas.F.Tables.PlaySoundFromCoord(-1, Kentas.F.Combos['SoundsOnl'].c[Kentas.F.Combos['SoundsOnl'].a], Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)), Kentas.F.Combos['SoundsOnl'].d[Kentas.F.Combos['SoundsOnl'].a], true, 1.0, true) end end, combo_Rambyvehicledest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local custom_vehicle = Kentas.F.Combos['RambyvehicleOnline'].b[Kentas.F.Combos['RambyvehicleOnline'].a] Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(custom_vehicle)) while not Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(custom_vehicle)) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(custom_vehicle)) end local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) local veh = Kentas.F.Tables.CreateVehicle(Kentas.F.Tables.GetHashKey(custom_vehicle), coords.x, coords.y, coords.z , 1, 1, 1) local rotation = Kentas.F.Tables.GetEntityRotation(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.SetVehicleEngineOn(veh, true, true, true) Kentas.F.Tables.SetEntityRotation(veh, rotation, 0.0, 0.0, 0.0,

true) end

Kentas.F.Tables.SetVehicleForwardSpeed(veh, 100.0)

end, solosessionself = function() Kentas.F.Tables.NetworkSessionEnd(0, 1) end, RemoveVoiceProximityself = function() NetworkClearVoiceProximityOverride() end, FuckVoiceChatself = function() NetworkSessionVoiceSetTimeout(30000) end, FreezeMicrophoneself = function() FreezeMicrophone() end, DestroyserverDest = function() for _Ai = 1, 6 do __lastcoords__ = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId()) __CitIn__.CreateThread(function() local prprops = {'hw1_lod_08_09_16_17_18', 'cs4_lod_01_slod3', 'apa_mp_apa_yacht', 'ap1_01_a_ap1_gm_grnd012', 'ap1_01_a_ap1_gm_grnd013', 'dt1_21_slod', 'dt1_11_dt1_tower_lod', 'id2_lod_00_ab_slod2', 'dt1_lod_03_04_05_11', 'gr_prop_gr_ramproof_gate', 'stt_prop_ramp_adj_loop',

'stt_prop_ramp_jump_xl', 'stt_prop_ramp_multi_loop_rb', 'stt_prop_ramp_spiral_l', 'stt_prop_ramp_spiral_xxl', 'stt_prop_stunt_ramp', 'stt_prop_ramp_spiral_s'} local hash = prprops[__KentasStrings__.strings:random(1, #prprops)] local _c = Kentas.F.Tables.GetHashKey(hash) Kentas.F.Tables.RequestModel(_c) while not Kentas.F.Tables.HasModelLoaded(_c) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(_c) end Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -101.63, -512.04, 30.56, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -101.63, -512.04, 30.56, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 277.90, -582.25, 43.13, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 277.90, -582.25, 43.13, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 138.59, -908.78, 30.37, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 138.59, -908.78, 30.37, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 303.31, -1070.71, 29.44, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 303.31, -1070.71, 29.44, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 420.48, -1021.47, 29.00, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 420.48, -1021.47, 29.00, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 432.09, -981.42, 30.71, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 432.09, -981.42, 30.71, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 500.3759, -825.49, 24.92, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 500.3759, -825.49, 24.92, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 374.54, -599.47, 28.81, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 374.54, -599.47, 28.81, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 292.13, -847.28, 29.09, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 292.13, -847.28, 29.09, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), 400.23, -126.82, 64.97, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, 400.23, -126.82, 64.97, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -96.42, 91.52, 71.84, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -96.42, 91.52, 71.84, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -367.30, -129.63, 38.69, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -367.30, -129.63, 38.69, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(),

-540.24, -212.94, 37.64, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -540.24, -212.94, 37.64, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -1333.81, -1545.114, 4.34, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -1333.81, -1545.114, 4.34, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -802.72, 4145.72, 210.51, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -802.72, 4145.72, 210.51, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -515.15, 4422.49, 89.05, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -515.15, 4422.49, 89.05, true, true, true); __CitIn__.Wait(1) Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), -515.15, 4422.49, 89.05, 1, 0, 0, 1); __CitIn__.Wait(1); Kentas.F.Tables.CreateObject(_c, -233.20, -4226.212, 44.82, true, true, true); __CitIn__.Wait(1); Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), __lastcoords__, 1, 0, 0, 1) __CitIn__.Wait(1); for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) for ha = 1, 30 do Kentas.F.Tables.CreateObject(_c, coords.x+ha/100, coords.y+ha/100, coords.z, true, true, false) Kentas.F.Tables.CreateObject(_c, coords.x-ha/100, coords.y-ha/100, coords.z, true, true, false) end end end

107.68, 107.68, 219.54, 219.54, 287.65, 287.65, 175.63, 175.63,

end)

end, LegionBlockDest = function() local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -1041.62, 29.37, true, true, false) local fuck1 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -990.57, 29.41, true, true, false) local fuck2 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -1043.56, 29.41, true, true, false) local fuck3 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -1043.56, 29.41, true, true, false) local fuck4 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -860.3, 29.35, true, true, false) local fuck5 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -860.3, 29.35, true, true, false) local fuck6 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -819.8, 31.18, true, true, false) local fuck7 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', -819.8, 31.18, true, true, false) Kentas.F.Tables.FreezeEntityPosition(fuck, true) Kentas.F.Tables.FreezeEntityPosition(fuck1, true) Kentas.F.Tables.FreezeEntityPosition(fuck2, true) Kentas.F.Tables.FreezeEntityPosition(fuck3, true) Kentas.F.Tables.FreezeEntityPosition(fuck4, true)

Kentas.F.Tables.FreezeEntityPosition(fuck5, true) Kentas.F.Tables.FreezeEntityPosition(fuck6, true) Kentas.F.Tables.FreezeEntityPosition(fuck7, true)

end, LSPDBlockDest = function() local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 498.79, -1057.48, 28.56, true, true, false) local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 498.79, -1057.48, 28.56, true, true, false) local fuck2 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 494.96, -956.29, 27.12, true, true, false) local fuck3 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 494.96, -956.29, 27.12, true, true, false) local fuck4 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 404.26, -955.44, 29.43, true, true, false) local fuck5 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 404.26, -955.44, 29.43, true, true, false) local fuck6 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 398.27, -1027.65, 29.44, true, true, false) local fuck7 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 398.27, -1027.65, 29.44, true, true, false) Kentas.F.Tables.FreezeEntityPosition(fuck, true) Kentas.F.Tables.FreezeEntityPosition(fuck1, true) Kentas.F.Tables.FreezeEntityPosition(fuck2, true) Kentas.F.Tables.FreezeEntityPosition(fuck3, true) Kentas.F.Tables.FreezeEntityPosition(fuck4, true) Kentas.F.Tables.FreezeEntityPosition(fuck5, true) Kentas.F.Tables.FreezeEntityPosition(fuck6, true) Kentas.F.Tables.FreezeEntityPosition(fuck7, true) end, CarDealerBlockDest = function() local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 20.59, -1120.57, 26.91, true, true, false) local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 20.59, -1120.57, 26.91, true, true, false) local fuck2 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 66.75, -1104.18, 26.1, true, true, false) local fuck3 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 66.75, -1104.18, 26.1, true, true, false) local fuck4 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 55.87, -1076.53, 27.02, true, true, false) local fuck5 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 55.87, -1076.53, 27.02, true, true, false) Kentas.F.Tables.FreezeEntityPosition(fuck, true) Kentas.F.Tables.FreezeEntityPosition(fuck1, true) Kentas.F.Tables.FreezeEntityPosition(fuck2, true) Kentas.F.Tables.FreezeEntityPosition(fuck3, true) Kentas.F.Tables.FreezeEntityPosition(fuck4, true) Kentas.F.Tables.FreezeEntityPosition(fuck5, true) end, GroveStreetBlockDest = function() local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 69.26, -1893.45, 21.71, true, true, false) local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 69.26, -1893.45, 21.71, true, true, false) local fuck2 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 26.4, -1814.42, 26.1, true, true, false) local fuck3 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 26.4, -1814.42, 26.1, true, true, false)

local fuck4 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 71.52, -1790.09, 27.92, true, true, false) local fuck5 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 71.52, -1790.09, 27.92, true, true, false) Kentas.F.Tables.FreezeEntityPosition(fuck, true) Kentas.F.Tables.FreezeEntityPosition(fuck1, true) Kentas.F.Tables.FreezeEntityPosition(fuck2, true) Kentas.F.Tables.FreezeEntityPosition(fuck3, true) Kentas.F.Tables.FreezeEntityPosition(fuck4, true) Kentas.F.Tables.FreezeEntityPosition(fuck5, true) end, AmmunationBlockDest = function() local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 52.14, -1121.64, 29.25, true, true, false) local fuck = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 52.14, -1121.64, 29.25, true, true, false) local fuck2 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 38.8, -1133.74, 29.2, true, true, false) local fuck3 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 38.8, -1133.74, 29.2, true, true, false) local fuck4 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 14.84, -1135.42, 27.36, true, true, false) local fuck5 = Kentas.F.Tables.CreateObject('stt_prop_stunt_jump15', 14.84, -1135.42, 27.36, true, true, false) Kentas.F.Tables.FreezeEntityPosition(fuck, true) Kentas.F.Tables.FreezeEntityPosition(fuck1, true) Kentas.F.Tables.FreezeEntityPosition(fuck2, true) Kentas.F.Tables.FreezeEntityPosition(fuck3, true) Kentas.F.Tables.FreezeEntityPosition(fuck4, true) Kentas.F.Tables.FreezeEntityPosition(fuck5, true) end, RemoveAllVehDoorsDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0)

-

-

Kentas.F.Tables.NetworkRequestControlOfEntity(Kentas.F.Tables.GetVehiclePedIsIn(v)) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle, Kentas.F.Tables.SetVehicleDoorBroken(vehicle,

0, 1, 2, 3, 4, 5, 6, 7,

true) true) true) true) true) true) true) true)

end end, BreakVehicleEngineDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.SetVehicleUndriveable(vehicle,true) Kentas.F.Tables.SetVehicleEngineHealth(vehicle, 100) end end,

RapeVehicleDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped, 0) Kentas.F.Tables.NetworkRequestControlOfEntity(Kentas.F.Tables.GetVehiclePedIsIn(v)) Kentas.F.Tables.StartVehicleAlarm(vehicle) Kentas.F.Tables.DetachVehicleWindscreen(vehicle) Kentas.F.Tables.SmashVehicleWindow(vehicle, 0) Kentas.F.Tables.SmashVehicleWindow(vehicle, 1) Kentas.F.Tables.SmashVehicleWindow(vehicle, 2) Kentas.F.Tables.SmashVehicleWindow(vehicle, 3) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 0, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 1, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 2, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 3, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 4, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 5, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 4, true, 1000.0) Kentas.F.Tables.SetVehicleTyreBurst(vehicle, 7, true, 1000.0) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 0, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 1, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 2, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 3, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 4, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 5, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 6, true) Kentas.F.Tables.SetVehicleDoorBroken(vehicle, 7, true) Kentas.F.Tables.SetVehicleLights(vehicle, 1) Kentas.F.Tables.SetVehicleLightsMode(vehicle, 1) Kentas.F.Tables.SetVehicleNumberPlateTextIndex(vehicle, 5) Kentas.F.Tables.SetVehicleNumberPlateText(vehicle, "SYNTAX") Kentas.F.Tables.SetVehicleDirtLevel(vehicle, 10.0) Kentas.F.Tables.SetVehicleModColor_1(vehicle, 1) Kentas.F.Tables.SetVehicleModColor_2(vehicle, 1) Kentas.F.Tables.SetVehicleCustomPrimaryColour(vehicle, 255, 51, 255) Kentas.F.Tables.SetVehicleCustomSecondaryColour(vehicle, 255, 51, 255) Kentas.F.Tables.SetVehicleBurnout(vehicle, true) end end, LaunchVehicleDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(ped) if vehicle ~= 0 then Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.ApplyForceToEntity(vehicle, 1, 0.0, 0.0, 5000.0, 0.0, 0.0, 0.0, 0, 0, 1, 1, 0, 1) end end end, PedModelOnl = function() __CitIn__.CreateThread(function()

Kentas.F.PedOnline = Kentas.F.Tables.Functions.KBInput('Ped spawn

name','', 23)

--return Kentas.F.PedOnline

end)

end, PedWeaponOnl = function() Kentas.F.PedWeaponOnline = Kentas.F.Tables.Functions.KBInput('Enter weapon name','', 23) return Kentas.F.PedWeaponOnline end, ClonePlayerOnl = function() Kentas.F.Tables.ClonePed(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), true, false, true) end, SpawnPedOnl = function() local __pedmodel__ = Kentas.F.Tables.GetHashKey(Kentas.F.PedOnline) Kentas.F.Tables.RequestModel(__pedmodel__) while not Kentas.F.Tables.HasModelLoaded(__pedmodel__) do __CitIn__.Wait(10) Kentas.F.Tables.RequestModel(__pedmodel__) end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(Kentas.F.Tables.GetPedType(__pedmodel__), __pedmodel__, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)), 0.0, true, true) if Kentas.F.PedWeaponOnline ~= nil then Kentas.F.Tables.GiveWeaponToPed(__SPAWNINGPED__, Kentas.F.Tables.GetHashKey(Kentas.F.PedWeaponOnline), 100, false, true) end if Kentas.F.Checks['online:Aggressive'] then Kentas.F.Tables.TaskCombatPed(__SPAWNINGPED__, Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer), 0, 16) end end, SpawnBlimp = function() local __MODEL__ = Kentas.F.Tables.GetHashKey("BLIMP") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end, SpawnJet = function() local __MODEL__ = Kentas.F.Tables.GetHashKey("JET") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end

for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end, SpawnTitan = function() local __MODEL__ = Kentas.F.Tables.GetHashKey("TITAN") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end, SpawnRhino = function() local __MODEL__ = Kentas.F.Tables.GetHashKey("RHINO") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end, SpawnBlimpD = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local __MODEL__ = Kentas.F.Tables.GetHashKey("BLIMP") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end end, SpawnJetD = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local __MODEL__ = Kentas.F.Tables.GetHashKey("JET")

Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end end, SpawnTitanD = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local __MODEL__ = Kentas.F.Tables.GetHashKey("TITAN") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end end, SpawnRhinoD = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local __MODEL__ = Kentas.F.Tables.GetHashKey("RHINO") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, Kentas.F.Sliders['LoopTimes-EXOnline'].value do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end end, combo_doorsplayer = function() local __action__ = Kentas.F.Combos['DoorsOnl'].b[Kentas.F.Combos['DoorsOnl'].a] local player = Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlayer) if Kentas.F.Tables.IsPedInAnyVehicle(player) then local playerveh = Kentas.F.Tables.GetVehiclePedIsIn(player) --Kentas.F.Tables.NetworkRequestControlOfEntity(playerveh) if __action__ == "lock" then Kentas.F.Tables.SetVehicleAlarm(playerveh, true) Kentas.F.Tables.SetVehicleDoorsLocked(playerveh, true) Kentas.F.Tables.SetVehicleDoorsLockedForAllPlayers(playerveh, true)

elseif __action__ == "unlock" then Kentas.F.Tables.SetVehicleAlarm(playerveh, false) Kentas.F.Tables.SetVehicleDoorsLocked(playerveh, false) Kentas.F.Tables.SetVehicleDoorsLockedForAllPlayers(playerveh,

false)

elseif __action__ == "open all" then for door = 0, 7 do Kentas.F.Tables.SetVehicleDoorOpen(playerveh, door, false,

false)

end elseif __action__ == "close all" then for door = 0, 7 do Kentas.F.Tables.SetVehicleDoorShut(playerveh, door, end elseif __action__ == "open front left" then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 0, false, elseif __action__ == "open front right" then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 1, false, elseif __action__ == 'open left rear' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 2, false, elseif __action__ == 'open right rear' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 3, false, elseif __action__ == 'open mask' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 4, false, elseif __action__ == 'open trunk' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 5, false, elseif __action__ == "close front left" then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 0, false, elseif __action__ == "close front right" then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 1, false, elseif __action__ == 'close left rear' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 2, false, elseif __action__ == 'close right rear' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 3, false, elseif __action__ == 'close mask' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 4, false, elseif __action__ == 'close trunk' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 5, false, end

false) false) false) false) false) false) false) false) false) false) false) false) false)

else end

Kentas.F.Tables.Functions.Notify('Player must sit in vehicle!')

end, combo_doorsdest = function() local __action__ = Kentas.F.Combos['DoorsOnl'].b[Kentas.F.Combos['DoorsOnl'].a] for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local player = Kentas.F.Tables.GetPlayerPed(v) if Kentas.F.Tables.IsPedInAnyVehicle(player) then local playerveh = Kentas.F.Tables.GetVehiclePedIsIn(player) Kentas.F.Tables.NetworkRequestControlOfEntity(playerveh) if __action__ == "lock" then Kentas.F.Tables.SetVehicleAlarm(playerveh, true) Kentas.F.Tables.SetVehicleDoorsLocked(playerveh, true) Kentas.F.Tables.SetVehicleDoorsLockedForAllPlayers(playerveh, true) elseif __action__ == "unlock" then Kentas.F.Tables.SetVehicleAlarm(playerveh, false)

Kentas.F.Tables.SetVehicleDoorsLocked(playerveh, false) Kentas.F.Tables.SetVehicleDoorsLockedForAllPlayers(playerveh, false) elseif __action__ == "open all" then for door = 0, 7 do Kentas.F.Tables.SetVehicleDoorOpen(playerveh, door, false, false) end elseif __action__ == "close all" then for door = 0, 7 do Kentas.F.Tables.SetVehicleDoorShut(playerveh, door, false) end elseif __action__ == "open front left" then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 0, false, false) elseif __action__ == "open front right" then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 1, false, false) elseif __action__ == 'open left rear' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 2, false, false) elseif __action__ == 'open right rear' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 3, false, false) elseif __action__ == 'open mask' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 4, false, false) elseif __action__ == 'open trunk' then Kentas.F.Tables.SetVehicleDoorOpen(playerveh, 5, false, false) elseif __action__ == "close front left" then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 0, false, false) elseif __action__ == "close front right" then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 1, false, false) elseif __action__ == 'close left rear' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 2, false, false) elseif __action__ == 'close right rear' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 3, false, false) elseif __action__ == 'close mask' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 4, false, false) elseif __action__ == 'close trunk' then Kentas.F.Tables.SetVehicleDoorShut(playerveh, 5, false, false) end else Kentas.F.Tables.Functions.Notify('Player must sit in vehicle!') end end end, combo_Strength = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_STRENGTH'), Kentas.F.Combos['Strength-stat'].b[Kentas.F.Combos['Strength-stat'].a]-1, true) end,

combo_Stamina = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_STAMINA'), Kentas.F.Combos['Stamina-stat'].b[Kentas.F.Combos['Stamina-stat'].a]-1, true) end, combo_Lung = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_LUNG_CAPACITY'), Kentas.F.Combos['Lung-stat'].b[Kentas.F.Combos['Lung-stat'].a]-1, true) end, combo_Shooting = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_SHOOTING_ABILITY'), Kentas.F.Combos['Shooting-stat'].b[Kentas.F.Combos['Shooting-stat'].a]-1, true) end, combo_Wheelie = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_WHEELIE_ABILITY'), Kentas.F.Combos['Wheelie-stat'].b[Kentas.F.Combos['Wheelie-stat'].a]-1, true) end, combo_Driving = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_DRIVING_ABILITY'), Kentas.F.Combos['Driving-stat'].b[Kentas.F.Combos['Driving-stat'].a]-1, true) end, combo_Flying = function() Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey('MP0_FLYING_ABILITY'), Kentas.F.Combos['Flying-stat'].b[Kentas.F.Combos['Flying-stat'].a]-1, true) end, combo_nil = function() end, CreateExplosion = function() if Kentas.F.Checks['explodeo:Camerashake'] then shakeshitok = 1230.0 else shakeshitok = 0.0 end Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlaye rPed(Kentas.F.SelectedPlayer)), Kentas.F.Combos['ExplodeTypeOnl'].b[Kentas.F.Combos['ExplodeTypeOnl'].a], 1.0, Kentas.F.Checks['explodeo:Audible'], Kentas.F.Checks['explodeo:Invisible'], shakeshitok) end, combo_setenginesound = function() local vehicle = Kentas.F.Tables.GetVehiclePedIsUsing(Kentas.F.Tables.PlayerPedId()) if vehicle ~= 0 then Kentas.F.Tables.ForceVehicleEngineAudio(vehicle, Kentas.F.Combos['EngineSound'].b[Kentas.F.Combos['EngineSound'].a]) end end, combo_spawnramp = function() local __style__ = Kentas.F.Combos['RampStyle'].b[Kentas.F.Combos['RampStyle'].a] local currentramp = Kentas.F.Combos['RampProp'].b[Kentas.F.Combos['RampProp'].a] if __style__== "Bumper" then local vehicle =

Kentas.F.Tables.GetVehiclePedIsUsing(Kentas.F.Tables.PlayerPedId()) local prop = Kentas.F.Tables.GetHashKey(currentramp) local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(vehicle, true)) Kentas.F._p1 = Kentas.F.Tables.CreateObject(prop, x, y, z, true, true, false) Kentas.F.Tables.AttachEntityToEntity(Kentas.F._p1, vehicle, Kentas.F.Tables.GetPedBoneIndex(vehicle, 0), 0.0, 2.5, 0.5, 180.0, 180.0, 0.0, false, true, true, false, 2, true) --[[ elseif __style__== "Custom rot" then local vehicle = Kentas.F.Tables.GetVehiclePedIsUsing(Kentas.F.Tables.PlayerPedId()) local prop = Kentas.F.Tables.GetHashKey(currentramp) local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(vehicle, true)) Kentas.F._p = Kentas.F.Tables.CreateObject(prop, x, y, z, true, true, false) Kentas.F.Tables.AttachEntityToEntity(Kentas.F._p, vehicle, Kentas.F.Tables.GetPedBoneIndex(vehicle, 0), 0.0, 2.5, 0.5, Kentas.F.Sliders['RotX'].value, Kentas.F.Sliders['Rot-Y'].value, Kentas.F.Sliders['Rot-Z'].value, false, true, true, false, 2, true)]] end end, rampsdetach = function() if Kentas.F._p ~= nil then Kentas.F.Tables.DetachEntity(Kentas.F._p, true, false) end if Kentas.F._p1 ~= nil then Kentas.F.Tables.DetachEntity(Kentas.F._p1, true, false) end end, BugAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local player = Kentas.F.Tables.GetPlayerPed(v) local prop1 = Kentas.F.Tables.GetHashKey('prop_atm_01') while not Kentas.F.Tables.HasModelLoaded(prop1) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(prop1) end local prop2 = Kentas.F.Tables.CreateObject(prop1, 0, 0, 0, true, true, false) Kentas.F.Tables.SetEntityVisible(prop2, false, 0) Kentas.F.Tables.AttachEntityToEntity(prop2, player, Kentas.F.Tables.GetPedBoneIndex(player, 57005), 0, 0, -1.0, 0, 0, 0, false, true, true, true, 1, true) end end, CageAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.GetPlayerPed(v), 0.0, 0.0, -1.0) Kentas.F.Tables.CreateObject(Kentas.F.Tables.GetHashKey('prop_container_ld_pu'),

c.x, c.y, c.z, true, true, true) end end, ExplodeAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlaye rPed(v)), 7, 1.0, true, false, 0.0) end end, CrushAllPlayersDest = function() __CitIn__.CreateThread(function() local vehicle = Kentas.F.Tables.Functions.KBInput('Enter vehicle spawn name','dump', 20) local VehicleHash = Kentas.F.Tables.GetHashKey(vehicle) Kentas.F.Tables.RequestModel(VehicleHash) for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local coords = (Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v))) while not Kentas.F.Tables.HasModelLoaded(VehicleHash) do Kentas.F.Tables.RequestModel(VehicleHash) __CitIn__.Wait(15) end Kentas.F.Tables.CreateVehicle(VehicleHash, coords.x, coords.y, coords.z + 5.0, 0.0, true, false) end end) end, SwastikaAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(ped, true)) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 3.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 6.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 9.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true)

Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 3.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 6.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 9.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 3.0, 0, 3.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 6.0, 0, 3.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 9.0, 0, 3.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -3.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -6.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -9.0, 0, 12.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -9.0, 0, 3.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -9.0, 0, 6.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -9.0, 0, 9.0, 0, 90, 0, false, false, false, false, 2, true)

Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 15.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 18.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 0, 0, 21.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 9.0, 0, 15.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 9.0, 0, 18.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), 9.0, 0, 21.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -3.0, 0, 21.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -6.0, 0, 21.0, 0, 90, 0, false, false, false, false, 2, true) Kentas.F.Tables.AttachEntityToEntity(Kentas.F.Tables.CreateObject(Kentas.F.Tables.G etHashKey("prop_container_05a"), x, y, z, true, true, false), ped, Kentas.F.Tables.GetPedBoneIndex(ped, 0), -9.0, 0, 21.0, 0, 90, 0, false, false, false, false, 2, true) end end, LaunchAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlaye rPed(v)), 7, 1.0, false, true, 0.0) end end, CrashAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetHashKey('mp_m_freemode_01')

Kentas.F.Tables.RequestModel(ped) while not Kentas.F.Tables.HasModelLoaded(ped) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(ped) end for i = 1, 33 do for a = 1, 3 do local pea = Kentas.F.Tables.CreatePed(31, ped, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)), 0.0, true, true) Kentas.F.Tables.GiveWeaponToPed(pea, Kentas.F.Tables.GetHashKey('weapon_rpg'), 222, false, true) end end end end, Deleteallplayervehicles = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local playerveh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.DeleteEntity(playerveh) end end, --[[Airstrikeallplayervehicles = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(v)) if vehicle ~= 0 then local coords = Kentas.F.Tables.GetEntityCoords(vehicle) local pedd = `mp_m_freemode_01` Kentas.F.Tables.RequestModel(pedd) while not Kentas.F.Tables.HasModelLoaded(pedd) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(pedd) end local __SPAWNINGPED__ = Kentas.F.Tables.CreatePed(21, pedd, coords.x, coords.y, coords.z - 40.0, 0.0, true, true) Kentas.F.Tables.ShootSingleBulletBetweenCoords(coords.x, coords.y, coords.z + 55.55, coords.x, coords.y, coords.z, 100.0, true, Kentas.F.Tables.GetHashKey('weapon_hominglauncher'), __SPAWNINGPED__, true, false, 1000.0) end end end,]] helidrivebyAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local ped = Kentas.F.Tables.GetPlayerPed(v) local coords = Kentas.F.Tables.GetEntityCoords(ped) local pedmodel = "a_m_m_eastsa_01" local heli = "frogger" Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(pedmodel)) Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(heli)) local loadattemps = 0

while not Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(pedmodel)) do loadattemps = loadattemps + 1 __CitIn__.Wait(1) if loadattemps > 10000 then break end end while not Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(heli)) and loadattemps < 10000 do __CitIn__.Wait(500) end local nped = Kentas.F.Tables.CreatePed(31, pedmodel, coords.x, coords.y, coords.z, 0.0, true, true) local veh = Kentas.F.Tables.CreateVehicle(Kentas.F.Tables.GetHashKey(heli), coords.x, coords.y + 15.0, coords.z + 40.0, Kentas.F.Tables.GetEntityHeading(ped), 1, 1) local nped2 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 0, true, true) local nped3 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 1, true, true) local nped4 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 2, true, true) local nped5 = Kentas.F.Tables.CreatePedInsideVehicle(veh, 31, pedmodel, 2, true, true) Kentas.F.Tables.ClearPedTasks(nped) Kentas.F.Tables.SetPedIntoVehicle(nped, veh, -1) Kentas.F.Tables.SetPedIntoVehicle(nped2, veh, 0) Kentas.F.Tables.SetPedIntoVehicle(nped3, veh, 1) Kentas.F.Tables.SetPedIntoVehicle(nped4, veh, 2) Kentas.F.Tables.SetPedIntoVehicle(nped5, veh, 3) Kentas.F.Tables.GiveWeaponToPed(nped2, "WEAPON_ASSAULTRIFLE", 9999, false, true) Kentas.F.Tables.GiveWeaponToPed(nped3, "WEAPON_ASSAULTRIFLE", 9999, false, true) Kentas.F.Tables.GiveWeaponToPed(nped4, "WEAPON_ASSAULTRIFLE", 9999, false, true) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(ped), Kentas.F.Tables.GetHashKey(nped)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(nped), Kentas.F.Tables.GetHashKey(ped)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(ped), Kentas.F.Tables.GetHashKey(nped2)) Kentas.F.Tables.SetRelationshipBetweenGroups(5, Kentas.F.Tables.GetHashKey(nped2), Kentas.F.Tables.GetHashKey(ped)) Kentas.F.Tables.SetVehicleEngineOn(veh, 10, true, false) Kentas.F.Tables.TaskVehicleChase(nped, Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.SetPedKeepTask(nped, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped2, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped3, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped4, true) Kentas.F.Tables.SetPedCanSwitchWeapon(nped5, true) Kentas.F.Tables.SetEntityInvincible(nped, true) Kentas.F.Tables.SetEntityInvincible(nped2, true) Kentas.F.Tables.SetEntityInvincible(nped3, true)

Kentas.F.Tables.SetEntityInvincible(nped2, true) Kentas.F.Tables.SetEntityInvincible(nped5, true) Kentas.F.Tables.TaskCombatPed(nped2, Kentas.F.Tables.GetPlayerPed(v), 0, 16) Kentas.F.Tables.TaskCombatPed(nped3, Kentas.F.Tables.GetPlayerPed(v), 0, 16) Kentas.F.Tables.TaskCombatPed(nped4, Kentas.F.Tables.GetPlayerPed(v), 0, 16) Kentas.F.Tables.TaskCombatPed(nped5, Kentas.F.Tables.GetPlayerPed(v), 0, 16) Kentas.F.Tables.SetPedKeepTask(nped, true) Kentas.F.Tables.SetPedKeepTask(nped2, true) Kentas.F.Tables.SetPedKeepTask(nped3, true) Kentas.F.Tables.SetPedKeepTask(nped4, true) Kentas.F.Tables.SetPedKeepTask(nped5, true) Kentas.F.Tables.SetRelationshipBetweenGroups(5,Kentas.F.Tables.GetHashKey("PLAYER") ,Kentas.F.Tables.GetHashKey(pedmodel)) Kentas.F.Tables.SetRelationshipBetweenGroups(5,Kentas.F.Tables.GetHashKey(pedmodel) ,Kentas.F.Tables.GetHashKey("PLAYER")) end end, hoodattackAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local attacker = "g_m_y_famca_01" local weapon = "WEAPON_PISTOL" for i = 0, 10 do local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.RequestModel(Kentas.F.Tables.GetHashKey(attacker)) __CitIn__.Wait(50) if Kentas.F.Tables.HasModelLoaded(Kentas.F.Tables.GetHashKey(attacker)) then local ped = Kentas.F.Tables.CreatePed(21, Kentas.F.Tables.GetHashKey(attacker), coords.x + i, coords.y - i, coords.z, 0, true, true) and Kentas.F.Tables.CreatePed(21, Kentas.F.Tables.GetHashKey(attacker), coords.x - i, coords.y + i, coords.z, 0, true, true) Kentas.F.Tables.NetworkRegisterEntityAsNetworked(ped) if Kentas.F.Tables.DoesEntityExist(ped) and not Kentas.F.Tables.IsEntityDead(Kentas.F.Tables.GetPlayerPed(v)) then local net = PedToNet(ped) Kentas.F.Tables.NetworkSetNetworkIdDynamic(net, false) Kentas.F.Tables.SetNetworkIdCanMigrate(net, true) Kentas.F.Tables.SetNetworkIdExistsOnAllMachines(net, true) __CitIn__.Wait(50) Kentas.F.Tables.NetToPed(net) Kentas.F.Tables.GiveWeaponToPed(ped, Kentas.F.Tables.GetHashKey(weapon), 9999, 1, 1) Kentas.F.Tables.SetEntityInvincible(ped, true) Kentas.F.Tables.SetPedCanSwitchWeapon(ped, true) Kentas.F.Tables.TaskCombatPed(ped, Kentas.F.Tables.GetPlayerPed(v), 0, 16)

elseif Kentas.F.Tables.IsEntityDead(Kentas.F.Tables.GetPlayerPed(v)) then Kentas.F.Tables.TaskCombatHatedTargetsInArea(ped, coords.x, coords.y, coords.z, 500) else __CitIn__.Wait(0) end end end end end, deletevehiclesAllPlayersDest = function() for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.DeleteEntity(vehicle) end end, customacdis = function() __CitIn__.CreateThread(function() local input = Kentas.F.Tables.Functions.KBInput('Input key (only key codes)','121', 30) Kentas.F.Tables.DisableControlAction(0, input, true) end) end, customacenbl = function() __CitIn__.CreateThread(function() local input = Kentas.F.Tables.Functions.KBInput('Input key (only key codes)','121', 30) Kentas.F.Tables.EnableAllControlActions(0, input, true) end) end, ResetMenu = function() Kentas.F.Checks.KeyboardDragXWM = 0.0 Kentas.F.Checks.KeyboardDragYWM = 0.0 --for i = 1, #Kentas.F.submenu do -Kentas.F.submenu[i].selectedfeature = 1 --end Kentas.maxoptcount = 18 Kentas.F.Combos['maxoptcountonscreen'].a = 8 end, ChangeMenuStyle = function() local style = Kentas.F.Combos['Menu-Style'].b[Kentas.F.Combos['MenuStyle'].a] if style == 'Kentas' then Kentas.F.NNstyle = 'Kentas' Kentas.F.Checks.MainR = 100 Kentas.F.Checks.MainG = 100 Kentas.F.Checks.MainB = 255 Kentas.F.Checks.MainR2, Kentas.F.Checks.MainG2, Kentas.F.Checks.MainB2 = 255, 255, 255 if Kentas.F.ImageUrlStyle ~= 'https://cdn.discordapp.com/attachments/826526555693645895/884445819254734918/ Comp_1.gif' then Kentas.F.ImageUrlStyle = 'https://cdn.discordapp.com/attachments/826526555693645895/884445819254734918/ Comp_1.gif'

Kentas.F.Tables.SetDuiUrl(Kentas.F.banner_dui1, Kentas.F.ImageUrlStyle) end elseif style == 'Kentas' then Kentas.F.NNstyle = 'Kentas' Kentas.F.Checks.MainR = 25 Kentas.F.Checks.MainG = 255 Kentas.F.Checks.MainB = 25 Kentas.F.Checks.MainR2, Kentas.F.Checks.MainG2, Kentas.F.Checks.MainB2 = 255, 255, 255 if Kentas.F.ImageUrlStyle ~= 'https://media.discordapp.net/attachments/826518016569114634/902995421671067718/ Comp_1.gif' then Kentas.F.ImageUrlStyle = 'https://media.discordapp.net/attachments/826518016569114634/902995421671067718/ Comp_1.gif' Kentas.F.Tables.SetDuiUrl(Kentas.F.banner_dui1, Kentas.F.ImageUrlStyle) end end end, ServerIP = function() Kentas.F.Tables.Functions.Notify('Server IP: '.. Kentas.F.Tables.GetCurrentServerEndpoint()) end, KillMenu = function() Kentas.enabled = false end, CrashMenu = function() ______________________________Kentas_________________________._______FUNCS________. CrashMenu() end, playanimation = function() local animation = Kentas.F.Combos['Animations'].b[Kentas.F.Combos['Animations'].a] Kentas.F.Tables.RequestAnimDict(animation.lib) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), animation.lib, animation.anim, 8.0, -8.0, -1, 0, 0, false, false, false) end, Stopanimations = function() Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId()) Kentas.F.Tables.ResetPedMovementClipset(Kentas.F.Tables.PlayerPedId(), 0.0) end, wotwar = function() local player = Kentas.F.Tables.PlayerPedId() local coords = Kentas.F.Tables.GetEntityCoords(player) local wotteam = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') Kentas.F.Tables.RequestModel(wotteam) while not Kentas.F.Tables.HasModelLoaded(wotteam) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(wotteam) end local wotteam2 = Kentas.F.Tables.GetHashKey('rhino') Kentas.F.Tables.RequestModel(wotteam2) while not Kentas.F.Tables.HasModelLoaded(wotteam2) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(wotteam2)

end local __veh__2 = Kentas.F.Tables.CreateVehicle(wotteam2, coords.x, coords.y, coords.z, Kentas.F.Tables.GetEntityHeading(ped), 1, 1) Kentas.F.Tables.SetPedIntoVehicle(player, __veh__2, -1) for bb = 1, 7 do local __ped__ = Kentas.F.Tables.CreatePed(21, wotteam, coords.x, coords.y, coords.z, 0, true, true) local foundGround, zPos = Kentas.F.Tables.GetGroundZFor_3dCoord(coords.x, coords.y, coords.z, 1) if foundGround then local random = math.random(5.0, 25.0) local __veh__ = Kentas.F.Tables.CreateVehicle(wotteam2, coords.x+random+0.0, coords.y+random+0.0, zPos, Kentas.F.Tables.GetEntityHeading(ped), 1, 1) Kentas.F.Tables.SetPedIntoVehicle(__ped__, __veh__, -1) Kentas.F.Tables.TaskCombatPed(__ped__, player, 0, 16) end end end, ClearPeds = function() for peds in Kentas.F.Tables.Functions.EnumeratePeds() do Kentas.F.Tables.DeleteEntity(peds) end end, ClearVehs = function() for vehicles in Kentas.F.Tables.Functions.EnumerateVehicles() do Kentas.F.Tables.DeleteEntity(vehicles) end end, stopcutscene = function() Kentas.F.Tables.StopCutscene(true) end, --setsnowlevel = function() -- SetSnowLevel(1.0) --end, ClearObjects = function() for objects in Kentas.F.Tables.Functions.EnumerateObjects() do Kentas.F.Tables.DeleteEntity(objects) end end, recruitk9 = function() local player = Kentas.F.Tables.PlayerPedId() local swatteam = Kentas.F.Tables.GetHashKey('a_c_chop') Kentas.F.Tables.RequestModel(swatteam) while not Kentas.F.Tables.HasModelLoaded(swatteam) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(swatteam) end local __ped__ = Kentas.F.Tables.CreatePed(0, swatteam, Kentas.F.Tables.GetEntityCoords(player), 0, true, true) local __group__ = Kentas.F.Tables.GetHashKey(Kentas.F.Tables.GetPedRelationshipGroupHash(__ped__)) Kentas.F.Tables.SetPedAsGroupMember(__ped__, Kentas.F.Tables.GetPlayerGroup(player)) Kentas.F.Tables.SetPedNeverLeavesGroup(__ped__, true) Kentas.F.Tables.SetRelationshipBetweenGroups(0, Kentas.F.Tables.GetHashKey("PLAYER"), __group__) Kentas.F.Tables.SetRelationshipBetweenGroups(0, __group__, Kentas.F.Tables.GetHashKey("PLAYER"))

Kentas.F.Tables.SetRelationshipBetweenGroups(1, Kentas.F.Tables.GetHashKey("PLAYER"), __group__) Kentas.F.Tables.SetRelationshipBetweenGroups(1, __group__, Kentas.F.Tables.GetHashKey("PLAYER")) Kentas.F.Tables.SetCanAttackFriendly(__ped__, false, false) Kentas.F.Tables.TaskFollowToOffsetOfEntity(__ped__, player, 0.0, 0.0, 0.0, 30.0, -1, 50.0, 1) Kentas.F.Tables.NetworkRegisterEntityAsNetworked(ped) end, setthistime = function() local h, m, s = Kentas.F.Combos['time-hours'].b[Kentas.F.Combos['timehours'].a], Kentas.F.Combos['time-minute'].b[Kentas.F.Combos['time-minute'].a], Kentas.F.Combos['time-Seconds'].b[Kentas.F.Combos['time-Seconds'].a] Kentas.F.Tables.NetworkOverrideClockTime(h, m, s) Kentas.F.Tables.SetClockTime(h, m, s) end, synchronizetime = function() local year, month, day, hour, min, sec = Kentas.F.Tables.GetLocalTime() Kentas.F.Tables.NetworkOverrideClockTime(hour, min, sec) Kentas.F.Tables.SetClockTime(hour, min, sec) end, getownped = function() local m1 = Kentas.F.Tables.Functions.KBInput('Ped spawn name','', 30) local model = Kentas.F.Tables.GetHashKey(m1) Kentas.F.Tables.RequestModel(model) while not Kentas.F.Tables.HasModelLoaded(model) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(model) end local ped = Kentas.F.Tables.PlayerPedId() local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(ped)) local p1 = Kentas.F.Tables.CreatePed(3, model, x, y, z, 1, true, true) Kentas.F.Tables.TaskFollowToOffsetOfEntity(p1, ped, 0.5, 0.0, 0.0, 5.0, -1, 0.0, 1) Kentas.F.Tables.SetPedKeepTask(p1, true) end, recruitswatteam = function() local player = Kentas.F.Tables.PlayerPedId() for bb = 1, 4 do local swatteam = Kentas.F.Tables.GetHashKey('s_m_y_swat_01') Kentas.F.Tables.RequestModel(swatteam) while not Kentas.F.Tables.HasModelLoaded(swatteam) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(swatteam) end local __ped__ = Kentas.F.Tables.CreatePed(21, swatteam, Kentas.F.Tables.GetEntityCoords(player), 0, true, true) local __group__ = Kentas.F.Tables.GetHashKey(Kentas.F.Tables.GetPedRelationshipGroupHash(__ped__)) Kentas.F.Tables.SetPedAsGroupMember(__ped__, Kentas.F.Tables.GetPlayerGroup(player)) Kentas.F.Tables.SetPedNeverLeavesGroup(__ped__, true) Kentas.F.Tables.SetRelationshipBetweenGroups(0, Kentas.F.Tables.GetHashKey("PLAYER"), __group__) Kentas.F.Tables.SetRelationshipBetweenGroups(0, __group__, Kentas.F.Tables.GetHashKey("PLAYER")) Kentas.F.Tables.SetRelationshipBetweenGroups(1, Kentas.F.Tables.GetHashKey("PLAYER"), __group__)

Kentas.F.Tables.SetRelationshipBetweenGroups(1, __group__, Kentas.F.Tables.GetHashKey("PLAYER")) Kentas.F.Tables.SetCanAttackFriendly(__ped__, false, false) Kentas.F.Tables.TaskFollowToOffsetOfEntity(__ped__, player, 0.0, 0.0, 0.0, 30.0, -1, 50.0, 1) Kentas.F.Tables.NetworkRegisterEntityAsNetworked(ped) Kentas.F.Tables.GiveWeaponToPed(__ped__, Kentas.F.Tables.GetHashKey('weapon_carbinerifle'), 9999, 1, 1) end end, } Kentas.F.Funcs.RequestIpls = function() Kentas.F.Tables.RequestIpl('shr_int')Kentas.F.Tables.RequestIpl('TrevorsTrailerTras h')Kentas.F.Tables.RequestIpl('post_hiest_unload')Kentas.F.Tables.RequestIpl('refit _unload')Kentas.F.Tables.RequestIpl('FINBANK')Kentas.F.Tables.RequestIpl('Coroner_I nt_on')Kentas.F.Tables.RequestIpl('coronertrash')Kentas.F.Tables.RequestIpl('CS1_02 _cf_onmission1')Kentas.F.Tables.RequestIpl('CS1_02_cf_onmission2')Kentas.F.Tables.R equestIpl('CS1_02_cf_onmission3')Kentas.F.Tables.RequestIpl('CS1_02_cf_onmission4') Kentas.F.Tables.RequestIpl('farm')Kentas.F.Tables.RequestIpl('farmint')Kentas.F.Tab les.RequestIpl('farm_lod')Kentas.F.Tables.RequestIpl('farm_props')Kentas.F.Tables.R equestIpl('des_farmhouse')Kentas.F.Tables.RequestIpl('FIBlobby')Kentas.F.Tables.Req uestIpl('FruitBB')Kentas.F.Tables.RequestIpl('sc1_01_newbill')Kentas.F.Tables.Reque stIpl('hw1_02_newbill')Kentas.F.Tables.RequestIpl('hw1_emissive_newbill')Kentas.F.T ables.RequestIpl('sc1_14_newbill')Kentas.F.Tables.RequestIpl('dt1_17_newbill')Kenta s.F.Tables.RequestIpl('id2_14_during_door')Kentas.F.Tables.RequestIpl('id2_14_durin g1')Kentas.F.Tables.RequestIpl('facelobby')Kentas.F.Tables.RequestIpl('v_tunnel_hol e')Kentas.F.Tables.RequestIpl('Carwash_with_spinners')Kentas.F.Tables.RequestIpl('s p1_10_real_interior')Kentas.F.Tables.RequestIpl('sp1_10_real_interior_lod')Kentas.F .Tables.RequestIpl('ch1_02_open')Kentas.F.Tables.RequestIpl('bkr_bi_id1_23_door')Ke ntas.F.Tables.RequestIpl('lr_cs6_08_grave_closed')Kentas.F.Tables.RequestIpl('metht railer_grp1')Kentas.F.Tables.RequestIpl('bkr_bi_hw1_13_int')Kentas.F.Tables.Request Ipl('CanyonRvrShallow')Kentas.F.Tables.RequestIpl('CS3_07_MPGates')Kentas.F.Tables. RequestIpl('RC12B_Default')Kentas.F.Tables.RequestIpl('bh1_47_joshhse_unburnt')Kent as.F.Tables.RequestIpl('bh1_47_joshhse_unburnt_lod')Kentas.F.Tables.RequestIpl('cs3 _05_water_grp1')Kentas.F.Tables.RequestIpl('cs3_05_water_grp1_lod')Kentas.F.Tables. RequestIpl('cs3_05_water_grp2')Kentas.F.Tables.RequestIpl('cs3_05_water_grp2_lod')K entas.F.Tables.RequestIpl('canyonriver01')Kentas.F.Tables.RequestIpl('canyonriver01 _lod')Kentas.F.Tables.RequestIpl('ch3_rd2_bishopschickengraffiti')Kentas.F.Tables.R equestIpl('cs5_04_mazebillboardgraffiti')Kentas.F.Tables.RequestIpl('cs5_roads_rono ilgraffiti')Kentas.F.Tables.RequestIpl('hei_carrier')Kentas.F.Tables.RequestIpl('he i_carrier_distantlights')Kentas.F.Tables.RequestIpl('hei_Carrier_int1')Kentas.F.Tab les.RequestIpl('hei_Carrier_int2')Kentas.F.Tables.RequestIpl('hei_Carrier_int3')Ken tas.F.Tables.RequestIpl('hei_Carrier_int4')Kentas.F.Tables.RequestIpl('hei_Carrier_ int5')Kentas.F.Tables.RequestIpl('hei_Carrier_int6')Kentas.F.Tables.RequestIpl('hei _carrier_lodlights')Kentas.F.Tables.RequestIpl('hei_carrier_slod')Kentas.F.Tables.R equestIpl('hei_yacht_heist')Kentas.F.Tables.RequestIpl('hei_yacht_heist_Bar')Kentas .F.Tables.RequestIpl('hei_yacht_heist_Bedrm')Kentas.F.Tables.RequestIpl('hei_yacht_ heist_Bridge')Kentas.F.Tables.RequestIpl('hei_yacht_heist_DistantLights')Kentas.F.T ables.RequestIpl('hei_yacht_heist_enginrm')Kentas.F.Tables.RequestIpl('hei_yacht_he ist_LODLights')Kentas.F.Tables.RequestIpl('hei_yacht_heist_Lounge')Kentas.F.Tables. RequestIpl('ex_dt1_02_office_01b')Kentas.F.Tables.RequestIpl('ex_dt1_11_office_01b' )Kentas.F.Tables.RequestIpl('ex_sm_13_office_01b')Kentas.F.Tables.RequestIpl('ex_sm _15_office_01b')Kentas.F.Tables.RequestIpl('apa_v_mp_h_01_a')Kentas.F.Tables.Reques tIpl('apa_v_mp_h_02_c')Kentas.F.Tables.RequestIpl('apa_v_mp_h_04_b')Kentas.F.Tables .RequestIpl('bkr_biker_interior_placement_interior_0_biker_dlc_int_01_milo')Kentas. F.Tables.RequestIpl('bkr_biker_interior_placement_interior_1_biker_dlc_int_02_milo' )Kentas.F.Tables.RequestIpl('bkr_biker_interior_placement_interior_2_biker_dlc_int_ ware01_milo')Kentas.F.Tables.RequestIpl('bkr_biker_interior_placement_interior_2_bi

ker_dlc_int_ware02_milo')Kentas.F.Tables.RequestIpl('bkr_biker_interior_placement_i nterior_2_biker_dlc_int_ware03_milo')Kentas.F.Tables.RequestIpl('bkr_biker_interior _placement_interior_2_biker_dlc_int_ware04_milo')Kentas.F.Tables.RequestIpl('bkr_bi ker_interior_placement_interior_2_biker_dlc_int_ware05_milo')Kentas.F.Tables.Reques tIpl('bkr_biker_interior_placement_interior_3_biker_dlc_int_ware02_milo')Kentas.F.T ables.RequestIpl('bkr_biker_interior_placement_interior_4_biker_dlc_int_ware03_milo ')Kentas.F.Tables.RequestIpl('bkr_biker_interior_placement_interior_5_biker_dlc_int _ware04_milo')Kentas.F.Tables.RequestIpl('bkr_biker_interior_placement_interior_6_b iker_dlc_int_ware05_milo')Kentas.F.Tables.RequestIpl('ex_exec_warehouse_placement_i nterior_1_int_warehouse_s_dlc_milo')Kentas.F.Tables.RequestIpl('ex_exec_warehouse_p lacement_interior_0_int_warehouse_m_dlc_milo')Kentas.F.Tables.RequestIpl('ex_exec_w arehouse_placement_interior_2_int_warehouse_l_dlc_milo')Kentas.F.Tables.RequestIpl( 'imp_impexp_interior_placement')Kentas.F.Tables.RequestIpl('imp_impexp_interior_pla cement_interior_0_impexp_int_01_milo_')Kentas.F.Tables.RequestIpl('imp_impexp_inter ior_placement_interior_1_impexp_intwaremed_milo_')Kentas.F.Tables.RequestIpl('imp_i mpexp_interior_placement_interior_2_imptexp_mod_int_01_milo_')Kentas.F.Tables.Reque stIpl('imp_impexp_interior_placement_interior_3_impexp_int_02_milo_')Kentas.F.Table s.RequestIpl('imp_dt1_02_modgarage')Kentas.F.Tables.RequestIpl('imp_dt1_02_cargarag e_a')Kentas.F.Tables.RequestIpl('imp_dt1_02_cargarage_b')Kentas.F.Tables.RequestIpl ('imp_dt1_02_cargarage_c')Kentas.F.Tables.RequestIpl('imp_dt1_11_modgarage')Kentas. F.Tables.RequestIpl('imp_dt1_11_cargarage_a')Kentas.F.Tables.RequestIpl('imp_dt1_11 _cargarage_b')Kentas.F.Tables.RequestIpl('imp_dt1_11_cargarage_c')Kentas.F.Tables.R equestIpl('imp_sm_13_modgarage')Kentas.F.Tables.RequestIpl('imp_sm_13_cargarage_a') Kentas.F.Tables.RequestIpl('imp_sm_13_cargarage_b')Kentas.F.Tables.RequestIpl('imp_ sm_13_cargarage_c')Kentas.F.Tables.RequestIpl('imp_sm_15_modgarage')Kentas.F.Tables .RequestIpl('imp_sm_15_cargarage_a')Kentas.F.Tables.RequestIpl('imp_sm_15_cargarage _b')Kentas.F.Tables.RequestIpl('imp_sm_15_cargarage_c')Kentas.F.Tables.RequestIpl(' gr_case0_bunkerclosed')Kentas.F.Tables.RequestIpl('gr_case1_bunkerclosed')Kentas.F. Tables.RequestIpl('gr_case2_bunkerclosed')Kentas.F.Tables.RequestIpl('gr_case3_bunk erclosed')Kentas.F.Tables.RequestIpl('gr_case4_bunkerclosed')Kentas.F.Tables.Reques tIpl('gr_case5_bunkerclosed')Kentas.F.Tables.RequestIpl('gr_case6_bunkerclosed')Ken tas.F.Tables.RequestIpl('gr_case7_bunkerclosed')Kentas.F.Tables.RequestIpl('gr_case 9_bunkerclosed')Kentas.F.Tables.RequestIpl('gr_case10_bunkerclosed')Kentas.F.Tables .RequestIpl('gr_case11_bunkerclosed')Kentas.F.Tables.RequestIpl('xm_siloentranceclo sed_x17')Kentas.F.Tables.RequestIpl('sm_smugdlc_interior_placement')Kentas.F.Tables .RequestIpl('sm_smugdlc_interior_placement_interior_0_smugdlc_int_01_milo_')Kentas. F.Tables.RequestIpl('xm_x17dlc_int_placement')Kentas.F.Tables.RequestIpl('xm_x17dlc _int_placement_interior_0_x17dlc_int_base_ent_milo_')Kentas.F.Tables.RequestIpl('xm _x17dlc_int_placement_interior_1_x17dlc_int_base_loop_milo_')Kentas.F.Tables.Reques tIpl('xm_x17dlc_int_placement_interior_2_x17dlc_int_bse_tun_milo_')Kentas.F.Tables. RequestIpl('xm_x17dlc_int_placement_interior_3_x17dlc_int_base_milo_')Kentas.F.Tabl es.RequestIpl('xm_x17dlc_int_placement_interior_4_x17dlc_int_facility_milo_')Kentas .F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_5_x17dlc_int_facility2_milo_ ')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_6_x17dlc_int_silo_01 _milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_7_x17dlc_int_s ilo_02_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_8_x17dlc _int_sub_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_9_x17d lc_int_01_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_10_x1 7dlc_int_tun_straight_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_in terior_11_x17dlc_int_tun_slope_flat_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_in t_placement_interior_12_x17dlc_int_tun_flat_slope_milo_')Kentas.F.Tables.RequestIpl ('xm_x17dlc_int_placement_interior_13_x17dlc_int_tun_30d_r_milo_')Kentas.F.Tables.R equestIpl('xm_x17dlc_int_placement_interior_14_x17dlc_int_tun_30d_l_milo_')Kentas.F .Tables.RequestIpl('xm_x17dlc_int_placement_interior_15_x17dlc_int_tun_straight_mil o_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_16_x17dlc_int_tun_ straight_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_17_x17 dlc_int_tun_slope_flat_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_i nterior_18_x17dlc_int_tun_slope_flat_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_i nt_placement_interior_19_x17dlc_int_tun_flat_slope_milo_')Kentas.F.Tables.RequestIp

l('xm_x17dlc_int_placement_interior_20_x17dlc_int_tun_flat_slope_milo_')Kentas.F.Ta bles.RequestIpl('xm_x17dlc_int_placement_interior_21_x17dlc_int_tun_30d_r_milo_')Ke ntas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_22_x17dlc_int_tun_30d_r_ milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_23_x17dlc_int_t un_30d_r_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interior_24_x17 dlc_int_tun_30d_r_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placement_interi or_25_x17dlc_int_tun_30d_l_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_int_placeme nt_interior_26_x17dlc_int_tun_30d_l_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc_in t_placement_interior_27_x17dlc_int_tun_30d_l_milo_')Kentas.F.Tables.RequestIpl('xm_ x17dlc_int_placement_interior_28_x17dlc_int_tun_30d_l_milo_')Kentas.F.Tables.Reques tIpl('xm_x17dlc_int_placement_interior_29_x17dlc_int_tun_30d_l_milo_')Kentas.F.Tabl es.RequestIpl('xm_x17dlc_int_placement_interior_30_v_apart_midspaz_milo_')Kentas.F. Tables.RequestIpl('xm_x17dlc_int_placement_interior_31_v_studio_lo_milo_')Kentas.F. Tables.RequestIpl('xm_x17dlc_int_placement_interior_32_v_garagem_milo_')Kentas.F.Ta bles.RequestIpl('xm_x17dlc_int_placement_interior_33_x17dlc_int_02_milo_')Kentas.F. Tables.RequestIpl('xm_x17dlc_in t_placement_interior_34_x17dlc_int_lab_milo_')Kentas.F.Tables.RequestIpl('xm_x17dlc _int_placement_interior_35_x17dlc_int_tun_entry_milo_')Kentas.F.Tables.RequestIpl(' xm_x17dlc_int_placement_strm_0')Kentas.F.Tables.RequestIpl('xm_bunkerentrance_door' )Kentas.F.Tables.RequestIpl('xm_hatch_01_cutscene')Kentas.F.Tables.RequestIpl('xm_h atch_02_cutscene')Kentas.F.Tables.RequestIpl('xm_hatch_03_cutscene')Kentas.F.Tables .RequestIpl('xm_hatch_04_cutscene')Kentas.F.Tables.RequestIpl('xm_hatch_06_cutscene ')Kentas.F.Tables.RequestIpl('xm_hatch_07_cutscene')Kentas.F.Tables.RequestIpl('xm_ hatch_08_cutscene')Kentas.F.Tables.RequestIpl('xm_hatch_09_cutscene')Kentas.F.Table s.RequestIpl('xm_hatch_10_cutscene')Kentas.F.Tables.RequestIpl('xm_hatch_closed')Ke ntas.F.Tables.RequestIpl('xm_hatches_terrain')Kentas.F.Tables.RequestIpl('xm_hatche s_terrain_lod')Kentas.F.Tables.RequestIpl('xm_mpchristmasadditions') end Kentas.F.ChangeOpenKey = function() local value, label = Kentas.F.Funcs.Binding() Kentas.F.Checks.OpenKeyV = value Kentas.F.Checks.OpenKeyL = label end Kentas.F.Funcs.loadallipls = function() __CitIn__.CreateThread(function() Kentas.F.Funcs.RequestIpls() for ak, ipl in __KentasStrings__.strings:pairs(Kentas.F.AllIpls) do for k, coords in __KentasStrings__.strings:pairs(ipl.coords) do local interiorID = Kentas.F.Tables.GetInteriorAtCoords(coords[1], coords[2], coords[3]) if Kentas.F.Tables.IsValidInterior(interiorID) then Kentas.F.Tables.PinInteriorInMemory(interiorID) for index,propName in __KentasStrings__.strings:pairs(ipl.interiorsProps) do Kentas.F.Tables.ActivateInteriorEntitySet(interiorID, propName) end if ipl.interiorsPropColors then for i=1, #ipl.interiorsPropColors, 1 do Kentas.F.Tables.SetInteriorEntitySetColor(interiorID, ipl.interiorsPropColors[i] [1], ipl.interiorsPropColors[i][2]) end end Kentas.F.Tables.RefreshInterior(interiorID) end end end

end) Kentas.F.Tables.Functions.Notify("All IPL's loaded / reloaded")

end Kentas.F.Funcs.FuckitallmenDest = function() __CitIn__.CreateThread(function() Kentas.F.Funcs.DestroyserverDest() for _Ai = 1, 12345 do __CitIn__.Wait(0) Kentas.F.Tables.PlaySound(-1, 'Checkpoint_Hit', 'GTAO_FM_Events_Soundset', true) Kentas.F.Tables.PlaySound(-1, 'Boss_Blipped', 'GTAO_Magnate_Hunt_Boss_SoundSet', true) Kentas.F.Tables.PlaySound(-1, 'Bomb_Disarmed', 'GTAO_Speed_Convoy_Soundset', true) Kentas.F.Tables.PlaySound(-1, 'All', 'SHORT_PLAYER_SWITCH_SOUND_SET', true) Kentas.F.Tables.PlaySound(-1, 'SELECT', 'HUD_MINI_GAME_SOUNDSET', true) Kentas.F.Tables.PlaySound(-1, 'Beep_Green', 'DLC_HEIST_HACKING_SNAKE_SOUNDS', true) end for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local __MODEL__ = Kentas.F.Tables.GetHashKey("Gauntlet") Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(__MODEL__) end for lpp = 1, 4 do local _c = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(v)) Kentas.F.Tables.CreateVehicle(__MODEL__, _c.x, _c.y, _c.z+3.0, 1, 1, 1) end end end) end Kentas.F.Funcs.VehicleModelOnl = function() Kentas.F.VehicleModelOnline = Kentas.F.Tables.Functions.KBInput('Vehicle spawn name','', 23) return Kentas.F.VehicleModelOnline end Kentas.F.Funcs.SpawnVehicleOnl = function() if Kentas.F.VehicleModelOnline ~= nil then local __MODEL__ = Kentas.F.Tables.GetHashKey(Kentas.F.VehicleModelOnline) Kentas.F.Tables.RequestModel(__MODEL__) while not Kentas.F.Tables.HasModelLoaded(__MODEL__) do __CitIn__.Wait(30) end __SPAWNINGMODEL__ = Kentas.F.Tables.CreateVehicle(__MODEL__, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)), 1, 1, 1) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['VehiclesO'].options, {text = 'Delete last', type = 'button', bind = 'online:Delete last', func = Kentas.F.Funcs.DeleteLastVehicleOnl})

__KentasStrings__.strings:tableinsert(Kentas.F.submenu['VehiclesO'].options, {text = 'Bring last', type = 'button', bind = 'online:Bring last', func = Kentas.F.Funcs.BringLastVehicleOnl}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['VehiclesO'].options, {text = 'Explode last', type = 'button', bind = 'online:Explode last', func = Kentas.F.Funcs.ExplodeLastVehicleOnl}) end end Kentas.F.Funcs.ExplodeLastVehicleOnl = function() Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(__SPAWNINGMODEL__), 7, 1.0, true, false, 0.0) end Kentas.F.Funcs.BringLastVehicleOnl = function() Kentas.F.Tables.SetEntityCoords(__SPAWNINGMODEL__, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r))) end Kentas.F.Funcs.DeleteLastVehicleOnl = function() local deleteentity = Kentas.F.Tables.DeleteEntity(__SPAWNINGMODEL__ or nil) if deleteentity then for k, v in __KentasStrings__.strings:pairs(Kentas.F.submenu['VehiclesO'].options) do if (v.text ~= "Vehicle Model" and v.text ~= "Spawn Vehicle") then for i = 1, 3 do __KentasStrings__.strings:tableremove(Kentas.F.submenu['VehiclesO'].options, k) end end end Kentas.F.submenu[Kentas.activemenu].selectedfeature = 1 end end Kentas.F.Funcs.PropModelOnl = function() Kentas.F.PropModelOnline = Kentas.F.Tables.Functions.KBInput('Prop spawn name','', 23) return Kentas.F.PropModelOnline end Kentas.F.Funcs.SpawnPropOnl = function() if Kentas.F.PropModelOnline ~= nil then local prop = Kentas.F.Tables.GetHashKey(Kentas.F.PropModelOnline) Kentas.F.Tables.RequestModel(prop) while not Kentas.F.Tables.HasModelLoaded(prop) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(prop) end __SPAWNINGPROP__ = Kentas.F.Tables.CreateObject(prop, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r)), true, true, true) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['PropsO'].options, {text = 'Delete last', type = 'button', bind = 'online:Delete lastp', func = Kentas.F.Funcs.DeleteLastPropOnl}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['PropsO'].options, {text = 'Bring last', type = 'button', bind = 'online:Bring lastp', func = Kentas.F.Funcs.BringLastPropOnl})

__KentasStrings__.strings:tableinsert(Kentas.F.submenu['PropsO'].options, {text = 'Explode last', type = 'button', bind = 'online:Explode lastp', func = Kentas.F.Funcs.ExplodeLastPropOnl}) end end Kentas.F.Funcs.CheckIfResourceExist = function(script) if Kentas.F.Tables.GetResourceState(script) == "started" or Kentas.F.Tables.GetResourceState(__KentasStrings__.strings:lower(script)) == "started" or Kentas.F.Tables.GetResourceState(__KentasStrings__.strings:upper(script)) == "started" then return true else return false end end Kentas.F.Funcs.DeleteLastPropOnl = function() local deleteentity = Kentas.F.Tables.DeleteEntity(__SPAWNINGPROP__ or nil) if deleteentity then for k, v in __KentasStrings__.strings:pairs(Kentas.F.submenu['PropsO'].options) do if (v.text ~= "Prop Model" and v.text ~= "Spawn Prop") then for i = 1, 3 do __KentasStrings__.strings:tableremove(Kentas.F.submenu['PropsO'].options, k) end end end Kentas.F.submenu[Kentas.activemenu].selectedfeature = 1 end end Kentas.F.Funcs.ExplodeLastPropOnl = function() Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(__SPAWNINGPROP__), 7, 1.0, true, false, 0.0) end Kentas.F.Funcs.BringLastPropOnl = function() Kentas.F.Tables.SetEntityCoords(__SPAWNINGPROP__, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPlaye r))) end

Kentas.F.submenu = { ['main'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "HOME", options = { {text = 'Self Options', type = 'submenu', bind = 'main:self', menu = 'self'}, {text = 'Online Options', type = 'submenu', bind = 'main:online', menu = 'online'}, {text = 'Visual Options', type = 'submenu', bind = 'main:Visuals', menu = 'Visuals'}, {text = 'Weapon Options', type = 'submenu', bind = 'main:Weapon',

menu = 'Weapon'}, {text = 'Vehicle Options', type = 'submenu', bind = 'main:Vehicle', menu = 'Vehicle'}, {text = 'Glife Options', type = 'submenu', bind = 'main:Vehicle', menu = 'Glife'}, {text = '100k or die', type = 'submenu', bind = 'main:100k or die', menu = '100k or die'}, {text = 'Cheater Protection', type = 'submenu', bind = 'main:Cheater Protection', menu = 'Cheater Protection'}, {text = 'Miscellaneous', type = 'submenu', bind = 'main:Miscellaneous', menu = 'Miscellaneous'}, {text = 'Commands', type = 'submenu', bind = 'main:Commands', menu = 'Commands'}, {text = 'LUA Options', type = 'submenu', bind = 'main:LUAOptions', menu = 'LUAOptions'}, {text = 'Configuration', type = 'submenu', bind = 'main:Configuration', menu = 'Configuration'}, }, }, ['Configuration'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Configuration", parentmenu = 'main', options = { {text = 'Reset Menu', type = 'button', func = Kentas.F.Funcs.ResetMenu}, {text = 'Max option count on screen', type = 'combo', index = Kentas.F.Combos['maxoptcountonscreen'], func = function() Kentas.maxoptcount = Kentas.F.Combos['maxoptcountonscreen'].b[Kentas.F.Combos['maxoptcountonscreen'].a] end}, {text = 'Style', type = 'combo', index = Kentas.F.Combos['MenuStyle'], func = Kentas.F.Funcs.ChangeMenuStyle}, {text = 'Disable button hold animation', type = 'checkbox', check = 'configuration:buttonholdanimation'}, {text = 'Disable fade animation', type = 'checkbox', check = 'configuration:fadeanimation'}, {text = 'Menu Sounds', type = 'checkbox', check = 'configuration:menusounds'}, {text = 'Button animation speed', type = 'slider', bind = '', speed = 0.001, index = Kentas.F.Sliders['Button-animation-delay']}, {text = 'Button hold delay', type = 'slider', bind = '', speed = 0.5, index = Kentas.F.Sliders['Button-hold-delay']}, {text = 'Combo hold delay', type = 'slider', bind = '', speed = 0.5, index = Kentas.F.Sliders['Combo-hold-delay']}, {text = 'Watermark', type = 'checkbox', check = 'configuration:watermark'}, {text = 'Keybinds', type = 'submenu', menu = 'Keybinds'}, {text = 'Configs', type = 'submenu', menu = 'Configs'}, {text = 'Server Info', type = 'submenu', menu = 'Server Info'}, --{text = 'Server IP', type = 'button', func = Kentas.F.Funcs.ServerIP}, {text = 'Kill Menu', type = 'button', func = Kentas.F.Funcs.KillMenu}, {text = 'Crash Menu', type = 'button', func = Kentas.F.Funcs.CrashMenu}, },

},

['Server Info'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Server Info", parentmenu = 'Configuration', options = { }, }, ['Configs'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Configs", parentmenu = 'Configuration', options = { }, }, ['Config list'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "My configs", parentmenu = 'Configs', options = { {text = 'Refresh configs', type = 'button', bind = 'configs:Refresh configs', func = Kentas.F.Funcs.Refreshconfigs}, }, }, ['Keybinds'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Keybinds", parentmenu = 'Configuration', options = { {text = 'open menu', type = 'button', bind = 'Keybinds:open menu', func = Kentas.F.ChangeOpenKey}, {text = 'aimbot keybind', type = 'button', bind = 'weapon:aimbot keybind', func = Kentas.F.Funcs.AimbotKeybind}, }, }, ['LUAOptions'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "LUAOptions", parentmenu = 'main', options = { }, }, ['Commands'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Commands", parentmenu = 'main', options = { {text = 'Create Command', type = 'button', bind = 'command:createcom', func = Kentas.F.Funcs.CreateCommand}, {text = 'All Commands', type = 'sepa', bind = ''}, --{text = 'Execute Command', type = 'combo', index = Kentas.F.Combos['Commands'], func = Kentas.F.Funcs.ExecuteCommand_nil}, }, }, ['Miscellaneous'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Miscellaneous", parentmenu = 'main', options = { {text = 'Dumper', type = 'submenu', menu = 'Dumper'}, {text = 'Stat editor', type = 'submenu', menu = 'Stateditor'},

{text = 'animations', type = 'submenu', menu = 'animations'}, {text = 'load ipls', type = 'button', bind = 'misc:iplsload', func = Kentas.F.Funcs.loadallipls}, {text = 'global chat', type = 'checkbox', bind = 'misc:global chat', check = 'misc:globalchat'}, {text = 'combat', type = 'sepa', bind = ''}, {text = 'aim animation', type = 'combo', index = Kentas.F.Combos['aimnaimation'], func = function() end}, {text = 'Aim position', type = 'checkbox', bind = 'misc:Aim position', check = 'misc:Aimposition'}, {text = 'bypass first person', type = 'checkbox', bind = 'misc:bypass first person', check = 'misc:bypassfirstperson'}, {text = 'rp servers be like', type = 'checkbox', bind = 'misc:rp servers be like', check = 'misc:rpserversbelike'}, {text = 'kill feed', type = 'checkbox', bind = 'misc:kill feed', check = 'misc:killfeed'}, {text = 'anti aim', type = 'checkbox', bind = 'misc:anti aim', check = 'misc:antiaim'}, {text = 'fake roll', type = 'checkbox', bind = 'misc:fake roll', check = 'misc:fakeroll'}, {text = 'fake crouch', type = 'checkbox', bind = 'misc:fake crouch', check = 'misc:fakecrouch'}, {text = 'lagging', type = 'checkbox', bind = 'misc:lagging', check = 'misc:lagging'}, {text = 'roll bug (x)', type = 'checkbox', bind = 'misc:roll bug (x)', check = 'misc:rollbug(x)'}, {text = 'Stick to ground', type = 'checkbox', bind = 'misc:Stick to ground', check = 'misc:Sticktoground'}, {text = 'Always friendly', type = 'checkbox', check = 'misc:Alwaysfriendly'}, {text = 'Infinite CombatRoll', type = 'checkbox', bind = 'misc:Infinite CombatRoll', check = 'misc:InfiniteCombatRoll'}, {text = 'Bunny Hop', type = 'checkbox', bind = 'misc:Bunny Hop', check = 'misc:BunnyHop'}, {text = 'Jump Delay', type = 'slider', bind = '', speed = 7, index = Kentas.F.Sliders['jump-delay']}, {text = 'get own ped', type = 'button', bind = 'misc:get own ped', func = Kentas.F.Funcs.getownped}, {text = 'recruit swat team', type = 'button', bind = 'misc:recruit swat team', func = Kentas.F.Funcs.recruitswatteam}, {text = 'WOT War', type = 'button', bind = 'misc:wotwar', func = Kentas.F.Funcs.wotwar}, {text = 'recruit k9', type = 'button', bind = 'misc:recruit k9', func = Kentas.F.Funcs.recruitk9}, {text = 'area', type = 'sepa', bind = ''}, {text = 'clear peds', type = 'button', bind = 'misc:clear peds', func = Kentas.F.Funcs.ClearPeds}, {text = 'clear objects', type = 'button', bind = 'misc:clear objects', func = Kentas.F.Funcs.ClearObjects}, {text = 'clear vehicles', type = 'button', bind = 'misc:clear vehicles', func = Kentas.F.Funcs.ClearVehs}, {text = 'other', type = 'sepa', bind = ''}, {text = 'stop cutscene', type = 'button', bind = 'misc:stop cutscene', func = Kentas.F.Funcs.stopcutscene}, --{text = 'set snow level', type = 'button', bind = 'misc:set snow level', func = Kentas.F.Funcs.setsnowlevel}, {text = 'Taze Time', type = 'combo', index = Kentas.F.Combos['TazeTime'], func = function() __CitIn__.InvokeNative(0xFA0675AB151073FA,

Kentas.F.Tables.PlayerPedId(), Kentas.F.Combos['TazeTime'].b[Kentas.F.Combos['Taze-Time'].a]) end}, {text = 'Road detector', type = 'checkbox', bind = 'misc:Road detector', check = 'misc:Roaddetector'}, {text = 'Vehicle detector', type = 'checkbox', bind = 'misc:Vehicle detector', check = 'misc:Vehicledetector'}, {text = 'Event logger', type = 'checkbox', bind = 'misc:Event logger', check = 'misc:Eventlogger'}, {text = 'Freecam Options', type = 'submenu', bind = 'main:Freecam Options', menu = 'Freecam'}, {text = 'Remote Car', type = 'submenu', bind = 'main:Remote Car', menu = 'RemoteCar'}, {text = 'Remote Ped', type = 'submenu', bind = 'main:Remote Ped', menu = 'RemotePed'}, {text = 'Bypass', type = 'submenu', bind = 'main:Bypass', menu = 'Bypass'}, {text = 'Controls', type = 'submenu', bind = 'main:Controls', menu = 'Controls'}, {text = 'World Colour', type = 'submenu', bind = 'main:World Colour', menu = 'WorldColour'}, {text = 'time', type = 'sepa', bind = ''}, {text = 'synchronize time with system', type = 'button', bind = 'misc:synchronize time', func = Kentas.F.Funcs.synchronizetime}, {text = 'Hour', type = 'combo', index = Kentas.F.Combos['timehours'], func = Kentas.F.Funcs.combo_nil}, {text = 'Minute', type = 'combo', index = Kentas.F.Combos['timeminute'], func = Kentas.F.Funcs.combo_nil}, {text = 'Seconds', type = 'combo', index = Kentas.F.Combos['timeSeconds'], func = Kentas.F.Funcs.combo_nil}, {text = 'set time', type = 'button', bind = 'misc:set time', func = Kentas.F.Funcs.setthistime}, }, }, ['RemotePed'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Remote control ped", parentmenu = 'Miscellaneous', options = { {text = 'Remote ped', type = 'checkbox', bind = 'misc:Remote ped', check = 'misc:Remoteped'}, }, }, ['Stateditor'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Stat editor", parentmenu = 'Miscellaneous', options = { {text = 'Strength', type = 'combo', index = Kentas.F.Combos['Strength-stat'], func = Kentas.F.Funcs.combo_Strength}, {text = 'Stamina', type = 'combo', index = Kentas.F.Combos['Stamina-stat'], func = Kentas.F.Funcs.combo_Stamina}, {text = 'Lung', type = 'combo', index = Kentas.F.Combos['Lungstat'], func = Kentas.F.Funcs.combo_Lung}, {text = 'Shooting', type = 'combo', index = Kentas.F.Combos['Shooting-stat'], func = Kentas.F.Funcs.combo_Shooting}, {text = 'Wheelie', type = 'combo', index = Kentas.F.Combos['Wheelie-stat'], func = Kentas.F.Funcs.combo_Wheelie}, {text = 'Driving', type = 'combo', index = Kentas.F.Combos['Driving-stat'], func = Kentas.F.Funcs.combo_Driving}, {text = 'Flying', type = 'combo', index = Kentas.F.Combos['Flying-

stat'], func = Kentas.F.Funcs.combo_Flying}, }, }, ['Dumper'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Resource Dumper", parentmenu = 'Miscellaneous', options = { }, }, ['WorldColour'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "World Colour", parentmenu = 'Miscellaneous', options = { {text = 'Colour it', type = 'checkbox', bind = 'wc:Colour it', check = 'wc:Colourit'}, {text = 'range', type = 'slider', bind = '', speed = 4, index = Kentas.F.Sliders['wc-range']}, {text = 'shadow', type = 'slider', bind = '', speed = 0.1, index = Kentas.F.Sliders['wc-shadow']}, {text = 'colour', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['wc-r']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['wc-g']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['wc-b']}, }, }, ['animations'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "animations", parentmenu = 'Miscellaneous', options = { {text = 'Animation', type = 'combo', index = Kentas.F.Combos['Animations'], func = Kentas.F.Funcs.playanimation, xd = true}, {text = 'Stop animations', type = 'button', bind = 'anims:Stop animations', func = Kentas.F.Funcs.Stopanimations}, {text = 'looped', type = 'checkbox', bind = 'anims:looped', check = 'anims:looped'}, {text = 'loop delay', type = 'slider', bind = '', speed = 4, index = Kentas.F.Sliders['anims-loopdelay']}, }, }, ['Controls'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Controls", parentmenu = 'Miscellaneous', options = { {text = 'disable all actions', type = 'checkbox', bind = 'ctrls:disallact', check = 'ctrls:disallact'}, {text = 'enable all actions', type = 'checkbox', bind = 'ctrls:enblallact', check = 'ctrls:enblallact'}, {text = 'disable custom action', type = 'button', bind = 'ctrls:customacdis', func = Kentas.F.Funcs.customacdis}, {text = 'enable custom action', type = 'button', bind = 'ctrls:customacenbl', func = Kentas.F.Funcs.customacenbl}, {text = 'disable fire', type = 'checkbox', bind = 'ctrls:disfire', check = 'ctrls:disfire'}, {text = 'enable fire', type = 'checkbox', bind = 'ctrls:enblfire', check = 'ctrls:enblfire'},

}, }, ['Bypass'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Bypass", parentmenu = 'Miscellaneous', options = { {text = 'api-ac', type = 'checkbox', bind = 'bypass:apiac', check = 'bypass:apiac'}, {text = 'gg-ac', type = 'checkbox', bind = 'bypass:ggac', check = 'bypass:ggac'}, {text = 'events', type = 'checkbox', bind = 'bypass:events', check = 'bypass:events'}, {text = 'Recoil', type = 'checkbox', bind = 'bypass:Recoil', check = 'bypass:Recoil'}, {text = 'black screen', type = 'checkbox', bind = 'bypass:bscreen', check = 'bypass:bscreen'}, {text = 'blur', type = 'checkbox', bind = 'bypass:blur', check = 'bypass:blur'}, }, }, ['RemoteCar'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Remote Car", parentmenu = 'Miscellaneous', options = { {text = 'vehicle', type = 'button', bind = 'rccar:vehicle', func = Kentas.F.Funcs.vehiclerc}, }, }, ['Freecam'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Freecam", parentmenu = 'Miscellaneous', options = { {text = 'freecam', type = 'checkbox', bind = 'misc:freecam', check = 'misc:freecam'}, {text = 'freecam coords', type = 'checkbox', bind = 'misc:freecamcoords', check = 'misc:freecamcoords'}, {text = 'fov', type = 'slider', bind = '', speed = 2, index = Kentas.F.Sliders['freecam-fov']}, {text = 'speed', type = 'slider', bind = '', speed = 0.2, index = Kentas.F.Sliders['freecam-speed']}, }, }, ['100k or die'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "100k or die options", parentmenu = 'main', options = { {text = 'Outfit', type = 'button', bind = '100kordie:Outfit', func = Kentas.F.Funcs.Outfit100k}, {text = 'loadout', type = 'button', bind = '100kordie:loadout', func = Kentas.F.Funcs.loadout100k}, {text = 'vehicle', type = 'button', bind = '100kordie:vehicle', func = Kentas.F.Funcs.vehicle100k}, {text = 'teleport options', type = 'sepa', bind = ''}, {text = 'redzone', type = 'button', bind = '100kordie:redzone', func = Kentas.F.Funcs.redzone100k}, {text = 'Weed', type = 'button', bind = '100kordie:Weed', func = Kentas.F.Funcs.Weed100k}, {text = 'Lean', type = 'button', bind = '100kordie:Lean', func =

Kentas.F.Funcs.Lean100k}, {text = 'Meth', type = 'button', bind = '100kordie:Meth', func = Kentas.F.Funcs.Meth100k}, {text = 'Coke', type = 'button', bind = '100kordie:Coke', func = Kentas.F.Funcs.Coke100k}, {text = 'Opium', type = 'button', bind = '100kordie:Opium', func = Kentas.F.Funcs.Opium100k}, --{text = 'other', type = 'sepa', bind = ''}, }, }, ['Cheater Protection'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Cheater Protection", parentmenu = 'main', options = { {text = 'Clear Props', type = 'button', bind = 'cheaterprotection:clearprops', func = Kentas.F.Funcs.ClearProps}, {text = 'Anti Particles', type = 'checkbox', bind = 'cheaterprotection:antipart', check = 'cheaterprotection:antipart'}, {text = 'Anti Freeze', type = 'checkbox', bind = 'cheaterprotection::antifreeze', check = 'cheaterprotection:antifreeze'}, {text = 'Anti Crash', type = 'checkbox', bind = 'cheaterprotection:anticrash', check = 'cheaterprotection:anticrash'}, {text = 'Anti Cage', type = 'checkbox', bind = 'cheaterprotection::anticage', check = 'cheaterprotection:anticage'}, {text = 'Anti Fire', type = 'checkbox', bind = 'cheaterprotection::antifire', check = 'cheaterprotection:antifire'}, {text = 'Anti Attach', type = 'checkbox', bind = 'cheaterprotection::antiattach', check = 'cheaterprotection:antiattach'}, {text = 'Anti Clone', type = 'checkbox', bind = 'cheaterprotection::anticlone', check = 'cheaterprotection:anticlone'}, {text = 'Anti Teleport', type = 'checkbox', bind = 'cheaterprotection::antitele', check = 'cheaterprotection:antitele'}, }, }, ['Glife'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Glife options", parentmenu = 'main', options = { }, }, ['Vehicle'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Vehicle options", parentmenu = 'main', options = { {text = 'Add tracker to vehicle', type = 'checkbox', bind = 'vehicle:Add tracker to vehicle', check = 'vehicle:Addtrackertovehicle'}, {text = 'Mors Mutual Insurance', type = 'button', bind = 'vehicle:Mors Mutual Insurance', func = Kentas.F.Funcs.MorsMutualInsurance}, {text = 'spawner', type = 'sepa', bind = ''}, {text = 'Addon Cars', type = 'submenu', bind = 'main:Addon Cars', menu = 'AddonCars'}, {text = 'Premade Cars', type = 'submenu', bind = 'main:Premade Cars', menu = 'PremadeCars'}, {text = 'Ramp', type = 'submenu', bind = 'main:Ramp', menu = 'Ramp'}, {text = 'Spawn vehicle', type = 'button', bind = 'vehicle:Spawn vehicle', func = Kentas.F.Funcs.Spawnvehicle}, {text = 'Upgrades', type = 'sepa', bind = ''},

{text = 'Tuning Upgrade', type = 'button', bind = 'vehicle:TuningUpgrade', func = Kentas.F.Funcs.TuningUpgrade}, {text = 'Body Upgrade', type = 'button', bind = 'vehicle:BodyUpgrade', func = Kentas.F.Funcs.BodyUpgrade}, {text = 'Repair vehicle', type = 'button', bind = 'vehicle:Repairvehicle', func = Kentas.F.Funcs.Repairvehicle}, {text = 'Multipliers', type = 'sepa', bind = ''}, {text = 'Torque Multi', type = 'checkbox', bind = 'vehicle:Torque Multi', check = 'vehicle:TorqueMulti'}, {text = 'Torque Multi', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['torque']}, {text = 'Power Multi', type = 'checkbox', bind = 'vehicle:Power Multi', check = 'vehicle:PowerMulti'}, {text = 'Power Multi', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['power']}, {text = 'basic', type = 'sepa', bind = ''}, {text = 'vehicle max speed', type = 'combo', index = Kentas.F.Combos['vehiclemaxspeed'], func = Kentas.F.Funcs.setentitymaxspeeed}, {text = 'instant brakes', type = 'checkbox', bind = 'vehicle:instant brakes', check = 'vehicle:instantbrakes'}, {text = 'no fall', type = 'checkbox', bind = 'vehicle:no fall', check = 'vehicle:nofall'}, {text = 'Lock Vehicle', type = 'button', bind = 'vehicle:Lock vehicle', func = Kentas.F.Funcs.Lockvehicle}, {text = 'Unlock Vehicle', type = 'button', bind = 'vehicle:Unlock vehicle', func = Kentas.F.Funcs.Unlockvehicle}, {text = 'Clean Vehicle', type = 'button', bind = 'vehicle:Clean vehicle', func = Kentas.F.Funcs.Cleanvehicle}, {text = 'Flip Vehicle', type = 'button', bind = 'vehicle:Flip vehicle', func = Kentas.F.Funcs.Flipvehicle}, {text = 'Random Colour', type = 'button', bind = 'vehicle:Random Colour', func = Kentas.F.Funcs.RandomColour}, {text = 'Break Engine', type = 'button', bind = 'vehicle:Break Engine', func = Kentas.F.Funcs.BreakEngine}, {text = 'Change Plate Vehicle', type = 'button', bind = 'vehicle:Change Plate Vehicle', func = Kentas.F.Funcs.ChangePlateVehicle}, {text = 'Delete Vehicle', type = 'button', bind = 'vehicle:Delete Vehicle', func = Kentas.F.Funcs.DeleteVehicle}, {text = 'Sticky car', type = 'checkbox', bind = 'vehicle:Sticky car', check = 'vehicle:Stickycar'}, {text = 'Auto Drive', type = 'checkbox', bind = 'vehicle:Auto Drive', check = 'vehicle:AutoDrive'}, {text = 'Modifiers', type = 'sepa', bind = ''}, {text = 'Vehicle Godmode', type = 'checkbox', bind = 'vehicle:Vehicle Godmode', check = 'vehicle:VehicleGodmode'}, {text = 'Advanced Handling', type = 'checkbox', bind = 'vehicle:Advanced Handling', check = 'vehicle:AdvancedHandling'}, {text = 'Horn Boost', type = 'checkbox', bind = 'vehicle:HornBoost', check = 'vehicle:HornBoost'}, {text = 'Bunny Hop', type = 'checkbox', bind = 'vehicle:Bunny Hop', check = 'vehicle:BunnyHop'}, {text = 'Drift Mode', type = 'checkbox', bind = 'vehicle:Drift Mode', check = 'vehicle:DriftMode'}, {text = 'Rainbow car', type = 'checkbox', bind = 'vehicle:Rainbow car', check = 'vehicle:Rainbowcar'}, {text = 'Misc', type = 'sepa', bind = ''}, {text = 'Bulletproof car', type = 'checkbox', bind = 'vehicle:Bulletproof car', check = 'vehicle:Bulletproofcar'}, {text = 'Invisible Car', type = 'checkbox', bind =

'vehicle:Invisible car', check = 'vehicle:Invisiblecar'}, {text = 'Auto Clean', type = 'checkbox', bind = 'vehicle:AutoClean', check = 'vehicle:AutoClean'}, {text = 'Always Wheelie', type = 'checkbox', bind = 'vehicle:Always Wheelie', check = 'vehicle:AlwaysWheelie'}, {text = 'Anti-Gravity', type = 'checkbox', bind = 'vehicle:AntiGravity', check = 'vehicle:Anti-Gravity'}, {text = 'No Collision', type = 'checkbox', bind = 'vehicle:No Collision', check = 'vehicle:NoCollision'}, {text = 'Other', type = 'sepa', bind = ''}, {text = 'instant sit in car', type = 'checkbox', check = 'misc:instantsitincar'}, {text = 'Toggle Engine', type = 'checkbox', bind = 'vehicle:Toggle Engine', check = 'vehicle:ToggleEngine'}, {text = 'Engine Sound', type = 'combo', index = Kentas.F.Combos['EngineSound'], func = Kentas.F.Funcs.combo_setenginesound}, {text = 'Wheel Size', type = 'button', bind = 'vehicle:Wheel Size', func = Kentas.F.Funcs.WheelSize}, {text = 'Suspension Height', type = 'button', bind = 'vehicle:Suspension Height', func = Kentas.F.Funcs.SuspensionHeight}, {text = 'Light Intensity', type = 'button', bind = 'vehicle:Light Intensity', func = Kentas.F.Funcs.LightIntensity}, {text = 'Primary Colour', type = 'button', bind = 'vehicle:Primary Colour', func = Kentas.F.Funcs.PrimaryColour}, {text = 'Seconadry Colour', type = 'button', bind = 'vehicle:Seconadry Colour', func = Kentas.F.Funcs.SeconadryColour}, }, }, ['AddonCars'] = {selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Addon vehicle options", parentmenu = 'Vehicle', options = {}}, ['Ramp'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Ramps", parentmenu = 'Vehicle', options = { {text = 'Prop', type = 'combo', index = Kentas.F.Combos['RampProp'], func = Kentas.F.Funcs.combo_nil}, {text = 'Attach', type = 'combo', index = Kentas.F.Combos['RampStyle'], func = Kentas.F.Funcs.combo_spawnramp}, {text = 'Detach', type = 'button', bind = 'ramps:Detach', func = Kentas.F.Funcs.rampsdetach}, }, }, ['PremadeCars'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Premade Cars", parentmenu = 'Vehicle', options = { {text = 'nero', type = 'button', bind = 'premadecars:nero', func = Kentas.F.Funcs.premadecarsNero}, {text = 'James Bond', type = 'button', bind = 'premadecars:jamesbond', func = Kentas.F.Funcs.premadecarsJB}, {text = 'Transformer', type = 'button', bind = 'premadecars:Transformer', func = Kentas.F.Funcs.premadecarsTransformer}, }, }, ['Weapon'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Weapon options", parentmenu = 'main', options = { {text = 'Weapon Spawning', type = 'submenu', bind =

'main:WeaponSpawning', menu = 'WeaponSpawning'}, {text = 'Weapon Customization', type = 'submenu', bind = 'main:WeaponCustomization', menu = 'WeaponCustomization'}, {text = 'Custom Ammo', type = 'submenu', bind = 'main:CustomAmmo', menu = 'CustomAmmo'}, {text = 'Rapid Fire', type = 'checkbox', bind = 'weapon:Rapid Fire', check = 'weapon:RapidFire'}, {text = 'Hit Marker', type = 'checkbox', bind = 'weapon:Hit Marker', check = 'weapon:HitMarker'}, {text = 'Hit Sound', type = 'checkbox', bind = 'weapon:Hit Sound', check = 'weapon:HitSound'}, {text = 'aimbot', type = 'sepa', bind = ''}, --{text = 'aimbot keybind', stext = Kentas.F.AimbotKeybindl, type = 'button', bind = 'weapon:aimbot keybind', func = Kentas.F.Funcs.AimbotKeybind}, {text = 'Aimbot', type = 'checkbox', bind = 'weapon:Aimbot', check = 'weapon:Aimbot'}, {text = 'Aimbot type', type = 'combo', index = Kentas.F.Combos['Aimbot type'], func = Kentas.F.Funcs.combo_nil}, {text = 'damage', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['aimbot-damage']}, {text = 'hit chance', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['aimbot-hitchance']}, {text = 'fov', type = 'submenu', bind = 'main:fov', menu = 'fov'}, {text = 'Aimbot distance', type = 'slider', bind = '', speed = 25, index = Kentas.F.Sliders['aimbot-distance']}, {text = 'triggerbot', type = 'sepa', bind = ''}, {text = 'Triggerbot', type = 'checkbox', bind = 'weapon:Triggerbot', check = 'weapon:Triggerbot'}, {text = 'Bone', type = 'combo', index = Kentas.F.Combos['Bone'], func = Kentas.F.Funcs.combo_nil}, {text = 'Friends', type = 'submenu', bind = 'main:Friends', menu = 'Friends'}, }, }, ['fov'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "fov", parentmenu = 'Weapon', options = { {text = 'Draw fov', type = 'checkbox', bind = 'weapon:Draw fov', check = 'weapon:Drawfov'}, {text = 'Aimbot fov', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['aimbot-fov']}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['FOV-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['FOV-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['FOV-B']}, }, }, ['Friends'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Aimbot Friends", parentmenu = 'Weapon', options = { {text = 'Show friends', type = 'checkbox', bind = 'weapon:Show friends', check = 'weapon:Showfriends'}, }, },

['CustomAmmo'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Ammo Customization", parentmenu = 'Weapon', options = { {text = 'ammo value', type = 'button', bind = 'customammo:ammo', func = Kentas.F.Funcs.ammoadd}, {text = 'Infinite Ammo', type = 'checkbox', bind = 'customammo:Infinite Ammo', check = 'customammo:InfiniteAmmo'}, {text = 'customization', type = 'sepa', bind = ''}, {text = 'save point', type = 'checkbox', bind = 'customammo:save point', check = 'customammo:savepoint'}, {text = 'tracers', type = 'checkbox', bind = 'customammo:tracers', check = 'customammo:tracers'}, {text = 'tracers timer', type = 'slider', bind = '', speed = 500, index = Kentas.F.Sliders['tracers-timer']}, {text = 'colour ammo', type = 'checkbox', bind = 'customammo:colour ammo', check = 'customammo:colourammo'}, {text = 'colour timer', type = 'slider', bind = '', speed = 500, index = Kentas.F.Sliders['colour-timer']}, {text = 'airstrike ammo', type = 'checkbox', bind = 'customammo:airstrike ammo', check = 'customammo:airstrikeeammo'}, --{text = 'black hole', type = 'checkbox', bind = 'customammo:black hole', check = 'customammo:blackholeammo'}, {text = 'no collision ammo', type = 'checkbox', bind = 'customammo:no collision ammo', check = 'customammo:nocollisionammo'}, {text = 'freeze ammo', type = 'checkbox', bind = 'customammo:freeze ammo', check = 'customammo:freezeammo'}, {text = 'Explosive Ammo', type = 'checkbox', bind = 'customammo:Explosive Ammo', check = 'customammo:ExplosiveAmmo'}, {text = 'Firework Ammo', type = 'checkbox', bind = 'customammo:Firework Ammo', check = 'customammo:FireworkAmmo'}, {text = 'Steam Ammo', type = 'checkbox', bind = 'customammo:Steam Ammo', check = 'customammo:SteamAmmo'}, {text = 'Flame Ammo', type = 'checkbox', bind = 'customammo:Flame Ammo', check = 'customammo:FlameAmmo'}, {text = 'Oil Slick Ammo', type = 'checkbox', bind = 'customammo:Oil Slick Ammo', check = 'customammo:OilSlickAmmo'}, {text = 'Hydrant Ammo', type = 'checkbox', bind = 'customammo:Hydrant Ammo', check = 'customammo:HydrantAmmo'}, {text = 'Flare Ammo', type = 'checkbox', bind = 'customammo:Flare Ammo', check = 'customammo:FlareAmmo'}, {text = 'Raygun Ammo', type = 'checkbox', bind = 'customammo:Raygun Ammo', check = 'customammo:RaygunAmmo'}, {text = 'Snowball Ammo', type = 'checkbox', bind = 'customammo:Snowball Ammo', check = 'customammo:SnowballAmmo'}, {text = 'Bird Poo Ammo', type = 'checkbox', bind = 'customammo:Bird Poo Ammo', check = 'customammo:BirdPooAmmo'}, {text = 'particle ammo', type = 'sepa', bind = ''}, {text = 'Particle size', type = 'slider', bind = '', speed = 0.2, index = Kentas.F.Sliders['size-of-particle-ammo']}, {text = 'Fire', type = 'checkbox', bind = 'pammo:Fire', check = 'pammo:Fire'}, {text = 'Stars', type = 'checkbox', bind = 'pammo:Stars', check = 'pammo:Stars'}, {text = 'bubble gum', type = 'checkbox', bind = 'pammo:bubble gum', check = 'pammo:bubblegum'}, {text = 'oranges', type = 'checkbox', bind = 'pammo:oranges', check = 'pammo:oranges'},

{text = 'Fireworks', type = 'checkbox', bind = 'pammo:Fireworks', check = 'pammo:Fireworks'}, {text = 'Smoke', type = 'checkbox', bind = 'pammo:Smoke', check = 'pammo:Smoke'}, {text = 'Clown', type = 'checkbox', bind = 'pammo:Clown', check = 'pammo:Clown'}, {text = 'Water', type = 'checkbox', bind = 'pammo:Water', check = 'pammo:Water'}, {text = 'Dirt', type = 'checkbox', bind = 'pammo:Dirt', check = 'pammo:Dirt'}, {text = 'Alien', type = 'checkbox', bind = 'pammo:Alien', check = 'pammo:Alien'}, {text = 'Explosion', type = 'checkbox', bind = 'pammo:Explosion', check = 'pammo:Explosion'}, {text = 'Blood', type = 'checkbox', bind = 'pammo:Blood', check = 'pammo:Blood'}, {text = 'yellow smoke', type = 'checkbox', bind = 'pammo:yellow smoke', check = 'pammo:yellowsmoke'}, {text = 'Flower', type = 'checkbox', bind = 'pammo:Flower', check = 'pammo:Flower'}, {text = 'Cartoon', type = 'checkbox', bind = 'pammo:Cartoon', check = 'pammo:Cartoon'}, }, }, ['WeaponCustomization'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Weapon Customization", parentmenu = 'Weapon', options = { {text = 'Double tap', type = 'checkbox', bind = 'weaponcustomization:double tap', check = 'weaponcustomization:doubletap'}, {text = 'Disable reload', type = 'checkbox', bind = 'weaponcustomization:Disable reload', check = 'weaponcustomization:Disablereload'}, {text = 'invisible weapon', type = 'checkbox', bind = 'weaponcustomization:invisible weapon', check = 'weaponcustomization:invisible weapon'}, {text = 'force reload', type = 'button', bind = 'weaponcustomization:force reload', func = Kentas.F.Funcs.forcereload}, {text = 'add suppressor', type = 'button', bind = 'weaponcustomization:suppressor', func = Kentas.F.Funcs.addsuppressor}, {text = 'add extended clip', type = 'button', bind = 'weaponcustomization:extendedclip', func = Kentas.F.Funcs.addextendedclip}, {text = 'add flashlight', type = 'button', bind = 'weaponcustomization:suppressor', func = Kentas.F.Funcs.addflashlight}, {text = 'add scope', type = 'button', bind = 'weaponcustomization:suppressor', func = Kentas.F.Funcs.addscope}, }, }, ['WeaponSpawning'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Weapon Spawning", parentmenu = 'Weapon', options = { {text = 'Give custom weapon', type = 'button', bind = 'weaponspawning:Givecustomweapon', func = Kentas.F.Funcs.GiveCustomWeapon}, {text = 'Remove weapon in hand', type = 'button', bind = 'weaponspawning:Removeweapon', func = Kentas.F.Funcs.RemoveWeapon}, {text = 'Give all weapons', type = 'button', bind = 'weaponspawning:Giveallweapons', func = Kentas.F.Funcs.GiveAllWeapons},

{text = 'Remove all weapons', type = 'button', bind = 'weaponspawning:Removeallweapons', func = Kentas.F.Funcs.RemoveAllWeapons}, {text = 'list', type = 'sepa', bind = ''}, {text = 'Melees', type = 'combo', index = Kentas.F.Combos['Melees'], func = Kentas.F.Funcs.combo_spawnmelee}, {text = 'Handguns', type = 'combo', index = Kentas.F.Combos['Handguns'], func = Kentas.F.Funcs.combo_spawnhandgun}, {text = 'SMG', type = 'combo', index = Kentas.F.Combos['SMG'], func = Kentas.F.Funcs.combo_spawnSMG}, {text = 'Rifles', type = 'combo', index = Kentas.F.Combos['Rifle'], func = Kentas.F.Funcs.combo_spawnRifle}, {text = 'Shotguns', type = 'combo', index = Kentas.F.Combos['Shotguns'], func = Kentas.F.Funcs.combo_spawnShotguns}, {text = 'Heavy', type = 'combo', index = Kentas.F.Combos['Heavy'], func = Kentas.F.Funcs.combo_spawnHeavy}, {text = 'Snipers', type = 'combo', index = Kentas.F.Combos['Snipers'], func = Kentas.F.Funcs.combo_spawnSnipers}, {text = 'Throwable', type = 'combo', index = Kentas.F.Combos['Throwable'], func = Kentas.F.Funcs.combo_spawnThrowable}, }, }, ['self'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Self options", parentmenu = 'main', options = { {text = 'revive', type = 'button', bind = 'self:revive', func = Kentas.F.Funcs.revive}, {text = 'suicide', type = 'button', bind = 'self:suicide', func = Kentas.F.Funcs.suicide}, {text = 'Health', type = 'combo', index = Kentas.F.Combos['SetHP'], func = Kentas.F.Funcs.combo_setentityhhealth}, {text = 'Armour', type = 'combo', index = Kentas.F.Combos['SetArmour'], func = Kentas.F.Funcs.combo_setpedarmour}, --{text = 'refill health', type = 'button', bind = 'self:refill health', func = Kentas.F.Funcs.refillhp}, --{text = 'refill armour', type = 'button', bind = 'self:refill armour', func = Kentas.F.Funcs.refillarm}, {text = 'Clean Ped', type = 'button', bind = 'self:Clean Ped', func = Kentas.F.Funcs.cleanped}, {text = 'AUTOMATED SYSTEM', type = 'sepa', bind = ''}, {text = 'Heal delay', type = 'slider', bind = '', speed = 100, index = Kentas.F.Sliders['heal']}, {text = 'Auto Heal', type = 'checkbox', bind = 'self:Auto Heal', check = 'self:autoheal'}, {text = 'Armour delay', type = 'slider', bind = '', speed = 100, index = Kentas.F.Sliders['armour']}, {text = 'Auto Armour', type = 'checkbox', bind = 'self:Auto Armour', check = 'self:autoarmour'}, {text = 'basic', type = 'sepa', bind = ''}, {text = 'Wardrobe', type = 'submenu', bind = 'main:Wardrobe', menu = 'Wardrobe'}, {text = 'Models', type = 'submenu', bind = 'main:Models', menu = 'Models'}, {text = 'Godmode', type = 'submenu', bind = 'main:Godmode', menu = 'Godmode'}, {text = 'Noclip', type = 'checkbox', bind = 'self:Noclip', check = 'self:noclip'}, {text = 'noclip speed', type = 'slider', bind = '', speed = 0.1, index = Kentas.F.Sliders['self-noclipspeed']},

{text = 'Invisible', type = 'checkbox', bind = 'self:Invisible', check = 'self:invisible'}, {text = 'Modifiers', type = 'sepa', bind = ''}, {text = 'Fastrun', type = 'checkbox', bind = 'self:Fastrun', check = 'self:fastrun'}, {text = 'Fastrun speed', type = 'slider', bind = '', speed = 0.01, index = Kentas.F.Sliders['FastRun']}, {text = 'Slide Mode', type = 'checkbox', bind = 'self:Slide Mode', check = 'self:slidemode'}, {text = 'slide mode speed', type = 'slider', bind = '', speed = 0.5, index = Kentas.F.Sliders['SlideMode']}, {text = 'Super Jump', type = 'checkbox', bind = 'self:Super Jump', check = 'self:superjump'}, {text = 'Infinite Stamina', type = 'checkbox', bind = 'self:Infinite Stamina', check = 'self:infinitestamina'}, {text = 'Tiny Player', type = 'checkbox', bind = 'self:Tiny Player', check = 'self:tinyplayer'}, {text = 'Powers', type = 'submenu', bind = 'main:Powers', menu = 'Powers'}, {text = 'spider man', type = 'checkbox', bind = 'self:spider man', check = 'self:tpwhereyoulooking'}, {text = 'Teleport', type = 'sepa', bind = ''}, {text = 'to waypoint', type = 'button', bind = 'self:tptowaypoint', func = Kentas.F.Funcs.tptowaypoint}, {text = 'to coords', type = 'button', bind = 'self:tptocoords', func = Kentas.F.Funcs.tptocoords}, {text = 'to nearest vehicle', type = 'button', bind = 'self:nearestveh', func = Kentas.F.Funcs.tptonearestveh}, {text = 'Locations', type = 'submenu', bind = 'main:Locations', menu = 'Locations'}, --{text = 'to custom location', type = 'combo', index = Kentas.F.Combos['CustomLocation'], func = Kentas.F.Funcs.combo_tptocustomloc}, {text = 'other', type = 'sepa', bind = ''}, {text = 'wanted level', type = 'combo', index = Kentas.F.Combos['wantedlevel'], func = Kentas.F.Funcs.combo_setwantedlevel}, {text = 'Ragdoll', type = 'checkbox', bind = 'self:Ragdoll', check = 'self:Ragdoll'}, {text = 'Anti-Ragdoll', type = 'checkbox', bind = 'self:AntiRagdoll', check = 'self:AntiRagdoll'}, {text = 'Anti-Taze', type = 'checkbox', bind = 'self:Anti-Taze', check = 'self:AntiTaze'}, {text = 'Anti-AFK', type = 'checkbox', bind = 'self:Anti-AFK', check = 'self:AntiAFK'}, {text = 'Anti-Headshot', type = 'checkbox', bind = 'self:AntiHeadshot', check = 'self:AntiHeadshot'}, {text = 'Anti-Drown', type = 'checkbox', bind = 'self:Anti-Drown', check = 'self:AntiDrown'}, {text = 'SlowMotion', type = 'checkbox', bind = 'self:SlowMotion', check = 'self:SlowMotion'}, {text = 'Skinchanger', type = 'button', bind = 'self:Skinchanger', func = Kentas.F.Funcs.Skinchanger}, {text = 'random Outfit', type = 'button', bind = 'self:randomOutfit', func = Kentas.F.Funcs.randomOutfit}, }, }, ['Locations'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Locations in GTA", parentmenu = 'self',

options = { {text = 'Ammunation', type = 'button', bind = 'customtp:Ammunation', func = Kentas.F.Funcs.tocustomlocation, result = vector3(22.09, -1107.28, 29.80)}, {text = 'Clothes Store', type = 'button', bind = 'customtp:Clothes Store', func = Kentas.F.Funcs.tocustomlocation, result = vector3(72.37259, 1398.917, 29.37615)}, {text = 'BarberShop', type = 'button', bind = 'customtp:BarberShop', func = Kentas.F.Funcs.tocustomlocation, result = vector3(137.7472, -1708.629, 29.30161)}, {text = 'Car Dealer', type = 'button', bind = 'customtp:Car Dealer', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-32.6915, 1097.226, 26.43849)}, {text = 'bunkers', type = 'sepa', bind = ''}, {text = 'Zancudo', type = 'button', bind = 'customtp:Zancudo', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-3058.714, 3329.19, 12.5844)}, {text = 'Route68', type = 'button', bind = 'customtp:Route68', func = Kentas.F.Funcs.tocustomlocation, result = vector3(24.43542, 2959.705, 58.35517)}, {text = 'Oilfields', type = 'button', bind = 'customtp:Oilfields', func = Kentas.F.Funcs.tocustomlocation, result = vector3(481.0465, 2995.135, 43.96672)}, {text = 'Desert', type = 'button', bind = 'customtp:Desert', func = Kentas.F.Funcs.tocustomlocation, result = vector3(848.6175, 2996.567, 45.81612)}, {text = 'SmokeTree', type = 'button', bind = 'customtp:SmokeTree', func = Kentas.F.Funcs.tocustomlocation, result = vector3(2126.785, 3335.04, 48.21422)}, {text = 'Scrapyard', type = 'button', bind = 'customtp:Scrapyard', func = Kentas.F.Funcs.tocustomlocation, result = vector3(2493.654, 3140.399, 51.28789)}, {text = 'Grapeseed', type = 'button', bind = 'customtp:Grapeseed', func = Kentas.F.Funcs.tocustomlocation, result = vector3(1823.961, 4708.14, 42.4991)}, {text = 'Palleto', type = 'button', bind = 'customtp:Palleto', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-783.0755, 5934.686, 24.31475)}, {text = 'Route1', type = 'button', bind = 'customtp:Route1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-3180.466, 1374.192, 19.9597)}, {text = 'Farmhouse', type = 'button', bind = 'customtp:Farmhouse', func = Kentas.F.Funcs.tocustomlocation, result = vector3(1570.372, 2254.549, 78.89397)}, {text = 'RatonCanyon', type = 'button', bind = 'customtp:RatonCanyon', func = Kentas.F.Funcs.tocustomlocation, result = vector3(391.3216, 4363.728, 58.65862)}, {text = 'Apartments', type = 'sepa', bind = ''}, {text = 'Modern 1', type = 'button', bind = 'customtp:Modern 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.8663, 315.7642, 217.6385)}, {text = 'Modern 2', type = 'button', bind = 'customtp:Modern 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.9563, 315.6229, 187.9136)}, {text = 'Modern 3', type = 'button', bind = 'customtp:Modern 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-774.0126, 342.0428, 196.6864)}, {text = 'Mody 1', type = 'button', bind = 'customtp:Mody 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.0749, 315.8198, 217.6386)}, {text = 'Mody 2', type = 'button', bind = 'customtp:Mody 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.8195, 315.5634, 187.9137)}, {text = 'Mody 3', type = 'button', bind = 'customtp:Mody 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-774.1382, 342.0316, 196.6864)},

{text = 'Vibrant 1', type = 'button', bind = 'customtp:Vibrant 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.6245, 315.6175, 217.6385)}, {text = 'Vibrant 2', type = 'button', bind = 'customtp:Vibrant 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.9584, 315.7974, 187.9135)}, {text = 'Vibrant 3', type = 'button', bind = 'customtp:Vibrant 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-774.0223, 342.1718, 196.6863)}, {text = 'Sharp 1', type = 'button', bind = 'customtp:Sharp 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.0902, 315.7039, 217.6384)}, {text = 'Sharp 2', type = 'button', bind = 'customtp:Sharp 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.0155, 315.7071, 187.9135)}, {text = 'Sharp 3', type = 'button', bind = 'customtp:Sharp 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-773.8976, 342.1525, 196.6863)}, {text = 'Monochrome 1', type = 'button', bind = 'customtp:Monochrome 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(786.9887, 315.7393, 217.6386)}, {text = 'Monochrome 2', type = 'button', bind = 'customtp:Monochrome 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(786.8809, 315.6634, 187.9136)}, {text = 'Monochrome 3', type = 'button', bind = 'customtp:Monochrome 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(774.0675, 342.0773, 196.6864)}, {text = 'Seductive 1', type = 'button', bind = 'customtp:Seductive 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.1423, 315.6943, 217.6384)}, {text = 'Seductive 2', type = 'button', bind = 'customtp:Seductive 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.0961, 315.815, 187.9135)}, {text = 'Seductive 3', type = 'button', bind = 'customtp:Seductive 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-773.9552, 341.9892, 196.6862)}, {text = 'Regal 1', type = 'button', bind = 'customtp:Regal 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.029, 315.7113, 217.6385)}, {text = 'Regal 2', type = 'button', bind = 'customtp:Regal 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-787.0574, 315.6567, 187.9135)}, {text = 'Regal 3', type = 'button', bind = 'customtp:Regal 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-774.0109, 342.0965, 196.6863)}, {text = 'Aqua 1', type = 'button', bind = 'customtp:Aqua 1', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.9469, 315.5655, 217.6383)}, {text = 'Aqua 2', type = 'button', bind = 'customtp:Aqua 2', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-786.9756, 315.723, 187.9134)}, {text = 'Aqua 3', type = 'button', bind = 'customtp:Aqua 3', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-774.0349, 342.0296, 196.6862)}, {text = 'Maze bank', type = 'sepa', bind = ''}, {text = 'Executive Rich', type = 'button', bind = 'customtp:Executive Rich', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.667, -480.4736, 72.04217)}, {text = 'Executive Cool', type = 'button', bind = 'customtp:Executive Cool', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.542, -480.4011, 72.04211)}, {text = 'Executive Contrast', type = 'button', bind = 'customtp:Executive Contrast', func = Kentas.F.Funcs.tocustomlocation, result =

vector3(-1392.626, -480.4856, 72.04212)}, {text = 'Old Spice Warm', type = 'button', bind = 'customtp:Old Spice Warm', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.617, 480.6363, 72.04208)}, {text = 'Old Spice Classical', type = 'button', bind = 'customtp:Old Spice Classical', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.532, -480.7649, 72.04207)}, {text = 'Old Spice Vintage', type = 'button', bind = 'customtp:Old Spice Vintage', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.611, -480.5562, 72.04214)}, {text = 'Power Broker Ice', type = 'button', bind = 'customtp:Power Broker Ice', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.563, 480.549, 72.0421)}, {text = 'Power Broker Convservative', type = 'button', bind = 'customtp:Power Broker Convservative', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.528, -480.475, 72.04206)}, {text = 'Power Broker Polished', type = 'button', bind = 'customtp:Power Broker Polished', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1392.416, -480.7485, 72.04207)}, {text = 'Special', type = 'sepa', bind = ''}, {text = 'Cargo Ship', type = 'button', bind = 'customtp:Cargo Ship', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-163.3628, 2385.161, 5.999994)}, {text = 'Red Carpet', type = 'button', bind = 'customtp:Red Carpet', func = Kentas.F.Funcs.tocustomlocation, result = vector3(300.5927, 300.5927, 104.3776)}, {text = 'Rekt Stilthouse', type = 'button', bind = 'customtp:Rekt Stilthouse', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-1020.518, 663.27, 153.5167)}, {text = 'Union Depository', type = 'button', bind = 'customtp:Union Depository', func = Kentas.F.Funcs.tocustomlocation, result = vector3(2.6968, 667.0166, 16.13061)}, {text = 'Trevors Trailer', type = 'button', bind = 'customtp:Trevors Trailer', func = Kentas.F.Funcs.tocustomlocation, result = vector3(1975.552, 3820.538, 33.44833)}, {text = 'Stadium', type = 'button', bind = 'customtp:Stadium', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-248.6731, -2010.603, 30.14562)}, {text = 'Max Renda Shop', type = 'button', bind = 'customtp:Max Renda Shop', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-585.8247, 282.72, 35.45475)}, {text = 'Jewel Store', type = 'button', bind = 'customtp:Jewel Store', func = Kentas.F.Funcs.tocustomlocation, result = vector3(-630.07, -236.332, 38.05704)}, {text = 'FIB Lobby', type = 'button', bind = 'customtp:FIB Lobby', func = Kentas.F.Funcs.tocustomlocation, result = vector3(110.4, -744.2, 45.7496)}, }, }, ['Visuals'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Visuals Options", parentmenu = 'main', options = { {text = 'Enable esp', type = 'checkbox', bind = 'visuals:Enable esp', check = 'visuals:enableesp'}, {text = 'include self', type = 'checkbox', bind = 'visuals:include self', check = 'visuals:includeself'}, {text = 'ESP Distance', type = 'slider', bind = '', speed = 25, index = Kentas.F.Sliders['esp-distance']},

{text = 'Extra Sensory Options', type = 'submenu', bind = 'main:ExtraSensoryOptions', menu = 'ExtraSensoryOptions'}, {text = 'Crosshair', type = 'submenu', bind = 'main:Crosshair', menu = 'Crosshair'}, {text = 'Line ESP', type = 'submenu', bind = 'main:Line ESP', menu = 'LineESP'}, {text = 'Boxes ESP', type = 'submenu', bind = 'main:Boxes ESP', menu = 'BoxesESP'}, {text = 'Skeleton ESP', type = 'submenu', bind = 'main:Skeleton ESP', menu = 'SkeletonESP'}, {text = 'Arrow ESP', type = 'submenu', bind = 'main:Arrow ESP', menu = 'ArrowESP'}, {text = 'Glowing ESP', type = 'submenu', bind = 'main:Glowing ESP', menu = 'GlowingESP'}, {text = 'Info ESP', type = 'submenu', bind = 'main:Info ESP', menu = 'InfoESP'}, {text = 'Blip ESP', type = 'submenu', bind = 'main:Blip ESP', menu = 'BlipESP'}, {text = 'Chams', type = 'submenu', bind = 'main:Chams', menu = 'Chams'}, {text = 'Weather', type = 'submenu', bind = 'main:Weather', menu = 'Weather'}, {text = 'Hud colours', type = 'button', bind = 'Visuals:hudcolours', func = Kentas.F.Funcs.hudcolours}, {text = 'Upside down', type = 'checkbox', bind = 'Visuals:Upside down', check = 'Visuals:Upsidedown'}, {text = 'weird rotation', type = 'checkbox', bind = 'Visuals:weird rotation', check = 'Visuals:weirdrotation'}, {text = 'Fov Changer', type = 'checkbox', bind = 'Visuals:Fov Changer', check = 'Visuals:FovChanger'}, {text = 'FOV', type = 'slider', bind = '', speed = 1.0, index = Kentas.F.Sliders['gameplay-fov-changer']}, }, }, ['ArrowESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "ArrowESP ESP", parentmenu = 'Visuals', options = { {text = 'Arrow ESP', type = 'checkbox', bind = 'visuals:ArrowESP', check = 'visuals:ArrowESP'}, {text = 'Floating arrows', type = 'checkbox', bind = 'visuals:FloatingArrowESP', check = 'visuals:FloatingArrowESP'}, {text = 'some cool dot', type = 'checkbox', bind = 'visuals:some cool dot', check = 'visuals:somecooldot'}, {text = 'FOV', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Arrows-FOV']}, {text = 'Size', type = 'slider', bind = '', speed = 0.25, index = Kentas.F.Sliders['Arrows-Size']}, {text = 'COLOUR', {text = 'R', type Kentas.F.Sliders['Arrows-R']}, {text = 'G', type Kentas.F.Sliders['Arrows-G']}, {text = 'B', type Kentas.F.Sliders['Arrows-B']}, }, },

type = 'sepa', bind = ''}, = 'slider', bind = '', speed = 5, index = = 'slider', bind = '', speed = 5, index = = 'slider', bind = '', speed = 5, index =

['SkeletonESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Skeleton ESP", parentmenu = 'Visuals', options = { {text = 'Skeleton', type = 'checkbox', bind = 'visuals:Skeletonesp', check = 'visuals:Skeletonesp'}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Skeleton-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Skeleton-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Skeleton-B']}, }, }, ['Weather'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Weather", parentmenu = 'Visuals', options = { {text = 'Sunny', type = 'button', bind = 'weather:Sunny', func = Kentas.F.Funcs.Sunny}, {text = 'Rainy', type = 'button', bind = 'weather:Rainy', func = Kentas.F.Funcs.Rainy}, {text = 'Cloudy', type = 'button', bind = 'weather:Cloudy', func = Kentas.F.Funcs.Cloudy}, {text = 'Clear', type = 'button', bind = 'weather:Clear', func = Kentas.F.Funcs.Clear}, {text = 'Thunder', type = 'button', bind = 'weather:Thunder', func = Kentas.F.Funcs.Thunder}, {text = 'Foggy', type = 'button', bind = 'weather:Foggy', func = Kentas.F.Funcs.Foggy}, {text = 'XMAS', type = 'button', bind = 'weather:XMAS', func = Kentas.F.Funcs.XMAS}, {text = 'Snowlight', type = 'button', bind = 'weather:Snowlight', func = Kentas.F.Funcs.Snowlight}, {text = 'Blizzard', type = 'button', bind = 'weather:Blizzard', func = Kentas.F.Funcs.Blizzard}, {text = 'Smog', type = 'button', bind = 'weather:Smog', func = Kentas.F.Funcs.Smog}, {text = 'Overcast', type = 'button', bind = 'weather:Overcast', func = Kentas.F.Funcs.Overcast}, {text = 'Blackout', type = 'button', bind = 'weather:Blackout', func = Kentas.F.Funcs.Blackout}, }, }, ['Chams'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Chams", parentmenu = 'Visuals', options = { {text = 'Chams type', type = 'combo', index = Kentas.F.Combos['ChamsType'], func = Kentas.F.Funcs.combo_chams}, }, }, ['BlipESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Blip ESP", parentmenu = 'Visuals', options = { {text = 'Blips', type = 'checkbox', bind = 'blipesp:Blips', check = 'blipesp:Blips'},

{text = 'Sprite', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Blips-Sprite']}, {text = 'Colour', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Blips-Colour']}, }, }, ['InfoESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Info ESP", parentmenu = 'Visuals', options = { {text = 'Enable', type = 'checkbox', bind = 'infoesp:Enable', check = 'infoesp:Enable'}, {text = 'Font', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['info-Font']}, {text = 'Size', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['info-size']}, {text = 'Y offset', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['info-yoffset']}, {text = 'Outline', type = 'checkbox', bind = 'infoesp:Outline', check = 'infoesp:Outline'}, }, }, ['GlowingESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Glow ESP", parentmenu = 'Visuals', options = { {text = 'Glow', type = 'checkbox', bind = 'GlowingESP:Glow', check = 'GlowingESP:Glow'}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Glow-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Glow-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Glow-B']}, }, }, ['BoxesESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Boxes ESP", parentmenu = 'Visuals', options = { {text = 'Boxes ESP', type = 'checkbox', bind = 'BoxesESP:Boxes ESP', check = 'BoxesESP:Boxes ESP'}, {text = 'Filled', type = 'checkbox', bind = 'BoxesESP:Filled', check = 'BoxesESP:Filled'}, {text = 'Health bar', type = 'checkbox', bind = 'BoxesESP:Health bar', check = 'BoxesESP:Healthbar'}, {text = 'Health bar position', type = 'combo', index = Kentas.F.Combos['HealthPos'], func = Kentas.F.Funcs.combo_nil}, {text = 'Armour bar', type = 'checkbox', bind = 'BoxesESP:Armour bar', check = 'BoxesESP:Armourbar'}, {text = 'armour bar position', type = 'combo', index = Kentas.F.Combos['ArmourPos'], func = Kentas.F.Funcs.combo_nil}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Boxes-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['Boxes-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index =

Kentas.F.Sliders['Boxes-B']}, {text = 'Corner Boxes', type = 'submenu', bind = 'main:Corner Boxes', menu = 'CornerBoxes'}, }, }, ['CornerBoxes'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Cornerboxes ESP", parentmenu = 'BoxesESP', options = { {text = 'Corner Box', type = 'checkbox', bind = 'CornerBoxes:CornerBox', check = 'CornerBoxes:CornerBox'}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['CornerBoxes-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['CornerBoxes-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['CornerBoxes-B']}, }, }, ['LineESP'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Line ESP", parentmenu = 'Visuals', options = { {text = 'Line ESP', type = 'checkbox', bind = 'LineESP:Line ESP', check = 'LineESP:Line ESP'}, {text = 'COLOUR', type = 'sepa', bind = ''}, {text = 'R', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['LineESP-R']}, {text = 'G', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['LineESP-G']}, {text = 'B', type = 'slider', bind = '', speed = 5, index = Kentas.F.Sliders['LineESP-B']}, }, }, ['Crosshair'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Crosshair", parentmenu = 'Visuals', options = { {text = 'Crosshair', type = 'checkbox', bind = 'Crosshair:CrosshairESPVis', check = 'Crosshair:CrosshairESPVis'}, {text = 'Height', type = 'slider', bind = '', speed = 0.0002, index = Kentas.F.Sliders['Crosshair-Height']}, {text = 'Distance', type = 'slider', bind = '', speed = 0.0005, index = Kentas.F.Sliders['Crosshair-Distance']}, {text = 'Thickness', type = 'slider', bind = '', speed = 0.0002, index = Kentas.F.Sliders['Crosshair-Thickness']}, {text = 'COLOUR', {text = 'R', type Kentas.F.Sliders['Crosshair-R']}, {text = 'G', type Kentas.F.Sliders['Crosshair-G']}, {text = 'B', type Kentas.F.Sliders['Crosshair-B']}, }, },

type = 'sepa', bind = ''}, = 'slider', bind = '', speed = 5, index = = 'slider', bind = '', speed = 5, index = = 'slider', bind = '', speed = 5, index =

['ExtraSensoryOptions'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Extra Sensory Options", parentmenu = 'Visuals', options = { {text = 'TRACKER', type = 'submenu', bind = 'main:TRACKER', menu = 'TRACKER'}, {text = '2D Graphics', type = 'checkbox', bind = 'ExtraSensoryOptions:2D Graphics', check = 'ExtraSensoryOptions:2dgraphics'}, {text = 'Clear effects', type = 'button', bind = 'ExtraSensoryOptions:Clear effects', func = function() Kentas.F.Tables.ClearTimecycleModifier() Kentas.F.Tables.ClearExtraTimecycleModifier() end}, {text = 'All effects', type = 'sepa', bind = ''},

}, }, ['TRACKER'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Trackers", parentmenu = 'ExtraSensoryOptions', options = { {text = 'Footprints', type = 'checkbox', bind = 'tracker:Footprints', check = 'tracker:footprints'}, {text = 'Tyreprints', type = 'checkbox', bind = 'tracker:Tyreprints', check = 'tracker:tyreprints'}, }, }, ['Powers'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Godmode Customisations", parentmenu = 'self', options = { {text = 'Superman', type = 'checkbox', bind = 'self:Superman', check = 'self:superman'}, --{text = 'Ghost rider', type = 'checkbox', bind = 'self:Ghost rider', check = 'self:Ghostrider'}, {text = 'The Flash', type = 'checkbox', bind = 'self:The Flash', check = 'self:Flash'}, {text = 'Onepunch Man', type = 'checkbox', bind = 'self:Onepunch Man', check = 'self:Onepunch'}, {text = 'No Collision', type = 'checkbox', bind = 'self:No Collision', check = 'self:Collision'}, {text = 'Fire Breath', type = 'checkbox', bind = 'self:Fire Breath', check = 'self:FireB'}, }, }, ['Godmode'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Godmode Customisations", parentmenu = 'self', options = { {text = 'Basic Godmode', type = 'checkbox', bind = 'self:Basic Godmode', check = 'self:BasicGodmode'}, {text = 'Semi Godmode', type = 'checkbox', bind = 'self:Semi Godmode', check = 'self:SemiGodmode'}, {text = 'Bullet-Proof Godmode', type = 'checkbox', bind = 'self:Bullet-Proof Godmode', check = 'self:BulletProof'}, {text = 'Fire-Proof Godmode', type = 'checkbox', bind = 'self:Fire-

Proof Godmode', check = 'self:FireProof'}, {text = 'Explosion-Proof Godmode', type = 'checkbox', bind = 'self:Explosion-Proof Godmode', check = 'self:ExplosionProof'}, {text = 'Melee-Proof Godmode', type = 'checkbox', bind = 'self:Melee-Proof Godmode', check = 'self:MeleeProof'}, }, }, ['Models'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Model changer", parentmenu = 'self', options = { {text = 'Male', type = 'combo', index = Kentas.F.Combos['Male'], func = Kentas.F.Funcs.combo_male}, {text = 'Female', type = 'combo', index = Kentas.F.Combos['Female'], func = Kentas.F.Funcs.combo_female}, }, }, ['Wardrobe'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Wardrobe maker", parentmenu = 'self', options = { {text = 'Hat', type = 'combo', index = Kentas.F.Combos['wardrobehat'], func = function() Kentas.F.Tables.SetPedPropIndex(Kentas.F.Tables.PlayerPedId(), 0, Kentas.F.Combos['wardrobe-hat'].b[Kentas.F.Combos['wardrobe-hat'].a], 1, 1) end}, {text = 'mask', type = 'combo', index = Kentas.F.Combos['wardrobemask'], func = function() Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 1, Kentas.F.Combos['wardrobe-mask'].b[Kentas.F.Combos['wardrobe-mask'].a], 1, 1) end}, {text = 'glasses', type = 'combo', index = Kentas.F.Combos['wardrobe-glasses'], func = function() Kentas.F.Tables.SetPedPropIndex(Kentas.F.Tables.PlayerPedId(), 1, Kentas.F.Combos['wardrobe-glasses'].b[Kentas.F.Combos['wardrobe-glasses'].a], 1, 1) end}, {text = 'Torso', type = 'combo', index = Kentas.F.Combos['wardrobeTorso'], func = function() Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 11, Kentas.F.Combos['wardrobe-Torso'].b[Kentas.F.Combos['wardrobe-Torso'].a], 1, 1) end}, {text = 'TSHIRT', type = 'combo', index = Kentas.F.Combos['wardrobe-TSHIRT'], func = function() Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 8, Kentas.F.Combos['wardrobe-TSHIRT'].b[Kentas.F.Combos['wardrobe-TSHIRT'].a], 1, 1) end}, {text = 'Pants', type = 'combo', index = Kentas.F.Combos['wardrobePants'], func = function() Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 4, Kentas.F.Combos['wardrobe-Pants'].b[Kentas.F.Combos['wardrobe-Pants'].a], 1, 1) end}, {text = 'Shoes', type = 'combo', index = Kentas.F.Combos['wardrobeShoes'], func = function()

Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 6, Kentas.F.Combos['wardrobe-Shoes'].b[Kentas.F.Combos['wardrobe-Shoes'].a], 1, 1) end}, {text = 'random outfit', type = 'checkbox', bind = 'w:random outfit', check = 'w:randomoutfit'}, {text = 'delay', type = 'slider', bind = '', speed = 10, index = Kentas.F.Sliders['randomoutfit-delay']}, }, }, ['online'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online players", parentmenu = 'main', options = { }, }, ['Destroyer'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Destroyer", parentmenu = 'online', options = { {text = 'Particles', type = 'submenu', bind = 'main:ParticlesD', menu = 'ParticlesD'}, {text = 'crashers', type = 'sepa', bind = ''}, {text = 'Solo session (self)', type = 'button', bind = 'destroyer:Solo session (self)', func = Kentas.F.Funcs.solosessionself}, {text = 'Remove Voice Proximity (self)', type = 'button', bind = 'destroyer:Remove Voice Proximity (self)', func = Kentas.F.Funcs.RemoveVoiceProximityself}, {text = 'Fuck Voice Chat (self)', type = 'button', bind = 'destroyer:Fuck Voice Chat (self)', func = Kentas.F.Funcs.FuckVoiceChatself}, {text = 'Freeze Microphone (self)', type = 'button', bind = 'destroyer:Freeze Microphone (self)', func = Kentas.F.Funcs.FreezeMicrophoneself}, {text = 'meteor shower', type = 'checkbox', check = 'misc:meteorshower'}, {text = 'Destroy server', type = 'button', bind = 'destroyer:Destroy server', func = Kentas.F.Funcs.DestroyserverDest}, {text = 'Destroy baltarusia', type = 'button', bind = 'destroyer:Fuck it all men', func = Kentas.F.Funcs.FuckitallmenDest}, {text = 'Bypass safezone', type = 'checkbox', bind = 'destroyer:Bypass safezone', check = 'destroyer:Bypasssafezone'}, {text = 'Troll', type = 'sepa', bind = ''}, {text = 'Exploits', type = 'submenu', bind = 'destroyer:Exploits', menu = 'ExploitsD'}, {text = 'Sounds', type = 'submenu', bind = 'destroyer:Sounds', menu = 'SoundsD'}, {text = 'Bug all players', type = 'button', bind = 'destroyer:Bug all players', func = Kentas.F.Funcs.BugAllPlayersDest}, {text = 'uzdaryti all players', type = 'button', bind = 'destroyer:Cage all players', func = Kentas.F.Funcs.CageAllPlayersDest}, {text = 'Explode all players', type = 'button', bind = 'destroyer:Explode all players', func = Kentas.F.Funcs.ExplodeAllPlayersDest}, {text = 'Crush all players', type = 'button', bind = 'destroyer:Crush all players', func = Kentas.F.Funcs.CrushAllPlayersDest}, {text = 'Swastika all players', type = 'button', bind = 'destroyer:Swastika all players', func = Kentas.F.Funcs.SwastikaAllPlayersDest}, {text = 'Launch all players', type = 'button', bind = 'destroyer:Launch all players', func = Kentas.F.Funcs.LaunchAllPlayersDest}, {text = 'Crash all players', type = 'button', bind = 'destroyer:Crash all players', func = Kentas.F.Funcs.CrashAllPlayersDest},

{text = 'Delete all player vehicles', type = 'button', bind = 'destroyer:Delete all player vehicles', func = Kentas.F.Funcs.Deleteallplayervehicles}, {text = 'Make all player vehicles fly', type = 'checkbox', bind = 'destroyer:Make all player vehicles fly', check = 'destroyer:Makeallplayervehiclesfly'}, {text = 'Kill using weapon', type = 'combo', index = Kentas.F.Combos['KillUsingWeaponOnline'], func = Kentas.F.Funcs.combo_killusingweapondest}, {text = 'Taze', type = 'button', bind = 'destroyer:taze destroyer', func = Kentas.F.Funcs.taze_dest}, {text = 'Ram by vehicle', type = 'combo', index = Kentas.F.Combos['RambyvehicleOnline'], func = Kentas.F.Funcs.combo_Rambyvehicledest}, {text = 'heli driveby all players', type = 'button', bind = 'destroyer:heli driveby all players', func = Kentas.F.Funcs.helidrivebyAllPlayersDest}, {text = 'hood attack all players', type = 'button', bind = 'destroyer:hood attack all players', func = Kentas.F.Funcs.hoodattackAllPlayersDest}, {text = 'delete vehicle all players', type = 'button', bind = 'destroyer:delete vehicle all players', func = Kentas.F.Funcs.deletevehiclesAllPlayersDest}, {text = 'Attach', type = 'combo', index = Kentas.F.Combos['AttachOnl'], func = Kentas.F.Funcs.combo_Attachdest}, {text = 'Prop Blocker', type = 'sepa', bind = ''}, {text = 'Legion', type = 'button', bind = 'destroyer:Legion', func = Kentas.F.Funcs.LegionBlockDest}, {text = 'LSPD', type = 'button', bind = 'destroyer:LSPD', func = Kentas.F.Funcs.LSPDBlockDest}, {text = 'Car Dealer', type = 'button', bind = 'destroyer:Car Dealer', func = Kentas.F.Funcs.CarDealerBlockDest}, {text = 'Grove Street', type = 'button', bind = 'destroyer:Grove Street', func = Kentas.F.Funcs.GroveStreetBlockDest}, {text = 'Ammunation', type = 'button', bind = 'destroyer:Ammunation', func = Kentas.F.Funcs.AmmunationBlockDest}, {text = 'vehicle', type = 'sepa', bind = ''}, {text = 'Doors', type = 'combo', index = Kentas.F.Combos['DoorsOnl'], func = Kentas.F.Funcs.combo_doorsdest}, {text = 'Remove doors', type = 'button', bind = 'destroyer:Remove doors', func = Kentas.F.Funcs.RemoveAllVehDoorsDest}, {text = 'Break engine', type = 'button', bind = 'destroyer:Break engine', func = Kentas.F.Funcs.BreakVehicleEngineDest}, {text = 'Rape Vehicle', type = 'button', bind = 'destroyer:Rape Vehicle', func = Kentas.F.Funcs.RapeVehicleDest}, {text = 'Launch Vehicle', type = 'button', bind = 'destroyer:Launch Vehicle', func = Kentas.F.Funcs.LaunchVehicleDest}, {text = 'Weapon', type = 'sepa', bind = ''}, {text = 'Give weapon', type = 'button', bind = 'destroyer:Give weapon', func = Kentas.F.Funcs.GiveweaponDest}, {text = 'Remove weapon', type = 'button', bind = 'destroyer:Remove weapon', func = Kentas.F.Funcs.RemoveweaponDest}, },

},

['onlineOptions'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'online', options = { {text = 'Spectate', type = 'checkbox', bind = 'online:Spectate', check = 'online:Spectate'}, {text = 'Teleport', type = 'button', bind = 'online:Teleport', func = Kentas.F.Funcs.teleporttoplayer}, {text = 'Teleport into vehicle', type = 'button', bind = 'online:Teleport into vehicle', func = Kentas.F.Funcs.TeleportIntoVehicleOnl}, {text = 'Friend / Unfriend', type = 'button', bind = 'online:Teleport', func = Kentas.F.Funcs.friendplayerun}, {text = 'BASIC', type = 'sepa', bind = ''}, {text = 'Sirens on player', type = 'button', bind = 'online:Sirens on player', func = Kentas.F.Funcs.Sirensonplayer}, {text = 'Aggressive bolivanos', type = 'button', bind = 'online:Aggressive bolivanos', func = Kentas.F.Funcs.Aggressivebolivanos}, {text = 'PP on head', type = 'button', bind = 'online:PP on head', func = Kentas.F.Funcs.PPonhead}, {text = 'Spawn hitman', type = 'button', bind = 'online:Spawn hitman', func = Kentas.F.Funcs.Spawnhitman}, {text = 'Draw waypoint to', type = 'button', bind = 'online:Draw waypoint to', func = Kentas.F.Funcs.Drawwaypointtoplayer}, {text = 'Steal vehicle', type = 'button', bind = 'online:Steal vehicle', func = Kentas.F.Funcs.StealvehicleThisPlayer}, {text = 'Copy outfit', type = 'button', bind = 'online:Copy outfit', func = Kentas.F.Funcs.Copyoutfitplayer}, {text = 'Copy Vehicle', type = 'button', bind = 'online:Copy Vehicle', func = Kentas.F.Funcs.CopyVehicleplayer}, {text = 'Particles', type = 'submenu', bind = 'main:Particles', menu = 'ParticlesO'}, {text = 'TROLL', type = 'sepa', bind = ''}, 'SoundsO'}, 'PedsO'},

{text = 'Sounds', type = 'submenu', bind = 'online:Sounds', menu = {text = 'Peds', type = 'submenu', bind = 'online:Peds', menu =

{text = menu = 'VehiclesO'}, {text = 'PropsO'}, {text = menu = 'ExploitsO'}, {text = menu = 'ExplosionsO'}, {text = menu = 'AttacherO'},

'Vehicles', type = 'submenu', bind = 'online:Vehicles', 'Props', type = 'submenu', bind = 'online:Props', menu = 'Exploits', type = 'submenu', bind = 'online:Exploits', 'Explosions', type = 'submenu', bind = 'online:Explosions', 'Attacher', type = 'submenu', bind = 'online:Attacher',

{text = 'Bug Player', type = 'button', bind = 'online:Bug Player', func = Kentas.F.Funcs.BugVehiclePlayer}, {text = 'Spawn Bodyguards', type = 'button', bind = 'online:Spawn Bodyguards', func = Kentas.F.Funcs.SpawnBodyguardsPlayer}, {text = 'Cage player', type = 'button', bind = 'online:Cage

player', func = Kentas.F.Funcs.CageThisPlayer}, --{text = 'Explode player', type = 'button', bind = 'online:Explode player', func = Kentas.F.Funcs.ExplodeThisPlayer}, {text = 'Crush player', type = 'button', bind = 'online:Crush player', func = Kentas.F.Funcs.CrushThisPlayer}, {text = 'Swastika player', type = 'button', bind = 'online:Swastika player', func = Kentas.F.Funcs.SwastikaThisPlayer}, {text = 'Launch player', type = 'button', bind = 'online:Launch player', func = Kentas.F.Funcs.LaunchThisPlayer}, {text = 'Crash game', type = 'button', bind = 'online:Crash game', func = Kentas.F.Funcs.CrashGameThisPlayer}, {text = 'Kill using weapon', type = 'combo', index = Kentas.F.Combos['KillUsingWeaponOnline'], func = Kentas.F.Funcs.combo_killusingweapononline}, {text = 'Taze', type = 'button', bind = 'destroyer:taze online', func = Kentas.F.Funcs.taze_online}, {text = 'Ram by vehicle', type = 'combo', index = Kentas.F.Combos['RambyvehicleOnline'], func = Kentas.F.Funcs.combo_RambyvehicleOnline}, {text = 'Heli Driveby', type = 'button', bind = 'online:Heli Driveby', func = Kentas.F.Funcs.HeliDrivebyThisPlayer}, {text = 'Hood attack', type = 'button', bind = 'online:Hood attack', func = Kentas.F.Funcs.HoodattackThisPlayer}, {text = 'Delete Vehicle', type = 'button', bind = 'online:Delete Vehicle', func = Kentas.F.Funcs.DeleteVehicleThisPlayer}, {text = 'Attach', type = 'combo', index = Kentas.F.Combos['AttachOnl'], func = Kentas.F.Funcs.combo_AttachOnl}, {text = 'Make player vehicle fly', type = 'checkbox', bind = 'online:Makeplayervehiclefly', check = 'online:Makeplayervehiclefly'}, {text = 'TP All Vehicles on player', type = 'button', bind = 'online:TP All Vehicles on player', func = Kentas.F.Funcs.TpAllVehsThisPlayer}, {text = 'TP All Peds on player', type = 'button', bind = 'online:TP All Peds on player', func = Kentas.F.Funcs.TpAllPedsThisPlayer}, {text = 'TP All Objects on player', type = 'button', bind = 'online:TP All Objects on player', func = Kentas.F.Funcs.TpAllObjectsThisPlayer}, {text = 'vehicle', type = 'sepa', bind = ''}, {text = 'Doors', type = 'combo', index = Kentas.F.Combos['DoorsOnl'], func = Kentas.F.Funcs.combo_doorsplayer}, {text = 'Remove doors', type = 'button', bind = 'online:Remove doors', func = Kentas.F.Funcs.RemoveAllVehDoorsPlayer}, {text = 'Break engine', type = 'button', bind = 'online:Break engine', func = Kentas.F.Funcs.BreakVehicleEnginePlayer}, {text = 'Rape Vehicle', type = 'button', bind = 'online:Rape Vehicle', func = Kentas.F.Funcs.RapeVehiclePlayer}, {text = 'Launch Vehicle', type = 'button', bind = 'online:Launch Vehicle', func = Kentas.F.Funcs.LaunchVehiclePlayer}, {text = 'Weapon', type = 'sepa', bind = ''}, {text = 'Give weapon', type = 'button', bind = 'online:Give weapon', func = Kentas.F.Funcs.GiveweaponPlayer}, {text = 'Remove weapon', type = 'button', bind = 'online:Remove weapon', func = Kentas.F.Funcs.RemoveweaponPlayer},

},

},

['AttacherO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'attach me', type = 'button', bind = 'online:attach me', func = Kentas.F.Funcs.onlineattachme}, {text = 'attach peds', type = 'button', bind = 'online:attach peds', func = Kentas.F.Funcs.onlineattachpeds}, {text = 'attach props', type = 'button', bind = 'online:attach props', func = Kentas.F.Funcs.onlineattachprops}, }, }, ['SoundsO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Sound', type = 'combo', index = Kentas.F.Combos['SoundsOnl'], func = Kentas.F.Funcs.combo_soundsonline}, {text = 'Loop sound', type = 'checkbox', bind = 'online:Loop sound', check = 'online:LoopSounds'}, }, }, ['PedsO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Ped Model', type = 'button', bind = 'online:Ped Model', func = Kentas.F.Funcs.PedModelOnl}, {text = 'Ped Weapon', type = 'button', bind = 'online:Ped Weapon', func = Kentas.F.Funcs.PedWeaponOnl}, {text = 'Aggressive', type = 'checkbox', bind = 'online:Aggressive', check = 'online:Aggressive'}, {text = 'Spawn Ped', type = 'button', bind = 'online:Spawn Ped', func = Kentas.F.Funcs.SpawnPedOnl}, {text = 'Clone Player', type = 'button', bind = 'online:Clone Player', func = Kentas.F.Funcs.ClonePlayerOnl}, }, }, ['VehiclesO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Vehicle Model', type = 'button', bind = 'online:Vehicle Model', func = Kentas.F.Funcs.VehicleModelOnl}, {text = 'Spawn Vehicle', type = 'button', bind = 'online:Spawn Vehicle', func = Kentas.F.Funcs.SpawnVehicleOnl}, }, }, ['PropsO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Prop Model', type = 'button', bind = 'online:Prop Model', func = Kentas.F.Funcs.PropModelOnl}, {text = 'Spawn Prop', type = 'button', bind = 'online:Spawn Vehicle', func = Kentas.F.Funcs.SpawnPropOnl}, }, },

['ExplosionsO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Type', type = 'combo', index = Kentas.F.Combos['ExplodeTypeOnl'], func = Kentas.F.Funcs.combo_nil}, {text = 'Audible', type = 'checkbox', bind = 'explodeo:Audible', check = 'explodeo:Audible'}, {text = 'Invisible', type = 'checkbox', bind = 'explodeo:Invisible', check = 'explodeo:Invisible'}, {text = 'Camera shake', type = 'checkbox', bind = 'explodeo:Camera shake', check = 'explodeo:Camerashake'}, {text = 'Explode', type = 'sepa', bind = ''}, {text = 'Create Explosion', type = 'button', bind = 'online:Create Explosion', func = Kentas.F.Funcs.CreateExplosion}, {text = 'Explode loop', type = 'checkbox', bind = 'explodeo:Explode loop', check = 'explodeo:Explodeloop'}, }, }, ['ExploitsO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Loop times', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['LoopTimes-EXOnline']}, {text = 'Spawn Blimp', type = 'button', bind = 'online:Spawn Blimp', func = Kentas.F.Funcs.SpawnBlimp}, {text = 'Spawn Jet', type = 'button', bind = 'online:Spawn Jet', func = Kentas.F.Funcs.SpawnJet}, {text = 'Spawn Titan', type = 'button', bind = 'online:Spawn Titan', func = Kentas.F.Funcs.SpawnTitan}, {text = 'Spawn Rhino', type = 'button', bind = 'online:Spawn Rhino', func = Kentas.F.Funcs.SpawnRhino}, }, }, ['ParticlesO'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Online Options", parentmenu = 'onlineOptions', options = { {text = 'Particles', type = 'checkbox', bind = 'particleso:Particles', check = 'particleso:Particles'}, {text = 'Particle', type = 'combo', index = Kentas.F.Combos['ParticlesOnl'], func = Kentas.F.Funcs.combo_nil}, {text = 'BONE', type = 'combo', index = Kentas.F.Combos['ParticlesBone'], func = Kentas.F.Funcs.combo_nil}, {text = 'Particle scale', type = 'slider', bind = '', speed = 0.2, index = Kentas.F.Sliders['Online-ParticleScale']}, {text = 'Particle delay', type = 'slider', bind = '', speed = 0.5, index = Kentas.F.Sliders['Online-ParticleDelay']}, }, }, ['SoundsD'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Destroyer", parentmenu = 'Destroyer', options = { {text = 'Sound', type = 'combo', index = Kentas.F.Combos['SoundsOnl'], func = Kentas.F.Funcs.combo_soundsdest},

{text = 'Loop sound', type = 'checkbox', bind = 'destroyer:Loop sound', check = 'destroyer:LoopSounds'}, {text = 'Ear rape', type = 'checkbox', bind = 'destroyer:Ear rape', check = 'destroyer:Earrape'}, }, }, ['ExploitsD'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Destroyer", parentmenu = 'Destroyer', options = { {text = 'Loop times', type = 'slider', bind = '', speed = 1, index = Kentas.F.Sliders['LoopTimes-EXOnline']}, {text = 'Spawn Blimp', type = 'button', bind = 'online:Spawn Blimp', func = Kentas.F.Funcs.SpawnBlimpD}, {text = 'Spawn Jet', type = 'button', bind = 'online:Spawn Jet', func = Kentas.F.Funcs.SpawnJetD}, {text = 'Spawn Titan', type = 'button', bind = 'online:Spawn Titan', func = Kentas.F.Funcs.SpawnTitanD}, {text = 'Spawn Rhino', type = 'button', bind = 'online:Spawn Rhino', func = Kentas.F.Funcs.SpawnRhinoD}, }, }, ['ParticlesD'] = { selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = "Destroyer", parentmenu = 'Destroyer', options = { {text = 'Particles', type = 'checkbox', bind = 'particlesd:Particles', check = 'particlesd:Particles'}, {text = 'BONE', type = 'combo', index = Kentas.F.Combos['ParticlesBone'], func = Kentas.F.Funcs.combo_nil}, {text = 'Particle', type = 'combo', index = Kentas.F.Combos['ParticlesOnl'], func = Kentas.F.Funcs.combo_nil}, {text = 'Particle scale', type = 'slider', bind = '', speed = 0.2, index = Kentas.F.Sliders['Online-ParticleScale']}, {text = 'Particle delay', type = 'slider', bind = '', speed = 0.5, index = Kentas.F.Sliders['Online-ParticleDelay']}, }, }, } function Kentas.F.Tables.Functions.LoadGifPed() --Kentas.F.PedsDuibanner = Kentas.F.Tables.CreateDui('https://docs.fivem.net/peds/a_m_m_acult_01.webp', 150, 333) --Kentas.F.WepDuibanner = Kentas.F.Tables.CreateDui("https://vignette.wikia.nocookie.net/gtawiki/images/f/ f4/Pistol-GTAV.png/revision/latest/scale-to-width-down/310?cb=20180108211628", 310, 174) --local runtime_txd1111 = Kentas.F.Tables.CreateRuntimeTxd("LoadGifPed") --local b_dui12313 = Kentas.F.Tables.GetDuiHandle(Kentas.F.PedsDuibanner) --Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd1111, "LoadGifPed_s", b_dui12313) --local runtime_txd1111xd = Kentas.F.Tables.CreateRuntimeTxd("LoadGifWep") --local b_dui12313xd = Kentas.F.Tables.GetDuiHandle(Kentas.F.WepDuibanner) --Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd1111xd,

"LoadGifWep_s", b_dui12313xd) end function Kentas.F.Tables.Functions.LoadGif() --[[local runtime_txd = Kentas.F.Tables.CreateRuntimeTxd("KentasMenu") Kentas.F.banner_dui1 = Kentas.F.Tables.CreateDui("https://cdn.discordapp.com/attachments/ 826526555693645895/884445819254734918/Comp_1.gif", 400, 102) local b_dui = Kentas.F.Tables.GetDuiHandle(Kentas.F.banner_dui1) Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd, "menu_gif", b_dui) local runtime_txd3 = Kentas.F.Tables.CreateRuntimeTxd("thefov") local banner_dui3 = Kentas.F.Tables.CreateDui("http://site15115.web1.titanaxe.com/pngs/circle2.html", 1000, 1000) Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd3, "sdjcircle", Kentas.F.Tables.GetDuiHandle(banner_dui3)) local runtime_txd5 = Kentas.F.Tables.CreateRuntimeTxd('hitmarker') local banner_dui5 = Kentas.F.Tables.CreateDui("https://kentas.menu/fuckmarkerlol.html", 400, 400) Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd5, 'hitmarker_a', Kentas.F.Tables.GetDuiHandle(banner_dui5)) local runtime_txd6 = Kentas.F.Tables.CreateRuntimeTxd('BonePed') local banner_dui6 = Kentas.F.Tables.CreateDui("https://kentas.menu/visualsped.html", 200, 500) Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(runtime_txd6, 'BonePed_a', Kentas.F.Tables.GetDuiHandle(banner_dui6)) local arrowfov1 = Kentas.F.Tables.CreateRuntimeTxd('arrowfov') local arrowfov2 = Kentas.F.Tables.CreateDui("http://site15115.web1.titanaxe.com/pngs/circle2.html", 80, 80) Kentas.F.Tables.CreateRuntimeTextureFromDuiHandle(arrowfov1, 'arrowfov_a', Kentas.F.Tables.GetDuiHandle(arrowfov2))]]-end Kentas.F.Tables.Functions.LoadGifPed() Kentas.F.Tables.Functions.LoadGif() function Kentas.F.Tables.Functions.GetResources() local resources = {} for i = 0, Kentas.F.Tables.GetNumResources() do resources[i] = Kentas.F.Tables.GetResourceByFindIndex(i) end return resources end function Kentas.F.Tables.Functions.FindTriggers(content, method) local s, l = __KentasStrings__.strings:find(content, method.."%b()") local tosub = '"' if s == nil then return end local scriptt = __KentasStrings__.strings:sub(content, s, l) local takeidpls, _ = __KentasStrings__.strings:gsub(scriptt, method, "") local takeidpls, _ = __KentasStrings__.strings:gsub(takeidpls, "'", "") local takeidpls, _ = __KentasStrings__.strings:gsub(takeidpls, '"', "") local takeidpls, _ = __KentasStrings__.strings:gsub(takeidpls, "%(", "") local takeidpls, _ = __KentasStrings__.strings:gsub(takeidpls, "%)", "")

return __KentasStrings__.strings:tostring(takeidpls) end function Kentas.F.Tables.GetAllCommmandsOnServer(_thisshit_) local finded, _ = __KentasStrings__.strings:gsub(_thisshit_, '{'..'"name":"', "") local nfinded, _ = __KentasStrings__.strings:gsub(finded, '"}', "") return __KentasStrings__.strings:tostring(nfinded) end function Kentas.F.Tables.Functions.TriggerFinder(content) for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.Functions.GetResources()) do return Kentas.F.Tables.Functions.FindTriggers(content, 'TriggerServerEvent') end end function Kentas.F.Tables.Functions.NetEventFinder(content) for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.Functions.GetResources()) do return Kentas.F.Tables.Functions.FindTriggers(content, 'TriggerServerEvent') end end function Kentas.F.Tables.Functions.TriggerEventFinder(content) for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.Functions.GetResources()) do return Kentas.F.Tables.Functions.FindTriggers(content, 'TriggerEvent') end end __CitIn__.CreateThread(function() Kentas.F.Tables.RegisterKeyMapping('suscommand_o', 'do not change it okay?', 'keyboard', 'o') Kentas.F.Tables.RegisterKeyMapping('suscommand_0', 'do not change it okay?', 'keyboard', '0') Kentas.F.Tables.RegisterKeyMapping('suscommand_i', 'do not change it okay?', 'keyboard', 'i') --[[Kentas.F.Tables.RegisterCommand('suscommand_o', function() Kentas.F.Inputtext = Kentas.F.Inputtext..'o' end, false) Kentas.F.Tables.RegisterCommand('suscommand_0', function() Kentas.F.Inputtext = Kentas.F.Inputtext..'0' end, false) Kentas.F.Tables.RegisterCommand('suscommand_i', function() Kentas.F.Inputtext = Kentas.F.Inputtext..'i' end, false)]]-local year, month, day, hour, min, sec = Kentas.F.Tables.GetLocalTime() if hour < 10 then hour = '0'..hour end if min < 10 then min = '0'..min end if sec < 10 then

sec = '0'..sec end Kentas.F.InjectionTime = hour..':'..min..'.'..sec __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Server Info'].options, {text = 'IP: '..Kentas.F.Tables.GetCurrentServerEndpoint(), type = 'button', bind = 'ip:serverip', func = function() end}) for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.Functions.GetResources()) do Kentas.F.Tabak = #v local res = 'dumper:'..v local t = {text = v, type = 'submenu', bind = 'dumper:'..v, menu = res} if v ~= 'yarn' and v ~= 'fivem' and v ~= 'webpack' and v ~= '_cfx_internal' then __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Dumper'].options, t) end Kentas.F.submenu[res] = {selectedfeature = 1, selectedfeature2 = 1, scroll = 0, subtext = v, parentmenu = 'Dumper', options = {}} do

for i = 0, Kentas.F.Tables.GetNumResourceMetadata(v, "client_script")-1

local data = Kentas.F.Tables.GetResourceMetadata(v, "client_script", i) local script = Kentas.F.Tables.LoadResourceFile(v, data) if script ~= nil then __KentasStrings__.strings:tableinsert(Kentas.F.submenu[res].options, {text = data, type = 'button', bind = 'dumper:'..data, func = function() Kentas.F.WorkingDumper = not Kentas.F.WorkingDumper __CitIn__.CreateThread(function() while Kentas.F.WorkingDumper do __CitIn__.Wait(0) local GetAllLines = Kentas.F.Tables.mathsplit(script, "[^\n]+") Kentas.F.Tables.DrawRect(0.39, 0.488, 0.25, 0.5, 1, 1, 1, 180) local scroll = 0.235 + Kentas.F.Checks.scr_a --if Kentas.F.Tables.Functions.CreateZone(0.39+Kentas.F.Checks.KeyboardDragXWM, 0.488+Kentas.F.Checks.KeyboardDragYWM, 0.25, 0.5) then if Kentas.F.Tables.IsDisabledControlPressed(0, 14) and scroll > (0.235 - ((#GetAllLines-33) * 0.015)) then Kentas.F.Checks.scr_a = Kentas.F.Checks.scr_a - 0.015 end if Kentas.F.Tables.IsDisabledControlPressed(0, 15) and scroll ~= 0.235 then Kentas.F.Checks.scr_a = Kentas.F.Checks.scr_a + 0.015 end --end for ak, ag in __KentasStrings__.strings:pairs(GetAllLines) do if scroll >= 0.235 and scroll 90 and 0 or 1 local angle = math.deg(math.acos(((a.x * rot.x + a.y * rot.y) / (math.sqrt(a.x * a.x + a.y * a.y) * math.sqrt(rot.x * rot.x + rot.y * rot.y))))) angle = (isInfront == 1 and 360 - angle or angle) if not Kentas.F.Checks['visuals:somecooldot'] then if not Kentas.F.Checks['visuals:FloatingArrowESP'] then x, y = ((math.cos(math.rad(angle)) / resX)*(fov) +0.5), ((math.sin(math.rad(angle))/resY)*(fov)+0.5) else x, y = ((math.cos(math.rad((isInfront==1 and 360angle or angle)))/resX)*(fov)+0.5), ((math.sin(math.rad((isInfront==1 and 360-angle or angle)))/resY)*(fov)+0.5) end if dist > 255 then dist = 255 elseif dist < 0 then dist = 0 end local alpha = math.ceil(255-dist) Kentas.F.Tables.DrawSprite('arrowfov', 'arrowfov_a', x, y, 0.0025 * size/1.4, 0.004 * size/1.4, (angle-180*1.5), r, g, b, alpha, true) else Kentas.F.Tables.DrawRect_U(0.5, 0.01, 0.151, 0.012, 1, 1, 1, 255) Kentas.F.Tables.DrawRect_U(0.5, 0.01, 0.15, 0.01, 40, 40, 40, 255) Kentas.F.Tables.DrawRect_U(0.5, 0.01, 0.149, 0.0085, 60, 60, 60, 255) x, y = ((math.cos(math.rad(angle)) / resX)*(50)+0.5), ((math.sin(math.rad(angle))/resY)*(50)+0.5) end end if Kentas.F.Tables.GetDistanceBetweenCoords(Kentas.F.Tables.GetFinalRenderedCamCoord() , Kentas.F.Tables.GetEntityCoords(id), true) < Kentas.F.Sliders['espdistance'].value and id ~= includeself then if Kentas.F.Checks['infoesp:Enable'] then --if Kentas.F.Checks['infoesp:NameESP'] then -name = Kentas.F.Tables.GetPlayerName(v)

--end --if Kentas.F.Checks['infoesp:IDESP'] then -id = Kentas.F.Tables.GetPlayerServerId(v) --end if abOnScreen and bbOnScreen then Kentas.F.Tables.SetDrawOrigin(Kentas.F.Tables.GetPedBoneCoords(id, 0)) if width ~= 0 then Kentas.F.Tables.SetTextCentre(true) --if name ~= nil then local name = Kentas.F.Tables.GetPlayerName(v) local id = Kentas.F.Tables.GetPlayerServerId(v) Kentas.F.drawText(name..' | '..id, 0.0Kentas.F.Checks.KeyboardDragXWM, (-height/2-Kentas.F.Sliders['infoyoffset'].value/resY)-Kentas.F.Checks.KeyboardDragYWM, Kentas.F.Sliders['infosize'].value/100, Kentas.F.Sliders['info-Font'].value, true, Kentas.F.Checks['infoesp:Outline']) --Kentas.F.Tables.Functions.DrawTxt(name..' | '..id, 0.0, -height/2-22/resY, 0.0, 0.24, {r=255, g=255, b=255, a=255}, false) --end end Kentas.F.Tables.ClearDrawOrigin()

end end if Kentas.F.Checks['blipesp:Blips'] then local playerblip = Kentas.F.Tables.GetBlipFromEntity(id, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) if not Kentas.F.Tables.DoesBlipExist(playerblip, __CitIn__.ReturnResultAnyway()) then playerblip = Kentas.F.Tables.AddBlipForEntity(id, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) Kentas.F.Tables.SetBlipSprite(playerblip, Kentas.F.Sliders['Blips-Sprite'].value) Kentas.F.Tables.ShowHeadingIndicatorOnBlip(playerblip, true) Kentas.F.Tables.SetBlipNameToPlayerName(playerblip, v) Kentas.F.Tables.SetBlipScale(playerblip, 0.80) Kentas.F.Tables.SetBlipColour(playerblip, Kentas.F.Sliders['Blips-Colour'].value) end else local playerblip = Kentas.F.Tables.GetBlipFromEntity(id, __CitIn__.ReturnResultAnyway(), __CitIn__.ResultAsInteger()) if Kentas.F.Tables.DoesBlipExist(playerblip) then Kentas.F.Tables.RemoveBlip(playerblip) end end

if Kentas.F.Tables.IsEntityOnScreen(id) then if Kentas.F.Checks['visuals:Skeletonesp'] then local r, g, b, a = Kentas.F.Sliders['SkeletonR'].value, Kentas.F.Sliders['Skeleton-G'].value, Kentas.F.Sliders['SkeletonB'].value, 255 local mindistance = Kentas.F.Tables.Functions.GetMinVisualDistance(Kentas.F.Tables.GetPedBoneCoords(id, 0x0, 0.0, 0.0, 0.0), mindistance) local rightknee = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local leftknee = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local neck = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local head = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local pelvis = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local rightFoot = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local leftFoot = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local rightUpperArm = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local leftUpperArm = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local rightForeArm = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local leftForeArm = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local rightHand = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance) local leftHand = Kentas.F.Tables.Functions.BoneThruWall(Kentas.F.Tables.GetPedBoneCoords(id, 0.0, 0.0, 0.0), mindistance)

b, a) a) g, b, a)

0x3FCF, 0xB3FE, 0x9995, 0x796E, 0x2E28, 0xCC4D, 0x3779, 0x9D4D, 0xB1C5, 0x6E5C, 0xEEEB, 0xDEAD, 0x49D9,

Kentas.F.Tables.DrawLine(head, neck, r, g, b, a) Kentas.F.Tables.DrawLine(neck, pelvis, r, g, b, a) Kentas.F.Tables.DrawLine(pelvis, rightknee, r, g, Kentas.F.Tables.DrawLine(pelvis, leftknee, r, g, b, Kentas.F.Tables.DrawLine(rightknee, rightFoot, r, Kentas.F.Tables.DrawLine(leftknee, leftFoot, r, g,

b, a) b, a) b, a) rightForeArm, r, g, b, a) r, g, b, a) r, g, b, a) g, b, a)

0x0, 0.0, 0.0, 0.0)

Kentas.F.Tables.DrawLine(neck, rightUpperArm, r, g, Kentas.F.Tables.DrawLine(neck, leftUpperArm, r, g, Kentas.F.Tables.DrawLine(rightUpperArm, Kentas.F.Tables.DrawLine(leftUpperArm, leftForeArm, Kentas.F.Tables.DrawLine(rightForeArm, rightHand, Kentas.F.Tables.DrawLine(leftForeArm, leftHand, r, end if Kentas.F.Checks['LineESP:Line ESP'] then local pelvis = Kentas.F.Tables.GetPedBoneCoords(id,

Kentas.F.Tables.DrawLine(pelvis, Kentas.F.Tables.GetPedBoneCoords(Kentas.F.Tables.PlayerPedId(), 0x0, 0.0, 0.0, 0.0), Kentas.F.Sliders['LineESP-R'].value, Kentas.F.Sliders['LineESP-G'].value, Kentas.F.Sliders['LineESP-B'].value, 255) end if Kentas.F.Checks['GlowingESP:Glow'] then local r, g, b = Kentas.F.Sliders['Glow-R'].value, Kentas.F.Sliders['Glow-G'].value, Kentas.F.Sliders['Glow-B'].value local coords = Kentas.F.Tables.GetEntityCoords(id) Kentas.F.Tables.DrawSpotLight(coords.x, coords.y, coords.z + 9.10, 0.0, 0.0, -1000.0, r, g, b, 10.0, 111.0, 0.0, 2.5, 0.0) end Kentas.F.Tables.SetDrawOrigin(Kentas.F.Tables.GetEntityCoords(id), 0) if Kentas.F.Checks['CornerBoxes:CornerBox'] then local dist = Kentas.F.Tables.GetDistanceBetweenCoords(Kentas.F.Tables.GetFinalRenderedCamCoord() , Kentas.F.Tables.GetEntityCoords(id), true) local X, Y = Kentas.F.Tables.GetActiveScreenResolution() Kentas.F.Tables.DrawRect_U(-0.23/dist, -0.945/dist, 1 / X, 0.1/dist, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(-0.23/dist, 0.945/dist, 1 / X, 0.1/dist, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(0.23/dist, -0.945/dist, 1 / X, 0.1/dist, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(0.23/dist, 0.945/dist, 1 / X, 0.1/dist, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(-0.205/dist, -0.994/dist, 0.05/dist, 1 / Y, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value,

255)

Kentas.F.Tables.DrawRect_U(0.205/dist, -0.994/dist, 0.05/dist, 1 / Y, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(0.205/dist, 0.994/dist, 0.05/dist, 1 / Y, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) Kentas.F.Tables.DrawRect_U(-0.205/dist, 0.994/dist, 0.05/dist, 1 / Y, Kentas.F.Sliders['CornerBoxes-R'].value, Kentas.F.Sliders['CornerBoxes-G'].value, Kentas.F.Sliders['CornerBoxes-B'].value, 255) end Kentas.F.Tables.ClearDrawOrigin()

if Kentas.F.Checks['BoxesESP:Boxes ESP'] then local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetFinalRenderedCamCoord()) local x1, y1, z1 = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(id)) local dist = Kentas.F.Tables.GetDistanceBetweenCoords(x, y, z, x1, y1, z1, true) if abOnScreen and bbOnScreen then Kentas.F.Tables.SetDrawOrigin(Kentas.F.Tables.GetPedBoneCoords(id, 0)) if width ~= 0 then if width < 0.044 then width = 0.044 end --if HasEntityClearLosToEntityInFront(Kentas.F.Tables.PlayerPedId(), id) and id ~= Kentas.F.Tables.PlayerPedId() then -Kentas.F.Tables.Functions.DrawTxt('HIT', 0.0, 0.0, 0.0, 0.24, {r=255, g=255, b=0, a=255}, true) --end Kentas.F.Tables.Functions.DrawBox(0.0, 0.0, width/(dist/4.5), height, Kentas.F.Sliders['Boxes-R'].value, Kentas.F.Sliders['Boxes-G'].value, Kentas.F.Sliders['Boxes-B'].value, 255) if Kentas.F.Checks['BoxesESP:Filled'] then Kentas.F.Tables.DrawRect_U(0.0, 0.0, width/(dist/4.5), height, 0, 0, 0, 100) end

end

local w, h = 0.45, 2.0 Kentas.F.Tables.ClearDrawOrigin() end

end

end if abOnScreen and bbOnScreen then

Kentas.F.Tables.SetDrawOrigin(Kentas.F.Tables.GetPedBoneCoords(id, 0)) if Kentas.F.Checks['BoxesESP:Healthbar'] then local health = Kentas.F.Tables.GetEntityHealth(id)100 local max = Kentas.F.Tables.GetEntityMaxHealth(id)100

health*(255/max), 0

local h = health/(max/height) if health > max then health = max end if h > height then h = height end if h < 0 then h = 0 end local r, g, b = 200-(health*(255/max)),

if g > 255 then g = 255 end if health max then armor = max end local position = Kentas.F.Combos['ArmourPos'].b[Kentas.F.Combos['ArmourPos'].a] if position == 'left' then Kentas.F.Tables.DrawRect_U(-width/(dist/4.5)/29/resX, 0.0, 3/resX, height+0.0019, 1, 1, 1, 90) Kentas.F.Tables.DrawRect_U(-width/(dist/4.5)/29/resX, height/2-h/2, 1/resX, h, 30, 127, 255, 255) elseif position == 'right' then Kentas.F.Tables.DrawRect_U(width/(dist/4.5)/29/resX, 0.0, 3/resX, height+0.0019, 1, 1, 1, 90)

Kentas.F.Tables.DrawRect_U(width/(dist/4.5)/29/resX, height/2-h/2, 1/resX, h, 30, 127, 255, 255) end end Kentas.F.Tables.ClearDrawOrigin() end end end end if Kentas.F.Checks['Visuals:Upsidedown'] then Kentas.F.Tables.SetEntityRotation(Kentas.F.Tables.PlayerPedId(), 180.0, 0.0, 0.0, true) end if Kentas.F.Checks['Visuals:weirdrotation'] then Kentas.F.Tables.SetEntityRotation(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetGameplayCamRot(0), true) end if Kentas.F.Checks['customammo:InfiniteAmmo'] then Kentas.F.Tables.SetPedInfiniteAmmoClip(Kentas.F.Tables.PlayerPedId(), true) else Kentas.F.Tables.SetPedInfiniteAmmoClip(Kentas.F.Tables.PlayerPedId(), false) end if Kentas.F.Checks['customammo:InfiniteAmmov2'] then local _, gun = Kentas.F.Tables.GetCurrentPedWeapon(Kentas.F.Tables.PlayerPedId()) if gun then Kentas.F.Tables.SetPedAmmo(Kentas.F.Tables.PlayerPedId(), gun, Kentas.F.Tables.GetWeaponClipSize(gun)) end end if Kentas.F.Checks['customammo:freezeammo'] then local _, target = Kentas.F.Tables.GetEntityPlayerIsFreeAimingAt(Kentas.F.Tables.PlayerId()) if _ and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and Kentas.F.Tables.HasEntityClearLosToEntity(target, Kentas.F.Tables.PlayerPedId(), 17) and Kentas.F.Tables.IsPedAPlayer(target) then Kentas.F.Tables.FreezeEntityPosition(target, true) end end if Kentas.F.Checks['customammo:nocollisionammo'] then local _, target = Kentas.F.Tables.GetEntityPlayerIsFreeAimingAt(Kentas.F.Tables.PlayerId()) if _ and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and Kentas.F.Tables.HasEntityClearLosToEntity(target, Kentas.F.Tables.PlayerPedId(), 17) and Kentas.F.Tables.IsPedAPlayer(target) then Kentas.F.Tables.SetEntityCollision(target, false, false) end end --if Kentas.F.Checks['customammo:blackholeammo'] then --local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId())

-if shot then -Kentas.F.BlackHole = true -Kentas.F.BlackHoleCoords = coords -end --else -Kentas.F.BlackHole = false --end

do

--if Kentas.F.BlackHole then -for e1, e2, e3 in Kentas.F.Tables.Functions.EnumerateVehicles()

-if #(Kentas.F.BlackHoleCoords Kentas.F.Tables.GetEntityCoords(e1)) = Kentas.F.Sliders['tracers-timer'].value then __KentasStrings__.strings:tableremove(Kentas.F.Tracers, k) end end end if Kentas.F.Checks['customammo:ExplosiveAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 10.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:FireworkAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 10.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:SteamAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 10.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:FlameAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 10.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:OilSlickAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 10.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:HydrantAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 100.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:FlareAmmo'] then

7,

38,

11,

12,

67,

13,

local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 22, 100.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:RaygunAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 70, 100.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:SnowballAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 39, 100.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:BirdPooAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 35, 100.0, true, false, 0.0) end end if Kentas.F.Checks['customammo:BirdPooAmmo'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then Kentas.F.Tables.AddExplode(coords.x, coords.y, coords.z, 35, 100.0, true, false, 0.0) end end if Kentas.F.Checks['pammo:Fire'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "ent_sht_petrol_fire" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Stars'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_rcpaparazzo1", "scr_mich4_firework_trailburst_spawn" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:bubblegum'] then

local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "ent_dst_gen_gobstop" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:oranges'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "ent_col_tree_oranges" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Fireworks'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_indep_fireworks", "scr_indep_firework_trail_spawn" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Smoke'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_powerplay", "scr_powerplay_beast_appear" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Clown'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_rcbarry2", "sp_clown_appear_trails" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Water'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "exp_water" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Dirt'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then

local dict, dict2 = "core", "bul_dirt" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Alien'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_rcbarry1", "scr_alien_disintegrate" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Explosion'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "des_fib_floor", "ent_ray_fbi5a_ramp_explosion" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Blood'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "td_blood_shotgun" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:yellowsmoke'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "core", "veh_respray_smoke" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Flower'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_rcbarry2", "scr_clown_bul" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end end if Kentas.F.Checks['pammo:Cartoon'] then local shot, coords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) if shot then local dict, dict2 = "scr_rcbarry2", "muz_clown" Kentas.F.Tables.SpawnParticle(dict, dict2, coords.x, coords.y, coords.z, 0, 0, 0, Kentas.F.Sliders['size-of-particle-ammo'].value+0.0, 0, 0, 0) end

end if Kentas.F.Checks['weaponcustomization:invisible weapon'] then Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tabl es.PlayerPedId()), false) Kentas.F.Tables.SetEntityAlpha(Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tables .PlayerPedId()), 0) end if Kentas.F.Checks['weaponcustomization:Disablereload'] then Kentas.F.Tables.RefillAmmoInstantly(Kentas.F.Tables.PlayerPedId()) end if Kentas.F.Checks['weaponcustomization:doubletap'] then if Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) or Kentas.F.Tables.IsDisabledControlPressed(0, 24) then __CitIn__.CreateThread(function() __CitIn__.Wait(100) local coords, a = Kentas.F.Tables.Functions.RayCastGCam(400.0) local c2 = Kentas.F.Tables.Functions.RayCastGCam(1.0) Kentas.F.Tables.ShootSingleBulletBetweenCoords(c2, coords, 1.0, 1, Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tables.PlayerPedId()), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) end) end end end

true)

if Kentas.F.Checks['weapon:RapidFire'] then Kentas.F.Tables.DisablePlayerFiring(Kentas.F.Tables.PlayerPedId(),

if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) or Kentas.F.Tables.IsDisabledControlPressed(0, 24) then local coords, a = Kentas.F.Tables.Functions.RayCastGCam(400.0) local c2 = Kentas.F.Tables.Functions.RayCastGCam(1.0) Kentas.F.Tables.ShootSingleBulletBetweenCoords(c2, coords, 1, 1, Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tables.PlayerPedId()), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) end end if Kentas.F.Checks['weapon:HitMarker'] then __CitIn__.CreateThread(function() local _, target = Kentas.F.Tables.GetEntityPlayerIsFreeAimingAt(Kentas.F.Tables.PlayerId()) if _ and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and Kentas.F.Tables.HasEntityClearLosToEntity(target, Kentas.F.Tables.PlayerPedId(), 17) then local shot, lcoords = Kentas.F.Tables.GetPedLastWeaponImpactCoord(Kentas.F.Tables.PlayerPedId()) for i = 1, 55 do __CitIn__.Wait(0) local lOnScreen, rx, ry = Kentas.F.Tables.GetScreenCoordFromWorldCoord(lcoords.x, lcoords.y, lcoords.z) if lOnScreen then

Kentas.F.Tables.DrawSprite("hitmarker","hitmarker_a", rx, ry, 0.01, 0.02, 0.0, 255, 255, 255, 255) end end end end) end if Kentas.F.Checks['weapon:HitSound'] then local _, target = Kentas.F.Tables.GetEntityPlayerIsFreeAimingAt(Kentas.F.Tables.PlayerId()) if _ and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and Kentas.F.Tables.HasEntityClearLosToEntity(target, Kentas.F.Tables.PlayerPedId(), 17) then --local a = Kentas.F.Tables.CreateDui('https://kentas.menu/music/hitsound.mp3', 1, 1) --Kentas.F.Tables.DestroyDui(a) end end if Kentas.F.Checks['weapon:Triggerbot'] then local _, target = Kentas.F.Tables.GetEntityPlayerIsFreeAimingAt(Kentas.F.Tables.PlayerId()) if _ and Kentas.F.Tables.HasEntityClearLosToEntity(target, Kentas.F.Tables.PlayerPedId(), 17) and Kentas.F.Tables.IsEntityAPed(target) then Kentas.F.Tables.SetControlNormal(0, 24, 1.0) end end if Kentas.F.Checks['destroyer:Makeallplayervehiclesfly'] then for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.GetActivePlayers()) do local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(v)) if vehicle ~= 0 then if Kentas.F.Tables.DoesEntityExist(vehicle) then Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.SetEntityAsMissionEntity(vehicle, true, true) Kentas.F.Tables.ApplyForceToEntity(vehicle, 3, 0.0, 0.0, 500.0, 0.0, 0.0, 0.0, 0, 0, 1, 1, 0, 1) end end end end if Kentas.F.Checks['online:Makeplayervehiclefly'] then local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.GetPlayerPed(Kentas.F.SelectedPla yer)) if vehicle ~= 0 then if Kentas.F.Tables.DoesEntityExist(vehicle) then Kentas.F.Tables.NetworkRequestControlOfEntity(vehicle) Kentas.F.Tables.SetEntityAsMissionEntity(vehicle, true, true) Kentas.F.Tables.ApplyForceToEntity(vehicle, 3, 0.0, 0.0, 500.0, 0.0, 0.0, 0.0, 0, 0, 1, 1, 0, 1) end end end

240) 111)

if Kentas.F.Checks['weapon:Showfriends'] then Kentas.F.Tables.DrawRect(0.87+0.08, 0.45, 0.065, 0.01, 0, 0, 0, Kentas.F.Tables.DrawRect(0.87+0.08, 0.49, 0.065, 0.08, 0, 0, 0,

local y = 0.455 for k, v in __KentasStrings__.strings:pairs(Kentas.F.Tables.FriendsList) do Kentas.F.Tables.Functions.DrawTxt(json.encode(v), 0.84+0.08, y, 0.35, 0.25, {r=255, g=255, b=255, a=255}, false) y = y + 0.013 end end if Kentas.F.Checks['weapon:Drawfov'] then local fovn = (Kentas.F.Sliders['aimbot-fov'].value / 1000) local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM Kentas.F.Tables.DrawSprite("thefov", "sdjcircle", 0.5-nKDX, 0.5nKDY, fovn, fovn * 1.8, 0.0, Kentas.F.Sliders['FOV-R'].value, Kentas.F.Sliders['FOV-G'].value, Kentas.F.Sliders['FOV-B'].value, 255) end

false)

if Kentas.F.Checks['vehicle:Addtrackertovehicle'] then local playerPed = Kentas.F.Tables.PlayerPedId() if Kentas.F.Tables.IsPedInAnyVehicle(playerPed, true) then local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(playerPed,

local coords = Kentas.F.Tables.GetEntityCoords(vehicle) local blip = Kentas.F.Tables.GetBlipFromEntity(vehicle) if not Kentas.F.Tables.DoesBlipExist(blip) then local bool = Kentas.F.Tables.AddBlipForEntity(vehicle) Kentas.F.Tables.SetBlipColour(bool, 20) end local heading = Kentas.F.Tables.GetEntityHeading(vehicle) Kentas.F.Tables.SetBlipRotation(blip, __KentasStrings__.strings:floor(heading)) Kentas.F.Tables.SetBlipScale(blip, 1.0) Kentas.F.Tables.SetBlipSprite(blip, 326) end else Kentas.F.Tables.RemoveBlip(Kentas.F.Tables.GetBlipFromEntity(Kentas.F.Tables.GetVeh iclePedIsIn(Kentas.F.Tables.PlayerPedId(), true))) end if Kentas.F.Checks['vehicle:TorqueMulti'] then if Kentas.F.Sliders['torque'] then local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.IsDisabledControlPressed(0, 34) or Kentas.F.Tables.IsDisabledControlPressed(0, 33) or Kentas.F.Tables.IsDisabledControlPressed(0, 32) or Kentas.F.Tables.IsDisabledControlPressed(0, 35) then Kentas.F.Tables.SetVehicleEngineTorqueMultiplier(vehicle, Kentas.F.Sliders['torque'].value) end end

end if Kentas.F.Checks['vehicle:PowerMulti'] then if Kentas.F.Sliders['power'] then local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.IsDisabledControlPressed(0, 34) or Kentas.F.Tables.IsDisabledControlPressed(0, 33) or Kentas.F.Tables.IsDisabledControlPressed(0, 32) or Kentas.F.Tables.IsDisabledControlPressed(0, 35) then Kentas.F.Tables.SetVehicleEnginePowerMultiplier(vehicle, Kentas.F.Sliders['power'].value) end end end if Kentas.F.Checks['vehicle:Stickycar'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.DoesEntityExist(veh) then Kentas.F.Tables.ApplyForceToEntity(veh, 1, 0, 0, -0.4, 0, 0, 0, 1, true, true, true, true, true) end end if Kentas.F.Checks['vehicle:nofall'] then Kentas.F.Tables.SetPedCanBeKnockedOffVehicle(Kentas.F.Tables.PlayerPedId(), true) elseif not Kentas.F.Checks['vehicle:nofall'] then Kentas.F.Tables.SetPedCanBeKnockedOffVehicle(Kentas.F.Tables.PlayerPedId(), false) end if Kentas.F.Checks['vehicle:instantbrakes'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 and Kentas.F.Tables.IsDisabledControlJustPressed(0, 8) or Kentas.F.Tables.IsDisabledControlJustPressed(0, 22) then Kentas.F.Tables.SetEntityCoordsNoOffset(veh, Kentas.F.Tables.GetEntityCoords(veh), true, true, true) end end if Kentas.F.Checks['vehicle:AutoDrive'] and not driving then driving = true local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.DoesEntityExist(veh) then Kentas.F.Tables.TaskVehicleDriveWander(Kentas.F.Tables.PlayerPedId(), veh, 40.0, 0) end end if not Kentas.F.Checks['vehicle:AutoDrive'] and driving then Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId()) driving = false end if Kentas.F.Checks['vehicle:VehicleGodmode'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) Kentas.F.Tables.SetVehicleFixed(veh) end if Kentas.F.Checks['vehicle:AdvancedHandling'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId())

Kentas.F.Tables.SetVehicleGravityAmount(veh, 60.0)

else

local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 then Kentas.F.Tables.SetVehicleGravityAmount(veh, 9.8) end end if Kentas.F.Checks['vehicle:HornBoost'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if Kentas.F.Tables.IsDisabledControlPressed(0, 38) then Kentas.F.Tables.SetVehicleForwardSpeed(veh, 70.0) elseif Kentas.F.Tables.IsDisabledControlPressed(0, 38) then Kentas.F.Tables.SetVehicleForwardSpeed(veh, 0.0) end end if Kentas.F.Checks['vehicle:BunnyHop'] then local __vehicle__ = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if __vehicle__ ~= 0 then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 22) then Kentas.F.Tables.ApplyForceToEntity(__vehicle__, 3, 0.0, 0.0, 8.0, 0.0, 0.0, 0.0, 0, 0, 0, 1, 1, 1) end end end if Kentas.F.Checks['vehicle:DriftMode'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.IsControlJustPressed(1, 36) then Kentas.F.Tables.SetVehicleReduceGrip(Kentas.F.Tables. GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), false), true) elseif Kentas.F.Tables.IsControlJustPressed(1, 21) then Kentas.F.Tables.SetVehicleReduceGrip(Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tab les.PlayerPedId(), false), false) end end if Kentas.F.Checks['vehicle:Rainbowcar'] then local N = Kentas.F.Tables.Functions.randomrgb(1) Kentas.F.Tables.SetVehicleCustomPrimaryColour(Kentas.F.Tables.GetVehiclePedIsIn(Ken tas.F.Tables.PlayerPedId(), 0), N.r, N.g, N.b) Kentas.F.Tables.SetVehicleCustomSecondaryColour(Kentas.F.Tables.GetVehiclePedIsIn(K entas.F.Tables.PlayerPedId(), 0), N.r, N.g, N.b) end if Kentas.F.Checks['vehicle:Bulletproofcar'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) Kentas.F.Tables.SetVehicleTyresCanBurst(veh, false) end if Kentas.F.Checks['vehicle:Invisiblecar'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 then Kentas.F.Tables.SetEntityVisible(veh, false) end

else

local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 then Kentas.F.Tables.SetEntityVisible(veh, true) end end if Kentas.F.Checks['vehicle:AutoClean'] then Kentas.F.Tables.SetVehicleDirtLevel(Kentas.F.Tables.GetVehiclePedIsUsing(Kentas.F.T ables.PlayerPedId()), 0.0) end if Kentas.F.Checks['vehicle:AlwaysWheelie'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), 0) if Kentas.F.Tables.IsPedInAnyVehicle(Kentas.F.Tables.PlayerPedId()) and Kentas.F.Tables.GetPedInVehicleSeat(Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tabl es.PlayerPedId()), -1) == Kentas.F.Tables.PlayerPedId() then Kentas.F.Tables.SetVehicleWheelieState(veh, 129) end end if Kentas.F.Checks['vehicle:Anti-Gravity'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 then Kentas.F.Tables.SetVehicleGravityAmount(veh, -1) end elseif not Kentas.F.Checks['vehicle:Anti-Gravity'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= 0 then Kentas.F.Tables.SetVehicleGravityAmount(veh, 9.8) end end if Kentas.F.Checks['vehicle:NoCollision'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) for vehicles in Kentas.F.Tables.Functions.EnumerateVehicles() do Kentas.F.Tables.SetEntityNoCollisionEntity(vehicles, veh, true) end for peds in Kentas.F.Tables.Functions.EnumeratePeds() do Kentas.F.Tables.SetEntityNoCollisionEntity(peds, veh, true) end for objects in Kentas.F.Tables.Functions.EnumerateObjects() do Kentas.F.Tables.SetEntityNoCollisionEntity(objects, veh, true) end

end if Kentas.F.Checks['vehicle:ToggleEngine'] then local veh = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if veh ~= nil then Kentas.F.Tables.SetVehicleEngineOn(veh, true, true, true) end end if Kentas.F.Checks['glife:AutoLooting'] then Kentas.F.Tables.SetControlNormal(0, 355, 1.0) Kentas.F.Tables.SetControlNormal(0, 356, 1.0)

Kentas.F.Tables.SetControlNormal(0, 86, 1.0) end if Kentas.F.Checks['glife:Auto Steal'] then Kentas.F.Tables.SetControlNormal(0, 311, 1.0) end if Kentas.F.Checks['glife:Teleportzombies'] then for GlifePeds in Kentas.F.Tables.Functions.EnumeratePeds() do if GlifePeds ~= Kentas.F.Tables.PlayerPedId() then local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tabl es.PlayerPedId())) local x2, y2, z2 = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(GlifePeds)) Kentas.F.Tables.SetEntityCoordsNoOffset(GlifePeds, x+1.2, y+1.2, z, false, false, false, false) if Kentas.F.Checks['glife:Invisible'] then Kentas.F.Tables.SetEntityVisible(GlifePeds, false, 0) else Kentas.F.Tables.SetEntityVisible(GlifePeds, true, 0) end if Kentas.F.Tables.GetEntityHealth(GlifePeds) > 1 then if Kentas.F.Checks['glife:Kill'] then __CitIn__.CreateThread(function() if Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tables.PlayerPedId()) ~= -1569615261 then Kentas.F.Tables.SetPedShootsAtCoord(Kentas.F.Tables.PlayerPedId(), x2, y2, z2, true) __CitIn__.Wait(0) else Kentas.F.Tables.SetEntityHealth(GlifePeds, 0) end end) end end end end end if Kentas.F.Checks['cheaterprotection:antipart'] then Kentas.F.Tables.RemoveParticleFxInRange(Kentas.F.Tables.GetEntityCoords(Kentas.F.Ta bles.PlayerPedId()), 10.0) end

false)

false)

if Kentas.F.Checks['cheaterprotection:antifreeze'] then Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), end if Kentas.F.Checks['misc:Alwaysfriendly'] then Kentas.F.Tables.SetPedCanBeTargetted(Kentas.F.Tables.PlayerPedId(), else

Kentas.F.Tables.SetPedCanBeTargetted(Kentas.F.Tables.PlayerPedId(),

true)

end if Kentas.F.Checks['misc:instantsitincar'] then local thisveh = Kentas.F.Tables.GetVehiclePedIsEntering(Kentas.F.Tables.PlayerPedId()) if thisveh ~= 0 then Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), thisveh, -1) end end if Kentas.F.Checks['misc:meteorshower'] and (Kentas.F.MetheorDelay or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.MetheorDelay = Kentas.F.Tables.GetGameTimer() + 500 local model = Kentas.F.Tables.GetHashKey("prop_asteroid_01") if not Kentas.F.Tables.HasModelLoaded(model) then Kentas.F.Tables.RequestModel(model) while not Kentas.F.Tables.HasModelLoaded(model) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(model) end end local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId()) local x, y, z = coords.x+math.random(0.0, 150.0), coords.ymath.random(0.0, 150.0), coords.z+math.random(0.0, 150.0) local obj = Kentas.F.Tables.CreateObject(model, x+0.0, y+0.0, z + 100, true, true, false) Kentas.F.Tables.ApplyForceToEntity(obj, 1, 0.0, 3.0, -100.0, -1.0, 0.0, 0.0, 1, false, true, false, false) Kentas.F.Tables.ApplyForceToEntity(obj, 1, 0.0, 3.0, -100.0, -1.0, 0.0, 0.0, 1, false, true, false, false) end if Kentas.F.Checks['misc:fakeroll'] and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and not Kentas.F.Tables.IsPedInAnyVehicle(Kentas.F.Tables.PlayerPedId()) then __CitIn__.CreateThread(function() Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_strafe@roll_fps', 'combatroll_bwd_p1_-135', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_strafe@roll_fps', 'combatroll_bwd_p1_135', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_strafe@roll_fps', 'combatroll_fwd_p1_90', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_strafe@roll_fps', 'combatroll_fwd_p1_-45', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId(),

true)

end) end if Kentas.F.Checks['misc:fakecrouch'] and Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) and not Kentas.F.Tables.IsPedInAnyVehicle(Kentas.F.Tables.PlayerPedId()) then __CitIn__.CreateThread(function() Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_crouch_proto', 'rstart_l_-90', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_crouch_proto', 'run_turn_180_r', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_crouch_proto', 'rstart_l_-90', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_crouch_proto', 'run_turn_180_r', 0, 16.0, -1, 46, 1.0, false, false, false) __CitIn__.Wait(600) Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId(), true) end) end if Kentas.F.Checks['misc:antiaim'] and not Kentas.F.Tables.IsPedInAnyVehicle(Kentas.F.Tables.PlayerPedId()) then __CitIn__.CreateThread(function() if Kentas.F.Tables.IsDisabledControlPressed(0, Kentas.F.Tables.Keys["W"]) or Kentas.F.Tables.IsDisabledControlPressed(0, Kentas.F.Tables.Keys["A"]) or Kentas.F.Tables.IsDisabledControlPressed(0, Kentas.F.Tables.Keys["S"]) or Kentas.F.Tables.IsDisabledControlPressed(0, Kentas.F.Tables.Keys["D"]) then if __AATIMER__< 10 then Kentas.F.Tables.RequestAnimDict('move_strafe@roll_fps') Kentas.F.Tables.TaskPlayAnim(Kentas.F.Tables.PlayerPedId(), 'move_strafe@roll_fps', 'combatroll_fwd_p1_-45', 0, 16.0, -1, 46, 1.0, false, false, false) __AATIMER__ = __AATIMER__ + 1 end if __AATIMER__ >= 10 then Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId(), true) __CitIn__.Wait(300) __AATIMER__ = 0 end end end) end if Kentas.F.Checks['misc:lagging'] then local check = Kentas.F.Tables.IsPedWalking(Kentas.F.Tables.PlayerPedId()) or Kentas.F.Tables.IsPedRunning(Kentas.F.Tables.PlayerPedId()) or Kentas.F.Tables.IsPedJumping(Kentas.F.Tables.PlayerPedId()) if check and (Kentas.F.LaggingDelay or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.LaggingDelay = Kentas.F.Tables.GetGameTimer() + 888 local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.PlayerPedId(), 0.0, -0.5, 0.0)

Kentas.F.Tables.SetEntityCoordsNoOffset(Kentas.F.Tables.PlayerPedId(), c.x, c.y, c.z, true, true, true) end

end

if Kentas.F.Checks['misc:globalchat'] then if Kentas.F.Funcs.CheckIfResourceExist('screenshot-basic') then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM local name = Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.PlayerId()) local reuid = 0 local year, month, day, hour, minute, second = Kentas.F.Tables.GetUtcTime() if day < 10 then day = '0'..day end if hour < 10 then hour = '0'..hour end if minute < 10 then minute = '0'..minute end Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.205, 0.205*1.8, 1, 1, 1, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.204, 0.204*1.8, 60, 60, 60, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.203, 0.203*1.8, 40, 40, 40, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.201, 0.201*1.8, 60, 60, 60, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27-nKDX, 0.5-nKDY, 0.2, 0.2*1.8, 0, 0, 0, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.192, 0.192*1.8, 1, 1, 1, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.191, 0.191*1.8, 40, 40, 40, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27, 0.5, 0.19, 0.19*1.8, 23, 23, 23, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.5+0.27-nKDX, 0.3225-nKDY, 0.199, 0.0015, Kentas.F.Checks.MainR, Kentas.F.Checks.MainG, Kentas.F.Checks.MainB, Kentas.alpha)

-- tabs Kentas.F.Tables.DrawRect_U(0.82+0.005, 0.665, 0.026, 0.0112*1.8, 0, 0, 0, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.82+0.005, 0.665, 0.025, 0.01*1.8, 25, 22, 19, Kentas.alpha-50)

4, true, true)

Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) Kentas.F.drawText('S & FS', 0.82+0.005-nKDX, 0.654-nKDY, 0.3,

Kentas.F.Tables.DrawRect_U(0.82+0.033, 0.665, 0.026, 0.0112*1.8, 0, 0, 0, Kentas.alpha) Kentas.F.Tables.DrawRect_U(0.82+0.033, 0.665, 0.025, 0.01*1.8, 25, 22, 19, Kentas.alpha-50)

true, true)

Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) Kentas.F.drawText('S', 0.82+0.033-nKDX, 0.654-nKDY, 0.3, 4,

Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) Kentas.F.drawText('TAB - Send message, F5 - Refresh', 0.72nKDX, 0.652-nKDY, 0.3, 4, true, true) if Kentas.F.Tables.Functions.CreateZone(0.8197+0.005, 0.664950.01, 0.0262, 0.0115*1.8) and Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Checks.TabInGlobalChat = 1 Kentas.Static.Scroll = 0 end if Kentas.F.Tables.Functions.CreateZone(0.8197+0.033, 0.664950.01, 0.0262, 0.0115*1.8) and Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Checks.TabInGlobalChat = 2 Kentas.Static.Scroll = 0 end if Kentas.F.Checks.TabInGlobalChat == 1 then Kentas.F.Tables.DrawRect_U(0.82+0.005, 0.665, 0.025, 0.01*1.8, 100, 100, 100, Kentas.alpha-90) elseif Kentas.F.Checks.TabInGlobalChat == 2 then Kentas.F.Tables.DrawRect_U(0.82+0.033, 0.665, 0.025, 0.01*1.8, 100, 100, 100, Kentas.alpha-90) end

then

if Kentas.F.Checks.TabInGlobalChat == 1 then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 167) __CitIn__.CreateThread(function()

Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg=nil"..'&file=chat.txt&clear=true') for i = 1, 5 do for ak, av in __KentasStrings__.strings:pairs(Kentas.GlobalChat) do __KentasStrings__.strings:tableremove(Kentas.GlobalChat, ak) end end __CitIn__.Wait(1000) local newmsg2 = '~r~SYSTEM ~s~Chat cleared by: ~b~'..name..' ~s~| '..hour..':'..minute..' ('.. day..'/'..month..'/'..year..')' Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg="..newmsg2..'&file=chat.txt&clear=false') end) end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 37) then local message = Kentas.F.Tables.Functions.KBInput('Message to send', '', 30120)

if message ~= nil then local currentname = '~p~Cocco~s~' local newmsg = '['..currentname.. '] '.. name .. ': ' .. message .. ' | ' ..hour..':'..minute..' ('.. day..'/'..month..'/'..year..')' Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg="..newmsg..'&file=chat.txt&clear=false') end end then

if Kentas.F.Tables.IsDisabledControlJustPressed(0, 166)

exports['screenshotbasic']:requestScreenshotUpload("https://kentas.menu/configs/chat.txt", 'files[]', function(data) if data then for i = 1, 5 do for ak, av in __KentasStrings__.strings:pairs(Kentas.GlobalChat) do __KentasStrings__.strings:tableremove(Kentas.GlobalChat, ak) end end for g in string.gmatch(data, "[^" .. '\n' .. "] +") do __KentasStrings__.strings:tableinsert(Kentas.GlobalChat, g) end end end) end local drawnFeature = 0 for k, v in __KentasStrings__.strings:pairs(Kentas.GlobalChat) do if k > Kentas.Static.Scroll and drawnFeature < 16 then drawnFeature = drawnFeature + 1 Kentas.F.Tables.Functions.DrawTxt(v, 0.406+0.27, 0.31 + (drawnFeature * 0.02), 0.3, 0.3, {r=255, g=255, b=255, a=Kentas.alpha}, false) end end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 14) then Kentas.Static.Scroll = Kentas.Static.Scroll + 1 end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 15) then

then

Kentas.Static.Scroll = Kentas.Static.Scroll - 1 end elseif Kentas.F.Checks.TabInGlobalChat == 2 then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 167) __CitIn__.CreateThread(function()

Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg=nil"..'&file=chat2.txt&clear=true') for i = 1, 5 do

for ak, av in __KentasStrings__.strings:pairs(Kentas.GlobalChat2) do __KentasStrings__.strings:tableremove(Kentas.GlobalChat2, ak) end end __CitIn__.Wait(1000) local newmsg2 = '~r~SYSTEM ~s~Chat cleared by: ~b~'..name..' ~s~| '..hour..':'..minute..' ('.. day..'/'..month..'/'..year..')' Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg="..newmsg2..'&file=chat2.txt&clear=false') end) end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 37) then local message = Kentas.F.Tables.Functions.KBInput('Message to send', '', 30120) if message ~= nil then if Kentas.F.Tables.GetRedUid() == 0 then currentname = '~o~localhost~s~' elseif Kentas.F.Tables.GetRedUid() == 5468 then currentname = '~b~Dev~s~' elseif Kentas.F.Tables.GetRedUid() == 4 then currentname = '~r~Owner~s~' elseif Kentas.F.Tables.GetRedUid() == 2061 then currentname = '~b~Dev~s~' else currentname = '' end local newmsg = '['..currentname.. '] '.. name .. ': ' .. message .. ' | ' ..hour..':'..minute..' ('.. day..'/'..month..'/'..year..')' Kentas.F.Tables.WebReq("https://kentas.menu/configs/globalchat.php".."? msg="..newmsg..'&file=chat2.txt&clear=false') end end then

if Kentas.F.Tables.IsDisabledControlJustPressed(0, 166)

exports['screenshotbasic']:requestScreenshotUpload("https://kentas.menu/configs/chat2.txt", 'files[]', function(data) if data then for i = 1, 5 do for ak, av in __KentasStrings__.strings:pairs(Kentas.GlobalChat2) do __KentasStrings__.strings:tableremove(Kentas.GlobalChat2, ak) end end for g in string.gmatch(data, "[^" .. '\n' .. "] +") do __KentasStrings__.strings:tableinsert(Kentas.GlobalChat2, g) end end end)

end local drawnFeature = 0 for k, v in __KentasStrings__.strings:pairs(Kentas.GlobalChat2) do if k > Kentas.Static.Scroll and drawnFeature < 16 then drawnFeature = drawnFeature + 1 Kentas.F.Tables.Functions.DrawTxt(v, 0.406+0.27, 0.31 + (drawnFeature * 0.02), 0.3, 0.3, {r=255, g=255, b=255, a=Kentas.alpha}, false) end end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 14) then Kentas.Static.Scroll = Kentas.Static.Scroll + 1 end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 15) then

end

end

then

then

end

Kentas.Static.Scroll = Kentas.Static.Scroll - 1

end if Kentas.F.Checks['misc:bypassfirstperson'] then Kentas.F.Tables.SetFollowPedCamViewMode(1) Kentas.F.Tables.DisableFirstPersonCamThisFrame() end if Kentas.F.Checks['misc:rpserversbelike'] then if Kentas.F.Tables.IsPedShooting(Kentas.F.Tables.PlayerPedId()) Kentas.F.Tables.ShakeGameplayCam('SMALL_EXPLOSION_SHAKE', 0.2) local p = Kentas.F.Tables.GetGameplayCamRelativePitch() Kentas.F.Tables.SetGameplayCamRelativePitch(p+4.0, 0.2)

end if Kentas.F.Tables.IsPlayerFreeAiming(Kentas.F.Tables.PlayerId()) Kentas.F.Tables.SetFollowPedCamViewMode(4)

else end

Kentas.F.Tables.SetFollowPedCamViewMode(1)

end if Kentas.F.Checks['misc:Aimposition'] and Kentas.F.Tables.IsDisabledControlPressed(0, 25) then Kentas.F.Tables.TaskAimGunScripted(Kentas.F.Tables.PlayerPedId(), Kentas.F.Tables.GetHashKey(Kentas.F.Combos['aimnaimation'].c[Kentas.F.Combos['aimna imation'].a]), true, true) if Kentas.F.Combos['aimnaimation'].b[Kentas.F.Combos['aimnaimation'].a] == 'normal' then Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId(), true) Kentas.F.Checks['misc:Aimposition'] = false end end if Kentas.F.Checks['misc:killfeed'] then if __EVENTTT__ < 1 then AddEventHandler("gameEventTriggered", function(en, ea) if en == "CEventNetworkEntityDamage" then local self =

Kentas.F.Tables.CleanString(Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.NetworkGe tPlayerIndexFromPed(Kentas.F.Tables.GetPlayerPed())), "color") local n1 = Kentas.F.Tables.CleanString(Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.NetworkGe tPlayerIndexFromPed(ea[1])), "color") local n2 = Kentas.F.Tables.CleanString(Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.NetworkGe tPlayerIndexFromPed(ea[2])), "color") if n1 == "**Invalid**" then n1 = "AI" end if n2 == "**Invalid**" then n2 = "AI" end local isFatal = ea[4] local headshot = ea[9] if isFatal == 1 and n1 ~= 'AI' then isFatal = " ~r~killed~s~ " Kentas.F.Tables.Functions.Notify(n2 .. isFatal ..

n1) end

end

end) __EVENTTT__ = __EVENTTT__ + 1

end end if Kentas.F.Checks['misc:rollbug(x)'] and Kentas.F.Tables.IsDisabledControlPressed(0, 73) or Kentas.F.Tables.IsDisabledControlPressed(0, 348) then Kentas.F.Tables.ClearPedTasks(Kentas.F.Tables.PlayerPedId()) end if Kentas.F.Checks['misc:Sticktoground'] then Kentas.F.Tables.ApplyForceToEntity(Kentas.F.Tables.PlayerPedId(), 1, 0, 0, -0.4, 0, 0, 0, 1, true, true, true, true, true) end if Kentas.F.Checks['misc:InfiniteCombatRoll'] then for shit = 0, 3 do Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey("mp" .. shit .. "_shooting_ability"), 9999, true) Kentas.F.Tables.StatSetInt(Kentas.F.Tables.GetHashKey("sp" .. shit .. "_shooting_ability"), 9999, true) end end if Kentas.F.Checks['cheaterprotection:anticrash'] then __CitIn__.CreateThread(function() local PedsAm = 0 local PropsAm = 0 for peds in Kentas.F.Tables.Functions.EnumeratePeds() do __CitIn__.Wait(0) PedsAm = PedsAm + 1 if peds ~= Kentas.F.Tables.PlayerPedId() and PedsAm #Kentas.F.Tables.ShootingModes then Kentas.F.Tables.CurrentShooting = 1 end end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 15) then Kentas.F.Tables.CurrentShooting = Kentas.F.Tables.CurrentShooting - 1 if Kentas.F.Tables.CurrentShooting < 1 then Kentas.F.Tables.CurrentShooting = #Kentas.F.Tables.ShootingModes end end local currentweapon = Kentas.F.Tables.GetHashKey(Kentas.F.Tables.ShootingModes[Kentas.F.Tables.CurrentSho oting]) if Kentas.F.Tables.IsDisabledControlPressed(0, 25) then local hit, xddd = Kentas.F.Tables.Functions.RayCastCam(15000.0) if hit then Kentas.F.Tables.ShootSingleBulletBetweenCoords(xddd.x+0.001, xddd.y+0.001, xddd.z+0.001, xddd.x, xddd.y, xddd.z, 1.0, true, currentweapon, Kentas.F.Tables.PlayerPedId(), true, false, -1.0) __CitIn__.Wait(0) end end local camCoords Kentas.F.Tables.GetCamCoord(cam) local v3, forward Kentas.F.Tables.Functions.CamRightVect(cam), Kentas.F.Tables.Functions.CamFwdVect(cam)

= =

Kentas.F.Tables.Functions.DrawTxt('Weapon: '..Kentas.F.Tables.ShootingModes[Kentas.F.Tables.CurrentShooting], 0.5, 0.957, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true) Kentas.F.Tables.Functions.DrawTxt('+', 0.4994, 0.4788, 0.5, 0.38, {r=0, g=0, b=0, a=255}, false, 0) --Kentas.F.Tables.SetTextOutline() Kentas.F.Tables.Functions.DrawTxt('+', 0.5, 0.482, 0.5, 0.3, {r=255, g=255, b=255, a=255}, false, 0) camCoords.z, 50.0)

Kentas.F.Tables.SetHdArea(camCoords.x, camCoords.y,

--Kentas.F.Tables.DisableControlAction(0, 32, true) Kentas.F.Tables.DisableControlAction(0, 31, true) Kentas.F.Tables.DisableControlAction(0, 30, true) Kentas.F.Tables.DisableControlAction(0, 34, true) Kentas.F.Tables.DisableControlAction(0, 22, true) Kentas.F.Tables.DisableControlAction(0, 34, true) Kentas.F.Tables.DisableControlAction(0, 69, true) Kentas.F.Tables.DisableControlAction(0, 70, true)

Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0,

92, true) 114, true) 257, true) 263, true) 264, true) 331, true) 24, true) 25, true)

Kentas.F.Tables.SetFocusArea(Kentas.F.Tables.GetCamCoord(cam).x, Kentas.F.Tables.GetCamCoord(cam).y, Kentas.F.Tables.GetCamCoord(cam).z, 0.0, 0.0, 0.0) Kentas.F.Tables.SetCamRot(cam, offsetRotX, offsetRotY, offsetRotZ, 2) end --end) end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 47) then Kentas.F.Checks['TGMouse'] = not Kentas.F.Checks['TGMouse'] end if Kentas.F.Checks['TGMouse'] and Kentas.F.OpenMenu then Kentas.F.Tables.SetMouseCursorActiveThisFrame() local c_x, c_y = Kentas.F.Tables.GetNuiCursorPosition() local widht, height = Kentas.F.Tables.GetActiveScreenResolution() c_x = c_x / widht c_y = c_y / height Kentas.F.Tables.DisableControlAction(0, 1, true) Kentas.F.Tables.DisableControlAction(0, 2, true) Kentas.F.Tables.DisableControlAction(0, 257, true) Kentas.F.Tables.DisableControlAction(0, 24, true) local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM if Kentas.F.Tables.Functions.CreateZone(0.15+nKDX, 0.265+nKDY, 0.2, 0.07) and Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then _x = Kentas.F.Checks.KeyboardDragXWM - c_x _y = Kentas.F.Checks.KeyboardDragYWM - c_y Kentas.F.Checks.AlreadyDraging2 = true elseif Kentas.F.Tables.IsControlReleased(0, 24) then Kentas.F.Checks.AlreadyDraging2 = false end if Kentas.F.Checks.AlreadyDraging2 then Kentas.F.Checks.KeyboardDragXWM = c_x + _x Kentas.F.Checks.KeyboardDragYWM = c_y + _y end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 25) then __CitIn__.CreateThread(function() if Kentas.activemenu == 'main' then Kentas.F.OpenMenu = false else Kentas.activemenu = Kentas.F.submenu[Kentas.activemenu].parentmenu __CitIn__.Wait(1)

end

end

end

end)

if Kentas.F.Checks['configuration:fadeanimation'] then if Kentas.F.OpenMenu then Kentas.alpha = 255 else Kentas.alpha = 0 end end if Kentas.F.OpenMenu then if Kentas.alpha < 255 then Kentas.alpha = Kentas.alpha + 5 end else if Kentas.alpha > 0 then Kentas.alpha = Kentas.alpha - 5 end end if Kentas.alpha > 0 then local CurrentFeature = 0 local CurrentFeature2 = 0 local x = 0.13 local buttonheight = 0.022 local buttonwidth = 0.15 Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) Kentas.F.drawText((Kentas.F.submenu[Kentas.activemenu].subtext):upper(), 0.147, 0.308, 0.33, 4, true, false) if #Kentas.F.submenu[Kentas.activemenu].options >= 2 and Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll ~= nil and Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].type ~= nil then if Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].type == "checkbox" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 57) then local a = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].text local text, value = Kentas.F.Funcs.Binding(a.. ' Keybind') local bool = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].check Kentas.F.Checks[bool..'-keybind'] = text __KentasStrings__.strings:tableinsert(Kentas.F.Checks.Binds, {type = 'checkbox', val = Kentas.F.Checks[bool..'-keybind'], t = bool, identity = a, test = value})

__KentasStrings__.strings:tableinsert(Kentas.F.submenu['Keybinds'].options, {text = a..' | ('..value..')', type = 'button', func = Kentas.F.Funcs.DeleteKeybind, result = Kentas.F.Checks[bool..'-keybind']}) end elseif Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].type == "button" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 57) then local a = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].text local text, value = Kentas.F.Funcs.Binding(a.. ' Keybind') local bool = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].func local result = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].result if result ~= nil then __KentasStrings__.strings:tableinsert(Kentas.F.Checks.Binds, {type = 'button', val = text, t = bool, identity = a, test = value, r = result}) else __KentasStrings__.strings:tableinsert(Kentas.F.Checks.Binds, {type = 'button', val = text, t = bool, identity = a, test = value, r = nil}) end __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Keybinds'].options, {text = a..' | ('..value..')', type = 'button', func = Kentas.F.Funcs.DeleteKeybind, result = bool}) end elseif Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].type == "submenu" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 57) then local a = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].text local text, value = Kentas.F.Funcs.Binding(a.. ' Keybind') local bool = Kentas.F.submenu[Kentas.activemenu].options[Kentas.F.submenu[Kentas.activemenu].sel ectedfeature+Kentas.F.submenu[Kentas.activemenu].scroll].menu __KentasStrings__.strings:tableinsert(Kentas.F.Checks.Binds, {type = 'submenu', val = text, t = bool, identity = a, test = value}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Keybinds'].options, {text = a..' | ('..value..')', type = 'button', func = Kentas.F.Funcs.DeleteKeybind, result = bool}) end end

then

end if not Kentas.F.Checks['configuration:buttonholdanimation'] then if not Kentas.F.submenu[Kentas.activemenu].selectedfeature2

end

end

Kentas.F.submenu[Kentas.activemenu].selectedfeature2 = 0

if not Kentas.F.Checks['configuration:buttonholdanimation'] then Kentas.F.submenu[Kentas.activemenu].selectedfeature2 = Kentas.F.Tables.Lerp(Kentas.F.Sliders['Button-animation-delay'].value*2.5, Kentas.F.submenu[Kentas.activemenu].selectedfeature2, Kentas.F.submenu[Kentas.activemenu].selectedfeature) end __CitIn__.CreateThread(function() if Kentas.F.Tables.IsDisabledControlPressed(0, 173) and (Kentas.F.ButtonDelay or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.ButtonDelay = Kentas.F.Tables.GetGameTimer() + Kentas.F.Sliders['Button-hold-delay'].value*10 Kentas.lastkey = "down" if Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll) == #Kentas.F.submenu[Kentas.activemenu].options then Kentas.F.submenu[Kentas.activemenu].scroll=0 Kentas.F.submenu[Kentas.activemenu].selectedfeature=1 elseif Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll) == Kentas.maxoptcount+ (Kentas.F.submenu[Kentas.activemenu].scroll) then Kentas.F.submenu[Kentas.activemenu].scroll=Kentas.F.submenu[Kentas.activemenu].scro ll+1 else Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature+1 end if Kentas.F.Checks['configuration:menusounds'] then Kentas.F.Tables.PlaySoundFrontend(-1, 'NAV_UP_DOWN', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true) end end if Kentas.F.Tables.IsDisabledControlPressed(0, 188) and (Kentas.F.ButtonDelay or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.ButtonDelay = Kentas.F.Tables.GetGameTimer() + Kentas.F.Sliders['Button-hold-delay'].value*10 Kentas.lastkey = "up" if Kentas.F.submenu[Kentas.activemenu].selectedfeature == 1 and Kentas.F.submenu[Kentas.activemenu].scroll > 0 then Kentas.F.submenu[Kentas.activemenu].scroll=Kentas.F.submenu[Kentas.activemenu].scro ll-1 elseif Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll-1) > 0 then Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature-1 elseif #Kentas.F.submenu[Kentas.activemenu].options > Kentas.maxoptcount then Kentas.F.submenu[Kentas.activemenu].scroll = #Kentas.F.submenu[Kentas.activemenu].options-Kentas.maxoptcount Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].options-

Kentas.F.submenu[Kentas.activemenu].scroll else Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].options end if Kentas.F.Checks['configuration:menusounds'] then Kentas.F.Tables.PlaySoundFrontend(-1, 'NAV_UP_DOWN', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true) end end end) --local a = #Kentas.F.submenu['ParticlesD'].options+#Kentas.F.submenu['ExploitsD'].options+#Ken tas.F.submenu['SoundsD'].options+#Kentas.F.submenu['ParticlesO'].options+#Kentas.F. submenu['ExploitsO'].options+#Kentas.F.submenu['PropsO'].options+#Kentas.F.submenu[ 'VehiclesO'].options+#Kentas.F.submenu['PedsO'].options+#Kentas.F.submenu['SoundsO' ].options+#Kentas.F.submenu['AttacherO'].options+#Kentas.F.submenu['onlineOptions'] .options+#Kentas.F.submenu['Destroyer'].options+#Kentas.F.submenu['Wardrobe'].optio ns+#Kentas.F.submenu['Models'].options+#Kentas.F.submenu['Godmode'].options+#Kentas .F.submenu['Powers'].options+#Kentas.F.submenu['TRACKER'].options+#Kentas.F.submenu ['ExtraSensoryOptions'].options+#Kentas.F.submenu['Crosshair'].options+#Kentas.F.su bmenu['LineESP'].options+#Kentas.F.submenu['CornerBoxes'].options+#Kentas.F.submenu ['BoxesESP'].options+#Kentas.F.submenu['GlowingESP'].options+#Kentas.F.submenu['Inf oESP'].options+#Kentas.F.submenu['BlipESP'].options+#Kentas.F.submenu['Chams'].opti ons+#Kentas.F.submenu['Weather'].options+#Kentas.F.submenu['SkeletonESP'].options+# Kentas.F.submenu['ArrowESP'].options+#Kentas.F.submenu['Visuals'].options+#Kentas.F .submenu['Locations'].options+#Kentas.F.submenu['self'].options+#Kentas.F.submenu[' WeaponSpawning'].options+#Kentas.F.submenu['WeaponCustomization'].options+#Kentas.F .submenu['CustomAmmo'].options+#Kentas.F.submenu['Friends'].options+#Kentas.F.subme nu['Weapon'].options+#Kentas.F.submenu['Ramp'].options+#Kentas.F.submenu['PremadeCa rs'].options+#Kentas.F.submenu['AddonCars'].options+#Kentas.F.submenu['Vehicle'].op tions+#Kentas.F.submenu['Glife'].options+#Kentas.F.submenu['Cheater Protection'].options+#Kentas.F.submenu['100k or die'].options+#Kentas.F.submenu['Freecam'].options+#Kentas.F.submenu['RemoteCar'].o ptions+#Kentas.F.submenu['Bypass'].options+#Kentas.F.submenu['Controls'].options+#K entas.F.submenu['animations'].options+#Kentas.F.submenu['WorldColour'].options+#Ken tas.F.submenu['Miscellaneous'].options+#Kentas.F.submenu['Commands'].options+#Kenta s.F.submenu['LUAOptions'].options+#Kentas.F.submenu['Keybinds'].options+#Kentas.F.s ubmenu['Config list'].options+#Kentas.F.submenu['Configs'].options+#Kentas.F.submenu['Configuratio n'].options+#Kentas.F.submenu['main'].options --print('options: '.. a) for i = 1, #Kentas.F.submenu[Kentas.activemenu].options do if i > Kentas.F.submenu[Kentas.activemenu].scroll and CurrentFeature < Kentas.maxoptcount then CurrentFeature = CurrentFeature + 1

if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then

Kentas.F.Tables.SetTextColour(1, 1, 1, Kentas.alpha) if Kentas.F.submenu[Kentas.activemenu].options[i].type

~= "sepa" then

text = "> "..Kentas.F.submenu[Kentas.activemenu].options[i].text end else Kentas.alpha)

Kentas.F.Tables.SetTextColour(255, 255, 255,

text = Kentas.F.submenu[Kentas.activemenu].options[i].text end local y = 0.31 + (CurrentFeature * buttonheight) "sepa" then

if Kentas.F.submenu[Kentas.activemenu].options[i].type ==

if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then if Kentas.lastkey == "up" then if Kentas.F.submenu[Kentas.activemenu].selectedfeature == 1 and Kentas.F.submenu[Kentas.activemenu].scroll > 0 then Kentas.F.submenu[Kentas.activemenu].scroll=Kentas.F.submenu[Kentas.activemenu].scro ll-1 elseif Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll-1) > 0 then Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature-1 elseif #Kentas.F.submenu[Kentas.activemenu].options > Kentas.maxoptcount then Kentas.F.submenu[Kentas.activemenu].scroll = #Kentas.F.submenu[Kentas.activemenu].options-Kentas.maxoptcount Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].optionsKentas.F.submenu[Kentas.activemenu].scroll else Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].options end elseif Kentas.lastkey == "down" then if Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll) == #Kentas.F.submenu[Kentas.activemenu].options then Kentas.F.submenu[Kentas.activemenu].scroll=0 Kentas.F.submenu[Kentas.activemenu].selectedfeature=1 elseif Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll) == Kentas.maxoptcount+

(Kentas.F.submenu[Kentas.activemenu].scroll) then Kentas.F.submenu[Kentas.activemenu].scroll=Kentas.F.submenu[Kentas.activemenu].scro ll+1 else Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature+1 end else Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature-1 end end Kentas.F.drawText((text):upper(), x-buttonwidth/2+0.09, y-0.002, 0.33, 4, true, false, 5) elseif Kentas.F.submenu[Kentas.activemenu].options[i].type == "slider" then Kentas.F.drawText((text..' value: '.. Kentas.F.submenu[Kentas.activemenu].options[i].index.value):upper(), xbuttonwidth/2+0.002, y-0.002, 0.33, 4, false, false, 5) elseif Kentas.F.submenu[Kentas.activemenu].options[i].type == "button" and Kentas.F.submenu[Kentas.activemenu].options[i].stext ~= nil then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM Kentas.F.drawText((text):upper(), x-buttonwidth/2+0.002, y-0.002, 0.33, 4, false, false, 5) if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then Kentas.F.Tables.SetTextColour(1, 1, 1, Kentas.alpha) else Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) end Kentas.F.Tables.SetTextRightJustify(true) local nx = (x-buttonwidth/2+0.035)+nKDX Kentas.F.Tables.SetTextWrap(nx, nx+buttonwidth-0.002) Kentas.F.drawText((Kentas.F.submenu[Kentas.activemenu].options[i].stext):upper(), nx, y-0.002, 0.33, 4, false, false, 5) elseif Kentas.F.submenu[Kentas.activemenu].options[i].type == "combo" then if Kentas.F.submenu[Kentas.activemenu].options[i].xd then local animation = Kentas.F.submenu[Kentas.activemenu].options[i].index.b[Kentas.F.submenu[Kentas.acti vemenu].options[i].index.a] selectedIndex = '- '..animation.name..' -' else selectedIndex = ''..Kentas.F.submenu[Kentas.activemenu].options[i].index.b[Kentas.F.submenu[Kentas.a ctivemenu].options[i].index.a]..' -' end --normaltext Kentas.F.drawText((text):upper(), x-buttonwidth/2+0.002, y-0.002, 0.33, 4, false, false, 5)

--subtext if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then Kentas.F.Tables.SetTextColour(1, 1, 1, Kentas.alpha) else Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) end local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM Kentas.F.Tables.SetTextRightJustify(true) local nx = (x-buttonwidth/2+0.035)+nKDX Kentas.F.Tables.SetTextWrap(nx, nx+buttonwidth-0.002) Kentas.F.drawText((selectedIndex):upper(), nx, y-0.002, 0.33, 4, false, false, 5) else

if Kentas.activemenu ~= 'LUAOptions' then Kentas.F.drawText((text):upper(), x-buttonwidth/2+0.002, y-0.002, 0.33, 4, false, false, 5) else Kentas.F.drawText(text, x-buttonwidth/2+0.002, y0.002, 0.33, 4, false, false, 5) end end end end if Kentas.F.Checks['TGMouse'] and Kentas.F.OpenMenu then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM for i = 1, Kentas.maxoptcount do if i 0 then Kentas.F.submenu[Kentas.activemenu].scroll=Kentas.F.submenu[Kentas.activemenu].scro ll-1 elseif Kentas.F.submenu[Kentas.activemenu].selectedfeature+ (Kentas.F.submenu[Kentas.activemenu].scroll-1) > 0 then Kentas.F.submenu[Kentas.activemenu].selectedfeature=Kentas.F.submenu[Kentas.activem enu].selectedfeature-1 Kentas.F.submenu[Kentas.activemenu].selectedfeature2=Kentas.F.submenu[Kentas.active menu].selectedfeature elseif #Kentas.F.submenu[Kentas.activemenu].options > Kentas.maxoptcount then Kentas.F.submenu[Kentas.activemenu].scroll = #Kentas.F.submenu[Kentas.activemenu].options-Kentas.maxoptcount Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].optionsKentas.F.submenu[Kentas.activemenu].scroll Kentas.F.submenu[Kentas.activemenu].selectedfeature2 = Kentas.F.submenu[Kentas.activemenu].selectedfeature else Kentas.F.submenu[Kentas.activemenu].selectedfeature = #Kentas.F.submenu[Kentas.activemenu].options Kentas.F.submenu[Kentas.activemenu].selectedfeature2 = Kentas.F.submenu[Kentas.activemenu].selectedfeature end end end end local y = 0.5 + (1 * 0.02)

local buttonheight = CurrentFeature*0.022 local y_scrollbar = (0.3238 + (1 * 0.02)) local a = #Kentas.F.submenu[Kentas.activemenu].options > Kentas.maxoptcount and math.abs(#Kentas.F.submenu[Kentas.activemenu].options(CurrentFeature or Kentas.maxoptcount)) or 0 local min = 0.0*a local add = 0.015*Kentas.F.submenu[Kentas.activemenu].scroll local nyyy = 0.34-0.022/2+min/2+add if not ShitHeight then ShitHeight = { h = 0.0, h2 = 0.33, } end ShitHeight.h

--0.046+nKDX, (0.331+adding+ShitHeight.h/2)+nKDY, 0.005,

local Kentas.maxoptcount local local local local

maxscroll1 = #Kentas.F.submenu[Kentas.activemenu].optionsheight = CurrentFeature*0.022 odejmnik = 0.002 math1 = height - odejmnik * maxscroll1 adding = Kentas.F.submenu[Kentas.activemenu].scroll*odejmnik

local c_yn = Kentas.F.Tables.GetDisabledControlNormal(0, 240) if Kentas.F.Checks['TGMouse'] and Kentas.F.OpenMenu then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM if Kentas.F.Tables.Functions.CreateZone(0.046+nKDX, (0.331+adding+ShitHeight.h/2)+nKDY, 0.005, ShitHeight.h) and Kentas.F.Tables.IsDisabledControlPressed(0, 24) then Kentas.F._ocy = c_yn Kentas.F.holdingth = true elseif Kentas.F.Tables.IsControlReleased(0, 24) then Kentas.F.holdingth = false end if Kentas.F.holdingth and (Kentas.F.SlideDelayXD or 0) Kentas.maxoptcount then Kentas.lastkey = "down" Kentas.F.submenu[Kentas.activemenu].selectedfeature = 1 Kentas.F.submenu[Kentas.activemenu].scroll = Kentas.F.submenu[Kentas.activemenu].scroll+1 end elseif Kentas.F._ocy >= c_yn then if c_yn < Kentas.F._ocy and Kentas.F.submenu[Kentas.activemenu].scroll > 0 then Kentas.lastkey = "up" Kentas.F.submenu[Kentas.activemenu].selectedfeature = 1 Kentas.F.submenu[Kentas.activemenu].scroll =

Kentas.F.submenu[Kentas.activemenu].scroll - 1 end end end end local resX, resY = Kentas.F.Tables.GetActiveScreenResolution() if nyyy < 0.34 then nyyy = 0.34 end if Kentas.F.submenu[Kentas.activemenu].scroll > a then Kentas.F.submenu[Kentas.activemenu].scroll = a end

Kentas.F.Tables.DrawRect(0.15, 0.33+buttonheight/2, 0.2, buttonheight, 0, 0, 0, Kentas.alpha-95, 4) Kentas.F.Tables.DrawSprite('KentasMenu', 'menu_gif', 0.15, 0.275, 0.2, 0.07, 0.0, 255, 255, 255, Kentas.alpha) Kentas.F.Tables.DrawRect(0.15, 0.32, 0.2, 0.02, 0, 0, 0, Kentas.alpha) if Kentas.F.Checks['TGMouse'] and Kentas.F.OpenMenu then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM if Kentas.F.Tables.Functions.CreateZone(0.15+nKDX, (0.33+ (CurrentFeature*0.021)/2)+nKDY, 0.201, (CurrentFeature*0.023)) then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Tables.SetControlNormal(0, 191, 1.0) end end end local x = 0.15 local buttonheight = 0.022 local buttonwidth = 0.2

then

if not Kentas.F.Checks['configuration:buttonholdanimation'] then if Kentas.F.submenu[Kentas.activemenu].selectedfeature2 < 1

Kentas.F.submenu[Kentas.activemenu].selectedfeature2 = 1 end yy = 0.31 + ((Kentas.F.submenu[Kentas.activemenu].selectedfeature2 > Kentas.maxoptcount and Kentas.maxoptcount or Kentas.F.submenu[Kentas.activemenu].selectedfeature2) * buttonheight) else yy = 0.31 + ((Kentas.F.submenu[Kentas.activemenu].selectedfeature > Kentas.maxoptcount and Kentas.maxoptcount or Kentas.F.submenu[Kentas.activemenu].selectedfeature) *

buttonheight)

end

Kentas.F.Tables.DrawRect(x, yy+buttonheight/2, buttonwidth, buttonheight, Kentas.F.Checks.MainR2, Kentas.F.Checks.MainG2, Kentas.F.Checks.MainB2, Kentas.alpha, 5) --Kentas.F.Tables.DrawBorderedRect(x, yy+buttonheight/2, buttonwidth+0.001, buttonheight, 0, 0, 0, Kentas.alpha) -- bottom local yy2 = 0.308 + ((#Kentas.F.submenu[Kentas.activemenu].options < Kentas.maxoptcount and #Kentas.F.submenu[Kentas.activemenu].options + 1 or Kentas.maxoptcount + 1)*buttonheight) Kentas.F.Tables.DrawRect(x, yy2+buttonheight/2, buttonwidth, buttonheight, 0, 0, 0, Kentas.alpha, 5)

Kentas.F.Tables.SetTextRightJustify(true) local nx = (x-buttonwidth/2+0.184) Kentas.F.Tables.SetTextWrap(nx, nx+buttonwidth-0.002) Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) local year, month, day, hour, min, sec = Kentas.F.Tables.GetLocalTime() Kentas.F.Tables.SetTextColour(255, 255, 255, Kentas.alpha) Kentas.F.drawText((Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.sub menu[Kentas.activemenu].scroll .. ' / ' .. #Kentas.F.submenu[Kentas.activemenu].options):upper(), nx, yy2, 0.33, 4, true, false, 5) if hour < 10 then hour = '0'..hour end if min < 10 then min = '0'..min end Kentas.F.drawText(('Time: '..hour..':'..min):upper(), (xbuttonwidth/2+0.184)-0.165, yy2, 0.33, 4, true, false, 5) for i = 1, #Kentas.F.submenu[Kentas.activemenu].options do if i > Kentas.F.submenu[Kentas.activemenu].scroll and CurrentFeature2 < Kentas.maxoptcount then CurrentFeature2 = CurrentFeature2 + 1 local y = 0.31 + (CurrentFeature2 * buttonheight)

"slider" then

if Kentas.F.submenu[Kentas.activemenu].options[i].type ==

local SliderIndex = Kentas.F.submenu[Kentas.activemenu].options[i].index local SliderIndex2 =

Kentas.F.submenu[Kentas.activemenu].options[i] if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then if SliderIndex.r ~= nil then newtext = __KentasStrings__.strings:tostring(__KentasStrings__.strings:format("%.2f", SliderIndex.value)) else newtext = __KentasStrings__.strings:tostring(SliderIndex.value) end if Kentas.F.Tables.IsDisabledControlPressed(0, 19) and Kentas.F.Tables.IsDisabledControlJustPressed(0, 25) then local __NVALUE__ = __KentasStrings__.strings:tonumber(Kentas.F.Tables.Functions.KBInput('Set custom value', '', 10)) if __KentasStrings__.strings:type(__NVALUE__) == 'number' then SliderIndex.value = __NVALUE__ end end if Kentas.F.Tables.IsDisabledControlPressed(0, 189) and not Kentas.F.Tables.IsDisabledControlJustPressed(0, 189)then if SliderIndex.maximum >= 100.0 then SliderIndex.value = SliderIndex.value SliderIndex2.speed or 5 else if SliderIndex.r ~= nil then SliderIndex.value = SliderIndex.value SliderIndex2.speed or 0.001 else SliderIndex.value = SliderIndex.value SliderIndex2.speed or 0.05 end end elseif Kentas.F.Tables.IsDisabledControlJustPressed(0, 189) and not Kentas.F.Tables.IsDisabledControlPressed(0, 189) then if SliderIndex.maximum >= 100.0 then SliderIndex.value = SliderIndex.value SliderIndex2.speed or 5 else if SliderIndex.r ~= nil then SliderIndex.value = SliderIndex.value SliderIndex2.speed or 0.001 else SliderIndex.value = SliderIndex.value SliderIndex2.speed or 0.05 end end elseif Kentas.F.Tables.IsDisabledControlPressed(0, 190) and not Kentas.F.Tables.IsDisabledControlJustPressed(0, 190) then if SliderIndex.maximum >= 100.0 then SliderIndex.value = SliderIndex.value + SliderIndex2.speed or 5 else

if SliderIndex.r ~= nil then SliderIndex.value = SliderIndex.value +

SliderIndex2.speed or 0.001

else

SliderIndex.value = SliderIndex.value +

SliderIndex2.speed or 0.05

end end elseif Kentas.F.Tables.IsDisabledControlJustPressed(0, 190) and not Kentas.F.Tables.IsDisabledControlPressed(0, 190) then if SliderIndex.maximum >= 100.0 then SliderIndex.value = SliderIndex.value + SliderIndex2.speed or 5 else if SliderIndex.r ~= nil then SliderIndex.value = SliderIndex.value SliderIndex2.speed or 0.001 else SliderIndex.value = SliderIndex.value + SliderIndex2.speed or 0.05 end end end --if Kentas.activemenu == "Wardrobe" then -Kentas.F.Tables.SetPedPropIndex(Kentas.F.Tables.PlayerPedId(), 0, Kentas.F.Sliders['Wardrobe-Self-Hat'].value, Kentas.F.Sliders['Wardrobe-SelfHat2'].value, 1) -Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 1, Kentas.F.Sliders['Wardrobe-Self-Mask'].value, Kentas.F.Sliders['Wardrobe-SelfMask2'].value, 1) -Kentas.F.Tables.SetPedPropIndex(Kentas.F.Tables.PlayerPedId(), 1, Kentas.F.Sliders['Wardrobe-Self-Glasses'].value, Kentas.F.Sliders['Wardrobe-SelfGlasses2'].value, 1) -Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 11, Kentas.F.Sliders['Wardrobe-Self-Torso'].value, Kentas.F.Sliders['Wardrobe-SelfTorso2'].value, 1) -Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 8, Kentas.F.Sliders['Wardrobe-Self-TSHIRT'].value, Kentas.F.Sliders['Wardrobe-SelfTSHIRT2'].value, 1) -Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 4, Kentas.F.Sliders['Wardrobe-Self-Pants'].value, Kentas.F.Sliders['Wardrobe-SelfPants2'].value, 1) -Kentas.F.Tables.SetPedComponentVariation(Kentas.F.Tables.PlayerPedId(), 6, Kentas.F.Sliders['Wardrobe-Self-Shoes'].value, Kentas.F.Sliders['Wardrobe-SelfShoes2'].value, 1) --end end if SliderIndex.value > SliderIndex.maximum then

SliderIndex.value = SliderIndex.maximum elseif SliderIndex.value < SliderIndex.minimum then SliderIndex.value = SliderIndex.minimum end local resX, resY = Kentas.F.Tables.GetActiveScreenResolution() if Kentas.F.Checks['TGMouse'] and Kentas.F.OpenMenu then local nKDX, nKDY = Kentas.F.Checks.KeyboardDragXWM, Kentas.F.Checks.KeyboardDragYWM local c_x = Kentas.F.Tables.GetDisabledControlNormal(0, 239) local c_y = Kentas.F.Tables.GetDisabledControlNormal(0, 240) local Vzs_x, dry_r = ((0.23 - 0.019) - (0.2095 0.1854))+nKDX, ((0.23 - 0.019) + (0.2364 - 0.2095))+nKDX if Kentas.F.Tables.Functions.CreateZone((0.23 0.019)+nKDX, y+nKDY, 0.05, 10/resY) then if Kentas.F.Tables.IsDisabledControlPressed(0, 24) then -Kentas.F.Tables.SetCursorLocation(Kentas.F.Tables.GetDisabledControlNormal(0, 239), (y+0.01)+nKDY) SliderIndex.value = math.floor((((c_x) (Vzs_x)) / (dry_r - Vzs_x) ) * (SliderIndex.maximum - SliderIndex.minimum) SliderIndex.minimum) end end end

== "combo" then

elseif Kentas.F.submenu[Kentas.activemenu].options[i].type

if Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then local selectedIndex = Kentas.F.submenu[Kentas.activemenu].options[i].index.b[Kentas.F.submenu[Kentas.acti vemenu].options[i].index.a] local itemsCount = #Kentas.F.submenu[Kentas.activemenu].options[i].index.b if Kentas.F.submenu[Kentas.activemenu].options[i].text == 'Bone' then local x = 0.32 local y = 0.35 Kentas.F.Tables.DrawSprite("BonePed", "BonePed_a", x, y, 0.1, 0.23, 0.0, 255, 255, 255, 255) local currentbone = Kentas.F.Combos['Bone'].b[Kentas.F.Combos['Bone'].a] if currentbone == "Head" then nx, ny = x-0.003-0.003, y-0.01-0.095

nx2, ny2 = x-0.003, y-0.095 elseif currentbone == "Neck" then nx, ny = x-0.003-0.003, y-0.01-0.08 nx2, ny2 = x-0.003, y-0.08 elseif currentbone == "Torso" then nx, ny = x-0.003-0.003, y-0.01-0.08+0.03 nx2, ny2 = x-0.003, y-0.08+0.03 elseif currentbone == "Left-Hand" then nx = x-0.041 ny = y-0.015 nx2 = x-0.038 ny2 = y-0.005 elseif currentbone == "Right-Hand" then nx = x-0.041+0.073 ny = y-0.015 nx2 = x-0.038+0.073 ny2 = y-0.005 elseif currentbone == "Pelvis" then nx = x-0.041+0.035 ny = y-0.015 nx2 = x-0.038+0.035 ny2 = y-0.005 elseif currentbone == "Left-Knee" then nx = x-0.041+0.023 ny = y-0.015+0.04 nx2 = x-0.038+0.023 ny2 = y-0.005+0.04 elseif currentbone == "Right-Knee" then nx = x-0.041+0.055 ny = y-0.015+0.04

end

nx2 = x-0.038+0.055 ny2 = y-0.005+0.04

Kentas.F.Tables.Functions.DrawTxt('+', nx+Kentas.F.Checks.KeyboardDragXWM, ny+Kentas.F.Checks.KeyboardDragYWM, 0.35, 0.25, {r=255, g=255, b=255, a=255}, false, 0, true) end if Kentas.F.Tables.IsDisabledControlPressed(0, 189) and (Kentas.F.ComboDelay or 0) 1 then Kentas.F.submenu[Kentas.activemenu].options[i].index.a = Kentas.F.submenu[Kentas.activemenu].options[i].index.a - 1 else Kentas.F.submenu[Kentas.activemenu].options[i].index.a = itemsCount end elseif Kentas.F.Tables.IsDisabledControlPressed(0,

190) and (Kentas.F.ComboDelay or 0) = 2 and Kentas.F.submenu[Kentas.activemenu].options[i] then if Kentas.F.submenu[Kentas.activemenu].options[i].text == "aimbot keybind" then Kentas.F.submenu[Kentas.activemenu].options[i].func() end if Kentas.F.submenu[Kentas.activemenu].options[i].text == "open menu" then Kentas.F.submenu[Kentas.activemenu].options[i].func() end end end end

end)

end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 194) and Kentas.F.submenu[Kentas.activemenu].selectedfeature+Kentas.F.submenu[Kentas.activem enu].scroll == i then __CitIn__.CreateThread(function() if Kentas.F.Checks['configuration:menusounds'] then Kentas.F.Tables.PlaySoundFrontend(-1, 'BACK', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true) end if Kentas.activemenu == 'main' then Kentas.F.OpenMenu = not Kentas.F.OpenMenu else Kentas.activemenu = Kentas.F.submenu[Kentas.activemenu].parentmenu __CitIn__.Wait(1) end end) end end end end if Kentas.activemenu == 'onlineOptions' then Kentas.F.Tables.Functions.InfoAboutPlayer(Kentas.F.SelectedPlayer)

elseif Kentas.activemenu == 'Wardrobe' then for i = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 0) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-hat'].b, i) end for ia = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 1) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-mask'].b, ia) end for ib = 1, Kentas.F.Tables.GetNumberOfPedPropDrawableVariations(Kentas.F.Tables.PlayerPedId(), 1) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-glasses'].b, ib) end for ib = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 3) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-Torso'].b, ib) end for ib = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 8) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-TSHIRT'].b, ib) end for ib = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 4) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-Pants'].b, ib) end for ib = 1, Kentas.F.Tables.GetNumberOfPedDrawableVariations(Kentas.F.Tables.PlayerPedId(), 6) do __KentasStrings__.strings:tableinsert(Kentas.F.Combos['wardrobe-Shoes'].b, ib) end elseif Kentas.activemenu == 'Glife' then Kentas.F.submenu['Glife'].options = {} __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Infinite Ammo', type = 'checkbox', bind = 'customammo:Infinite Ammov2', check = 'customammo:InfiniteAmmov2'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Teleport zombies', type = 'checkbox', bind = 'glife:Teleport zombies', check = 'glife:Teleportzombies'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Looting custom', type = 'sepa', bind = ''}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Kill', type = 'checkbox', bind = 'glife:Kill', check = 'glife:Kill'})

__KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Invisible', type = 'checkbox', bind = 'glife:Invisible', check = 'glife:Invisible'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Auto Looting', type = 'checkbox', bind = 'glife:Auto Looting', check = 'glife:AutoLooting'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Vehicle stealer', type = 'sepa', bind = ''}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Auto Steal', type = 'checkbox', bind = 'glife:Auto Steal', check = 'glife:Auto Steal'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'Empty check', type = 'checkbox', bind = 'glife:Empty check', check = 'glife:Empty check'}) __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = 'all vehicles', type = 'sepa', bind = ''}) if #Kentas.F.submenu['Glife'].options > Kentas.maxoptcount then if Kentas.F.submenu['Glife'].scroll > #Kentas.F.submenu['Glife'].options-Kentas.maxoptcount then Kentas.F.submenu['Glife'].scroll = #Kentas.F.submenu['Glife'].options-Kentas.maxoptcount end end for vehicles in Kentas.F.Tables.Functions.EnumerateVehicles() do if vehicles ~= nil then __KentasStrings__.strings:tableinsert(Kentas.F.submenu['Glife'].options, {text = Kentas.F.Tables.GetDisplayNameFromVehicleModel(Kentas.F.Tables.GetEntityModel(vehic les)), bind = 'glife:'..vehicles, type = 'button', func = function() local seats = Kentas.F.Tables.GetVehicleMaxNumberOfPassengers(vehicles) for i = 0, seats do if Kentas.F.Tables.IsVehicleSeatFree(vehicles, i) then Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), vehicles, i) end end end}) end end elseif Kentas.activemenu == 'online' then --[[local players = Kentas.F.Tables.GetActivePlayers() if Kentas.F.allplayers ~= #players then Kentas.F.submenu['online'].options = {} Kentas.F.OnlinePlayers.T = {} for k, v in __KentasStrings__.strings:pairs(players) do

__KentasStrings__.strings:tableinsert(Kentas.F.OnlinePlayers.T, Kentas.F.Tables.GetPlayerServerId(v)) end

__KentasStrings__.strings:tableinsert(Kentas.F.submenu['online'].options, {text = 'Destroyer', type = 'submenu', bind = 'main:Destroyer', menu = 'Destroyer', player = nil}) for k,v in Kentas.F.Tables.Functions.pairsSorted(Kentas.F.OnlinePlayers.T) do __KentasStrings__.strings:tableinsert(Kentas.F.submenu['online'].options, {text = '[' .. v .. '] ' .. Kentas.F.Tables.GetPlayerName(Kentas.F.Tables.GetPlayerFromServerId(v)), bind = v..':playergay', type = 'submenu', menu = 'onlineOptions', player = Kentas.F.Tables.GetPlayerFromServerId(v), func = function() end}) end Kentas.F.allplayers = #players end]] if #Kentas.F.submenu['online'].options > Kentas.maxoptcount then if Kentas.F.submenu['online'].scroll > #Kentas.F.submenu['online'].options-Kentas.maxoptcount then Kentas.F.submenu['online'].scroll = #Kentas.F.submenu['online'].options-Kentas.maxoptcount end end

local players = Kentas.F.Tables.GetActivePlayers() Kentas.F.submenu['online'].options = {} __KentasStrings__.strings:tableinsert(Kentas.F.submenu['online'].options, {text = 'Destroyer', type = 'submenu', bind = 'main:Destroyer', menu = 'Destroyer', player = nil}) for k, v in __KentasStrings__.strings:pairs(players) do __KentasStrings__.strings:tableinsert(Kentas.F.submenu['online'].options, {text = '[' .. Kentas.F.Tables.GetPlayerServerId(v) .. '] ' .. Kentas.F.Tables.GetPlayerName(v), bind = v..':playergay', type = 'submenu', menu = 'onlineOptions', player = v, func = function() end}) end end

then

for k, v in __KentasStrings__.strings:pairs(Kentas.F.Checks.Binds) do if v.val ~= 12345 then if v.type == "checkbox" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, v.val)

if Kentas.F.Checks[__KentasStrings__.strings:tostring(v.t)] then Kentas.F.Checks[__KentasStrings__.strings:tostring(v.t)] = false elseif not Kentas.F.Checks[__KentasStrings__.strings:tostring(v.t)] then Kentas.F.Checks[__KentasStrings__.strings:tostring(v.t)] = true end

end elseif v.type == "button" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, v.val)

then

if v.r ~= nil then v.t(v.r) else v.t(v.r) end

end elseif v.type == "submenu" then if Kentas.F.Tables.IsDisabledControlJustPressed(0, v.val)

then

end

end

end

end

Kentas.activemenu = v.t

Kentas.F.Tables.Functions.LastVehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId(), true) end end) __CitIn__.CreateThread(function() while Kentas.enabled do __CitIn__.Wait(1) if Kentas.F.Checks['misc:freecam'] then if Kentas.F.ThisCamFromFreecam == nil then Kentas.F.ThisCamFromFreecam = Kentas.F.Tables.CreateCam('DEFAULT_SCRIPTED_Camera', 1) cam = Kentas.F.ThisCamFromFreecam end Kentas.F.Tables.RenderScriptCams(1, 0, 0, 1, 1) Kentas.F.Tables.SetCamActive(Kentas.F.ThisCamFromFreecam, true) Kentas.F.Tables.SetCamCoord(Kentas.F.ThisCamFromFreecam, Kentas.F.Tables.GetGameplayCamCoord()) local offsetRotX = Kentas.F.Tables.GetGameplayCamRot(2).x local offsetRotY = Kentas.F.Tables.GetGameplayCamRot(2).y local offsetRotZ = Kentas.F.Tables.GetGameplayCamRot(2).z while Kentas.F.Tables.DoesCamExist(Kentas.F.ThisCamFromFreecam) do __CitIn__.Wait(0) if not Kentas.F.Checks['misc:freecam'] then Kentas.F.Tables.DestroyCam(Kentas.F.ThisCamFromFreecam) Kentas.F.Tables.RenderScriptCams(false, false, 0, 1, 0) Kentas.F.Tables.SetFocusEntity(Kentas.F.Tables.PlayerPedId()) Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), false) Kentas.F.ThisCamFromFreecam = nil break end local playerRot = Kentas.F.Tables.GetEntityRotation(Kentas.F.Tables.PlayerPedId(), 2)

local rotX = playerRot.x local rotY = playerRot.y local rotZ = playerRot.z offsetRotX = offsetRotX (Kentas.F.Tables.GetDisabledControlNormal(1, 2) * 8.0) offsetRotZ = offsetRotZ (Kentas.F.Tables.GetDisabledControlNormal(1, 1) * 8.0) if (offsetRotX > 90.0) then offsetRotX = 90.0 elseif (offsetRotX < -90.0) then offsetRotX = -90.0 end if (offsetRotY > 90.0) then offsetRotY = 90.0 elseif (offsetRotY < -90.0) then offsetRotY = -90.0 end if (offsetRotZ > 360.0) then offsetRotZ = offsetRotZ - 360.0 elseif (offsetRotZ < -360.0) then offsetRotZ = offsetRotZ + 360.0 end local x, y, z = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamF romFreecam)) local camCoords = Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreecam) local v3, forward = Kentas.F.Tables.Functions.CamRightVect(Kentas.F.ThisCamFromFreecam), Kentas.F.Tables.Functions.CamFwdVect(Kentas.F.ThisCamFromFreecam) local speedMultiplier = nil local currentmode = Kentas.F.Tables.Functions.FreecamModes[Kentas.F.Tables.Functions.FreecamMode] local xspeed = Kentas.F.Sliders['freecam-speed'].value local currenttext = currentmode..' | Speed: '..xspeed..' | ('..Kentas.F.Tables.Functions.FreecamMode..' / '..#Kentas.F.Tables.Functions.FreecamModes..')' Kentas.F.Tables.Functions.DrawTxt(currenttext, 0.5, 0.957, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true) Kentas.F.Tables.SetTextOutline() Kentas.F.Tables.Functions.DrawTxt('+', 0.5, 0.487, 0.5, 0.3, {r=255, g=255, b=255, a=255}, true, 0) Kentas.F.Tables.SetCamFov(Kentas.F.ThisCamFromFreecam, Kentas.F.Sliders['freecam-fov'].value+0.0) Kentas.F.Tables.SetHdArea(camCoords.x, camCoords.y, camCoords.z, 50.0) Kentas.F.Tables.DisableAllControlActions() Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), true) if Kentas.F.Tables.IsDisabledControlPressed(0, 21) then speedMultiplier = 3.0*xspeed elseif Kentas.F.Tables.IsDisabledControlPressed(0, 36) then speedMultiplier = 0.025*xspeed

else end

speedMultiplier = 0.25*xspeed

if Kentas.F.Tables.IsDisabledControlPressed(0, 32)

then

local newCamPos = camCoords + forward * speedMultiplier Kentas.F.Tables.SetCamCoord(Kentas.F.ThisCamFromFreecam, newCamPos.x, newCamPos.y, newCamPos.z) end if Kentas.F.Tables.IsDisabledControlPressed(0, 33) then local newCamPos = camCoords + forward * -

speedMultiplier

Kentas.F.Tables.SetCamCoord(Kentas.F.ThisCamFromFreecam, newCamPos.x, newCamPos.y, newCamPos.z) end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) then local newCamPos = camCoords + v3 * -speedMultiplier Kentas.F.Tables.SetCamCoord(Kentas.F.ThisCamFromFreecam, newCamPos.x, newCamPos.y, newCamPos.z) end if Kentas.F.Tables.IsDisabledControlPressed(0, 30) then local newCamPos = camCoords + v3 * speedMultiplier Kentas.F.Tables.SetCamCoord(Kentas.F.ThisCamFromFreecam, newCamPos.x, newCamPos.y, newCamPos.z) end -- SHIFT

-- LEFT CTRL

if (Kentas.F.Tables.IsDisabledControlPressed(1, 21)) then z = z + (0.1 * 2.5) end if (Kentas.F.Tables.IsDisabledControlPressed(1, 36)) then end

z = z - (0.1 * 0.5)

Kentas.F.Tables.SetFocusArea(Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreeca m).x, Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreecam).y, Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreecam).z, 0.0, 0.0, 0.0) Kentas.F.Tables.SetCamRot(Kentas.F.ThisCamFromFreecam, offsetRotX, offsetRotY, offsetRotZ, 2) local entity = Kentas.F.Tables.Functions.GetEntityInFrontOfCam() local hit, Markerloc = Kentas.F.Tables.Functions.RayCastCam(15000.0) if Kentas.F.Tables.IsDisabledControlJustPressed(1, 14) then Kentas.F.Tables.Functions.FreecamMode = Kentas.F.Tables.Functions.FreecamMode + 1 if Kentas.F.Tables.Functions.FreecamMode > #Kentas.F.Tables.Functions.FreecamModes then Kentas.F.Tables.Functions.FreecamMode = 1 end end

if Kentas.F.Tables.IsDisabledControlJustPressed(1, 15) then Kentas.F.Tables.Functions.FreecamMode = Kentas.F.Tables.Functions.FreecamMode - 1 if Kentas.F.Tables.Functions.FreecamMode < 1 then Kentas.F.Tables.Functions.FreecamMode = #Kentas.F.Tables.Functions.FreecamModes end end if Kentas.F.Checks['misc:freecamcoords'] then Kentas.F.Tables.SetTextCentre(true) local xx2 = __KentasStrings__.strings:tonumber(__KentasStrings__.strings:format("%.2f", Markerloc.x)) local yy2 = __KentasStrings__.strings:tonumber(__KentasStrings__.strings:format("%.2f", Markerloc.y)) local zz2 = __KentasStrings__.strings:tonumber(__KentasStrings__.strings:format("%.2f", Markerloc.z)) if xx2 == 0.0 or yy2 == 0.0 or zz2 == 0.0 then text = 'Not found!' else text = 'X: '..xx2..' Y: '..yy2..' Z: '..zz2 end Kentas.F.Tables.Functions.DrawTxt(text, 0.5035, 0.501, 0.5, 0.25, {r=255, g=255, b=255, a=255}, false, 4) end if currentmode == 'Look Around' then if Kentas.F.Tables.IsDisabledControlPressed(0, 24) then if entity ~= nil then if not Kentas.F.Tables.Functions.Hovering then nentity = entity end end Kentas.F.Tables.Functions.Hovering = true

else

then

Kentas.F.Tables.Functions.Hovering = false end if Kentas.F.Tables.DoesEntityExist(nentity) then if Kentas.F.Tables.IsDisabledControlPressed(0, 24) Kentas.F.Tables.Functions.Hovering = true

else end

Kentas.F.Tables.Functions.Hovering = false

end if Kentas.F.Tables.Functions.Hovering then local coords = Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreecam) + (Kentas.F.Tables.Functions.RotToDir(Kentas.F.Tables.GetCamRot(Kentas.F.ThisCamFromF reecam, 2)) * 15) Kentas.F.Tables.NetworkHasControlOfEntity(nentity) Kentas.F.Tables.SetEntityCoords(nentity, coords) end elseif currentmode == 'Teleporting' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24)

then Kentas.F.Tables.SetEntityCoords(Kentas.F.Tables.PlayerPedId(), Markerloc.x, Markerloc.y, Markerloc.z) end elseif currentmode == 'Player Bug' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then if entity ~= 0 and Kentas.F.Tables.DoesEntityExist(entity) and Kentas.F.Tables.GetEntityType(entity) ~= 0 or nil then local prop = Kentas.F.Tables.GetHashKey('prop_atm_01') while not Kentas.F.Tables.HasModelLoaded(prop) do __CitIn__.Wait(0) Kentas.F.Tables.RequestModel(prop) end local prop = Kentas.F.Tables.CreateObject(prop, 0, 0, 0, true, true, false) Kentas.F.Tables.SetEntityVisible(prop, 0, 0) Kentas.F.Tables.AttachEntityToEntity(prop, entity, Kentas.F.Tables.GetPedBoneIndex(entity, 57005), 0, 0, -1.0, 0, 0, 0, false, true, true, true, 1, true) end end elseif currentmode == 'Shooting' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Tables.ShootSingleBulletBetweenCoords(Markerloc.x+0.001, Markerloc.y+0.001, Markerloc.z+0.001, Markerloc.x, Markerloc.y, Markerloc.z, 1.0, true, Kentas.F.Tables.GetHashKey('weapon_combatpistol'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) elseif Kentas.F.Tables.IsDisabledControlPressed(0, 25) then Kentas.F.Tables.ShootSingleBulletBetweenCoords(Markerloc.x+0.001, Markerloc.y+0.001, Markerloc.z+0.001, Markerloc.x, Markerloc.y, Markerloc.z, 1.0, true, Kentas.F.Tables.GetHashKey('weapon_combatpistol'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) end elseif currentmode == 'Taze' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Tables.ShootSingleBulletBetweenCoords(Markerloc.x+0.001, Markerloc.y+0.001, Markerloc.z+0.001, Markerloc.x, Markerloc.y, Markerloc.z, 1, true, Kentas.F.Tables.GetHashKey('weapon_stungun'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) elseif Kentas.F.Tables.IsDisabledControlPressed(0, 25) then Kentas.F.Tables.ShootSingleBulletBetweenCoords(Markerloc.x+0.001, Markerloc.y+0.001, Markerloc.z+0.001, Markerloc.x, Markerloc.y, Markerloc.z, 1, true, Kentas.F.Tables.GetHashKey('weapon_stungun'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) end

then

elseif currentmode == 'RPG' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24)

Kentas.F.Tables.RequestWeaponAsset(Kentas.F.Tables.GetHashKey('weapon_rpg')) Kentas.F.Tables.ShootSingleBulletBetweenCoords(Kentas.F.Tables.GetCamCoord(Kentas.F .ThisCamFromFreecam) + (Kentas.F.Tables.Functions.RotToDir(Kentas.F.Tables.GetCamRot(Kentas.F.ThisCamFromF reecam, 2)) * 15), Markerloc.x, Markerloc.y, Markerloc.z, 1, true, Kentas.F.Tables.GetHashKey('weapon_rpg'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) elseif Kentas.F.Tables.IsDisabledControlPressed(0, 25) then Kentas.F.Tables.RequestWeaponAsset(Kentas.F.Tables.GetHashKey('weapon_rpg')) Kentas.F.Tables.ShootSingleBulletBetweenCoords(Kentas.F.Tables.GetCamCoord(Kentas.F .ThisCamFromFreecam) + (Kentas.F.Tables.Functions.RotToDir(Kentas.F.Tables.GetCamRot(Kentas.F.ThisCamFromF reecam, 2)) * 15), Markerloc.x, Markerloc.y, Markerloc.z, 1, true, Kentas.F.Tables.GetHashKey('weapon_rpg'), Kentas.F.Tables.PlayerPedId(), true, false, -1.0) end elseif currentmode == 'Fire' then if Kentas.F.Tables.IsDisabledControlPressed(0, 24) then Kentas.F.Tables.SpawnParticle("core", "ent_sht_petrol_fire", Markerloc.x, Markerloc.y, Markerloc.z, 0, 0, 0, 0.3, 0, 0, 0) end elseif currentmode == 'Props' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then if Kentas.F.IsCustomPropmen == 'random' then currentprop = Kentas.F.Tables.Functions.PropsSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.PropsSpawnerModes)] else currentprop = Kentas.F.IsCustomPropmen end local __prophash__ = Kentas.F.Tables.GetHashKey(currentprop) Kentas.F.Tables.CreateObject(__prophash__, Markerloc.x, Markerloc.y, Markerloc.z, 1, 1, 1) end then

if Kentas.F.Tables.IsDisabledControlJustPressed(0, 25)

local __NVALUE__ = Kentas.F.Tables.Functions.KBInput('prop to select', '', 25) Kentas.F.IsCustomPropmen = __NVALUE__ end Kentas.F.Tables.Functions.DrawTxt('RMB To select prop | '..Kentas.F.IsCustomPropmen, 0.502, 0.977, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true, 4) elseif currentmode == 'Ped Spawning' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 25) then

local __NVALUE__ = Kentas.F.Tables.Functions.KBInput('vehicle to select', '', 25) Kentas.F.IsCustomPedMen = __NVALUE__ end Kentas.F.Tables.Functions.DrawTxt('RMB To select ped | '..Kentas.F.IsCustomPedMen, 0.502, 0.977, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true, 4) if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then __CitIn__.CreateThread(function() if Kentas.F.IsCustomPedMen == 'random' then currentped = Kentas.F.Tables.Functions.PedsSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.PedsSpawnerModes)] else currentped = Kentas.F.IsCustomPedMen end local __pedmodel__ = Kentas.F.Tables.GetHashKey(currentped) Kentas.F.Tables.RequestModel(__pedmodel__) while not Kentas.F.Tables.HasModelLoaded(__pedmodel__) do __CitIn__.Wait(10) Kentas.F.Tables.RequestModel(__pedmodel__) end Kentas.F.Tables.CreatePed(21, __pedmodel__, Markerloc.x, Markerloc.y, Markerloc.z, 0.0, true, true) end) end elseif currentmode == 'Vehicles Spammer' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then __CitIn__.CreateThread(function() for i = 1, 10 do local currentveh = Kentas.F.Tables.Functions.VehiclesSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.VehiclesSpawnerModes)] local __VehicleHash__ = Kentas.F.Tables.GetHashKey(currentveh) Kentas.F.Tables.RequestModel(__VehicleHash__) while not Kentas.F.Tables.HasModelLoaded(__VehicleHash__) do __CitIn__.Wait(0) end Kentas.F.Tables.CreateVehicle(__VehicleHash__, Markerloc.x, Markerloc.y, Markerloc.z, 0.0, false, false) end end) end elseif currentmode == 'Ped Spammer' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then __CitIn__.CreateThread(function() for i = 1, 10 do local currentped = Kentas.F.Tables.Functions.PedsSpawnerModes[__KentasStrings__.strings:random(1,

#Kentas.F.Tables.Functions.PedsSpawnerModes)] local __pedmodel__ = Kentas.F.Tables.GetHashKey(currentped) Kentas.F.Tables.RequestModel(__pedmodel__) while not Kentas.F.Tables.HasModelLoaded(__pedmodel__) do __CitIn__.Wait(10) Kentas.F.Tables.RequestModel(__pedmodel__) end Kentas.F.Tables.CreatePed(21, __pedmodel__, Markerloc.x, Markerloc.y, Markerloc.z, 0.0, true, true) end end) end elseif currentmode == 'Ptfx Spammer' then --local p1 = Kentas.F.Tables.Functions.ParticleModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.ParticleModes)] if Kentas.F.Tables.IsDisabledControlJustPressed(0, 190) then Kentas.F.Tables.Functions.ParticleMode = Kentas.F.Tables.Functions.ParticleMode + 1 if Kentas.F.Tables.Functions.ParticleMode > #Kentas.F.Tables.Functions.ParticleModes then Kentas.F.Tables.Functions.ParticleMode = 1 end end if Kentas.F.Tables.IsDisabledControlJustPressed(0, 189) then Kentas.F.Tables.Functions.ParticleMode = Kentas.F.Tables.Functions.ParticleMode - 1 if Kentas.F.Tables.Functions.ParticleMode < 1 then Kentas.F.Tables.Functions.ParticleMode = #Kentas.F.Tables.Functions.ParticleModes end end if Kentas.F.Tables.IsDisabledControlPressed(0, 24) then __CitIn__.CreateThread(function() Kentas.F.Tables.SpawnParticle(Kentas.F.Tables.Functions.ParticleModes[Kentas.F.Tabl es.Functions.ParticleMode].a, Kentas.F.Tables.Functions.ParticleModes[Kentas.F.Tables.Functions.ParticleMode].b, Markerloc.x, Markerloc.y, Markerloc.z, 0, 0, 0, Kentas.F.Tables.Functions.ParticleSizel+0.0, 0, 0, 0) end) end if Kentas.F.Tables.IsDisabledControlPressed(0, 25) then local nsize = __KentasStrings__.strings:tonumber(Kentas.F.Tables.Functions.KBInput('Size', '', 25)) if __KentasStrings__.strings:type(nsize) == 'number' then Kentas.F.Tables.Functions.ParticleSizel = nsize+0.0 end end Kentas.F.Tables.Functions.DrawTxt('~c~Particle:

~o~'..Kentas.F.Tables.Functions.ParticleModes[Kentas.F.Tables.Functions.ParticleMod e].c .. ' ~c~| ~o~('..Kentas.F.Tables.Functions.ParticleSizel..') ~c~| ~o~RMB to change', 0.502, 0.977, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true, 4)

then

elseif currentmode == 'Vehicles' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 25)

local __NVALUE__ = Kentas.F.Tables.Functions.KBInput('vehicle to select', '', 25) Kentas.F.IsCustomVehmen = __NVALUE__ end Kentas.F.Tables.Functions.DrawTxt('RMB To select vehicle | '..Kentas.F.IsCustomVehmen, 0.502, 0.977, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true, 4) if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then __CitIn__.CreateThread(function() if Kentas.F.IsCustomVehmen == 'random' then currentveh = Kentas.F.Tables.Functions.VehiclesSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.VehiclesSpawnerModes)] else currentveh = Kentas.F.IsCustomVehmen end local __VehicleHash__ = Kentas.F.Tables.GetHashKey(currentveh) Kentas.F.Tables.RequestModel(__VehicleHash__) while not Kentas.F.Tables.HasModelLoaded(__VehicleHash__) do __CitIn__.Wait(0) end Kentas.F.Tables.CreateVehicle(__VehicleHash__, Markerloc.x, Markerloc.y, Markerloc.z, 0.0, true, false) end) end elseif currentmode == 'Entity Deleter' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then if entity ~= nil then Kentas.F.Tables.DeleteEntity(entity) end end elseif currentmode == 'Freezer' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then if entity ~= nil then Kentas.F.Tables.FreezeEntityPosition(entity, true) end end elseif currentmode == 'Explosions' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24) then Kentas.F.Tables.AddExplode(Markerloc.x, Markerloc.y, Markerloc.z, 7, 1234.0, true, false, 0.0) end elseif currentmode == 'Car stealer' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24)

and Kentas.F.Tables.DoesEntityExist(entity) and Kentas.F.Tables.IsEntityAVehicle(entity) then Kentas.F.Tables.NetworkRequestControlOfEntity(entity) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, 4) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, 3) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, 2) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, 1) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, 0) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.PlayerPedId(), entity, -1) end elseif currentmode == 'Shoot vehicles' then if Kentas.F.Tables.IsDisabledControlJustPressed(0, 25) then local __NVALUE__ = Kentas.F.Tables.Functions.KBInput('vehicle to select', '', 25) Kentas.F.IsCustomVehmen2 = __NVALUE__ end Kentas.F.Tables.Functions.DrawTxt('RMB To select vehicle | '..Kentas.F.IsCustomVehmen2, 0.502, 0.977, 0.35, 0.35, {r=255, g=255, b=255, a=255}, true, 4) if Kentas.F.Tables.IsDisabledControlJustPressed(0, 24)

then

if Kentas.F.IsCustomVehmen2 == 'random' then currentveh = Kentas.F.Tables.Functions.VehiclesSpawnerModes[__KentasStrings__.strings:random(1, #Kentas.F.Tables.Functions.VehiclesSpawnerModes)] else currentveh = Kentas.F.IsCustomVehmen2 end local __VehicleHash__ = Kentas.F.Tables.GetHashKey(currentveh) Kentas.F.Tables.RequestModel(__VehicleHash__) if not Kentas.F.Tables.HasModelLoaded(__VehicleHash__) then Kentas.F.Tables.RequestModel(__VehicleHash__) else local veh = Kentas.F.Tables.CreateVehicle(__VehicleHash__, Kentas.F.Tables.GetCamCoord(Kentas.F.ThisCamFromFreecam), 0.0, true, false) Kentas.F.Tables.SetVehicleEngineOn(veh, true, true, true) Kentas.F.Tables.SetEntityRotation(veh, Kentas.F.Tables.GetCamRot(Kentas.F.ThisCamFromFreecam, 2), 0.0, 0.0, 0.0, true) Kentas.F.Tables.SetVehicleForwardSpeed(veh, 500.0) end end

end

end

end

if Kentas.F.Checks['rccar:spawn'] then local t1 = 0 local t2 = 0 if rctimer < 1 then if Kentas.F.Tables.IsModelValid(Kentas.F.Tables.GetHashKey(Kentas.F.Tables.RC__spawnna me__)) and Kentas.F.Tables.IsModelAVehicle(Kentas.F.Tables.GetHashKey(Kentas.F.Tables.RC__spaw nname__)) then spawnname = Kentas.F.Tables.RC__spawnname__ else spawnname = 'rcbandito' end local veh = Kentas.F.Tables.GetHashKey(spawnname or 'rcbandito') local ped = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') Kentas.F.Tables.RequestModel(ped) Kentas.F.Tables.RequestModel(veh) while not Kentas.F.Tables.HasModelLoaded(ped) and t1 < 50 do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(ped) t1 = t1 + 1 end while not Kentas.F.Tables.HasModelLoaded(veh) and t2 < 50 do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(veh) t2 = t2 + 1 end Kentas.F.Tables.RC_veh_ = Kentas.F.Tables.CreateVehicle(veh, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId()), 1, 1, 1) Kentas.F.Tables.RC_ped_ = Kentas.F.Tables.CreatePed(31, ped, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId()), 0.0, true, true) --TaskSetBlockingOfNonTemporaryEvents(_ped_, true) Kentas.F.Tables.NetworkRequestControlOfEntity(Kentas.F.Tables.RC_veh_) Kentas.F.Tables.SetVehicleEngineOn(Kentas.F.Tables.RC_veh_, true) Kentas.F.Tables.SetPedAlertness(Kentas.F.Tables.RC_ped_, 0.0) Kentas.F.Tables.SetPedIntoVehicle(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, -1) Kentas.F.Tables.SetVehicleEngineOn(Kentas.F.Tables.RC_veh_, true, true) Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.RC_ped_, false, false) rctimer = rctimer + 1 end if Kentas.F.Tables.IsModelValid(Kentas.F.Tables.GetHashKey(Kentas.F.Tables.RC__spawnna me__)) and Kentas.F.Tables.IsModelAVehicle(Kentas.F.Tables.GetHashKey(Kentas.F.Tables.RC__spaw nname__)) then local t1 = 0 local t2 = 0 local camrc = camrc if not camrc ~= nil then

camrc = Kentas.F.Tables.CreateCam("DEFAULT_SCRIPTED_Camera", 1) end Kentas.F.Tables.RenderScriptCams(1, 0, 0, 1, 1) Kentas.F.Tables.SetCamActive(camrc, true) local coords = Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.RC_veh_) Kentas.F.Tables.SetCamCoord(camrc, coords.x, coords.y, coords.z + 3) Kentas.F.Tables.SetCamRot(cam, Kentas.F.Tables.GetEntityRotation(Kentas.F.Tables.RC_veh_), 2) local local local local

offsetRotX = 0.0 OffsetZ = 0.0 offsetRotY = 0.0 offsetRotZ = 0.0

Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0, Kentas.F.Tables.DisableControlAction(0,

32, 31, 30, 34,

true) true) true) true)

-----

W S D A

while Kentas.F.Tables.DoesCamExist(camrc) do __CitIn__.Wait(0) if not Kentas.F.Checks['rccar:spawn'] then if Kentas.F.Tables.DoesEntityExist(Kentas.F.Tables.RC_veh_) then Kentas.F.Tables.DeleteEntity(Kentas.F.Tables.RC_veh_) end Kentas.F.Tables.DeleteEntity(Kentas.F.Tables.RC_ped_) Kentas.F.Tables.DestroyCam(camrc, false) Kentas.F.Tables.RenderScriptCams(false, false, 0, 1, 0) Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), false) Kentas.F.Tables.SetFocusEntity(Kentas.F.Tables.PlayerPedId()) break end if Kentas.F.Checks['rccar:invisible'] then Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.RC_veh_, false, false) else Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.RC_veh_, true, true) end if Kentas.F.Checks['rccar:explode'] then Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.RC_veh_) , 4, 1.0, true, false, 0.0) end

if Kentas.F.Tables.IsDisabledControlPressed(0, 129) and not Kentas.F.Tables.IsDisabledControlPressed(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 9, 1) end if Kentas.F.Tables.IsDisabledControlJustReleased(0, 129) or Kentas.F.Tables.IsDisabledControlJustReleased(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 6, 2500) end if Kentas.F.Tables.IsDisabledControlPressed(0, 130) and not Kentas.F.Tables.IsDisabledControlPressed(0, 129) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 22, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 89) and Kentas.F.Tables.IsDisabledControlPressed(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 13, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 90) and Kentas.F.Tables.IsDisabledControlPressed(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 14, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 129) and Kentas.F.Tables.IsDisabledControlPressed(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 30, 100) end if Kentas.F.Tables.IsDisabledControlPressed(0, 89) and Kentas.F.Tables.IsDisabledControlPressed(0, 129) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 7, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 90) and Kentas.F.Tables.IsDisabledControlPressed(0, 129) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 8, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 89) and not Kentas.F.Tables.IsDisabledControlPressed(0, 129) and not Kentas.F.Tables.IsDisabledControlPressed(0, 130) then

Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 4, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 90) and not Kentas.F.Tables.IsDisabledControlPressed(0, 129) and not Kentas.F.Tables.IsDisabledControlPressed(0, 130) then Kentas.F.Tables.TaskVehicleTempAction(Kentas.F.Tables.RC_ped_, Kentas.F.Tables.RC_veh_, 5, 1) end

local x, y, z = table.unpack(Kentas.F.Tables.GetCamCoord(camrc)) Kentas.F.Tables.AttachCamToEntity(camrc, Kentas.F.Tables.RC_veh_, 0.0, -3.4, 1.4, true) then

--[[if Kentas.F.Tables.Functions.RemoteControlCarInvisible

Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.RC_veh_, false, false) else Kentas.F.Tables.SetEntityVisible(Kentas.F.Tables.RC_veh_, true, false) end if Kentas.F.Tables.Functions.RemoteControlCarExplode then Kentas.F.Tables.AddExplode(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.RC_veh_) , 7, 1.0, true, false, 0.0) end if Kentas.F.Tables.Functions.RemoteControlCarPowerBoost then Kentas.F.Tables.SetVehicleGravityAmount(Kentas.F.Tables.RC_veh_, 27.8) else Kentas.F.Tables.SetVehicleGravityAmount(Kentas.F.Tables.RC_veh_, 9.8) end]] if not Displayed then Kentas.F.Tables.SetFocusArea(Kentas.F.Tables.GetCamCoord(camrc).x, Kentas.F.Tables.GetCamCoord(camrc).y, Kentas.F.Tables.GetCamCoord(camrc).z, 0.0, 0.0, 0.0) Kentas.F.Tables.SetCamRot(camrc, Kentas.F.Tables.GetEntityRotation(Kentas.F.Tables.RC_veh_), 2) end end end else rctimer = 0 end if Kentas.F.Checks['misc:BunnyHop'] then if Kentas.F.Tables.IsDisabledControlPressed(1, 22) and (Kentas.F.JumpDelay or 0) < Kentas.F.Tables.GetGameTimer() then

Kentas.F.JumpDelay = Kentas.F.Tables.GetGameTimer() + Kentas.F.Sliders['jump-delay'].value Kentas.F.Tables.TaskJump(Kentas.F.Tables.PlayerPedId(), true) end

end

if Kentas.F.Checks['misc:Roaddetector'] then local playerX, playerY, playerZ = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityCoords(Kentas.F.Tabl es.PlayerPedId())) local ActualRoad = Kentas.F.Tables.GetCurrentRoad(playerX, playerY, playerZ) 200) 204, 200)

Kentas.F.Tables.DrawRect_U(0.21+0.01, 0.798, 0.1, 0.025, 0, 0, 0, Kentas.F.Tables.DrawRect_U(0.161+0.01, 0.798, 0.003, 0.025, 8, 105,

Kentas.F.Tables.Functions.DrawTxt(ActualRoad, 0.175, 0.785, 0.3, 0.3, {r=255, g=255, b=255, a=255}, false, 4) end if Kentas.F.Checks['misc:Vehicledetector'] then local vehicle = Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tables.PlayerPedId()) if vehicle ~= nil then local ActualCar = Kentas.F.Tables.GetDisplayNameFromVehicleModel(Kentas.F.Tables.GetEntityModel(vehic le)) if ActualCar ~= "CARNOTFOUND" then Kentas.F.Tables.DrawRect(0.21+0.01, 0.798+0.027, 0.1, 0.025, 0, 0, 0, 200) Kentas.F.Tables.DrawRect(0.161+0.01, 0.798+0.027, 0.003, 0.025, 8, 105, 204, 200) local speed = __KentasStrings__.strings:tonumber(string.format("%.2f", (Kentas.F.Tables.GetVehicleEstimatedMaxSpeed(vehicle) * 1.60934 ))) Kentas.F.Tables.Functions.DrawTxt(ActualCar..' | Max speed: '..(speed*2)..'mph', 0.175, 0.785+0.027, 0.3, 0.3, {r=255, g=255, b=255, a=255}, false, 4) end end end if Kentas.F.Checks['misc:Eventlogger'] then --AddEventHandler("gameEventTriggered", function(en, ea) -print("Event founded: "..en) --end) _G.TriggerEvent = function(...) local a = __KentasStrings__.strings:tableunpack({...}) print("Event founded: "..a) end _G.TriggerServerEvent = function(...) local a = __KentasStrings__.strings:tableunpack({...}) print("Event founded: "..a) end TriggerEvent = function(...) local a = __KentasStrings__.strings:tableunpack({...}) print("Event founded: "..a)

end

1)

end TriggerServerEvent = function(...) local a = __KentasStrings__.strings:tableunpack({...}) print("Event founded: "..a) end

if Kentas.F.Checks['ExtraSensoryOptions:2dgraphics'] then --__CitIn__.CreateThread(function() if not cam ~= nil then cam = Kentas.F.Tables.CreateCam('DEFAULT_SCRIPTED_Camera', end if not cam ~= nil then cam = Kentas.F.Tables.CreateCam("DEFAULT_SCRIPTED_Camera",

1)

end

camera = cam

Kentas.F.Tables.RenderScriptCams(1, 0, 0, 1, 1) --Kentas.F.Tables.SetCamActive(cam, true) -- 2d graphics local offsetRotX = 0.0 local offsetRotY = 0.0 local offsetRotZ = 0.0 while Kentas.F.Tables.DoesCamExist(camera) do __CitIn__.Wait(0) Kentas.F.Tables.SetCamCoord(camera, 0.0, 0.0, 0.0) if not Kentas.F.Checks['ExtraSensoryOptions:2dgraphics']

then

Kentas.F.Tables.SetCamCoord(camera, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId())) Kentas.F.Tables.DestroyCam(camera) Kentas.F.Tables.RenderScriptCams(false, false, 0, 1, 0) Kentas.F.Tables.SetFocusEntity(Kentas.F.Tables.PlayerPedId()) break end if not Displayed then Kentas.F.Tables.SetFocusPosAndVel(Kentas.F.Tables.GetCamCoord(camera).x,Kentas.F.Ta bles.GetCamCoord(camera).y,Kentas.F.Tables.GetCamCoord(camera).z,0.0,0.0,0.0) Kentas.F.Tables.SetCamRot(camera, Kentas.F.Tables.GetGameplayCamRot(2), 2) end end --end) end

1)

if Kentas.F.Checks['Visuals:FovChanger'] then local camerat = camerat if not camerat ~= nil then camerat = Kentas.F.Tables.CreateCam("DEFAULT_SCRIPTED_Camera", end

Kentas.F.Tables.RenderScriptCams(1, 0, 0, 1, 1) Kentas.F.Tables.SetCamActive(camerat, true) while Kentas.F.Tables.DoesCamExist(camerat) do __CitIn__.Wait(0) Kentas.F.Tables.SetCamCoord(camerat, Kentas.F.Tables.GetGameplayCamCoord()) Kentas.F.Tables.SetCamRot(camerat, Kentas.F.Tables.GetGameplayCamRot(2), 2) Kentas.F.Tables.SetCamFov(camerat, Kentas.F.Sliders['gameplayfov-changer'].value+0.0) if not Kentas.F.Checks['Visuals:FovChanger'] then Kentas.F.Tables.DestroyCam(camerat, false) Kentas.F.Tables.RenderScriptCams(false, false, 0, 1, 0) Kentas.F.Tables.SetFocusEntity(Kentas.F.Tables.PlayerPedId()) break end end end if Kentas.F.Checks['misc:Remoteped'] then local camrc = camrc if not camrc ~= nil then camrc = Kentas.F.Tables.CreateCam("DEFAULT_SCRIPTED_Camera", 1) end if cockmenyoo < 1 then local t1 = 0 local ped = Kentas.F.Tables.GetHashKey('mp_m_freemode_01') Kentas.F.Tables.RequestModel(ped) while not Kentas.F.Tables.HasModelLoaded(ped) and t1 < 50 do __CitIn__.Wait(1) Kentas.F.Tables.RequestModel(ped) t1 = t1 + 1 end _ped_ = Kentas.F.Tables.CreatePed(31, ped, Kentas.F.Tables.GetEntityCoords(Kentas.F.Tables.PlayerPedId()), 0.0, true, true) Kentas.F.Tables.TaskSetBlockingOfNonTemporaryEvents(_ped_, true) Kentas.F.Tables.SetPedAlertness(_ped_, 0.0) Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), true) cockmenyoo = cockmenyoo + 1 end __CitIn__.CreateThread(function() Kentas.F.Tables.RenderScriptCams(1, 0, 0, 1, 1) Kentas.F.Tables.SetCamActive(camrc, true) local coords = Kentas.F.Tables.GetEntityCoords(_ped_) Kentas.F.Tables.SetCamCoord(camrc, coords.x, coords.y, coords.z + 3) Kentas.F.Tables.SetCamRot(cam, Kentas.F.Tables.GetEntityRotation(_ped_), 2) local local local local

offsetRotX = 0.0 OffsetZ = 0.0 offsetRotY = 0.0 offsetRotZ = 0.0

local offsetRotX2 = 0.0 local offsetRotY2 = 0.0 local offsetRotZ2 = 0.0

while Kentas.F.Tables.DoesCamExist(camrc) do __CitIn__.Wait(0) local hit, Markerloc = Kentas.F.Tables.Functions.RayCastCam(15000.0, camrc) if not Kentas.F.Checks['misc:Remoteped'] then Kentas.F.Tables.DestroyCam(camrc, false) Kentas.F.Tables.RenderScriptCams(false, false, 0, 1, 0) Kentas.F.Tables.SetFocusEntity(Kentas.F.Tables.PlayerPedId()) Kentas.F.Tables.FreezeEntityPosition(Kentas.F.Tables.PlayerPedId(), false) cockmenyoo = 0 break end local coords = Kentas.F.Tables.GetEntityCoords(_ped_) offsetRotX2 = offsetRotX2 (Kentas.F.Tables.GetDisabledControlNormal(1, 2) * 8.0) offsetRotZ2 = offsetRotZ2 (Kentas.F.Tables.GetDisabledControlNormal(1, 1) * 8.0) if (offsetRotX2 > 90.0) then offsetRotX2 = 90.0 elseif (offsetRotX2 < -90.0) then offsetRotX2 = -90.0 end if (offsetRotY2 > 90.0) then offsetRotY2 = 90.0 elseif (offsetRotY2 < -90.0) then offsetRotY2 = -90.0 end if (offsetRotZ2 > 360.0) then offsetRotZ2 = offsetRotZ2 - 360.0 elseif (offsetRotZ2 < -360.0) then offsetRotZ2 = offsetRotZ2 + 360.0 end if Kentas.F.Checks['misc:Remoteped'] then local x, y, z = __KentasStrings__.strings:tableunpack(coords) false)

0.0, -3.4, 1.0, true)

local _veh_ = Kentas.F.Tables.GetVehiclePedIsIn(_ped_, if Kentas.F.Tables.IsPedInAnyVehicle(_ped_) then Kentas.F.Tables.DetachCam(camrc) Kentas.F.Tables.AttachCamToEntity(camrc, _veh_,

Kentas.F.Tables.TaskSetBlockingOfNonTemporaryEvents(_ped_, true) Kentas.F.Tables.NetworkRequestControlOfEntity(_veh_) Kentas.F.Tables.SetVehicleEngineOn(_veh_, true)

true) 23) then 0.0, -3.4, 2.0, true) y, z)

Kentas.F.Tables.SetVehicleEngineOn(_veh_, true, if Kentas.F.Tables.IsDisabledControlJustPressed(0, Kentas.F.Tables.DetachCam(camrc) Kentas.F.Tables.AttachCamToEntity(camrc, _ped_, Kentas.F.Tables.SetEntityCoords(_ped_, x+0.2,

end if Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 9, 1) end if Kentas.F.Tables.IsDisabledControlJustReleased(0, 32) or Kentas.F.Tables.IsDisabledControlJustReleased(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 6, 2500) end if Kentas.F.Tables.IsDisabledControlPressed(0, 8) and not Kentas.F.Tables.IsDisabledControlPressed(0, 32) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 22, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) and Kentas.F.Tables.IsDisabledControlPressed(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 13, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 9) and Kentas.F.Tables.IsDisabledControlPressed(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 14, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 32) and Kentas.F.Tables.IsDisabledControlPressed(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 30, 100) end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) and Kentas.F.Tables.IsDisabledControlPressed(0, 32) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 7, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 9) and Kentas.F.Tables.IsDisabledControlPressed(0, 32) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 8, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) and not Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 8) then Kentas.F.Tables.TaskVehicleTempAction(_ped_, _veh_, 4, 1) end if Kentas.F.Tables.IsDisabledControlPressed(0, 9) and not Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 8) then

_veh_, 5, 1) then

Kentas.F.Tables.TaskVehicleTempAction(_ped_, end if Kentas.F.Tables.IsDisabledControlPressed(0, 22)

Kentas.F.Tables.SetVehicleReduceGrip(Kentas.F.Tables.GetVehiclePedIsIn(Kentas.F.Tab les.PlayerPedId(), false), true) end Kentas.F.Tables.SetCamRot(camrc, offsetRotX2, offsetRotY2, offsetRotZ2, 2) else Kentas.F.Tables.SetEntityRotation(_ped_, 0.0, offsetRotY2, offsetRotZ2, true) if Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 33) then __CitIn__.CreateThread(function() local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.PlayerPedId(), 0.0, 0.5, 0.0) Kentas.F.Tables.TaskPedSlideToCoord(_ped_, c.x, c.y, c.z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 10.0) __CitIn__.Wait(222) Kentas.F.Tables.ClearPedTasks(_ped_) end) end if not Kentas.F.Tables.IsDisabledControlPressed(0, 37) then Kentas.F.Tables.DisableAllControlActions() end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) and Kentas.F.Tables.IsDisabledControlPressed(0, 32) then Kentas.F.Tables.TaskPedSlideToCoord(_ped_, x, y+0.5, z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 100.0) end if Kentas.F.Tables.IsDisabledControlPressed(0, 235) and Kentas.F.Tables.IsDisabledControlPressed(0, 32) then Kentas.F.Tables.TaskPedSlideToCoord(_ped_, x, y-0.5, z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 100.0) end if Kentas.F.Tables.IsDisabledControlPressed(0, 34) and not Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 173) then __CitIn__.CreateThread(function() local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.PlayerPedId(), 0.5, 0.0, 0.0) Kentas.F.Tables.TaskPedSlideToCoord(_ped_, c.x, c.y, c.z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 10.0) __CitIn__.Wait(222) Kentas.F.Tables.ClearPedTasks(_ped_) end) end if Kentas.F.Tables.IsDisabledControlPressed(0, 235) and not Kentas.F.Tables.IsDisabledControlPressed(0, 32) and not Kentas.F.Tables.IsDisabledControlPressed(0, 173) then

__CitIn__.CreateThread(function() local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.PlayerPedId(), 0.5, 0.0, 0.0) Kentas.F.Tables.TaskPedSlideToCoord(_ped_, c.x, c.y, c.z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 10.0) __CitIn__.Wait(222) Kentas.F.Tables.ClearPedTasks(_ped_) end) end if Kentas.F.Tables.IsDisabledControlPressed(0, 8) then __CitIn__.CreateThread(function() local c = Kentas.F.Tables.GetOffsetFromEntityInWorldCoords(Kentas.F.Tables.PlayerPedId(), 0.0, -0.5, 0.0) Kentas.F.Tables.TaskPedSlideToCoord(_ped_, c.x, c.y, c.z, Kentas.F.Tables.GetEntityRotation(_ped_, 2), 10.0) __CitIn__.Wait(222) Kentas.F.Tables.ClearPedTasks(_ped_) end) end local weaopn = Kentas.F.Tables.GetSelectedPedWeapon(Kentas.F.Tables.PlayerPedId()) if weaopn ~= -1569615261 then Kentas.F.Tables.GiveWeaponToPed(_ped_, weaopn, 222, true, true) if Kentas.F.Tables.IsDisabledControlPressed(0, 25) then Kentas.F.Tables.ShowHudComponentThisFrame(14) Kentas.F.Tables.TaskAimGunScripted(_ped_, Kentas.F.Tables.GetHashKey("SCRIPTED_GUN_TASK_DINGY_RPG"), true, true) end if Kentas.F.Tables.IsDisabledControlPressed(0, 24) then if hit and (Kentas.F.smthlmao or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.smthlmao = Kentas.F.Tables.GetGameTimer() + 10 Kentas.F.Tables.SetPedInfiniteAmmoClip(_ped_, true) Kentas.F.Tables.SetPedShootsAtCoord(_ped_, Markerloc.x, Markerloc.y, Markerloc.z, true)

end

end

end

if Kentas.F.Tables.IsDisabledControlPressed(1, 22) and (Kentas.F.JumpDelayn or 0) < Kentas.F.Tables.GetGameTimer() then Kentas.F.JumpDelayn = Kentas.F.Tables.GetGameTimer() + 500 Kentas.F.Tables.TaskJump(_ped_, true)

23) then

end if Kentas.F.Tables.IsDisabledControlJustPressed(0,

local vehicle = Kentas.F.Tables.GetClosestVehicle(Kentas.F.Tables.GetEntityCoords(_ped_), 25.0, 0, 70) TaskEnterVehicle(_ped_, vehicle, 1.0, -1, 2.0, 1, 0) end Kentas.F.Tables.DetachCam(camrc) Kentas.F.Tables.AttachCamToEntity(camrc, _ped_, 0.0, -3.4, 1.0, true) local offsetRotX, offsetRotY, offsetRotZ = __KentasStrings__.strings:tableunpack(Kentas.F.Tables.GetEntityRotation(_ped_)) Kentas.F.Tables.SetCamRot(camrc, offsetRotX, offsetRotY, offsetRotZ, 2) end if not Displayed then Kentas.F.Tables.SetFocusArea(Kentas.F.Tables.GetCamCoord(camrc).x, Kentas.F.Tables.GetCamCoord(camrc).y, Kentas.F.Tables.GetCamCoord(camrc).z, 0.0, 0.0, 0.0) end end end end) end end end) end)