API tools faq
paste
View difference between Paste ID: XEVPGUjv and X1td3aGZ
SHOW: | | - or go back to the newest paste.
1
---------------
2
--Jevil Done (I think)--
3
----------------------------------------------------------------
4
print([[
5
--made by Makhail07
6
--FE code by Mokiros
7
--Edited by ozzak1003 and then by 1nd1k                       --
8
--YT: https://www.youtube.com/channel/UC38cAdtSgPWJVEHV8zgZi6A--
9
--Discord: ozzak1003#3275
10
--------------------------------
11
hello good sir
12
Don't leak pls
13
Enjoy ;)
14
--------------------------------
15
]])
16
17
if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end

18
local Player,game,owner = owner,game

19
local RealPlayer = Player

20
do

21
	local rp = RealPlayer

22
	script.Parent = rp.Character

23
	

24
	--RemoteEvent for communicating

25
	local Event = Instance.new("RemoteEvent")

26
	Event.Name = "UserInput_Event"

27
28
	--Fake event to make stuff like Mouse.KeyDown work

29
	local function fakeEvent()

30
		local t = {_fakeEvent=true,Functions={},Connect=function(self,f)table.insert(self.Functions,f) end}

31
		t.connect = t.Connect

32
		return t

33
	end

34
35
	--Creating fake input objects with fake variables

36
    local m = {Target=nil,Hit=CFrame.new(),KeyUp=fakeEvent(),KeyDown=fakeEvent(),Button1Up=fakeEvent(),Button1Down=fakeEvent()}

37
	local UIS = {InputBegan=fakeEvent(),InputEnded=fakeEvent()}

38
	local CAS = {Actions={},BindAction=function(self,name,fun,touch,...)

39
		CAS.Actions[name] = fun and {Name=name,Function=fun,Keys={...}} or nil

40
	end}

41
	--Merged 2 functions into one by checking amount of arguments

42
	CAS.UnbindAction = CAS.BindAction

43
44
	--This function will trigger the events that have been :Connect()'ed

45
	local function te(self,ev,...)

46
		local t = m[ev]

47
		if t and t._fakeEvent then

48
			for _,f in pairs(t.Functions) do

49
				f(...)

50
			end

51
		end

52
	end

53
	m.TrigEvent = te

54
	UIS.TrigEvent = te

55
56
	Event.OnServerEvent:Connect(function(plr,io)

57
	    if plr~=rp then return end

58
		m.Target = io.Target

59
		m.Hit = io.Hit

60
		if not io.isMouse then

61
			local b = io.UserInputState == Enum.UserInputState.Begin

62
			if io.UserInputType == Enum.UserInputType.MouseButton1 then

63
				return m:TrigEvent(b and "Button1Down" or "Button1Up")

64
			end

65
			for _,t in pairs(CAS.Actions) do

66
				for _,k in pairs(t.Keys) do

67
					if k==io.KeyCode then

68
						t.Function(t.Name,io.UserInputState,io)

69
					end

70
				end

71
			end

72
			m:TrigEvent(b and "KeyDown" or "KeyUp",io.KeyCode.Name:lower())

73
			UIS:TrigEvent(b and "InputBegan" or "InputEnded",io,false)

74
	    end

75
	end)

76
	Event.Parent = NLS([==[

77
	local Player = game:GetService("Players").LocalPlayer

78
	local Event = script:WaitForChild("UserInput_Event")

79
80
	local Mouse = Player:GetMouse()

81
	local UIS = game:GetService("UserInputService")

82
	local input = function(io,a)

83
		if a then return end

84
		--Since InputObject is a client-side instance, we create and pass table instead

85
		Event:FireServer({KeyCode=io.KeyCode,UserInputType=io.UserInputType,UserInputState=io.UserInputState,Hit=Mouse.Hit,Target=Mouse.Target})

86
	end

87
	UIS.InputBegan:Connect(input)

88
	UIS.InputEnded:Connect(input)

89
90
	local h,t

91
	--Give the server mouse data 30 times every second, but only if the values changed

92
	--If player is not moving their mouse, client won't fire events

93
	while wait(1/30) do

94
		if h~=Mouse.Hit or t~=Mouse.Target then

95
			h,t=Mouse.Hit,Mouse.Target

96
			Event:FireServer({isMouse=true,Target=t,Hit=h})

97
		end

98
	end]==],Player.Character)

99
100
	----Sandboxed game object that allows the usage of client-side methods and services

101
	--Real game object

102
	local _rg = game

103
104
	--Metatable for fake service

105
	local fsmt = {

106
		__index = function(self,k)

107
			local s = rawget(self,"_RealService")

108
			if s then return s[k] end

109
		end,

110
		__newindex = function(self,k,v)

111
			local s = rawget(self,"_RealService")

112
			if s then s[k]=v end

113
		end,

114
		__call = function(self,...)

115
			local s = rawget(self,"_RealService")

116
			if s then return s(...) end

117
		end

118
	}

119
	local function FakeService(t,RealService)

120
		t._RealService = typeof(RealService)=="string" and _rg:GetService(RealService) or RealService

121
		return setmetatable(t,fsmt)

122
	end

123
124
	--Fake game object

125
	local g = {

126
		GetService = function(self,s)

127
			return self[s]

128
		end,

129
		Players = FakeService({

130
			LocalPlayer = FakeService({GetMouse=function(self)return m end},Player)

131
		},"Players"),

132
		UserInputService = FakeService(UIS,"UserInputService"),

133
		ContextActionService = FakeService(CAS,"ContextActionService"),

134
	}

135
	rawset(g.Players,"localPlayer",g.Players.LocalPlayer)

136
	g.service = g.GetService

137
	

138
	g.RunService = FakeService({

139
		RenderStepped = _rg:GetService("RunService").Heartbeat,

140
		BindToRenderStep = function(self,name,_,fun)

141
			self._btrs[name] = self.Heartbeat:Connect(fun)

142
		end,

143
		UnbindFromRenderStep = function(self,name)

144
			self._btrs[name]:Disconnect()

145
		end,

146
	},"RunService")

147
148
	setmetatable(g,{

149
		__index=function(self,s)

150
			return _rg:GetService(s) or typeof(_rg[s])=="function"

151
			and function(_,...)return _rg[s](_rg,...)end or _rg[s]

152
		end,

153
		__newindex = fsmt.__newindex,

154
		__call = fsmt.__call

155
	})

156
	--Changing owner to fake player object to support owner:GetMouse()

157
	game,owner = g,g.Players.LocalPlayer

158
end

159
160
Player = owner

161
PlayerGui = Player.PlayerGui

162
Cam = workspace.CurrentCamera

163
Backpack = Player.Backpack

164
Character = Player.Character

165
Humanoid = Character.Humanoid

166
Mouse = Player:GetMouse()

167
RootPart = Character["HumanoidRootPart"]

168
Torso = Character["Torso"]

169
Head = Character["Head"]

170
RightArm = Character["Right Arm"]

171
LeftArm = Character["Left Arm"]

172
RightLeg = Character["Right Leg"]

173
LeftLeg = Character["Left Leg"]

174
RootJoint = RootPart["RootJoint"]

175
Neck = Torso["Neck"]

176
RightShoulder = Torso["Right Shoulder"]

177
LeftShoulder = Torso["Left Shoulder"]

178
RightHip = Torso["Right Hip"]

179
LeftHip = Torso["Left Hip"]

180
181
Character = Player.Character

182
Humanoid = Character.Humanoid

183
184
---------

185
plr = game.Players.LocalPlayer

186
chara = plr.Character

187
mouse = plr:GetMouse()

188
Create = Instance.new

189
Huge = math.huge

190
191
192
local shadowhead = Create("Part",chara.Head)

193
shadowhead.BrickColor = BrickColor.new("Black")

194
shadowhead.Size = Vector3.new(1.2, 0.6, 1)

195
shadowhead.CanCollide = false

196
local shadowheadmesh = Create("SpecialMesh",shadowhead)

197
shadowheadmesh.MeshType = "Head"

198
shadowheadmesh.Scale = Vector3.new(1.26, 1.5, 1.26)

199
local weld2 = Create("Weld",shadowhead)

200
weld2.Part0 = shadowhead

201
weld2.Part1 = chara.Head

202
weld2.C1 = CFrame.new(0, 0.200000048, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1)

203
204
Player = game:GetService("Players").LocalPlayer

205
PlayerGui = Player.PlayerGui

206
Cam = workspace.CurrentCamera

207
Backpack = Player.Backpack

208
Character = Player.Character

209
char = Player.Character

210
Humanoid = Character.Humanoid

211
Mouse = Player:GetMouse()

212
RootPart = Character["HumanoidRootPart"]

213
Torso = Character["Torso"]

214
Head = Character["Head"]

215
RightArm = Character["Right Arm"]

216
LeftArm = Character["Left Arm"]

217
RightLeg = Character["Right Leg"]

218
LeftLeg = Character["Left Leg"]

219
RootJoint = RootPart["RootJoint"]

220
Neck = Torso["Neck"]

221
RightShoulder = Torso["Right Shoulder"]

222
LeftShoulder = Torso["Left Shoulder"]

223
RightHip = Torso["Right Hip"]

224
LeftHip = Torso["Left Hip"]

225
226
local Orin = "http://www.roblox.com/asset/?id=7074786"

227
Head.face.Texture = Orin

228
function weld(a, b, acf)

229
	local w = Instance.new("Weld", a)

230
	w.Part0 = a

231
	w.Part1 = b

232
	w.C0 = acf

233
end

234
235
236
local righteyebrickcolor = "Institutional white"

237
local reye = Instance.new("Part", char)

238
reye.CanCollide = false

239
reye.BrickColor = BrickColor.new(righteyebrickcolor)

240
reye.Material = "Neon"

241
reye.Size = Vector3.new(.25,.35,.15)

242
weld(reye, char.Head, CFrame.new(0.15,-0.2,0.55), CFrame.new(1,0,0))

243
m1 = Instance.new("SpecialMesh", reye)

244
m1.MeshType = "Sphere"

245
m1.Scale = Vector3.new(0.9,0.9,0.9)

246
reye.Locked = true

247
reye.Name = "re"

248
--------------------------------

249
char.Head.face.Texture = "rbxassetid://241553801"

250
--------------------------------

251
252
-------------------------------------------------------

253
254
local FavIDs = {

255
	340106355, --Nefl Crystals

256
	927529620, --Dimension

257
	876981900, --Fantasy

258
	398987889, --Ordinary Days

259
	1117396305, --Oh wait, it's you.

260
	885996042, --Action Winter Journey

261
	919231299, --Sprawling Idiot Effigy

262
	743466274, --Good Day Sunshine

263
	727411183, --Knife Fight

264
	1402748531, --The Earth Is Counting On You!

265
	595230126 --Robot Language

266
	}

267
268
269
270
--The reality of my life isn't real but a Universe -makhail07

271
wait(0.2)

272
local plr = game:service'Players'.LocalPlayer

273
print('Local User is '..plr.Name)

274
print('SCRIPTNAME Loaded')

275
print('SCRIPT DESCRIPTION')

276
local char = plr.Character

277
local hum = char.Humanoid

278
local hed = char.Head

279
local root = char.HumanoidRootPart

280
local rootj = root.RootJoint

281
local tors = char.Torso

282
local ra = char["Right Arm"]

283
local la = char["Left Arm"]

284
local rl = char["Right Leg"]

285
local ll = char["Left Leg"]

286
local neck = tors["Neck"]

287
local mouse = plr:GetMouse()

288
local RootCF = CFrame.fromEulerAnglesXYZ(-1.57, 0, 3.14)

289
local RHCF = CFrame.fromEulerAnglesXYZ(0, 1.6, 0)

290
local LHCF = CFrame.fromEulerAnglesXYZ(0, -1.6, 0)

291
local maincolor = BrickColor.new("Storm blue")

292
293
-------------------------------------------------------

294
--Start Good Stuff--

295
-------------------------------------------------------

296
cam = game.Workspace.CurrentCamera

297
CF = CFrame.new

298
angles = CFrame.Angles

299
attack = false

300
Euler = CFrame.fromEulerAnglesXYZ

301
Rad = math.rad

302
IT = Instance.new

303
BrickC = BrickColor.new

304
Cos = math.cos

305
Acos = math.acos

306
Sin = math.sin

307
Asin = math.asin

308
Abs = math.abs

309
Mrandom = math.random

310
Floor = math.floor

311
-------------------------------------------------------

312
--End Good Stuff--

313
-------------------------------------------------------

314
necko = CF(0, 1, 0, -1, -0, -0, 0, 0, 1, 0, 1, 0)

315
RSH, LSH = nil, nil 

316
RW = Instance.new("Weld") 

317
LW = Instance.new("Weld")

318
RH = tors["Right Hip"]

319
LH = tors["Left Hip"]

320
RSH = tors["Right Shoulder"] 

321
LSH = tors["Left Shoulder"] 

322
RSH.Parent = nil 

323
LSH.Parent = nil 

324
RW.Name = "RW"

325
RW.Part0 = tors 

326
RW.C0 = CF(1.5, 0.5, 0)

327
RW.C1 = CF(0, 0.5, 0) 

328
RW.Part1 = ra

329
RW.Parent = tors 

330
LW.Name = "LW"

331
LW.Part0 = tors 

332
LW.C0 = CF(-1.5, 0.5, 0)

333
LW.C1 = CF(0, 0.5, 0) 

334
LW.Part1 = la

335
LW.Parent = tors

336
Effects = {}

337
-------------------------------------------------------

338
--Start HeartBeat--

339
-------------------------------------------------------

340
ArtificialHB = Instance.new("BindableEvent", script)

341
ArtificialHB.Name = "Heartbeat"

342
script:WaitForChild("Heartbeat")

343
344
frame = 1 / 60

345
tf = 0

346
allowframeloss = false

347
tossremainder = false

348
349
350
lastframe = tick()

351
script.Heartbeat:Fire()

352
353
354
game:GetService("RunService").Heartbeat:connect(function(s, p)

355
	tf = tf + s

356
	if tf >= frame then

357
		if allowframeloss then

358
			script.Heartbeat:Fire()

359
			lastframe = tick()

360
		else

361
			for i = 1, math.floor(tf / frame) do

362
				script.Heartbeat:Fire()

363
			end

364
			lastframe = tick()

365
		end

366
		if tossremainder then

367
			tf = 0

368
		else

369
			tf = tf - frame * math.floor(tf / frame)

370
		end

371
	end

372
end)

373
-------------------------------------------------------

374
--End HeartBeat--

375
-------------------------------------------------------

376
377
-------------------------------------------------------

378
--Start Important Functions--

379
-------------------------------------------------------

380
function swait(num)

381
	if num == 0 or num == nil then

382
		game:service("RunService").Stepped:wait(0)

383
	else

384
		for i = 0, num do

385
			game:service("RunService").Stepped:wait(0)

386
		end

387
	end

388
end

389
function thread(f)

390
	coroutine.resume(coroutine.create(f))

391
end

392
function clerp(a, b, t)

393
	local qa = {

394
		QuaternionFromCFrame(a)

395
	}

396
	local qb = {

397
		QuaternionFromCFrame(b)

398
	}

399
	local ax, ay, az = a.x, a.y, a.z

400
	local bx, by, bz = b.x, b.y, b.z

401
	local _t = 1 - t

402
	return QuaternionToCFrame(_t * ax + t * bx, _t * ay + t * by, _t * az + t * bz, QuaternionSlerp(qa, qb, t))

403
end

404
function QuaternionFromCFrame(cf)

405
	local mx, my, mz, m00, m01, m02, m10, m11, m12, m20, m21, m22 = cf:components()

406
	local trace = m00 + m11 + m22

407
	if trace > 0 then

408
		local s = math.sqrt(1 + trace)

409
		local recip = 0.5 / s

410
		return (m21 - m12) * recip, (m02 - m20) * recip, (m10 - m01) * recip, s * 0.5

411
	else

412
		local i = 0

413
		if m00 < m11 then

414
			i = 1

415
		end

416
		if m22 > (i == 0 and m00 or m11) then

417
			i = 2

418
		end

419
		if i == 0 then

420
			local s = math.sqrt(m00 - m11 - m22 + 1)

421
			local recip = 0.5 / s

422
			return 0.5 * s, (m10 + m01) * recip, (m20 + m02) * recip, (m21 - m12) * recip

423
		elseif i == 1 then

424
			local s = math.sqrt(m11 - m22 - m00 + 1)

425
			local recip = 0.5 / s

426
			return (m01 + m10) * recip, 0.5 * s, (m21 + m12) * recip, (m02 - m20) * recip

427
		elseif i == 2 then

428
			local s = math.sqrt(m22 - m00 - m11 + 1)

429
			local recip = 0.5 / s

430
			return (m02 + m20) * recip, (m12 + m21) * recip, 0.5 * s, (m10 - m01) * recip

431
		end

432
	end

433
end

434
function QuaternionToCFrame(px, py, pz, x, y, z, w)

435
	local xs, ys, zs = x + x, y + y, z + z

436
	local wx, wy, wz = w * xs, w * ys, w * zs

437
	local xx = x * xs

438
	local xy = x * ys

439
	local xz = x * zs

440
	local yy = y * ys

441
	local yz = y * zs

442
	local zz = z * zs

443
	return CFrame.new(px, py, pz, 1 - (yy + zz), xy - wz, xz + wy, xy + wz, 1 - (xx + zz), yz - wx, xz - wy, yz + wx, 1 - (xx + yy))

444
end

445
function QuaternionSlerp(a, b, t)

446
	local cosTheta = a[1] * b[1] + a[2] * b[2] + a[3] * b[3] + a[4] * b[4]

447
	local startInterp, finishInterp

448
	if cosTheta >= 1.0E-4 then

449
		if 1 - cosTheta > 1.0E-4 then

450
			local theta = math.acos(cosTheta)

451
			local invSinTheta = 1 / Sin(theta)

452
			startInterp = Sin((1 - t) * theta) * invSinTheta

453
			finishInterp = Sin(t * theta) * invSinTheta

454
		else

455
			startInterp = 1 - t

456
			finishInterp = t

457
		end

458
	elseif 1 + cosTheta > 1.0E-4 then

459
		local theta = math.acos(-cosTheta)

460
		local invSinTheta = 1 / Sin(theta)

461
		startInterp = Sin((t - 1) * theta) * invSinTheta

462
		finishInterp = Sin(t * theta) * invSinTheta

463
	else

464
		startInterp = t - 1

465
		finishInterp = t

466
	end

467
	return a[1] * startInterp + b[1] * finishInterp, a[2] * startInterp + b[2] * finishInterp, a[3] * startInterp + b[3] * finishInterp, a[4] * startInterp + b[4] * finishInterp

468
end

469
function rayCast(Position, Direction, Range, Ignore)

470
	return game:service("Workspace"):FindPartOnRay(Ray.new(Position, Direction.unit * (Range or 999.999)), Ignore)

471
end

472
local RbxUtility = LoadLibrary("RbxUtility")

473
local Create = RbxUtility.Create

474
475
-------------------------------------------------------

476
--Start Damage Function--

477
-------------------------------------------------------

478
function Damage(Part, hit, minim, maxim, knockback, Type, Property, Delay, HitSound, HitPitch)

479
	if hit.Parent == nil then

480
		return

481
	end

482
	local h = hit.Parent:FindFirstChildOfClass("Humanoid")

483
	for _, v in pairs(hit.Parent:children()) do

484
		if v:IsA("Humanoid") then

485
			h = v

486
		end

487
	end

488
         if h ~= nil and hit.Parent.Name ~= char.Name and hit.Parent:FindFirstChild("UpperTorso") ~= nil then

489
	

490
         hit.Parent:FindFirstChild("Head"):BreakJoints()

491
         end

492
493
	if h ~= nil and hit.Parent.Name ~= char.Name and hit.Parent:FindFirstChild("Torso") ~= nil then

494
		if hit.Parent:findFirstChild("DebounceHit") ~= nil then

495
			if hit.Parent.DebounceHit.Value == true then

496
				return

497
			end

498
		end

499
         if insta == true then

500
         hit.Parent:FindFirstChild("Head"):BreakJoints()

501
         end

502
		local c = Create("ObjectValue"){

503
			Name = "creator",

504
			Value = game:service("Players").LocalPlayer,

505
			Parent = h,

506
		}

507
		game:GetService("Debris"):AddItem(c, .5)

508
		if HitSound ~= nil and HitPitch ~= nil then

509
			CFuncs.Sound.Create(HitSound, hit, 1, HitPitch) 

510
		end

511
		local Damage = math.random(minim, maxim)

512
		local blocked = false

513
		local block = hit.Parent:findFirstChild("Block")

514
		if block ~= nil then

515
			if block.className == "IntValue" then

516
				if block.Value > 0 then

517
					blocked = true

518
					block.Value = block.Value - 1

519
					print(block.Value)

520
				end

521
			end

522
		end

523
		if blocked == false then

524
			h.Health = h.Health - Damage

525
			ShowDamage((Part.CFrame * CFrame.new(0, 0, (Part.Size.Z / 2)).p + Vector3.new(0, 1.5, 0)), -Damage, 1.5, tors.BrickColor.Color)

526
		else

527
			h.Health = h.Health - (Damage / 2)

528
			ShowDamage((Part.CFrame * CFrame.new(0, 0, (Part.Size.Z / 2)).p + Vector3.new(0, 1.5, 0)), -Damage, 1.5, tors.BrickColor.Color)

529
		end

530
		if Type == "Knockdown" then

531
			local hum = hit.Parent.Humanoid

532
			hum.PlatformStand = true

533
			coroutine.resume(coroutine.create(function(HHumanoid)

534
				swait(1)

535
				HHumanoid.PlatformStand = false

536
			end), hum)

537
			local angle = (hit.Position - (Property.Position + Vector3.new(0, 0, 0))).unit

538
			local bodvol = Create("BodyVelocity"){

539
				velocity = angle * knockback,

540
				P = 5000,

541
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

542
				Parent = hit,

543
			}

544
			local rl = Create("BodyAngularVelocity"){

545
				P = 3000,

546
				maxTorque = Vector3.new(500000, 500000, 500000) * 50000000000000,

547
				angularvelocity = Vector3.new(math.random(-10, 10), math.random(-10, 10), math.random(-10, 10)),

548
				Parent = hit,

549
			}

550
			game:GetService("Debris"):AddItem(bodvol, .5)

551
			game:GetService("Debris"):AddItem(rl, .5)

552
		elseif Type == "Normal" then

553
			local vp = Create("BodyVelocity"){

554
				P = 500,

555
				maxForce = Vector3.new(math.huge, 0, math.huge),

556
				velocity = Property.CFrame.lookVector * knockback + Property.Velocity / 1.05,

557
			}

558
			if knockback > 0 then

559
				vp.Parent = hit.Parent.Torso

560
			end

561
			game:GetService("Debris"):AddItem(vp, .5)

562
		elseif Type == "Up" then

563
			local bodyVelocity = Create("BodyVelocity"){

564
				velocity = Vector3.new(0, 20, 0),

565
				P = 5000,

566
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

567
				Parent = hit,

568
			}

569
			game:GetService("Debris"):AddItem(bodyVelocity, .5)

570
		elseif Type == "DarkUp" then

571
			coroutine.resume(coroutine.create(function()

572
				for i = 0, 1, 0.1 do

573
					swait()

574
					Effects.Block.Create(BrickColor.new("Really red"), hit.Parent.Torso.CFrame, 5, 5, 5, 1, 1, 1, .08, 1)

575
				end

576
			end))

577
			local bodyVelocity = Create("BodyVelocity"){

578
				velocity = Vector3.new(0, 20, 0),

579
				P = 5000,

580
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

581
				Parent = hit,

582
			}

583
			game:GetService("Debris"):AddItem(bodyVelocity, 1)

584
		elseif Type == "Snare" then

585
			local bp = Create("BodyPosition"){

586
				P = 2000,

587
				D = 100,

588
				maxForce = Vector3.new(math.huge, math.huge, math.huge),

589
				position = hit.Parent.Torso.Position,

590
				Parent = hit.Parent.Torso,

591
			}

592
			game:GetService("Debris"):AddItem(bp, 1)

593
		elseif Type == "Freeze" then

594
			local BodPos = Create("BodyPosition"){

595
				P = 50000,

596
				D = 1000,

597
				maxForce = Vector3.new(math.huge, math.huge, math.huge),

598
				position = hit.Parent.Torso.Position,

599
				Parent = hit.Parent.Torso,

600
			}

601
			local BodGy = Create("BodyGyro") {

602
				maxTorque = Vector3.new(4e+005, 4e+005, 4e+005) * math.huge ,

603
				P = 20e+003,

604
				Parent = hit.Parent.Torso,

605
				cframe = hit.Parent.Torso.CFrame,

606
			}

607
			hit.Parent.Torso.Anchored = true

608
			coroutine.resume(coroutine.create(function(Part) 

609
				swait(1.5)

610
				Part.Anchored = false

611
			end), hit.Parent.Torso)

612
			game:GetService("Debris"):AddItem(BodPos, 3)

613
			game:GetService("Debris"):AddItem(BodGy, 3)

614
		end

615
		local debounce = Create("BoolValue"){

616
			Name = "DebounceHit",

617
			Parent = hit.Parent,

618
			Value = true,

619
		}

620
		game:GetService("Debris"):AddItem(debounce, Delay)

621
		c = Create("ObjectValue"){

622
			Name = "creator",

623
			Value = Player,

624
			Parent = h,

625
		}

626
		game:GetService("Debris"):AddItem(c, .5)

627
	end

628
end

629
-------------------------------------------------------

630
--End Damage Function--

631
-------------------------------------------------------

632
633
-------------------------------------------------------

634
--Start Damage Function Customization--

635
-------------------------------------------------------

636
function ShowDamage(Pos, Text, Time, Color)

637
	local Rate = (1 / 30)

638
	local Pos = (Pos or Vector3.new(0, 0, 0))

639
	local Text = (Text or "")

640
	local Time = (Time or 2)

641
	local Color = (Color or Color3.new(1, 0, 1))

642
	local EffectPart = CFuncs.Part.Create(workspace, "SmoothPlastic", 0, 1, BrickColor.new(Color), "Effect", Vector3.new(0, 0, 0))

643
	EffectPart.Anchored = true

644
	local BillboardGui = Create("BillboardGui"){

645
		Size = UDim2.new(3, 0, 3, 0),

646
		Adornee = EffectPart,

647
		Parent = EffectPart,

648
	}

649
	local TextLabel = Create("TextLabel"){

650
		BackgroundTransparency = 1,

651
		Size = UDim2.new(1, 0, 1, 0),

652
		Text = Text,

653
		Font = "Bodoni",

654
		TextColor3 = Color,

655
		TextScaled = true,

656
		TextStrokeColor3 = Color3.fromRGB(0,0,0),

657
		Parent = BillboardGui,

658
	}

659
	game.Debris:AddItem(EffectPart, (Time))

660
	EffectPart.Parent = game:GetService("Workspace")

661
	delay(0, function()

662
		local Frames = (Time / Rate)

663
		for Frame = 1, Frames do

664
			wait(Rate)

665
			local Percent = (Frame / Frames)

666
			EffectPart.CFrame = CFrame.new(Pos) + Vector3.new(0, Percent, 0)

667
			TextLabel.TextTransparency = Percent

668
		end

669
		if EffectPart and EffectPart.Parent then

670
			EffectPart:Destroy()

671
		end

672
	end)

673
end

674
-------------------------------------------------------

675
--End Damage Function Customization--

676
-------------------------------------------------------

677
678
function MagniDamage(Part, magni, mindam, maxdam, knock, Type)

679
  for _, c in pairs(workspace:children()) do

680
    local hum = c:findFirstChild("Humanoid")

681
    if hum ~= nil then

682
      local head = c:findFirstChild("Head")

683
      if head ~= nil then

684
        local targ = head.Position - Part.Position

685
        local mag = targ.magnitude

686
        if magni >= mag and c.Name ~= plr.Name then

687
          Damage(head, head, mindam, maxdam, knock, Type, root, 0.1, "http://www.roblox.com/asset/?id=0", 1.2)

688
        end

689
      end

690
    end

691
  end

692
end

693
694
695
CFuncs = {

696
	Part = {

697
		Create = function(Parent, Material, Reflectance, Transparency, BColor, Name, Size)

698
			local Part = Create("Part")({

699
				Parent = Parent,

700
				Reflectance = Reflectance,

701
				Transparency = Transparency,

702
				CanCollide = false,

703
				Locked = true,

704
				BrickColor = BrickColor.new(tostring(BColor)),

705
				Name = Name,

706
				Size = Size,

707
				Material = Material

708
			})

709
			RemoveOutlines(Part)

710
			return Part

711
		end

712
	},

713
	Mesh = {

714
		Create = function(Mesh, Part, MeshType, MeshId, OffSet, Scale)

715
			local Msh = Create(Mesh)({

716
				Parent = Part,

717
				Offset = OffSet,

718
				Scale = Scale

719
			})

720
			if Mesh == "SpecialMesh" then

721
				Msh.MeshType = MeshType

722
				Msh.MeshId = MeshId

723
			end

724
			return Msh

725
		end

726
	},

727
	Mesh = {

728
		Create = function(Mesh, Part, MeshType, MeshId, OffSet, Scale)

729
			local Msh = Create(Mesh)({

730
				Parent = Part,

731
				Offset = OffSet,

732
				Scale = Scale

733
			})

734
			if Mesh == "SpecialMesh" then

735
				Msh.MeshType = MeshType

736
				Msh.MeshId = MeshId

737
			end

738
			return Msh

739
		end

740
	},

741
	Weld = {

742
		Create = function(Parent, Part0, Part1, C0, C1)

743
			local Weld = Create("Weld")({

744
				Parent = Parent,

745
				Part0 = Part0,

746
				Part1 = Part1,

747
				C0 = C0,

748
				C1 = C1

749
			})

750
			return Weld

751
		end

752
	},

753
	Sound = {

754
		Create = function(id, par, vol, pit)

755
			coroutine.resume(coroutine.create(function()

756
				local S = Create("Sound")({

757
					Volume = vol,

758
					Pitch = pit or 1,

759
					SoundId = id,

760
					Parent = par or workspace

761
				})

762
				wait()

763
				S:play()

764
				game:GetService("Debris"):AddItem(S, 6)

765
			end))

766
		end

767
	},

768
	ParticleEmitter = {

769
		Create = function(Parent, Color1, Color2, LightEmission, Size, Texture, Transparency, ZOffset, Accel, Drag, LockedToPart, VelocityInheritance, EmissionDirection, Enabled, LifeTime, Rate, Rotation, RotSpeed, Speed, VelocitySpread)

770
			local fp = Create("ParticleEmitter")({

771
				Parent = Parent,

772
				Color = ColorSequence.new(Color1, Color2),

773
				LightEmission = LightEmission,

774
				Size = Size,

775
				Texture = Texture,

776
				Transparency = Transparency,

777
				ZOffset = ZOffset,

778
				Acceleration = Accel,

779
				Drag = Drag,

780
				LockedToPart = LockedToPart,

781
				VelocityInheritance = VelocityInheritance,

782
				EmissionDirection = EmissionDirection,

783
				Enabled = Enabled,

784
				Lifetime = LifeTime,

785
				Rate = Rate,

786
				Rotation = Rotation,

787
				RotSpeed = RotSpeed,

788
				Speed = Speed,

789
				VelocitySpread = VelocitySpread

790
			})

791
			return fp

792
		end

793
	}

794
}

795
function RemoveOutlines(part)

796
	part.TopSurface, part.BottomSurface, part.LeftSurface, part.RightSurface, part.FrontSurface, part.BackSurface = 10, 10, 10, 10, 10, 10

797
end

798
function CreatePart(FormFactor, Parent, Material, Reflectance, Transparency, BColor, Name, Size)

799
	local Part = Create("Part")({

800
		formFactor = FormFactor,

801
		Parent = Parent,

802
		Reflectance = Reflectance,

803
		Transparency = Transparency,

804
		CanCollide = false,

805
		Locked = true,

806
		BrickColor = BrickColor.new(tostring(BColor)),

807
		Name = Name,

808
		Size = Size,

809
		Material = Material

810
	})

811
	RemoveOutlines(Part)

812
	return Part

813
end

814
function CreateMesh(Mesh, Part, MeshType, MeshId, OffSet, Scale)

815
	local Msh = Create(Mesh)({

816
		Parent = Part,

817
		Offset = OffSet,

818
		Scale = Scale

819
	})

820
	if Mesh == "SpecialMesh" then

821
		Msh.MeshType = MeshType

822
		Msh.MeshId = MeshId

823
	end

824
	return Msh

825
end

826
function CreateWeld(Parent, Part0, Part1, C0, C1)

827
	local Weld = Create("Weld")({

828
		Parent = Parent,

829
		Part0 = Part0,

830
		Part1 = Part1,

831
		C0 = C0,

832
		C1 = C1

833
	})

834
	return Weld

835
end

836
837
838
-------------------------------------------------------

839
--Start Effect Function--

840
-------------------------------------------------------

841
EffectModel = Instance.new("Model", char)

842
Effects = {

843
  Block = {

844
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay, Type)

845
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

846
      prt.Anchored = true

847
      prt.CFrame = cframe

848
      local msh = CFuncs.Mesh.Create("BlockMesh", prt, "", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

849
      game:GetService("Debris"):AddItem(prt, 10)

850
      if Type == 1 or Type == nil then

851
        table.insert(Effects, {

852
          prt,

853
          "Block1",

854
          delay,

855
          x3,

856
          y3,

857
          z3,

858
          msh

859
        })

860
      elseif Type == 2 then

861
        table.insert(Effects, {

862
          prt,

863
          "Block2",

864
          delay,

865
          x3,

866
          y3,

867
          z3,

868
          msh

869
        })

870
      else

871
        table.insert(Effects, {

872
          prt,

873
          "Block3",

874
          delay,

875
          x3,

876
          y3,

877
          z3,

878
          msh

879
        })

880
      end

881
    end

882
  },

883
  Sphere = {

884
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

885
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new())

886
      prt.Anchored = true

887
      prt.CFrame = cframe

888
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "Sphere", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

889
      game:GetService("Debris"):AddItem(prt, 10)

890
      table.insert(Effects, {

891
        prt,

892
        "Cylinder",

893
        delay,

894
        x3,

895
        y3,

896
        z3,

897
        msh

898
      })

899
    end

900
  },

901
  Cylinder = {

902
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

903
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

904
      prt.Anchored = true

905
      prt.CFrame = cframe

906
      local msh = CFuncs.Mesh.Create("CylinderMesh", prt, "", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

907
      game:GetService("Debris"):AddItem(prt, 10)

908
      table.insert(Effects, {

909
        prt,

910
        "Cylinder",

911
        delay,

912
        x3,

913
        y3,

914
        z3,

915
        msh

916
      })

917
    end

918
  },

919
  Wave = {

920
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

921
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new())

922
      prt.Anchored = true

923
      prt.CFrame = cframe

924
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://20329976", Vector3.new(0, 0, 0), Vector3.new(x1 / 60, y1 / 60, z1 / 60))

925
      game:GetService("Debris"):AddItem(prt, 10)

926
      table.insert(Effects, {

927
        prt,

928
        "Cylinder",

929
        delay,

930
        x3 / 60,

931
        y3 / 60,

932
        z3 / 60,

933
        msh

934
      })

935
    end

936
  },

937
  Ring = {

938
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

939
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

940
      prt.Anchored = true

941
      prt.CFrame = cframe

942
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://3270017", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

943
      game:GetService("Debris"):AddItem(prt, 10)

944
      table.insert(Effects, {

945
        prt,

946
        "Cylinder",

947
        delay,

948
        x3,

949
        y3,

950
        z3,

951
        msh

952
      })

953
    end

954
  },

955
  Break = {

956
    Create = function(brickcolor, cframe, x1, y1, z1)

957
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new(0.5, 0.5, 0.5))

958
      prt.Anchored = true

959
      prt.CFrame = cframe * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50))

960
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "Sphere", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

961
      local num = math.random(10, 50) / 1000

962
      game:GetService("Debris"):AddItem(prt, 10)

963
      table.insert(Effects, {

964
        prt,

965
        "Shatter",

966
        num,

967
        prt.CFrame,

968
        math.random() - math.random(),

969
        0,

970
        math.random(50, 100) / 100

971
      })

972
    end

973
  },

974
Spiral = {

975
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

976
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

977
      prt.Anchored = true

978
      prt.CFrame = cframe

979
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://1051557", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

980
      game:GetService("Debris"):AddItem(prt, 10)

981
      table.insert(Effects, {

982
        prt,

983
        "Cylinder",

984
        delay,

985
        x3,

986
        y3,

987
        z3,

988
        msh

989
      })

990
    end

991
  },

992
Push = {

993
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

994
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

995
      prt.Anchored = true

996
      prt.CFrame = cframe

997
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://437347603", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

998
      game:GetService("Debris"):AddItem(prt, 10)

999
      table.insert(Effects, {

1000
        prt,

1001
        "Cylinder",

1002
        delay,

1003
        x3,

1004
        y3,

1005
        z3,

1006
        msh

1007
      })

1008
    end

1009
  }

1010
}

1011
function part(formfactor ,parent, reflectance, transparency, brickcolor, name, size)

1012
	local fp = IT("Part")

1013
	fp.formFactor = formfactor 

1014
	fp.Parent = parent

1015
	fp.Reflectance = reflectance

1016
	fp.Transparency = transparency

1017
	fp.CanCollide = false 

1018
	fp.Locked = true

1019
	fp.BrickColor = brickcolor

1020
	fp.Name = name

1021
	fp.Size = size

1022
	fp.Position = tors.Position 

1023
	RemoveOutlines(fp)

1024
	fp.Material = "SmoothPlastic"

1025
	fp:BreakJoints()

1026
	return fp 

1027
end 

1028
 

1029
function mesh(Mesh,part,meshtype,meshid,offset,scale)

1030
	local mesh = IT(Mesh) 

1031
	mesh.Parent = part

1032
	if Mesh == "SpecialMesh" then

1033
		mesh.MeshType = meshtype

1034
	if meshid ~= "nil" then

1035
		mesh.MeshId = "http://www.roblox.com/asset/?id="..meshid

1036
		end

1037
	end

1038
	mesh.Offset = offset

1039
	mesh.Scale = scale

1040
	return mesh

1041
end

1042
1043
function Magic(bonuspeed, type, pos, scale, value, color, MType)

1044
	local type = type

1045
	local rng = Instance.new("Part", char)

1046
	rng.Anchored = true

1047
	rng.BrickColor = color

1048
	rng.CanCollide = false

1049
	rng.FormFactor = 3

1050
	rng.Name = "Ring"

1051
	rng.Material = "Neon"

1052
	rng.Size = Vector3.new(1, 1, 1)

1053
	rng.Transparency = 0

1054
	rng.TopSurface = 0

1055
	rng.BottomSurface = 0

1056
	rng.CFrame = pos

1057
	local rngm = Instance.new("SpecialMesh", rng)

1058
	rngm.MeshType = MType

1059
	rngm.Scale = scale

1060
	local scaler2 = 1

1061
	if type == "Add" then

1062
		scaler2 = 1 * value

1063
	elseif type == "Divide" then

1064
		scaler2 = 1 / value

1065
	end

1066
	coroutine.resume(coroutine.create(function()

1067
		for i = 0, 10 / bonuspeed, 0.1 do

1068
			swait()

1069
			if type == "Add" then

1070
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1071
			elseif type == "Divide" then

1072
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1073
			end

1074
			rng.Transparency = rng.Transparency + 0.01 * bonuspeed

1075
			rngm.Scale = rngm.Scale + Vector3.new(scaler2 * bonuspeed, scaler2 * bonuspeed, scaler2 * bonuspeed)

1076
		end

1077
		rng:Destroy()

1078
	end))

1079
end

1080
1081
function Eviscerate(dude)

1082
	if dude.Name ~= char then

1083
		local bgf = IT("BodyGyro", dude.Head)

1084
		bgf.CFrame = bgf.CFrame * CFrame.fromEulerAnglesXYZ(Rad(-90), 0, 0)

1085
		local val = IT("BoolValue", dude)

1086
		val.Name = "IsHit"

1087
		local ds = coroutine.wrap(function()

1088
			dude:WaitForChild("Head"):BreakJoints()

1089
			wait(0.5)

1090
			target = nil

1091
			coroutine.resume(coroutine.create(function()

1092
				for i, v in pairs(dude:GetChildren()) do

1093
					if v:IsA("Accessory") then

1094
						v:Destroy()

1095
					end

1096
					if v:IsA("Humanoid") then

1097
						v:Destroy()

1098
					end

1099
					if v:IsA("CharacterMesh") then

1100
						v:Destroy()

1101
					end

1102
					if v:IsA("Model") then

1103
						v:Destroy()

1104
					end

1105
					if v:IsA("Part") or v:IsA("MeshPart") then

1106
						for x, o in pairs(v:GetChildren()) do

1107
							if o:IsA("Decal") then

1108
								o:Destroy()

1109
							end

1110
						end

1111
						coroutine.resume(coroutine.create(function()

1112
							v.Material = "Neon"

1113
							v.CanCollide = false

1114
							local PartEmmit1 = IT("ParticleEmitter", v)

1115
							PartEmmit1.LightEmission = 1

1116
							PartEmmit1.Texture = "rbxassetid://284205403"

1117
							PartEmmit1.Color = ColorSequence.new(maincolor.Color)

1118
							PartEmmit1.Rate = 150

1119
							PartEmmit1.Lifetime = NumberRange.new(1)

1120
							PartEmmit1.Size = NumberSequence.new({

1121
								NumberSequenceKeypoint.new(0, 0.75, 0),

1122
								NumberSequenceKeypoint.new(1, 0, 0)

1123
							})

1124
							PartEmmit1.Transparency = NumberSequence.new({

1125
								NumberSequenceKeypoint.new(0, 0, 0),

1126
								NumberSequenceKeypoint.new(1, 1, 0)

1127
							})

1128
							PartEmmit1.Speed = NumberRange.new(0, 0)

1129
							PartEmmit1.VelocitySpread = 30000

1130
							PartEmmit1.Rotation = NumberRange.new(-500, 500)

1131
							PartEmmit1.RotSpeed = NumberRange.new(-500, 500)

1132
							local BodPoss = IT("BodyPosition", v)

1133
							BodPoss.P = 3000

1134
							BodPoss.D = 1000

1135
							BodPoss.maxForce = Vector3.new(50000000000, 50000000000, 50000000000)

1136
							BodPoss.position = v.Position + Vector3.new(Mrandom(-15, 15), Mrandom(-15, 15), Mrandom(-15, 15))

1137
							v.Color = maincolor.Color

1138
							coroutine.resume(coroutine.create(function()

1139
								for i = 0, 49 do

1140
									swait(1)

1141
									v.Transparency = v.Transparency + 0.08

1142
								end

1143
								wait(0.5)

1144
								PartEmmit1.Enabled = false

1145
								wait(3)

1146
								v:Destroy()

1147
								dude:Destroy()

1148
							end))

1149
						end))

1150
					end

1151
				end

1152
			end))

1153
		end)

1154
		ds()

1155
	end

1156
end

1157
1158
function FindNearestHead(Position, Distance, SinglePlayer)

1159
	if SinglePlayer then

1160
		return Distance > (SinglePlayer.Torso.CFrame.p - Position).magnitude

1161
	end

1162
	local List = {}

1163
	for i, v in pairs(workspace:GetChildren()) do

1164
		if v:IsA("Model") and v:findFirstChild("Head") and v ~= char and Distance >= (v.Head.Position - Position).magnitude then

1165
			table.insert(List, v)

1166
		end

1167
	end

1168
	return List

1169
end

1170
1171
function Aura(bonuspeed, FastSpeed, type, pos, x1, y1, z1, value, color, outerpos, MType)

1172
	local type = type

1173
	local rng = Instance.new("Part", char)

1174
	rng.Anchored = true

1175
	rng.BrickColor = color

1176
	rng.CanCollide = false

1177
	rng.FormFactor = 3

1178
	rng.Name = "Ring"

1179
	rng.Material = "Neon"

1180
	rng.Size = Vector3.new(1, 1, 1)

1181
	rng.Transparency = 0

1182
	rng.TopSurface = 0

1183
	rng.BottomSurface = 0

1184
	rng.CFrame = pos

1185
	rng.CFrame = rng.CFrame + rng.CFrame.lookVector * outerpos

1186
	local rngm = Instance.new("SpecialMesh", rng)

1187
	rngm.MeshType = MType

1188
	rngm.Scale = Vector3.new(x1, y1, z1)

1189
	local scaler2 = 1

1190
	local speeder = FastSpeed

1191
	if type == "Add" then

1192
		scaler2 = 1 * value

1193
	elseif type == "Divide" then

1194
		scaler2 = 1 / value

1195
	end

1196
	coroutine.resume(coroutine.create(function()

1197
		for i = 0, 10 / bonuspeed, 0.1 do

1198
			swait()

1199
			if type == "Add" then

1200
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1201
			elseif type == "Divide" then

1202
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1203
			end

1204
			speeder = speeder - 0.01 * FastSpeed * bonuspeed

1205
			rng.CFrame = rng.CFrame + rng.CFrame.lookVector * speeder * bonuspeed

1206
			rng.Transparency = rng.Transparency + 0.01 * bonuspeed

1207
			rngm.Scale = rngm.Scale + Vector3.new(scaler2 * bonuspeed, scaler2 * bonuspeed, 0)

1208
		end

1209
		rng:Destroy()

1210
	end))

1211
end

1212
1213
function SoulSteal(dude)

1214
if dude.Name ~= char then

1215
local bgf = IT("BodyGyro", dude.Head)

1216
bgf.CFrame = bgf.CFrame * CFrame.fromEulerAnglesXYZ(Rad(-90), 0, 0)

1217
local val = IT("BoolValue", dude)

1218
val.Name = "IsHit"

1219
local torso = (dude:FindFirstChild'Head' or dude:FindFirstChild'Torso' or dude:FindFirstChild'UpperTorso' or dude:FindFirstChild'LowerTorso' or dude:FindFirstChild'HumanoidRootPart')

1220
local soulst = coroutine.wrap(function()

1221
local soul = Instance.new("Part",dude)

1222
soul.Size = Vector3.new(1,1,1)

1223
soul.CanCollide = false

1224
soul.Anchored = false

1225
soul.Position = torso.Position

1226
soul.Transparency = 1

1227
local PartEmmit1 = IT("ParticleEmitter", soul)

1228
PartEmmit1.LightEmission = 1

1229
PartEmmit1.Texture = "rbxassetid://569507414"

1230
PartEmmit1.Color = ColorSequence.new(maincolor.Color)

1231
PartEmmit1.Rate = 250

1232
PartEmmit1.Lifetime = NumberRange.new(1.6)

1233
PartEmmit1.Size = NumberSequence.new({

1234
	NumberSequenceKeypoint.new(0, 1, 0),

1235
	NumberSequenceKeypoint.new(1, 0, 0)

1236
})

1237
PartEmmit1.Transparency = NumberSequence.new({

1238
	NumberSequenceKeypoint.new(0, 0, 0),

1239
	NumberSequenceKeypoint.new(1, 1, 0)

1240
})

1241
PartEmmit1.Speed = NumberRange.new(0, 0)

1242
PartEmmit1.VelocitySpread = 30000

1243
PartEmmit1.Rotation = NumberRange.new(-360, 360)

1244
PartEmmit1.RotSpeed = NumberRange.new(-360, 360)

1245
local BodPoss = IT("BodyPosition", soul)

1246
BodPoss.P = 3000

1247
BodPoss.D = 1000

1248
BodPoss.maxForce = Vector3.new(50000000000, 50000000000, 50000000000)

1249
BodPoss.position = torso.Position + Vector3.new(Mrandom(-15, 15), Mrandom(-15, 15), Mrandom(-15, 15))

1250
wait(1.6)

1251
soul.Touched:connect(function(hit)

1252
	if hit.Parent == char then

1253
	soul:Destroy()

1254
	end

1255
end)

1256
wait(1.2)

1257
while soul do

1258
	swait()

1259
	PartEmmit1.Color = ColorSequence.new(maincolor.Color)

1260
	BodPoss.Position = tors.Position

1261
end

1262
end)

1263
	soulst()

1264
	end

1265
end

1266
function FaceMouse()

1267
local	Cam = workspace.CurrentCamera

1268
	return {

1269
		CFrame.new(char.Torso.Position, Vector3.new(mouse.Hit.p.x, char.Torso.Position.y, mouse.Hit.p.z)),

1270
		Vector3.new(mouse.Hit.p.x, mouse.Hit.p.y, mouse.Hit.p.z)

1271
	}

1272
end

1273
1274
BTAUNT = Instance.new("Sound", tors)

1275
BTAUNT.SoundId = "http://www.roblox.com/asset/?id=2533880583"

1276
BTAUNT.Volume = 3

1277
BTAUNT.Pitch = 1

1278
BTAUNT.Looped = true

1279
BTAUNT.TimePosition = 0

1280
1281
BTAUNT3 = Instance.new("Sound", tors)

1282
BTAUNT3.SoundId = "http://www.roblox.com/asset/?id=157016540"

1283
BTAUNT3.Volume = 10

1284
BTAUNT3.Pitch = 1

1285
BTAUNT3.Looped = false

1286
BTAUNT3.TimePosition = 0

1287
1288
TEST = Instance.new("Sound", tors)

1289
TEST.SoundId = "http://www.roblox.com/asset/?id=2544975373"

1290
TEST.Volume = 25

1291
TEST.Pitch = 1

1292
TEST.Looped = false

1293
TEST.TimePosition = 0

1294
-------------------------------------------------------

1295
--End Effect Function--

1296
-------------------------------------------------------

1297
function Cso(ID, PARENT, VOLUME, PITCH)

1298
	local NSound = nil

1299
	coroutine.resume(coroutine.create(function()

1300
		NSound = IT("Sound", PARENT)

1301
		NSound.Volume = VOLUME

1302
		NSound.Pitch = PITCH

1303
		NSound.SoundId = "http://www.roblox.com/asset/?id="..ID

1304
		swait()

1305
		NSound:play()

1306
		game:GetService("Debris"):AddItem(NSound, 50)

1307
	end))

1308
	return NSound

1309
end

1310
function CameraEnshaking(Length, Intensity)

1311
	coroutine.resume(coroutine.create(function()

1312
		local intensity = 1 * Intensity

1313
		local rotM = 0.01 * Intensity

1314
		for i = 0, Length, 0.1 do

1315
			swait()

1316
			intensity = intensity - 0.05 * Intensity / Length

1317
			rotM = rotM - 5.0E-4 * Intensity / Length

1318
			hum.CameraOffset = Vector3.new(Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)))

1319
			cam.CFrame = cam.CFrame * CF(Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity))) * Euler(Rad(Mrandom(-intensity, intensity)) * rotM, Rad(Mrandom(-intensity, intensity)) * rotM, Rad(Mrandom(-intensity, intensity)) * rotM)

1320
		end

1321
		hum.CameraOffset = Vector3.new(0, 0, 0)

1322
	end))

1323
end

1324
-------------------------------------------------------

1325
--End Important Functions--

1326
-------------------------------------------------------

1327
1328
1329
-------------------------------------------------------

1330
--Start Customization--

1331
-------------------------------------------------------

1332
local Player_Size = 1

1333
if Player_Size ~= 1 then

1334
root.Size = root.Size * Player_Size

1335
tors.Size = tors.Size * Player_Size

1336
hed.Size = hed.Size * Player_Size

1337
ra.Size = ra.Size * Player_Size

1338
la.Size = la.Size * Player_Size

1339
rl.Size = rl.Size * Player_Size

1340
ll.Size = ll.Size * Player_Size

1341
----------------------------------------------------------------------------------

1342
rootj.Parent = root

1343
neck.Parent = tors

1344
RW.Parent = tors

1345
LW.Parent = tors

1346
RH.Parent = tors

1347
LH.Parent = tors

1348
----------------------------------------------------------------------------------

1349
rootj.C0 = RootCF * CF(0 * Player_Size, 0 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0))

1350
rootj.C1 = RootCF * CF(0 * Player_Size, 0 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0))

1351
neck.C0 = necko * CF(0 * Player_Size, 0 * Player_Size, 0 + ((1 * Player_Size) - 1)) * angles(Rad(0), Rad(0), Rad(0))

1352
neck.C1 = CF(0 * Player_Size, -0.5 * Player_Size, 0 * Player_Size) * angles(Rad(-90), Rad(0), Rad(180))

1353
RW.C0 = CF(1.5 * Player_Size, 0.5 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0)) --* RIGHTSHOULDERC0

1354
LW.C0 = CF(-1.5 * Player_Size, 0.5 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0)) --* LEFTSHOULDERC0

1355
----------------------------------------------------------------------------------

1356
RH.C0 = CF(1 * Player_Size, -1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1357
LH.C0 = CF(-1 * Player_Size, -1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(-90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1358
RH.C1 = CF(0.5 * Player_Size, 1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1359
LH.C1 = CF(-0.5 * Player_Size, 1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(-90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1360
--hat.Parent = Character

1361
end

1362
----------------------------------------------------------------------------------

1363
----------------------------------------------------------------------------------

1364
local equipped = false

1365
local idle = 0

1366
local change = 1

1367
local val = 0

1368
local toim = 0

1369
local idleanim = 0.4

1370
local sine = 0

1371
local Sit = 1

1372
----------------------------------------------------------------------------------

1373
hum.WalkSpeed = 8

1374
hum.JumpPower = 57

1375
hum.Animator.Parent = nil

1376
----------------------------------------------------------------------------------

1377
wait(1)

1378
player = game.Players.LocalPlayer

1379
torso = player.Character:WaitForChild("Torso")

1380
mouse = player:GetMouse()

1381
1382
mouse.KeyDown:connect(function(key)

1383
    if key == "t" then

1384
    Cso("2545012765", hed, 3.5, 1)

1385
        dist = (torso.Position - mouse.Hit.p).magnitude

1386
        if dist <= 10000 then

1387
            torso.CFrame = CFrame.new(mouse.Hit.p) + Vector3.new(0,3,0)

1388
        end

1389
    end

1390
end)

1391
-------------------------------------------------------

1392
--End Customization--

1393
-------------------------------------------------------

1394
local Blobby = Instance.new("Part", char)

1395
Blobby.Name = "Blob"

1396
Blobby.CanCollide = false

1397
Blobby.BrickColor = BrickColor.new("Really black")

1398
Blobby.Transparency = 0

1399
Blobby.Material = "Plastic"

1400
Blobby.Size = Vector3.new(1, 1, 2)

1401
Blobby.TopSurface = Enum.SurfaceType.Smooth

1402
Blobby.BottomSurface = Enum.SurfaceType.Smooth

1403
1404
local Weld = Instance.new("Weld", Blobby)

1405
Weld.Part0 = ra

1406
Weld.Part1 = Blobby

1407
Weld.C1 = CFrame.new(0, 0.8, 0)

1408
Weld.C0 = CFrame.Angles(Rad(-180),0,135)

1409
1410
local M2 = Instance.new("SpecialMesh")

1411
M2.Parent = Blobby

1412
M2.MeshId = "rbxassetid://28140935"

1413
M2.TextureId = "rbxassetid://26884682"

1414
M2.Scale = Vector3.new(1, 0.8, 1)

1415
1416
--[[local naeeym2 = Instance.new("BillboardGui",char)

1417
naeeym2.AlwaysOnTop = true

1418
naeeym2.Size = UDim2.new(5,35,2,15)

1419
naeeym2.StudsOffset = Vector3.new(0, 3.5, 0)

1420
naeeym2.Adornee = hed

1421
naeeym2.Name = "Name"

1422
--naeeym2.PlayerToHideFrom = Player

1423
local tecks2 = Instance.new("TextLabel",naeeym2)

1424
tecks2.BackgroundTransparency = 1

1425
tecks2.TextScaled = true

1426
tecks2.BorderSizePixel = 0

1427
tecks2.Text = "Fight Me"

1428
tecks2.Font = Enum.Font.Bodoni

1429
tecks2.TextSize = 30

1430
tecks2.TextStrokeTransparency = 0

1431
tecks2.TextColor3 = Color3.new(0, 0, 0)

1432
tecks2.TextStrokeColor3 = Color3.new(1, 1, 1)

1433
tecks2.Size = UDim2.new(1,0,0.5,0)

1434
tecks2.Parent = naeeym2]]

1435
----------------------------------------------------------------------------------

1436
local AddInstance = function(Object, ...)

1437
local Obj = Instance.new(Object)

1438
for i,v in next,(...) do

1439
Obj[i] = v

1440
end

1441
return Obj

1442
end

1443
----------------------------------------------------

1444
		local Reaper = AddInstance("Part",{

1445
			Parent = hed,

1446
			CFrame = hed.CFrame,

1447
			formFactor = "Symmetric",

1448
			Size = Vector3.new(1, 1, 1),

1449
			CanCollide = false,

1450
			TopSurface = "Smooth",

1451
			BottomSurface = "Smooth",

1452
			Locked = true,

1453
		})

1454
		local Weld = AddInstance("Weld",{

1455
			Parent = Reaper,

1456
			Part0 = hed,

1457
			C0 = CFrame.new(0, 0.8, 0.4)*CFrame.Angles(0, 0, 0),

1458
			Part1 = Reaper,

1459
		})

1460
		local Mesh = AddInstance("SpecialMesh",{

1461
			Parent = Reaper,

1462
			MeshId = "rbxassetid://193760002",

1463
			TextureId = "rbxassetid://89867215",

1464
			Scale = Vector3.new(1.1, 1.1, 1.1),

1465
			VertexColor = Vector3.new(0.5, 0.5, 0.5),

1466
		})

1467
-------------------------------------------------------

1468
wait(1)

1469
plr = game.Players.LocalPlayer

1470
char = plr.Character

1471
mouse = plr:GetMouse()

1472
whitecolor = Color3.new(1,1,1)

1473
epicmode = false

1474
normal = true

1475
for i,v in pairs(char:GetChildren()) do

1476
   if v.ClassName == "Shirt" or v.ClassName == "Pants" or v.ClassName == "ShirtGraphic" then

1477
      v:Destroy()

1478
     end

1479
end

1480
local shirt = Instance.new("Shirt",char)

1481
shirt.ShirtTemplate = "rbxassetid://2544612637"

1482
local pants = Instance.new("Pants",char)

1483
pants.PantsTemplate = "rbxassetid://2544611861"

1484
local bdycolors = char["Body Colors"]

1485
bdycolors.HeadColor3 = whitecolor

1486
bdycolors.LeftArmColor3 = whitecolor

1487
bdycolors.LeftLegColor3 = whitecolor

1488
bdycolors.RightArmColor3 = whitecolor

1489
bdycolors.RightLegColor3 = whitecolor

1490
bdycolors.TorsoColor3 = whitecolor

1491
for i,v in pairs(char:GetChildren()) do

1492
    if v.ClassName == "Hat" or v.ClassName == "Accessory" then

1493
        v:Destroy()

1494
    end

1495
end

1496
1497
-------------------------------------------------------

1498
--Start Attacks N Stuff--

1499
-------------------------------------------------------

1500
local naeeym2 = Instance.new("BillboardGui",char)

1501
naeeym2.AlwaysOnTop = true

1502
naeeym2.Size = UDim2.new(5,35,2,35)

1503
naeeym2.StudsOffset = Vector3.new(0,2,0)

1504
naeeym2.Adornee = hed

1505
naeeym2.Name = "Name"

1506
1507
local tecks2 = Instance.new("TextLabel",naeeym2)

1508
tecks2.BackgroundTransparency = 1

1509
tecks2.TextScaled = true

1510
tecks2.BorderSizePixel = 0

1511
tecks2.Text = "JEVIL"

1512
tecks2.Font = "Fantasy"

1513
tecks2.TextSize = 50

1514
tecks2.TextStrokeTransparency = 0

1515
tecks2.TextColor3 = BrickColor.new('Really black').Color

1516
tecks2.TextStrokeColor3 = BrickColor.new('Bright blue').Color

1517
tecks2.Size = UDim2.new(1,0,0.5,0)

1518
tecks2.Parent = naeeym2

1519
textfag = tecks2

1520
tecks2.Text = "JEVIL"

1521
BTAUNT:Play()

1522
coroutine.resume(coroutine.create(function()

1523
    while textfag ~= nil do

1524
        swait()

1525
        textfag.Position = UDim2.new(math.random(-.2,.2),math.random(-3,3),.05,math.random(-3,3))  

1526
        textfag.Rotation = math.random(-3,3)

1527
    end

1528
end))

1529
1530
function get_out()

1531
        BTAUNT:Stop()

1532
	attack = true

1533
        BTAUNT3:Remove()

1534
        BTAUNT3:Play()

1535
        repeat

1536
	hum.WalkSpeed = 10

1537
	for i = 0,0.37,0.03 do 

1538
                swait()

1539
                BTAUNT3.Parent = tors

1540
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1541
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1542
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(0)), 0.15)

1543
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1544
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.2 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(math.random(-360,360)), Rad(math.random(-360,360)), Rad(math.random(-360,360))), 1)

1545
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(math.random(-360,360)), Rad(math.random(-360,360)), Rad(math.random(-360,360))), 1)	

1546
             end

1547
        for i = 0,0.37,0.03 do

1548
                swait()

1549
                BTAUNT3.Parent = tors

1550
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1551
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1552
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(0)), 0.15)

1553
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1554
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.2 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(math.random(-360,360)), Rad(math.random(-360,360)), Rad(math.random(-360,360))), 1)

1555
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(math.random(-360,360)), Rad(math.random(-360,360)), Rad(math.random(-360,360))), 1)	

1556
             end

1557
        until BTAUNT3.Playing == false

1558
        BTAUNT3:Stop()

1559
        BTAUNT3:Play()

1560
        BTAUNT3:Remove()

1561
        BTAUNT:Play()

1562
	attack = false

1563
	hum.WalkSpeed = 20

1564
        BTAUNT:Play()

1565
end

1566
function Taunt2()

1567
	attack = true

1568
	hum.WalkSpeed = 0

1569
	CFuncs.Sound.Create("rbxassetid://2545008459", head, 100, 1)

1570
	for i = 0, 2, 0.1 do

1571
		swait()

1572
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.5 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1573
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1574
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1575
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1576
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1577
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1578
	end

1579
	for i = 0, 6, 0.1 do

1580
		swait()

1581
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, .2 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1582
		neck.C0 = clerp(neck.C0, necko * CF(0, 0, 2) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.15)

1583
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1.2 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1584
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -1.2 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1585
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1586
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1587
	end

1588
	for i = 0, 2, 0.1 do

1589
		swait()

1590
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.5 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1591
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1592
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1593
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1594
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1595
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1596
	end

1597
	attack = false

1598
	hum.WalkSpeed = 20

1599
end

1600
function icando()

1601
print('>:3')

1602
	attack = true

1603
	hum.WalkSpeed = 0

1604
        TEST:Remove()

1605
        TEST:Play()

1606
        repeat

1607
	for i = 0,4,0.1 do

1608
		swait()

1609
                TEST.Parent = tors

1610
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 12)) * angles(Rad(0), Rad(0), Rad(20)), 0.15)

1611
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(-20)), 0.3)

1612
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1613
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1614
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.5 + 0.05 * Cos(sine / 12)* Player_Size, -0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(-76)), 0.1)

1615
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.5 + 0.05 * Cos(sine / 12)* Player_Size, -0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(56)), 0.1)

1616
	end

1617
        until TEST.Playing == false

1618
        TEST:Stop()

1619
        TEST:Play()

1620
        TEST:Remove()

1621
        print('I CAN DO ANYTHING')

1622
		attack = false

1623
		hum.WalkSpeed = 20

1624
end

1625
function Blood_ball()

1626
	local orb = Instance.new("Part", char)

1627
	orb.Anchored = true

1628
	orb.BrickColor = BrickC("Royal Purple")

1629
	orb.CanCollide = false

1630
	orb.FormFactor = 3

1631
	orb.Name = "Ring"

1632
	orb.Material = "Neon"

1633
	orb.Size = Vector3.new(1, 1, 1)

1634
	orb.Transparency = 0

1635
	orb.TopSurface = 0

1636
	orb.BottomSurface = 0

1637
	local orbm = Instance.new("SpecialMesh", orb)

1638
	orbm.MeshType = "Sphere"

1639
	orbm.Name = "SizeMesh"

1640
	orbm.Scale = Vector3.new(0, 0, 0)

1641
	local scaled = 0.1

1642
	local posid = 0

1643
	for i = 0, 109, 0.1 do

1644
		swait()

1645
		scaled = scaled + 0.001

1646
		posid = posid - scaled

1647
		orb.CFrame = ra.CFrame * CF(0, -0.1 + posid / 1.05, 0)

1648
		orbm.Scale = orbm.Scale + Vector3.new(scaled, scaled, scaled)

1649
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1650
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1651
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(79), Rad(0)) * angles(Rad(-10), Rad(0), Rad(-10)), 0.2)

1652
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-79), Rad(0)) * angles(Rad(-15), Rad(0), Rad(10)), 0.2)

1653
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(125), Rad(-7.5 * Sin(sine / 20)), Rad(40)), 0.2)

1654
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-25), Rad(7.5 * Sin(sine / 20)), Rad(-25)), 0.2)

1655
	end

1656
	coroutine.resume(coroutine.create(function()

1657
		orb.Anchored = false

1658
		--CFuncs.Sound.Create("rbxassetid://260433768", root, 1.25, 1)

1659
		mes("CALAMITY ORB COMING IN EVERYTHING WILL BE DESTROYED",0.05)

1660
		local a = Instance.new("Part", workspace)

1661
		a.Name = "Direction"

1662
		a.Anchored = true

1663
		a.BrickColor = BrickC("Crimson")

1664
		a.Material = "Neon"

1665
		a.Transparency = 1

1666
		a.CanCollide = false

1667
		local ray = Ray.new(orb.CFrame.p, (root.CFrame.lookVector - orb.CFrame.p).unit * 500)

1668
		local ignore = orb

1669
		local hit, position, normal = workspace:FindPartOnRay(ray, ignore)

1670
		a.BottomSurface = 10

1671
		a.TopSurface = 10

1672
		local distance = (orb.CFrame.p - position).magnitude

1673
		a.Size = Vector3.new(0.1, 0.1, 0.1)

1674
		a.CFrame = CF(orb.CFrame.p, position) * CF(0, 0, 0)

1675
		orb.CFrame = a.CFrame

1676
		a:Destroy()

1677
		local bv = Instance.new("BodyVelocity")

1678
		bv.maxForce = Vector3.new(1000000000, 1000000000, 1000000000)

1679
		bv.velocity = orb.CFrame.lookVector * 125

1680
		bv.Parent = orb

1681
		local hitted = false

1682
		game:GetService("Debris"):AddItem(orb, 15)

1683
		wait()

1684
		local hit = orb.Touched:connect(function(hit)

1685
			if hitted == false then

1686
				hitted = true

1687
				coroutine.resume(coroutine.create(function() 

1688
		for i = 0,1.8,0.1 do

1689
			swait()

1690
			hum.CameraOffset = Vector3.new(Mrandom(-1,1),0,Mrandom(-1,1))

1691
		end

1692
		for i = 0,1.8,0.1 do

1693
			swait()

1694
		hum.CameraOffset = Vector3.new(0,0,0)

1695
		end

1696
	end))

1697
				CFuncs.Sound.Create("rbxassetid://151304356", orb, 5, 1)

1698
					for i, v in pairs(FindNearestHead(orb.CFrame.p, 50000)) do

1699
		if v:FindFirstChild("Head") then

1700
			Eviscerate(v)

1701
		end

1702
	end

1703
				Magic(1, "Add", orb.CFrame, Vector3.new(orbm.Scale.x, orbm.Scale.y, orbm.Scale.z), 1, BrickC("Royal Purple"), "Sphere")

1704
				Magic(2, "Add", orb.CFrame, Vector3.new(orbm.Scale.x, orbm.Scale.y, orbm.Scale.z), 2, BrickC("Royal Purple"), "Sphere")

1705
				for i = 0, 9 do

1706
					--Aura(1, 2.5, "Add", orb.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 5, 5, 50, -0.05, BrickColor.new("Royal purple"), 0, "Sphere")

1707
					--Aura(2, 5, "Add", orb.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 5, 5, 50, -0.05, BrickColor.new("Royal purple"), 0, "Sphere")

1708
				end

1709
				orb.Anchored = true

1710
				orb.Transparency = 1

1711
				wait(8)

1712
				orb:Destroy()

1713
			end

1714
		end)

1715
	end))

1716
	for i = 0, 2, 0.1 do

1717
		swait()

1718
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1719
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1720
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(79), Rad(0)) * angles(Rad(-10), Rad(0), Rad(-10)), 0.2)

1721
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-79), Rad(0)) * angles(Rad(-15), Rad(0), Rad(10)), 0.2)

1722
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(45), Rad(-7.5 * Sin(sine / 20)), Rad(40)), 0.2)

1723
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-25), Rad(7.5 * Sin(sine / 20)), Rad(-25)), 0.2)

1724
	end

1725
	attack = false

1726
end

1727
function Blood_ball()

1728
	attack = true

1729
	local orb = Instance.new("Part", char)

1730
	orb.Anchored = true

1731
	orb.BrickColor = BrickC("Royal Purple")

1732
	orb.CanCollide = false

1733
	orb.FormFactor = 3

1734
	orb.Name = "Ring"

1735
	orb.Material = "Neon"

1736
	orb.Size = Vector3.new(1, 1, 1)

1737
	orb.Transparency = 0

1738
	orb.TopSurface = 0

1739
	orb.BottomSurface = 0

1740
	local orbm = Instance.new("SpecialMesh", orb)

1741
	orbm.MeshType = "Sphere"

1742
	orbm.Name = "SizeMesh"

1743
	orbm.Scale = Vector3.new(0, 0, 0)

1744
	local scaled = 0.1

1745
	local posid = 0

1746
	for i = 0, 12, 0.1 do

1747
		swait()

1748
		scaled = scaled + 0.001

1749
		posid = posid - scaled

1750
		orb.CFrame = ra.CFrame * CF(0, -0.1 + posid / 1.05, 0)

1751
		orbm.Scale = orbm.Scale + Vector3.new(scaled, scaled, scaled)

1752
	rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1753
				tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1754
				RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(0)), 0.15)

1755
				LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1756
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(145), Rad(0), Rad(15 + 2.5 * Sin(sine / 20))), 0.12)

1757
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1758
	end

1759
	coroutine.resume(coroutine.create(function()

1760
		orb.Anchored = false

1761
		local a = Instance.new("Part", workspace)

1762
		a.Name = "Direction"

1763
		a.Anchored = true

1764
		a.BrickColor = BrickC("Royal purple")

1765
		a.Material = "Neon"

1766
		a.Transparency = 1

1767
		a.CanCollide = false

1768
		local ray = Ray.new(orb.CFrame.p, (mouse.Hit.p - orb.CFrame.p).unit * 500)

1769
		local ignore = orb

1770
		local hit, position, normal = workspace:FindPartOnRay(ray, ignore)

1771
		a.BottomSurface = 10

1772
		a.TopSurface = 10

1773
		local distance = (orb.CFrame.p - position).magnitude

1774
		a.Size = Vector3.new(0.1, 0.1, 0.1)

1775
		a.CFrame = CFrame.new(orb.CFrame.p, position) * CFrame.new(0, 0, 0)

1776
		orb.CFrame = a.CFrame

1777
		a:Destroy()

1778
		local bv = Instance.new("BodyVelocity")

1779
		bv.maxForce = Vector3.new(1000000000, 1000000000, 1000000000)

1780
		bv.velocity = orb.CFrame.lookVector * 125

1781
		bv.Parent = orb

1782
		local hitted = false

1783
		game:GetService("Debris"):AddItem(orb, 15)

1784
		swait()

1785
		local hit = orb.Touched:connect(function(hit)

1786
			if hitted == false then

1787
				hitted = true

1788
				CFuncs.Sound.Create("rbxassetid://151304356", orb, 5, 1)

1789
				for i, v in pairs(FindNearestHead(orb.CFrame.p, 25)) do

1790
					if v:FindFirstChild("Head") then

1791
						Eviscerate(v)

1792
					end

1793
				end

1794
				Magic(1, "Add", orb.CFrame, Vector3.new(orbm.Scale.x, orbm.Scale.y, orbm.Scale.z), 1, BrickC("Royal Purple"), "Sphere")

1795
				Magic(2, "Add", orb.CFrame, Vector3.new(orbm.Scale.x, orbm.Scale.y, orbm.Scale.z), 2, BrickC("Royal Purple"), "Sphere")

1796
				for i = 0, 9 do

1797
					Aura(1, 2.5, "Add", orb.CFrame * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 5, 5, 50, -0.05, BrickC("Royal Purple"), 0, "Sphere")

1798
					Aura(2, 5, "Add", orb.CFrame * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 5, 5, 50, -0.05, BrickC("Royal Purple"), 0, "Sphere")

1799
				end

1800
				orb.Anchored = true

1801
				orb.Transparency = 1

1802
				wait(8)

1803
				orb:Destroy()

1804
			end

1805
		end)

1806
	end))

1807
	for i = 0, 1, 0.1 do

1808
		swait()

1809
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(6), Rad(0), Rad(30)), 0.3)

1810
		neck.C0 = clerp(neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-20 - 2.5 * Sin(sine / 20)), Rad(Mrandom(-15, 15)), Rad(-30)), 0.3)

1811
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(85), Rad(0)) * angles(Rad(-5), Rad(0), Rad(6)), 0.3)

1812
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-85), Rad(0)) * angles(Rad(-5), Rad(0), Rad(-6)), 0.3)

1813
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.1 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(65), Rad(Mrandom(-15, 15)), Rad(5 - 4.5 * Sin(sine / 20))), 0.3)

1814
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.1 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(6), Rad(Mrandom(-15, 15)), Rad(-5 + 4.5 * Sin(sine / 20))), 0.3)

1815
	end

1816
	attack = false

1817
end

1818
function blast()

1819
	attack = true

1820
	hum.WalkSpeed = 0

1821
	for i = 0,1.2,0.1 do

1822
		swait()

1823
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-20), Rad(0), Rad(0)), 0.15)

1824
		tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-20 - 2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1825
		RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(-20)), 0.15)

1826
		LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(5 * Cos(sine / 20)), Rad(25)), 0.15)

1827
		RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(200), Rad(0), Rad(25 - 2.5 * Sin(sine / 20))), 0.1)

1828
		LW.C0 = clerp(LW.C0, CF(-1.5, 0.1 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(-15)), 0.1)

1829
	end

1830
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1831
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1832
        Effects.Sphere.Create(BrickColor.new("Royal Purple"), root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 15.1, 15.1, 15.1, 0.01)

1833
		Effects.Sphere.Create(maincolor, root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 11.1, 11.1, 11.1, 0.01)

1834
		Magic(5, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, BrickColor.new("Really blue"), "Sphere")

1835
		Magic(10, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, BrickColor.new("Royal Purple"), "Sphere")

1836
		Magic(1, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(35, 0.1, 35), 0.01, BrickColor.new("Royal Purple"), "Sphere")

1837
1838
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1839
		if v:FindFirstChild("Head") then

1840
			Eviscerate(v)

1841
		end

1842
	end

1843
1844
	for i = 1,4.7,0.1 do

1845
	rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -1.4 + 0.1 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

1846
	tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(35), Rad(0), Rad(0)), 0.3)

1847
	RH.C0 = clerp(RH.C0, CF(1, .4 - 0.1 * Cos(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-5), Rad(0), Rad(45)), 0.15)

1848
	LH.C0 = clerp(LH.C0, CF(-1, -0.6 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-5), Rad(0), Rad(-0)), 0.15)

1849
	RW.C0 = clerp(RW.C0, CF(1.2, 0.1 + 0.05 * Sin(sine / 30), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(-34)), 0.1)

1850
	LW.C0 = clerp(LW.C0, CF(-1.5, 0.4 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(-15)), 0.1)

1851
	end

1852
	 wait(.6)

1853
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1854
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1855
        Effects.Sphere.Create(BrickColor.new("Royal purple"), root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 15.1, 15.1, 15.1, 0.01)

1856
		Effects.Sphere.Create(maincolor, root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 11.1, 11.1, 11.1, 0.01)

1857
		Magic(5, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, BrickColor.new("Really blue"), "Sphere")

1858
		Magic(10, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, BrickColor.new("Bright blue"), "Sphere")

1859
		Magic(1, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(35, 0.1, 35), 0.01,BrickColor.new("Royal Purple"), "Sphere")

1860
1861
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1862
		if v:FindFirstChild("Head") then

1863
			Eviscerate(v)

1864
		end

1865
	end

1866
1867
	for i = 1,4.7,0.1 do

1868
	rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -1.4 + 0.1 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

1869
	tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(35), Rad(0), Rad(0)), 0.3)

1870
	RH.C0 = clerp(RH.C0, CF(1, .4 - 0.1 * Cos(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-5), Rad(0), Rad(45)), 0.15)

1871
	LH.C0 = clerp(LH.C0, CF(-1, -0.6 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-5), Rad(0), Rad(-0)), 0.15)

1872
	RW.C0 = clerp(RW.C0, CF(1.2, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(15)), 0.1)

1873
	LW.C0 = clerp(LW.C0, CF(-1.5, 0.1 + 0.05 * Sin(sine / 30), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(34)), 0.1)

1874
	end

1875
      wait(.6)

1876
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1877
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1878
        Effects.Sphere.Create(BrickColor.new("Royal purple"), root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 15.1, 15.1, 15.1, 0.01)

1879
		Effects.Sphere.Create(maincolor, root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 11.1, 11.1, 11.1, 0.01)

1880
		Magic(5, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, BrickColor.new("Really blue"), "Sphere")

1881
		Magic(10, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, BrickColor.new("Royal purple"), "Sphere")

1882
		Magic(1, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(35, 0.1, 35), 0.01, BrickColor.new("Royal purple"), "Sphere")

1883
1884
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1885
		if v:FindFirstChild("Head") then

1886
			Eviscerate(v)

1887
		end

1888
	end

1889
1890
	for i = 1,4.7,0.1 do

1891
	rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -1.4 + 0.1 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

1892
	tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(35), Rad(0), Rad(0)), 0.3)

1893
	RH.C0 = clerp(RH.C0, CF(1, .4 - 0.1 * Cos(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-5), Rad(0), Rad(45)), 0.15)

1894
	LH.C0 = clerp(LH.C0, CF(-1, -0.6 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-5), Rad(0), Rad(-0)), 0.15)

1895
	RW.C0 = clerp(RW.C0, CF(1.2, 0.1 + 0.05 * Sin(sine / 30), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(-34)), 0.1)

1896
	LW.C0 = clerp(LW.C0, CF(-1.5, 0.4 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(-15)), 0.1)

1897
	end

1898
	 wait(.6)

1899
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1900
		Aura(6, 0.3, "Add", root.CFrame * CF(0,-2,0) * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Brick")

1901
        Effects.Sphere.Create(BrickColor.new("Royal purple"), root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 15.1, 15.1, 15.1, 0.01)

1902
		Effects.Sphere.Create(maincolor, root.CFrame * CFrame.new(0,-2,0) , 85, 85, 85, 11.1, 11.1, 11.1, 0.01)

1903
		Magic(5, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, BrickColor.new("Really blue"), "Sphere")

1904
		Magic(10, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, BrickColor.new("Bright blue"), "Sphere")

1905
		Magic(1, "Add", root.CFrame * CFrame.new(0, -2.9, 0), Vector3.new(35, 0.1, 35), 0.01, BrickColor.new("Royal purple"), "Sphere")

1906
1907
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1908
		if v:FindFirstChild("Head") then

1909
			Eviscerate(v)

1910
		end

1911
	end

1912
1913
	for i = 1,4.7,0.1 do

1914
	rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -1.4 + 0.1 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

1915
	tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(35), Rad(0), Rad(0)), 0.3)

1916
	RH.C0 = clerp(RH.C0, CF(1, .4 - 0.1 * Cos(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-5), Rad(0), Rad(45)), 0.15)

1917
	LH.C0 = clerp(LH.C0, CF(-1, -0.6 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-5), Rad(0), Rad(-0)), 0.15)

1918
	RW.C0 = clerp(RW.C0, CF(1.2, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(15)), 0.1)

1919
	LW.C0 = clerp(LW.C0, CF(-1.5, 0.1 + 0.05 * Sin(sine / 30), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(34)), 0.1)

1920
	end

1921
      wait(.6)

1922
	attack = false

1923
	hum.WalkSpeed = 8

1924
end

1925
function dejzrXD()

1926
        attack = true

1927
    hum.WalkSpeed = 20

1928
    for i = 0, 4, 0.1 do

1929
        swait()

1930
        Cso("2545012765", char, 10, 1)

1931
        hum.CameraOffset = Vector3.new(0, -0.1 + 0.1 * Cos(sine / 20), 0)

1932
        rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-10), Rad(0), Rad(40)), 0.2)

1933
        tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(0), Rad(-40)), 0.2)

1934
        RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(79), Rad(0)) * angles(Rad(-10), Rad(0), Rad(-10)), 0.2)

1935
        LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-79), Rad(0)) * angles(Rad(-15), Rad(0), Rad(10)), 0.2)

1936
        RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(125), Rad(-7.5 * Sin(sine / 20)), Rad(40)), 0.2)

1937
        LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-25), Rad(7.5 * Sin(sine / 20)), Rad(-25)), 0.2)

1938
    end

1939
    Magic(5, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

1940
    Magic(10, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, maincolor, "Sphere")

1941
    Magic(1, "Add", mouse.Hit, Vector3.new(1, 100000, 1), 0.5, maincolor, "Sphere")

1942
    Magic(1, "Add", mouse.Hit, Vector3.new(1, 1, 1), 0.75, maincolor, "Sphere")

1943
    CameraEnshaking(4, 5)

1944
    for i, v in pairs(FindNearestHead(mouse.Hit.p, 14.5)) do

1945
        if v:FindFirstChild("Head") then

1946
            Eviscerate(v)

1947
        end

1948
    end

1949
    for i = 0, 2, 0.1 do

1950
        swait()

1951
        hum.CameraOffset = Vector3.new(0, -0.2 + 0.1 * Cos(sine / 20), 0)

1952
        rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-5), Rad(0), Rad(40)), 0.2)

1953
        tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(0), Rad(-40)), 0.2)

1954
        RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(79), Rad(0)) * angles(Rad(-10), Rad(0), Rad(-10)), 0.2)

1955
        LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-79), Rad(0)) * angles(Rad(-15), Rad(0), Rad(10)), 0.2)

1956
        RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(45), Rad(-7.5 * Sin(sine / 20)), Rad(40)), 0.2)

1957
        LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-25), Rad(7.5 * Sin(sine / 20)), Rad(-25)), 0.2)

1958
    end

1959
	attack = false

1960
	Speed = 20

1961
end

1962
1963
function Attack()

1964
	attack = true

1965
	for i = 0, 2.6, 0.1 do

1966
		swait()

1967
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(-60)), 0.2)

1968
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-7.5 * Sin(sine / 30)), Rad(0), Rad(60)), 0.2)

1969
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.2)

1970
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, -.6* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(20)), 0.2)

1971
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(160), Rad(-.6), Rad(13)), 0.2)

1972
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(15), Rad(-6), Rad(-25 - 4.5 * Sin(sine / 20))), 0.2)

1973
	end

1974
	Cso("2545012765", tors, 10, 1)

1975
	CameraEnshaking(2, 15)

1976
	Effects.Wave.Create(BrickColor.new("Royal purple"), tors.CFrame * CF(0, -6, 0) * angles(math.rad(0), math.rad(math.random(0, 180)), math.rad(0)), 550.5, 100.5, 550.5, 200, 20, 200, 0.05)

1977
  	Effects.Wave.Create(BrickColor.new("Royal purple"), tors.CFrame * CF(0, -6, 0) * angles(math.rad(0), math.rad(math.random(0, 180)), math.rad(0)), 550.5, 100.5, 550.5, 200, 20, 200, 0.05)

1978
  	Effects.Wave.Create(BrickColor.new("Royal purple"), tors.CFrame * CF(0, -6, 0) * angles(math.rad(0), math.rad(math.random(0, 180)), math.rad(0)), 550.5, 100.5, 550.5, 200, 20, 200, 0.05)

1979
 	for i, v in pairs(FindNearestHead(Blobby.CFrame.p, 9.5)) do

1980
		if v:FindFirstChild("Head") then

1981
			Eviscerate(v)

1982
		end

1983
	end

1984
	for i = 0, 3, 0.1 do

1985
		swait()

1986
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(-15)), 0.3)

1987
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 7.5 * Sin(sine / 30)), Rad(0), Rad(15)), 0.3)

1988
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-20)), 0.3)

1989
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.3)

1990
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.02 * Sin(sine / 20)* Player_Size, -.6* Player_Size) * angles(Rad(5), Rad(-.6), Rad(-25)), 0.3)

1991
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(15), Rad(-6), Rad(-25 - 4.5 * Sin(sine / 20))), 0.3)

1992
	end

1993
	attack = false

1994
end

1995
function Orb_Strike()

1996
	attack = true

1997
    	Cso("2545012765", char, 7, 0.8)

1998
    	for i = 0, 9 do

1999
			Aura(1, 1.5, "Add", mouse.Hit * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 5, 5, 45, -0.05, maincolor, 0, "Sphere")

2000
			Aura(2, 1.5, "Add", mouse.Hit * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 5, 5, 45, -0.05, maincolor, 0, "Sphere")

2001
		end

2002
		Magic(5, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

2003
		Magic(10, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, maincolor, "Sphere")

2004
		Magic(1, "Add", mouse.Hit, Vector3.new(1, 100000, 1), 0.5, maincolor, "Sphere")

2005
		Magic(1, "Add", mouse.Hit, Vector3.new(1, 1, 1), 0.75, maincolor, "Sphere")

2006
	for i, v in pairs(FindNearestHead(Mouse.Hit.p, 14.5)) do

2007
		if v:FindFirstChild("Head") then

2008
			Eviscerate(v)

2009
		end

2010
	end

2011
	attack = false

2012
	hum.WalkSpeed = 20

2013
end

2014
2015
function Astigmatism()

2016
    attack = true

2017
    hum.WalkSpeed = 0

2018
    local Ring1 = Instance.new("Part", char)

2019
    Ring1.Anchored = true

2020
    Ring1.BrickColor = maincolor

2021
    Ring1.CanCollide = false

2022
    Ring1.FormFactor = 3

2023
    Ring1.Name = "Ring"

2024
    Ring1.Material = "Neon"

2025
    Ring1.Size = Vector3.new(1, 0.05, 1)

2026
    Ring1.Transparency = 1

2027
    Ring1.TopSurface = 0

2028
    Ring1.BottomSurface = 0

2029
    local Ring1Mesh = Instance.new("SpecialMesh", Ring1)

2030
    Ring1Mesh.MeshType = "Brick"

2031
    Ring1Mesh.Name = "SizeMesh"

2032
    Ring1Mesh.Scale = Vector3.new(0, 1, 0)

2033
    local InnerRing1 = Ring1:Clone()

2034
    InnerRing1.Parent = char

2035
    InnerRing1.Transparency = 0

2036
    InnerRing1.BrickColor = BrickColor.new("New Yeller")

2037
    InnerRing1.Size = Vector3.new(1, 1, 1)

2038
    local InnerRing1Mesh = InnerRing1.SizeMesh

2039
    InnerRing1Mesh.Scale = Vector3.new(0, 0, 0)

2040
    InnerRing1Mesh.MeshType = "Sphere"

2041
    Ring1:Destroy()

2042
    for i = 0, 6, 0.1 do

2043
        swait()

2044
        --orb.CFrame = Head.CFrame

2045
        Aura(7, 0.12, "Add", Head.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Sphere")

2046
        rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

2047
        neck.C0 = clerp(neck.C0, necko * CF(0, 0, 1) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2048
        RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

2049
        LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

2050
        RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(165 + 2.5 * Sin(sine / 20))), 0.12)

2051
        LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-165 + 2.5 * Sin(sine / 20))), 0.12)

2052
    end

2053
    InnerRing1.Transparency = 1

2054
    InnerRing1.CFrame = Head.CFrame + root.CFrame.lookVector * 5

2055
    Cso("294188875", char, 2.3, 1)

2056
    local a = IT("Part", char)

2057
    a.Name = "Direction"

2058
    a.Anchored = true

2059
    a.BrickColor = BrickC("Pastel violet")

2060
    a.Material = "SmoothPlastic"

2061
    a.Transparency = 0

2062
    a.Shape = "Cylinder"

2063
    a.CanCollide = false

2064
    local a2 = IT("Part", char)

2065
    a2.Name = "Direction"

2066
    a2.Anchored = true

2067
    a2.BrickColor = maincolor

2068
    a2.Color = maincolor.Color

2069
    a2.Material = "Neon"

2070
    a2.Transparency = 0.7

2071
    a2.Shape = "Cylinder"

2072
    a2.CanCollide = false

2073
    local ba = IT("Part", char)

2074
    ba.Name = "HitDirect"

2075
    ba.Anchored = true

2076
    ba.BrickColor = maincolor

2077
    ba.Material = "Neon"

2078
    ba.Transparency = 1

2079
    ba.CanCollide = false

2080
    local ray = Ray.new(InnerRing1.CFrame.p, (mouse.Hit.p - InnerRing1.CFrame.p).unit * 1000)

2081
    local ignore = char

2082
    local hit, position, normal = workspace:FindPartOnRay(ray, ignore)

2083
    a.BottomSurface = 10

2084
    a.TopSurface = 10

2085
    a2.BottomSurface = 10

2086
    a2.TopSurface = 10

2087
    local distance = (InnerRing1.CFrame.p - position).magnitude

2088
    a.Size = Vector3.new(distance, 1, 1)

2089
    a.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

2090
    a2.Size = Vector3.new(distance, 1, 1)

2091
    a2.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

2092
    ba.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance)

2093
    a.CFrame = a.CFrame * angles(0, Rad(90), 0)

2094
    a2.CFrame = a2.CFrame * angles(0, Rad(90), 0)

2095
    game:GetService("Debris"):AddItem(a, 20)

2096
    game:GetService("Debris"):AddItem(a2, 20)

2097
    game:GetService("Debris"):AddItem(ba, 20)

2098
    local msh = Instance.new("SpecialMesh", a)

2099
    msh.MeshType = "Brick"

2100
    msh.Scale = Vector3.new(1, 5, 5)

2101
    local msh2 = Instance.new("SpecialMesh", a2)

2102
    msh2.MeshType = "Brick"

2103
    msh2.Scale = Vector3.new(1, 7, 7)

2104
    for i = 0, 10, 0.1 do

2105
        swait()

2106
        CameraEnshaking(1, 5)

2107
        a2.Color = maincolor.Color

2108
        root.CFrame = FaceMouse()[1]

2109
        InnerRing1.CFrame = Head.CFrame + root.CFrame.lookVector * 4

2110
        ray = Ray.new(InnerRing1.CFrame.p, (mouse.Hit.p - InnerRing1.CFrame.p).unit * 1000)

2111
        hit, position, normal = workspace:FindPartOnRay(ray, ignore)

2112
        distance = (InnerRing1.CFrame.p - position).magnitude

2113
        a.Size = Vector3.new(distance, 1, 1)

2114
        a.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

2115
        a2.Size = Vector3.new(distance, 1, 1)

2116
        a2.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

2117
        ba.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance)

2118
        a.CFrame = a.CFrame * angles(0, Rad(90), 0)

2119
        a2.CFrame = a2.CFrame * angles(0, Rad(90), 0)

2120
        msh.Scale = msh.Scale - Vector3.new(0, 0.05, 0.05)

2121
        msh2.Scale = msh2.Scale - Vector3.new(0, 0.03, 0.03)

2122
        Aura(5, 0.15, "Add", ba.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 15, 15, 25, -0.15, maincolor, 0, "Sphere")

2123
        for i, v in pairs(FindNearestHead(ba.CFrame.p, 14.5)) do

2124
        if v:FindFirstChild("Head") then

2125
                Eviscerate(v)

2126
            end

2127
        end

2128
    end

2129
    a:Destroy()

2130
    a2:Destroy()

2131
    ba:Destroy()

2132
    InnerRing1:Destroy()

2133
    attack = false

2134
    hum.WalkSpeed = 10

2135
    hum.CameraOffset = Vector3.new(0,0,0)

2136
end

2137
2138-
function GIMME_THOSE()

2138+
function DRAG_YOURSELF_TO_HELL()

2139-
	if Mouse.Target.Parent ~= char and Mouse.Target.Parent.Parent ~= char and Mouse.Target.Parent:FindFirstChildOfClass("Humanoid") ~= nil then

2139+
	if mouse.Target.Parent ~= char and mouse.Target.Parent.Parent ~= char and mouse.Target.Parent:FindFirstChildOfClass("Humanoid") ~= nil then

2140-
	local HUM = Mouse.Target.Parent:FindFirstChildOfClass("Humanoid")

2140+
	local HUM = mouse.Target.Parent:FindFirstChildOfClass("Humanoid")

2141
	local TORSO = HUM.Parent:FindFirstChild("Torso") or HUM.Parent:FindFirstChild("UpperTorso")

2142
	local HEAD = HUM.Parent:FindFirstChild("Head")

2143-
	local RIGHTARM = HUM.Parent:FindFirstChild("Right Arm") or HUM.Parent:FindFirstChild("RightLowerArm")

2143+
2144-
	local LEFTARM = HUM.Parent:FindFirstChild("Left Arm") or HUM.Parent:FindFirstChild("LeftLowerArm")

2144+
2145
	GYRO.D = 275

2146
	GYRO.P = 20000

2147
	GYRO.MaxTorque = Vector3.new(0,40000,0)

2148
	attack = true

2149
	hum.WalkSpeed = 0

2150
	local hit,pos,hummie;

2151
	local Hook = Part(EffectModel, Color3.new(),Enum.Material.Neon,Vector3.new(.05,.05,.05),root.CFrame,true,false)

2152
	Hook.Transparency = 1

2153
	local A = NewInstance("Attachment",Hook)

2154-
	local Hook2 = Part(EffectModel, Color3.new(),Enum.Material.Neon,Vector3.new(.05,.05,.05),root.CFrame,true,false)

2154+
2155
	local Chain = NewInstance("Beam",Hook,{Attachment0 = A,Attachment1=B,Color = Color3.fromRGB(138,138,138),FaceCamera=true,LightInfluence=0,Texture="rbxassetid://73042633",TextureLength=5,Transparency=NumberSequence.new(0),TextureSpeed=0,CurveSize0=0,CurveSize1=0,FaceCamera=true,Segments=10,Width0=1,Width1=1})

2156-
	Hook2.Transparency = 1

2156+
	local POS = mouse.Hit.p

2157
	local CHAINS = false

2158
	local CHAINLINKS = {}

2159-
	local A2 = NewInstance("Attachment",Hook2)

2159+
	local A = IT("Attachment",ra)

2160-
	local B2 = NewInstance("Attachment",la,{Position = Vector3.new(0,-ra.Size.Y/2,0)})

2160+
	A.Position = Vector3.new(1,-1,0)*Player_Size

2161
	A.Orientation = Vector3.new(-90, -89.982, 0)

2162-
	local Chain2 = NewInstance("Beam",Hook2,{Attachment0 = A2,Attachment1=B2,Color = Color3.fromRGB(138,138,138),FaceCamera=true,LightInfluence=0,Texture="rbxassetid://73042633",TextureLength=5,Transparency=NumberSequence.new(0),TextureSpeed=0,CurveSize0=0,CurveSize1=0,FaceCamera=true,Segments=10,Width0=1,Width1=1})

2162+
	local B = IT("Attachment",ra)

2163
	B.Position = Vector3.new(-1,-1,0)*Player_Size

2164
	B.Orientation = Vector3.new(-90, 89.988, 0)

2165
	local C = IT("Attachment",ra)

2166-
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(-7), Rad(0), Rad(0)), 0.15)

2166+
	C.Position = Vector3.new(0.5,-1.3,0)*Player_Size

2167-
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2167+
	C.Orientation = Vector3.new(-90, -89.982, 0)

2168-
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-7)), 0.15)

2168+
	local D = IT("Attachment",ra)

2169-
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(7)), 0.15)

2169+
	D.Position = Vector3.new(-0.5,-1.3,0)*Player_Size

2170
	D.Orientation = Vector3.new(-90, 89.988, 0)

2171-
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(-25)), 0.1)

2171+
	local LIGHT = IT("Attachment",ra)

2172
	LIGHT.Position = Vector3.new(0,-1,0)*Player_Size

2173
	local LIGHT2 = IT("PointLight",LIGHT)

2174-
	for i = 0, 5, .1 do

2174+
	LIGHT2.Range = 7

2175
	LIGHT2.Brightness = 5

2176
	LIGHT2.Color = Color3.new(0,0,0)

2177
	for i = 1, 2 do

2178-
		Hook.CFrame = TORSO.CFrame

2178+
		local TWIST = -2

2179-
		Hook2.CFrame = TORSO.CFrame

2179+
		local START = A

2180-
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(7), Rad(0), Rad(0)), 0.15)

2180+
		local END = B

2181-
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2181+
		if i == 1 then

2182-
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(7)), 0.15)

2182+
			START = B

2183-
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-7)), 0.15)

2183+
			END = A

2184-
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, -0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(25)), 0.1)

2184+
2185-
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, -0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(-25)), 0.1)

2185+
		local ChainLink = IT("Beam",tors)

2186
		ChainLink.Texture = "rbxassetid://73042633"

2187
		ChainLink.Color = ColorSequence.new(Color3.fromRGB(138,138,138))

2188
		ChainLink.TextureSpeed = 1

2189
		ChainLink.Width0 = 1

2190
		ChainLink.Width1 = 1

2191
		ChainLink.TextureLength = 2.5

2192
		ChainLink.Attachment0 = START

2193
		ChainLink.Attachment1 = END

2194
		ChainLink.CurveSize0 = TWIST

2195-
	Cso("1474367957", TORSO, 2, 1)

2195+
		ChainLink.CurveSize1 = TWIST

2196
		--ChainLink.FaceCamera = true

2197-
	TORSO:BreakJoints()

2197+
		ChainLink.Segments = 45

2198-
	for i = 0, 6, .1 do

2198+
		ChainLink.Transparency = NumberSequence.new(0.25)

2199
		table.insert(CHAINLINKS,ChainLink)

2200-
		Hook.CFrame = Hook.CFrame:lerp(tors.CFrame * CF(0, 0, -1), .2)

2200+
2201
	for i = 1, 2 do

2202
		local TWIST = -1

2203-
		if((Hook.CFrame.p-tors.CFrame.p).magnitude < 2)then

2203+
		local START = C

2204
		local END = D

2205
		if i == 1 then

2206-
		Hook2.CFrame = Hook2.CFrame:lerp(tors.CFrame * CF(0, 0, -1), .2)

2206+
			START = D

2207-
		if(hit)then hit.CFrame = Hook2.CFrame; hit.Velocity = Vector3.new() 

2207+
			END = C

2208
		end

2209-
		if((Hook2.CFrame.p-tors.CFrame.p).magnitude < 2)then

2209+
		local ChainLink = IT("Beam",tors)

2210
		ChainLink.Texture = "rbxassetid://73042633"

2211
		ChainLink.Color = ColorSequence.new(Color3.fromRGB(138,138,138))

2212
		ChainLink.TextureSpeed = 1

2213-
		Chain2.TextureLength = 4

2213+
		ChainLink.Width0 = 1

2214-
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(-7), Rad(0), Rad(0)), 0.15)

2214+
		ChainLink.Width1 = 1

2215-
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2215+
		ChainLink.TextureLength = 5

2216-
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(90)), 0.15)

2216+
		ChainLink.Attachment0 = START

2217-
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(7)), 0.15)

2217+
		ChainLink.Attachment1 = END

2218
		ChainLink.CurveSize0 = TWIST

2219-
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(-25)), 0.1)

2219+
		ChainLink.CurveSize1 = TWIST

2220
		--ChainLink.FaceCamera = true

2221
		ChainLink.Segments = 25

2222
		ChainLink.LightEmission = 0.5

2223-
		Hook2:Destroy()

2223+
		ChainLink.Transparency = NumberSequence.new(0.25)

2224
		table.insert(CHAINLINKS,ChainLink)

2225
	end

2226
	for i = 0, 2.3, .1 do

2227
		swait()

2228
		GYRO.cframe = CF(root.Position,TORSO.Position)

2229
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(15), Rad(0), Rad(-45)), 0.15)

2230
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(45)), 0.3)

2231
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -0.4* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-10)), 0.15)

2232
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-10)), 0.15)

2233
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(25)), 0.1)

2234
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(-13 - 4.5 * Sin(sine / 20))), 0.1)

2235
	end

2236
	Cso("169105657", ra, 7, 1.2)

2237
	for i = 0, 4, .1 do

2238
		if(hit)then break end

2239
		swait()

2240
		GYRO.cframe = CF(root.Position,TORSO.Position)

2241
		Hook.CFrame = HEAD.CFrame

2242
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(5), Rad(45)), 0.15)

2243
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-5 - 2.5 * Sin(sine / 30)), Rad(0), Rad(-45)), 0.3)

2244
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-10)), 0.15)

2245
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-10)), 0.15)

2246-
		elseif key == 'b' then

2246+
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, -0.4* Player_Size) * angles(Rad(90), Rad(-.6), Rad(45)), 0.1)

2247-
			GIMME_THOSE()

2247+
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-30), Rad(-.6), Rad(-25 - 4.5 * Sin(sine / 20))), 0.1)

2248
	end

2249
	for _,v in next, getRegion(Hook.Position,1,{char}) do

2250
			if(v.Parent and GetTorso(v.Parent) and v.Parent:FindFirstChildOfClass'Humanoid')then

2251
				hit = GetTorso(v.Parent);

2252
				hummie = v.Parent:FindFirstChildOfClass'Humanoid';

2253
			break;

2254
		end

2255
	end

2256
	Cso("169105657", ra, 5, .8)

2257
	Cso("271693128", tors, 2, 1)

2258
	GYRO:remove()

2259
	for i = 0, 3, .1 do

2260
		swait()

2261
		root.CFrame = Hook.CFrame:lerp(ra.CFrame * CF(0, 0, -1), .2)

2262
		if(hit)then hit.CFrame = Hook.CFrame; hit.Velocity = Vector3.new() 

2263
		end

2264
		if((Hook.CFrame.p-ra.CFrame.p).magnitude < 2)then

2265
			break

2266
		end

2267
		Chain.TextureLength = 4

2268
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(90), Rad(-5), Rad(0)), 0.15)

2269
		tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-45 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2270
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

2271
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-84), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

2272
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0.4* Player_Size) * angles(Rad(0), Rad(-.6), Rad(25)), 0.1)

2273
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(-25)), 0.1)

2274
	end

2275
		hum.WalkSpeed = 16

2276
		attack = false

2277
		Hook:Destroy()

2278
		A:remove()

2279
		B:remove()

2280
		C:remove()

2281
		D:remove()

2282
		end

2283
	end

2284
end

2285
2286
-------------------------------------------------------

2287
--End Attacks N Stuff--

2288
-------------------------------------------------------

2289
mouse.KeyDown:connect(function(key)

2290
	if attack == false then

2291
		if key == 'e' then

2292
                       icando()

2293
		elseif key == 'c' then

2294
                       Blood_ball()

2295
		elseif key == "x" then

2296
                        blast()

2297
        elseif key == "y" then

2298
                        Taunt2()

2299
        elseif key == 'h' then

2300
                   Orb_Strike()

2301
		elseif key == "z" then

2302
                        dejzrXD()

2303
		elseif key == 'v' then

2304
			DRAG_YOURSELF_TO_HELL()

2305
        elseif key == 'v' then

2306
            Astigmatism()

2307
 		end

2308
	end

2309
end)

2310
2311
mouse.Button1Down:connect(function(key)

2312
	if attack == false then

2313
		Attack()

2314
	end

2315
end)

2316
2317
2318
2319
-------------------------------------------------------

2320
--Start Animations--

2321
-------------------------------------------------------

2322
print("By Makhail07")

2323
while true do

2324
	swait()

2325
	sine = sine + change

2326
	local torvel = (root.Velocity * Vector3.new(1, 0, 1)).magnitude

2327
	local velderp = root.Velocity.y

2328
	hitfloor, posfloor = rayCast(root.Position, CFrame.new(root.Position, root.Position - Vector3.new(0, 1, 0)).lookVector, 4* Player_Size, char)

2329
	if equipped == true or equipped == false then

2330
		if attack == false then

2331
			idle = idle + 1

2332
		else

2333
			idle = 0

2334
		end

2335
		if 1 < root.Velocity.y and hitfloor == nil then

2336
			Anim = "Jump"

2337
			if attack == false then

2338
				rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1 * Cos(sine / 20)* Player_Size) * angles(Rad(-16), Rad(0), Rad(0)), 0.15)

2339
				neck.C0 = clerp(neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(10 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2340
				RH.C0 = clerp(RH.C0, CF(1* Player_Size, -.2 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * RHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.15)

2341
				LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.9 - 0.1 * Cos(sine / 20), -.5* Player_Size) * LHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.15)

2342
				RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25), Rad(-.6), Rad(13 + 4.5 * Sin(sine / 20))), 0.1)

2343
				LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25), Rad(-.6), Rad(-13 - 4.5 * Sin(sine / 20))), 0.1)

2344
			end

2345
		elseif -1 > root.Velocity.y and hitfloor == nil then

2346
			Anim = "Fall"

2347
			if attack == false then

2348
				rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1 * Cos(sine / 20)* Player_Size) * angles(Rad(24), Rad(0), Rad(0)), 0.15)

2349
				neck.C0 = clerp(neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(10 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2350
				RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * RHCF * angles(Rad(-3.5), Rad(0), Rad(0)), 0.15)

2351
				LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.8 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * LHCF * angles(Rad(-3.5), Rad(0), Rad(0)), 0.15)

2352
				RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(65), Rad(-.6), Rad(45 + 4.5 * Sin(sine / 20))), 0.1)

2353
				LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(55), Rad(-.6), Rad(-45 - 4.5 * Sin(sine / 20))), 0.1)

2354
			end

2355
		elseif torvel < 1 and hitfloor ~= nil then

2356
			Anim = "Idle"

2357
			change = 1

2358
			if attack == false then

2359
				rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

2360
				tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2361
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(0)), 0.15)

2362
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

2363
				RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-10 * Cos(sine / 20)), Rad(5 - 2.5 * Sin(sine / 20))), 0.1)

2364
				LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

2365
			end

2366
		elseif torvel > 2 and torvel < 25 and hitfloor ~= nil then

2367
			Anim = "Walk"

2368
			change = 1

2369
			if attack == false then

2370
				rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(3 * Cos(sine / 7))), 0.15)

2371
				tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2372
				RH.C0 = clerp(RH.C0, CF(1, -0.8 - 0.5 * Cos(sine / 7) / 2, 0.6 * Cos(sine / 7) / 2)  * angles(Rad(-15 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2373
         		LH.C0 = clerp(LH.C0, CF(-1, -0.8 + 0.5 * Cos(sine / 7) / 2, -0.6 * Cos(sine / 7) / 2) * angles(Rad(-15 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2374
					RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-10 * Cos(sine / 20)), Rad(5 - 2.5 * Sin(sine / 20))), 0.1)

2375
				LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

2376
			end

2377
		elseif torvel >= 25 and hitfloor ~= nil then

2378
			Anim = "Sprint"

2379
			change = 1.35

2380
			if attack == false then

2381
			rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2382
			tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2383
			RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.925 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.7 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-15 - 55 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2384
         	LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.925 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.7 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-15 + 55 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2385
			RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 30)* Player_Size, 0.34 * Cos(sine / 7* Player_Size)) * angles(Rad(110)  * Cos(sine / 7) , Rad(0), Rad(13) - ra.RotVelocity.Y / 75), 0.15)

2386
			LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 30)* Player_Size, -0.34 * Cos(sine / 7* Player_Size)) * angles(Rad(-110)  * Cos(sine / 7) , Rad(0) ,	Rad(-13) + la.RotVelocity.Y / 75), 0.15)

2387
			end

2388
		end

2389
	end

2390
	if 0 < #Effects then

2391
		for e = 1, #Effects do

2392
			if Effects[e] ~= nil then

2393
				local Thing = Effects[e]

2394
				if Thing ~= nil then

2395
					local Part = Thing[1]

2396
					local Mode = Thing[2]

2397
					local Delay = Thing[3]

2398
					local IncX = Thing[4]

2399
					local IncY = Thing[5]

2400
					local IncZ = Thing[6]

2401
					if 1 >= Thing[1].Transparency then

2402
						if Thing[2] == "Block1" then

2403
							Thing[1].CFrame = Thing[1].CFrame * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50))

2404
							local Mesh = Thing[1].Mesh

2405
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2406
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2407
						elseif Thing[2] == "Block2" then

2408
							Thing[1].CFrame = Thing[1].CFrame + Vector3.new(0, 0, 0)

2409
							local Mesh = Thing[7]

2410
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2411
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2412
						elseif Thing[2] == "Block3" then

2413
							Thing[1].CFrame = Thing[1].CFrame * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50)) + Vector3.new(0, 0.15, 0)

2414
							local Mesh = Thing[7]

2415
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2416
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2417
						elseif Thing[2] == "Cylinder" then

2418
							local Mesh = Thing[1].Mesh

2419
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2420
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2421
						elseif Thing[2] == "Blood" then

2422
							local Mesh = Thing[7]

2423
							Thing[1].CFrame = Thing[1].CFrame * Vector3.new(0, 0.5, 0)

2424
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2425
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2426
						elseif Thing[2] == "Elec" then

2427
							local Mesh = Thing[1].Mesh

2428
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[7], Thing[8], Thing[9])

2429
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2430
						elseif Thing[2] == "Disappear" then

2431
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2432
						elseif Thing[2] == "Shatter" then

2433
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2434
							Thing[4] = Thing[4] * CFrame.new(0, Thing[7], 0)

2435
							Thing[1].CFrame = Thing[4] * CFrame.fromEulerAnglesXYZ(Thing[6], 0, 0)

2436
							Thing[6] = Thing[6] + Thing[5]

2437
						end

2438
					else

2439
						Part.Parent = nil

2440
						table.remove(Effects, e)

2441
					end

2442
				end

2443
			end

2444
		end

2445
	end

2446
end

2447
-------------------------------------------------------

2448
--End Animations And Script--

2449
-------------------------------------------------------
        

    


            


                                


        

            



                
    

        Public Pastes
    

    
            

    

                    

        

    





    


    
    
    
    
    
    
    
    




    


    



                

            We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.             OK, I Understand
        

    
                

            

                
                    
                
            

            

                Not a member of Pastebin yet?

                Sign Up, it unlocks many cool features!