owner=owner
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TweenService = game:GetService("TweenService")
local HttpService = game:GetService("HttpService")
local LogService = game:GetService("LogService")
local OWNER_NAME = owner and owner.Name or script:GetAttribute("OwnerName")
local OWNER = Players:FindFirstChild(OWNER_NAME)
local ASSETS do
if RunService:IsStudio() then
ASSETS = require(script.MainModule)()
else
local thread = coroutine.running()
LogService.MessageOut:Once(function()
ASSETS = require(15195905128)()
coroutine.resume(thread)
end)
task.defer(print, ":3")
coroutine.yield()
end
end
local LOCALSCRIPTS = ASSETS.LocalScripts:Clone()
local MODULES = ASSETS.Modules:Clone()
local MODELS = ASSETS.Models:Clone()
local IMMUTABLE = require(MODULES.IMMUTABLE)
local LAEVATEINN = require(MODULES.LAEVATEINN)
local CSF = require(MODULES.CSF)()
local CSE = require(MODULES.CSE)()
local ANIMATOR = require(MODULES.ANIMATOR).new()
local CONNECTIONS = {}
script.Enabled = false; script:Destroy()
--[[ ----------------------------------
-- REMOTE SETUP --
---------------------------------- ]]--
-- REMOTE
local RemoteName = "[["..tostring(os.clock()).. tostring(OWNER.UserId)
RemoteName = RemoteName:sub(1, 30) -- fat name limit
local Remote = Instance.new("RemoteEvent")
Remote.Name = RemoteName
Remote.Parent = ReplicatedStorage
local RemoteRequests = {}
local function OnServerEvent(player, RequestType, ...)
if player == OWNER and RemoteRequests[RequestType] then
RemoteRequests[RequestType](...)
end
end
Remote.OnServerEvent:Connect(OnServerEvent)
-- REMOTE CHECKER
local RemoteBlackmail = {}
local RemoteCheck = RunService.Heartbeat:Connect(function()
local remotes = 0
for i, remote in ReplicatedStorage:GetChildren() do
pcall(function()
if remote:IsA("RemoteEvent") and remote.Name == RemoteName then
remotes = remotes + 1
end
end)
end
if remotes ~= 1 or CSF:IsRobloxLocked(Remote) then
pcall(function()
Remote:Destroy()
end)
for i, remote in ReplicatedStorage:GetChildren() do
pcall(function()
if remote:IsA("RemoteEvent") and remote.Name == RemoteName then
remote:Destroy()
end
end)
end
-- New Remote
Remote = Instance.new("RemoteEvent")
Remote.Name = RemoteName
Remote.Parent = ReplicatedStorage
Remote.OnServerEvent:Connect(OnServerEvent)
-- Blackmail the people trying to kill the remote by lagging the hell out of the server lolmao
local rnd = Random.new()
for i = 1, 1000 do
local part = Instance.new("Part")
table.insert(RemoteBlackmail, part)
part.CFrame = CFrame.new(rnd:NextNumber(-9999999999, 9999999999), rnd:NextNumber(-9999999999, 9999999999), rnd:NextNumber(-9999999999, 9999999999))
end
else
if #RemoteBlackmail > 0 then
for i = math.floor(#RemoteBlackmail * 2/3), 1, -1 do
RemoteBlackmail[i]:Destroy()
table.remove(RemoteBlackmail, i)
end
end
end
end)
function EFFECT(EffectName, ...)
Remote:FireAllClients("EFFECT", EffectName, ...)
end
--[[ ----------------------------------
-- CHARACTER SETUP --
---------------------------------- ]]--
local CHARACTER_MODEL = MODELS.YAGWICK:Clone()
local HEALTH_MODEL = MODELS.FakeYagwick:Clone()
local EIZOKU = IMMUTABLE.new({CHARACTER_MODEL, HEALTH_MODEL}, {workspace, workspace})
local CFRAMES = {
ROOTCF = script:GetAttribute("StartCF") or CFrame.new(0, 3, 0),
LIMBS = {}
}
local ORIGINAL_ROOTCF = CFrame.new(0, 9e3, 0)
CHARACTER_MODEL:PivotTo(ORIGINAL_ROOTCF)
HEALTH_MODEL:PivotTo(ORIGINAL_ROOTCF)
local NAME_TO_LIMB_MAP = {
["Torso"] = {
Inst = CHARACTER_MODEL.Torso,
OffsetFrom = function() return CFRAMES.ROOTCF end
},
["Head"] = {
Inst = CHARACTER_MODEL.Head,
OffsetFrom = CHARACTER_MODEL.Torso,
},
["Right Arm"] = {
Inst = CHARACTER_MODEL["Right Arm"],
OffsetFrom = CHARACTER_MODEL.Torso,
},
["Left Arm"] = {
Inst = CHARACTER_MODEL["Left Arm"],
OffsetFrom = CHARACTER_MODEL.Torso,
},
["Right Leg"] = {
Inst = CHARACTER_MODEL["Right Leg"],
OffsetFrom = CHARACTER_MODEL.Torso,
},
["Left Leg"] = {
Inst = CHARACTER_MODEL["Left Leg"],
OffsetFrom = CHARACTER_MODEL.Torso,
}
}
function GetBasePartAncestorOrRoot(instanceRep)
if instanceRep.Parent then
return instanceRep -- is root
end
local parent = instanceRep.Parent or instanceRep.ParentData.Inst
if parent:IsA("BasePart") then
return instanceRep.ParentData
else
return GetBasePartAncestorOrRoot(instanceRep.ParentData)
end
end
--// START DEFENSE
local DEFENSE_CurrentLevel = 1
local HNEnabled = true
do
local function LOOP(requiredLv)
if DEFENSE_CurrentLevel >= requiredLv then
EIZOKU:CheckEverything()
end
end
local loopTypes = {
{"Heartbeat", 1},
{"Stepped", 2},
{"HeartbeatPrio", 3},
{"SteppedPrio", 3},
{"TweenPrio", 1},
{"TaskWait", 4}
}
for _, data in loopTypes do
EIZOKU:Loop(data[1], function()
LOOP(data[2])
end)
end
end
function DEFENSE_ResetSettings()
EIZOKU.Settings = table.clone(EIZOKU.SettingsCopy)
end
function DEFENSE_ToggleHN(enabled: boolean)
HNEnabled = enabled
EIZOKU.Settings.HNEnabled = HNEnabled
DEFENSE_ChangeLevel(DEFENSE_CurrentLevel, true)
end
function DEFENSE_ChangeLevel(newLv: number, bypassCheck: boolean)
if newLv == DEFENSE_CurrentLevel and not bypassCheck then return end
DEFENSE_CurrentLevel = newLv
DEFENSE_ResetSettings()
local settings = EIZOKU.Settings
if newLv == 0 then
settings.LoopsEnabled = false
settings.EventsEnabled = false
elseif newLv == 1 then
-- hm...
elseif newLv == 2 then
settings.EventsEnabled = true
elseif newLv == 3 then
settings.EventsEnabled = true
settings.EventsPriorityGrab = true
settings.LoopSNEnabled = true
settings.LoopSN = {2}
elseif newLv == 4 then
settings.EventsEnabled = true
settings.HNEnabled = HNEnabled
settings.LoopSNEnabled = true
settings.CheckSpamEnabled = true
settings.CheckPropSNEnabled = true
end
EIZOKU.PropsCache[HEALTH_MODEL.Humanoid].DisplayName.PropValue = string.format("Yagwick [LV. %d] [HNENABLED: %s]", newLv, HNEnabled and 1 or 0)
EIZOKU:CheckEverything({DisableAttackedFuncs = true})
end
-- Hypernull alert
do
local HNALERT_Debounce = os.clock()
EIZOKU:RegisterHypernullFunc(function(method, HN)
if os.clock() - HNALERT_Debounce < 5 then return end
HNALERT_Debounce = os.clock()
EFFECT("YELLOW_ALERT", CFRAMES.ROOTCF)
end)
end
--[[ ----------------------------------
-- EOTW --
---------------------------------- ]]--
do
local KILLALL_Enabled = false
local KILLALL = LAEVATEINN.new()
KILLALL.Settings.PropertyStrength = 4
KILLALL.Settings.FunctionStrength = 1
KILLALL.Settings.LoopSNEnabled = true
KILLALL.Settings.LoopSN = {1, 3, 5, 10, 12}
local function KILL(inst: Instance)
KILLALL:ModelVoid(workspace)
local ok = pcall(function() return type(inst) end)
if not ok then
-- IS DEADLY BY ITSELF
-- may work for deadly baseparts (caught through descadded maybe)
KILLALL:LockVoid(inst)
else
local HAS_DEADLY_CHILDREN = false
pcall(function()
for _, desc in inst:GetDescendants() do
local ok = pcall(function() return type(inst) end)
if not ok then
HAS_DEADLY_CHILDREN = true
KILLALL:LockVoid(desc) -- try to void these children
end
end
end)
-- has deadly children but isn't deadly by itself
if HAS_DEADLY_CHILDREN then
KILLALL:ForceVoid(inst)
KILLALL:LockVoid(inst)
end
pcall(function()
KILLALL:AstroInHand(inst)
end)
pcall(function()
workspace:ClearAllChildren()
end)
pcall(function()
workspace.Terrain:ClearAllChildren()
end)
KILLALL:Eliminate(inst)
end
end
local function LOOP()
if not KILLALL_Enabled then return end
if HNEnabled then
KILLALL:HN(function()
for _, desc in workspace:GetDescendants() do
pcall(KILL, desc)
end
local descs = workspace:GetDescendants()
for i = #descs, 1, -1 do
pcall(KILL, descs[i])
end
end)
else
for _, desc in workspace:GetDescendants() do
pcall(KILL, desc)
end
local descs = workspace:GetDescendants()
for i = #descs, 1, -1 do
pcall(KILL, descs[i])
end
end
end
local die: RBXScriptConnection
local function DIE(inst: Instance)
if not KILLALL_Enabled then return end
die:Disconnect()
die = workspace.DescendantAdded:Connect(DIE)
KILLALL:SN({2}, KILLALL.HN, KILLALL, KILL, inst)
KILLALL:SN({1}, LOOP)
end
die = workspace.DescendantAdded:Connect(DIE)
--
local loopTypes = {"Heartbeat", "Stepped", "HeartbeatPrio", "SteppedPrio", "TweenPrio"}
KILLALL:SN({1, 3, 5, 7, 10}, function()
for _, loopType in loopTypes do
KILLALL:Loop(loopType, LOOP)
end
end)
--
function KILLALL_Activate()
KILLALL.Settings.PropertyStrength = HNEnabled and 4 or 3
KILLALL_Enabled = true
end
function KILLALL_Deactivate()
KILLALL_Enabled = false
KILLALL:ClearEvents()
end
function KILLALL_Clear()
KILLALL_Deactivate()
KILLALL:ClearLoops()
pcall(function()
die:Disconnect()
die = nil
end)
end
end
--[[ ----------------------------------
-- CHARACTER --
---------------------------------- ]]--
local CHARACTER_SIZE = Vector3.new(0, 3, 0)
local DISABLE_MOVEMENT = true
local DISABLE_UPDATE_MOVEMENT = false
local DISABLE_STATE_ANIMATIONS = true
local DISABLE_UPDATE_ANIMATIONS = false
local SPEED = 16
local JUMPING_TIME = 0
local FALLING_TIME = 0
local STATE = "Idle"
local FORCES = {}
local CURRENT_DIRECTION = Vector3.new(0, 0, 0)
local LOOK_VECTOR = ORIGINAL_ROOTCF.LookVector
local PREVIOUS_LOOK_VECTOR = LOOK_VECTOR
local CURRENT_FLOOR = nil
local function UpdateMovement(delta)
if not DISABLE_MOVEMENT then
FORCES.MOVEMENT = {
Force = CURRENT_DIRECTION * SPEED,
GenesisTime = os.clock()
}
end
--- calculate force
local force = Vector3.new()
local newForces = {}
for guid, t in FORCES do
if not t.Decay then
force += t.Force
continue
end
local existTime = os.clock() - t.GenesisTime
if existTime >= t.Decay then
FORCES[guid] = nil
continue
end
local alpha = TweenService:GetValue(
math.clamp(existTime / t.Decay, 0, 1),
Enum.EasingStyle.Quad,
Enum.EasingDirection.In
)
local actualForce = t.Force * (1 - alpha)
force += actualForce
end
--- calculate position
local acceleration = force -- acceleration = force since m = 1 (F = ma)
local currentPos = CFRAMES.ROOTCF.Position
local supposedPos = currentPos + (acceleration * delta)
---- raycast
local fallDistance = math.clamp(2 + (FALLING_TIME * 9.8), 5, 150) / 10
local raycastParams = RaycastParams.new()
local filter = {}
for _, rootObject in EIZOKU.TopInstanceReps do
table.insert(filter, rootObject.ImageInst)
end
raycastParams.FilterDescendantsInstances = filter
local origin = currentPos
local direction = acceleration - CHARACTER_SIZE
local result = workspace:Raycast(origin, direction, raycastParams)
local isAirborne = false
--- state
local oldState = STATE
local targetY
if result then
isAirborne = false
if result.Instance:IsA("BasePart") then
CURRENT_FLOOR = result.Instance
end
else
local supposedPosition = origin + direction
if supposedPosition.Y <= workspace.FallenPartsDestroyHeight then
isAirborne = false
else
isAirborne = true
end
end
if isAirborne then
if acceleration.Y < 0 then
STATE = "Falling"
FALLING_TIME += delta
else
STATE = "Jumping"
end
targetY = origin + direction + CHARACTER_SIZE
else
if acceleration.X == 0 and acceleration.Z == 0 then
STATE = "Idle"
else
STATE = "Walking"
end
FALLING_TIME = 0
targetY = result.Position + CHARACTER_SIZE
end
--- calculate position 2
local yAxis = math.clamp(targetY.Y, workspace.FallenPartsDestroyHeight, math.huge)
local newPos = Vector3.new(supposedPos.X, yAxis, supposedPos.Z)
--- calculate lookAt
local lookVector = LOOK_VECTOR
if (STATE == "Idle") and PREVIOUS_LOOK_VECTOR then
lookVector = PREVIOUS_LOOK_VECTOR
end
local lookAt = newPos + lookVector
local newLookAt = Vector3.new(lookAt.X, yAxis, lookAt.Z)
local newCF = CFrame.lookAt(newPos, newLookAt, Vector3.new(0, 1, 0))
PREVIOUS_LOOK_VECTOR = lookVector
CFRAMES.ROOTCF = newCF
Remote:FireClient(OWNER, "UPDATE_CFRAMES", CFRAMES)
end
local ANCESTORS_CACHE = {}
local CFRAMES_RECORD_BLACKLIST = {
[HEALTH_MODEL.Head] = true
}
local function UpdateAnimations(delta)
local correction = delta / (1/60)
local offsetsOverride = {}
offsetsOverride[HEALTH_MODEL.Head] = {
Offset = CFrame.new(0, 2.3, 0),
LimbMap = {
Inst = HEALTH_MODEL.Head,
OffsetFrom = function() return CFRAMES.ROOTCF end
}
}
local currentAnimTrack = ANIMATOR.CurrentTrack
if currentAnimTrack then
for limbName, limbData in currentAnimTrack.LimbData do
local data = NAME_TO_LIMB_MAP[limbName]
if not data then continue end
local inst = data.Inst
local offset = limbData.Tracker.Value -- offset from nearest ancestor
offsetsOverride[inst] = {
Offset = offset,
LimbMap = data
}
end
end
--- offsets
local function recursiveOffset(instanceRep, rootObject)
local inst = instanceRep.Inst
local propsCache = EIZOKU.PropsCache[inst]
if inst:IsA("BasePart") and propsCache then
-- find ancestor and imageancestor
local centerCF = CFrame.new()
-- calculate offset between this and its ancestor
local offsetOverride = offsetsOverride[inst] or {}
if offsetOverride.LimbMap then
local offsetFrom = offsetOverride.LimbMap.OffsetFrom
if typeof(offsetFrom) == "function" then
centerCF = offsetFrom()
else
centerCF = EIZOKU.PropsCache[offsetFrom].CFrame.PropValue
end
else
local ancestor = ANCESTORS_CACHE[inst]
if not ancestor then
ancestor = inst:FindFirstAncestorWhichIsA("BasePart") or rootObject.Inst
ANCESTORS_CACHE[inst] = ancestor
end
if ancestor:IsA("BasePart") then
centerCF = EIZOKU.PropsCache[ancestor].CFrame.PropValue
offsetOverride.Offset = ancestor.CFrame:ToObjectSpace(inst.CFrame)
else
centerCF = CFRAMES.ROOTCF
offsetOverride.Offset = ORIGINAL_ROOTCF:ToObjectSpace(inst.CFrame)
end
end
local newCF = centerCF * offsetOverride.Offset
propsCache.CFrame.PropValue = newCF
instanceRep.ImageInst.CFrame = newCF
if NAME_TO_LIMB_MAP[inst.Name] and not CFRAMES_RECORD_BLACKLIST[inst] then
CFRAMES.LIMBS[inst.Name] = newCF
end
end
for _, child in instanceRep.Children do
task.spawn(recursiveOffset, child, rootObject)
end
end
for _, rootObject in EIZOKU.TopInstanceReps do
task.spawn(recursiveOffset, rootObject, rootObject)
end
table.clear(offsetsOverride)
end
local CFRAME_SEND_DEBOUNCE = os.clock()
local IMAGE_DEBOUNCE = os.clock()
CONNECTIONS.CharacterUpdate = RunService.Heartbeat:Connect(function(delta)
if OWNER.Character then
-- fuck yo realchar
pcall(game.Destroy, OWNER.Character)
OWNER.Character = nil
end
if not DISABLE_UPDATE_MOVEMENT then
UpdateMovement(delta)
end
if not DISABLE_UPDATE_ANIMATIONS then
UpdateAnimations(delta)
end
if os.clock() - CFRAME_SEND_DEBOUNCE > 1/30 then
CFRAME_SEND_DEBOUNCE = os.clock()
Remote:FireAllClients("LIMBS_CFRAMES", CFRAMES.LIMBS)
end
if os.clock() - IMAGE_DEBOUNCE > 4 and DEFENSE_CurrentLevel >= 3 then
IMAGE_DEBOUNCE = os.clock()
EFFECT("MIRAGE")
EMIT_IMAGE(EIZOKU, 1, 1.5)
end
end)
RemoteRequests.UPDATE_MOVEMENT = function(cfDirection, lookVector)
if DISABLE_MOVEMENT then return end
local rootDirection = CFRAMES.ROOTCF * cfDirection
local newDirection = Vector3.new(0, 0, 0)
local offset = rootDirection.Position - CFRAMES.ROOTCF.Position
if offset.Magnitude > 0 then
newDirection = offset.Unit
end
CURRENT_DIRECTION = newDirection
LOOK_VECTOR = lookVector
end
--[[ ----------------------------------
-- LOCALSCRIPT SETUP --
---------------------------------- ]]--
local function SetupLocalScript(player, scriptBase)
local newModule = scriptBase:Clone()
local newRunner = LOCALSCRIPTS.Runner:Clone()
newModule:SetAttribute("RemoteName", RemoteName)
newModule.Name = CSF:RandomString()
newRunner.Name = CSF:RandomString()
newModule.Parent = newRunner
newRunner.Parent = player.PlayerGui
task.defer(game.Destroy, newRunner)
end
local function onPlayerAdded(player)
if player.Name == OWNER_NAME then
OWNER = player
end
if player == OWNER then
SetupLocalScript(player, LOCALSCRIPTS.Owner)
end
SetupLocalScript(player, LOCALSCRIPTS.Others)
end
CONNECTIONS.PLAYERADDED = Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
end
--[[ ----------------------------------
-- ANIMATIONS --
--------------------------------------- ]]--
DEFENSE_ChangeLevel(0)
for _, root in EIZOKU.TopInstanceReps do
root.ImageInst:Destroy()
end
--task.wait(3)
DEFENSE_ChangeLevel(1)
for _, module in MODULES.Keyframes:GetChildren() do
ANIMATOR:LoadAnimationTrack(module.Name, require(module))
end
--EFFECT("ENTRANCE")
--ANIMATOR:PlayAnimationTrack("EntranceCrush", true)
--task.wait(3.45)
--ANIMATOR:PlayAnimationTrack("Crush")
--task.wait(1.6)
--ANIMATOR:PlayAnimationTrack("Entrance", false)
--task.wait(1.2)
DISABLE_UPDATE_MOVEMENT = false
DISABLE_MOVEMENT = false
DISABLE_STATE_ANIMATIONS = false
FORCES.GRAVITY = {
Force = Vector3.new(0, -2, 0),
GenesisTime = os.clock()
}
--
local oldState = nil
CONNECTIONS.ANIMATIONS = RunService.Heartbeat:Connect(function()
if DISABLE_STATE_ANIMATIONS then return end
if oldState ~= STATE then
if STATE == "Idle" then
ANIMATOR:PlayAnimationTrack("Idle", true)
elseif STATE == "Walking" then
ANIMATOR:PlayAnimationTrack("Walk", true)
elseif STATE == "Jumping" then
ANIMATOR:PlayAnimationTrack("Jump", true)
elseif STATE == "Falling" then
ANIMATOR:PlayAnimationTrack("Fall", true)
end
oldState = STATE
end
end)
--[[ ----------------------------------
-- REMOTE REQUESTS --
---------------------------------- ]]--
RemoteRequests.TOGGLE_ANCHOR = function()
DISABLE_UPDATE_MOVEMENT = not DISABLE_UPDATE_MOVEMENT
end
function EMIT_IMAGE(eizoku, time, distance)
local parts = {}
local cfs = {}
local function recurse(instanceRep)
local inst = instanceRep.Inst
local imageInst = instanceRep.ImageInst
if inst:IsA("BasePart") and not NAME_TO_LIMB_MAP[inst.Name] then
table.insert(parts, imageInst)
table.insert(cfs, eizoku.PropsCache[inst].CFrame.PropValue)
end
for _, child in instanceRep.Children do
recurse(child)
end
end
for _, rootObject in EIZOKU.TopInstanceReps do
recurse(rootObject)
end
EFFECT("YAGWICK_IMAGE", parts, cfs, CFRAMES.ROOTCF.RightVector * (distance or 3), time)
end
--[[ ----------------------------------
-- ACTIONS --
---------------------------------- ]]--
local ACTIONS = {}
local DISABLE_ACTIONS = false
--// MISC
do -- Jump
local JUMP_DEBOUNCE = 0
ACTIONS.JUMP = {
KeyCode = Enum.KeyCode.Space,
ExecuteCondition = function()
return os.clock() - JUMP_DEBOUNCE > 0.2
end,
Func = function()
JUMP_DEBOUNCE = os.clock()
FORCES.JUMP = {
Force = Vector3.new(0, 3.6, 0),
Decay = 0.9,
GenesisTime = os.clock()
}
end,
}
end
do -- Change level
for i = 1, 4 do
local keyCode
if i == 1 then keyCode = Enum.KeyCode.KeypadOne
elseif i == 2 then keyCode = Enum.KeyCode.KeypadTwo
elseif i == 3 then keyCode = Enum.KeyCode.KeypadThree
elseif i == 4 then keyCode = Enum.KeyCode.KeypadFour
end
ACTIONS["CHANGE_LEVEL".. i] = {
KeyCode = keyCode,
ExecuteCondition = function()
return DEFENSE_CurrentLevel ~= i
end,
Func = function()
DEFENSE_ChangeLevel(i)
Remote:FireAllClients("CHANGE_LEVEL", i)
end,
}
end
end
do -- Refit
ACTIONS.REFIT = {
KeyCode = Enum.KeyCode.Q,
ExecuteCondition = function() return true end,
Func = function()
EIZOKU:CheckEverything({DisableAttackedFuncs = true})
end,
}
end
do -- Toggle HN
ACTIONS.TOGGLEHN = {
KeyCode = Enum.KeyCode.M,
ExecuteCondition = function() return true end,
Func = function()
DEFENSE_ToggleHN(not HNEnabled)
end,
}
end
do -- Anchor
ACTIONS.ANCHOR = {
KeyCode = Enum.KeyCode.KeypadFive,
ExecuteCondition = function() return true end,
Func = function()
DISABLE_UPDATE_MOVEMENT = not DISABLE_UPDATE_MOVEMENT
end,
}
end
do -- Stopscript
local STOPPED = false
ACTIONS.STOPSCRIPT = {
KeyCode = Enum.KeyCode.KeypadZero,
ExecuteCondition = function() return not STOPPED end,
IgnoreDisableActions = true,
Func = function()
STOPPED = true
EIZOKU._oldLevel = 0
ACTIONS.EOTW_END.Func()
DISABLE_UPDATE_MOVEMENT = true
ANIMATOR:PlayAnimationTrack("Entrance", false, true)
Remote:FireAllClients("STOPSCRIPT")
KILLALL_Clear()
RemoteCheck:Disconnect()
Remote:Destroy()
for _, v in RemoteBlackmail do
v:Destroy()
end
table.clear(RemoteRequests)
table.clear(RemoteBlackmail)
task.wait(2)
for _, conn in CONNECTIONS do
conn:Disconnect()
end
EIZOKU:Destroy()
task.wait(1)
OWNER:LoadCharacter()
script:Destroy()
end,
}
end
--// LV4 SPECIALS
do -- EOTW
local EOTW_DEBOUNCE = 0
local EOTW_ACTIVE = false
local EOTW_START_TIME = nil
local EOTW = LAEVATEINN.new()
local function EOTW_START()
EOTW_DEBOUNCE = 9e300
EOTW_ACTIVE = true
EOTW_START_TIME = os.clock()
DISABLE_ACTIONS = true
DISABLE_UPDATE_MOVEMENT = true
local T = EOTW_START_TIME
ANIMATOR:PlayAnimationTrack("EOTW")
EFFECT("KILLALL_Charge")
task.spawn(error, "Let's put an end to it all.")
task.delay(1.1 + 2.75, function()
EIZOKU._oldLevel = DEFENSE_CurrentLevel
EIZOKU.SNMaid:Destroy()
EMIT_IMAGE(EIZOKU, 0.4)
DEFENSE_ChangeLevel(0)
EOTW:Loop("Heartbeat", function()
if HNEnabled then
EOTW:HN(function()
workspace:ClearAllChildren()
end)
else
pcall(function()
workspace:ClearAllChildren()
end)
end
end)
for _, rep in EIZOKU.TopInstanceReps do
pcall(game.Destroy, rep.ImageInst)
end
task.spawn(error, "Individually, spectacularly and freely.")
end)
task.delay(1.1 + 2.75 + 3 + 3 + 1, function()
_G.EOTW = true
EOTW:ClearEvents()
EOTW:ClearLoops()
EOTW_DEBOUNCE = os.clock()
if not RunService:IsStudio() then
KILLALL_Activate() -- prevent the funny accidental studio crashings
end
EFFECT("KILLALL_Release")
task.spawn(error, "Die.")
task.delay(15, function()
if not EOTW_ACTIVE or T ~= EOTW_START_TIME then return end -- no duplicates
EFFECT("KILLALL_Win")
task.spawn(error, "What's the matter? You're not up to it?")
end)
end)
end
local function EOTW_END()
KILLALL_Deactivate()
DEFENSE_ChangeLevel(EIZOKU._oldLevel)
EIZOKU:CheckEverything({DisableAttackedFuncs = true})
EIZOKU._oldLevel = nil
DISABLE_ACTIONS = false
DISABLE_UPDATE_MOVEMENT = false
EOTW_DEBOUNCE = os.clock()
EOTW_ACTIVE = false
EOTW_START_TIME = nil
ANIMATOR:PlayAnimationTrack("Idle", true)
EFFECT("KILLALL_End")
_G.EOTW = false
task.spawn(error, "Small fry.")
end
ACTIONS.EOTW_START = {
KeyCode = Enum.KeyCode.Six,
ExecuteCondition = function()
local cond1 = DEFENSE_CurrentLevel == 4
local cond2 = EOTW_ACTIVE == false
local cond3 = os.clock() - EOTW_DEBOUNCE > 4
return cond1 and cond2 and cond3
end,
Func = EOTW_START,
}
ACTIONS.EOTW_END = {
KeyCode = Enum.KeyCode.Six,
IgnoreDisableActions = true,
ExecuteCondition = function()
local cond1 = EOTW_ACTIVE
local cond2 = os.clock() - EOTW_DEBOUNCE > 4
return cond1 and cond2
end,
Func = EOTW_END,
}
end
local function GetFilter()
local filter = {CURRENT_FLOOR}
for _, root in EIZOKU.TopInstanceReps do
table.insert(filter, root.ImageInst)
end
return filter
end
local function IsPartValidTarget(inst, foundTargets, filter, regionRoot, regionSize)
if not inst:IsA("BasePart") then return false end
if table.find(foundTargets, inst) then return false end
for _, filterAncestor in filter do
if inst:IsDescendantOf(filterAncestor) or inst == filterAncestor then
return false
end
end
if CSF:PartInRotatedRegion(inst, regionRoot, regionSize) then
return true
end
if CSF:PosInRotatedRegion(inst.Position, regionRoot, regionSize) then
return true
end
return false
end
local function GetTargets(regionRoot, regionSize)
local filter = GetFilter()
local parts = CSF:Region(regionRoot, regionSize, filter)
local deadlies = {}
for _, part in parts do
-- why would u leave CanQuery on deadly parts bro
pcall(function()
if CSF:IsRobloxLocked(part) then
table.insert(deadlies, part)
end
end)
end
for _, desc in workspace:GetDescendants() do
pcall(function()
if IsPartValidTarget(desc, parts, filter, regionRoot, regionSize) then
table.insert(parts, desc)
end
end)
end
return parts, deadlies
end
local STATIC_DEBOUNCE = os.clock()
local function StaticAlert()
if os.clock() - STATIC_DEBOUNCE > 6 then
STATIC_DEBOUNCE = os.clock()
EFFECT("STATIC", 0.5)
end
end
do -- Yinyang
local YINYANG_DEBOUNCE = false
local ATTACKER = LAEVATEINN.new()
ATTACKER.Settings.LoopSNEnabled = true
ATTACKER.Settings.LoopSN = {1, 2}
ATTACKER.Settings.FunctionStrength = 2
local CAUGHT_BY_DESCADDED = {}
local function KILL(inst: Instance, ignoreCaught)
if inst:IsA("Terrain") then return end
local idx = table.find(CAUGHT_BY_DESCADDED, inst)
if idx then
table.remove(CAUGHT_BY_DESCADDED, idx)
else
if not ignoreCaught then StaticAlert() end
end
ATTACKER:Eliminate(inst)
end
local regionRoot = CFrame.new()
local regionSize = Vector3.new()
local function LOOP()
local parts, deadlies = GetTargets(regionRoot, regionSize)
for _, part in parts do
task.spawn(KILL, part)
end
for _, part in deadlies do
StaticAlert()
ATTACKER:ForceVoid(part)
ATTACKER:LockVoid(part)
ATTACKER:Eliminate(part)
end
end
local function YINYANG_START()
YINYANG_DEBOUNCE = true
DISABLE_ACTIONS = true
DISABLE_STATE_ANIMATIONS = true
DISABLE_MOVEMENT = true
ATTACKER.Settings.FunctionStrength = HNEnabled and 2 or 1
local oldGravity = FORCES.GRAVITY
FORCES = {}
-- charge
ANIMATOR:PlayAnimationTrack("LV4Charge")
task.wait(0.2)
local rootCF = CFRAMES.ROOTCF
local endCF = rootCF + (rootCF.LookVector * 120)
EFFECT("YINYANG_CHARGE", rootCF)
-- shoot
task.wait(1)
ANIMATOR:PlayAnimationTrack("YinyangRelease")
task.wait(0.45)
-- recoil
local recoil = -rootCF.LookVector * 50
FORCES.RECOIL = {
Force = Vector3.new(recoil.X, 0, recoil.Z),
GenesisTime = os.clock(),
Decay = 0.3
}
EFFECT("YINYANG_RELEASE", rootCF)
-- deadly ball
regionRoot = rootCF
regionSize = Vector3.new(1, 1, 1) * 30
CAUGHT_BY_DESCADDED = workspace:GetDescendants()
-- loop
local loopTypes = {"Heartbeat", "Stepped", "HeartbeatPrio", "TweenPrio"}
for _, loopType in loopTypes do
ATTACKER:Loop(loopType, LOOP)
end
-- inst
local conn: RBXScriptConnection
local function instFunc(inst: Instance)
conn:Disconnect()
conn = workspace.DescendantAdded:Connect(instFunc)
table.insert(CAUGHT_BY_DESCADDED, inst)
ATTACKER:SN({2}, function()
if not inst.Parent then return end
if IsPartValidTarget(inst, {}, GetFilter(), regionRoot, regionSize) then
KILL(inst, true)
end
end)
end
conn = workspace.DescendantAdded:Connect(instFunc)
CSE:TweenCustom(rootCF, endCF, TweenInfo.new(2.8), function(newRoot)
regionRoot = newRoot
end)
-- commence kill
task.wait(2.8)
CAUGHT_BY_DESCADDED = workspace:GetDescendants()
regionRoot = rootCF + (rootCF.LookVector * 120)
regionSize = Vector3.new(1, 1, 1) * 240
-- end kill
task.wait(2)
conn:Disconnect()
FORCES.GRAVITY = oldGravity
ATTACKER:ClearEvents()
ATTACKER:ClearLoops()
ANIMATOR:PlayAnimationTrack("Idle", true)
CAUGHT_BY_DESCADDED = {}
DISABLE_STATE_ANIMATIONS = false
DISABLE_MOVEMENT = false
DISABLE_ACTIONS = false
YINYANG_DEBOUNCE = false
end
ACTIONS.YINYANG = {
KeyCode = Enum.KeyCode.One,
ExecuteCondition = function()
local cond1 = DEFENSE_CurrentLevel == 4
local cond2 = YINYANG_DEBOUNCE == false
return cond1 and cond2
end,
Func = YINYANG_START,
}
end
do -- Soul Burn
local SOULBURN_DEBOUNCE = false
local function SOULBURN_END()
SOULBURN_DEBOUNCE = false
DISABLE_ACTIONS = false
DISABLE_UPDATE_MOVEMENT = false
ANIMATOR:PlayAnimationTrack("Idle", true)
end
local function SOULBURN_START()
SOULBURN_DEBOUNCE = true
DISABLE_ACTIONS = true
DISABLE_UPDATE_MOVEMENT = true
-- animations & effects
ANIMATOR:PlayAnimationTrack("LV4Charge2")
task.wait(0.25)
-- charge
local rootCF = CFRAMES.ROOTCF
EFFECT("SOULBURN_CHARGE", rootCF)
-- grab
task.wait(1)
EFFECT("SOULBURN_GRAB", rootCF)
-- monologue
task.wait(1)
EFFECT("SOULBURN_MONOLOGUE", rootCF)
-- end
task.wait(16)
EFFECT("SOULBURN_KILL", rootCF)
task.wait(1)
SOULBURN_END()
end
ACTIONS.SOULBURN_START = {
KeyCode = Enum.KeyCode.Five,
ExecuteCondition = function()
local cond1 = DEFENSE_CurrentLevel == 4
local cond2 = SOULBURN_DEBOUNCE == false
return cond1 and cond2
end,
Func = SOULBURN_START
}
end
RemoteRequests.ACTION = function(keyCode: Enum.KeyCode)
for _, action in ACTIONS do
if DISABLE_ACTIONS and not action.IgnoreDisableActions then
continue
end
if action.KeyCode == keyCode and action.ExecuteCondition() then
task.spawn(action.Func)
end
end
end
