API tools faq
paste
View difference between Paste ID: RNcw9wcW and h4evmn60
SHOW: | | - or go back to the newest paste.
1
--Jevil Done (I think)--
2
----------------------------------------------------------------
3
print([[
4
--made by Makhail07
5
--FE code by Mokiros
6
--Edited by ozzak1003 and then by 1nd1k                       --
7
--YT: https://www.youtube.com/channel/UC38cAdtSgPWJVEHV8zgZi6A--
8
--Discord: ozzak1003#3275
9
--------------------------------
10
hello good sir
11
Don't leak pls
12
Enjoy ;)
13
T - Taunt
14
F = enable jevilmode
15
Jevilmode Enabled >
16
Z - Choas Chaos
17
X - Spade Ring
18
C - Devilsknife
19
V - I can do anything
20
B - final chaos chaos
21
--------------------------------
22
]])
23
24
if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end

25
local Player,game,owner = owner,game

26
local RealPlayer = Player

27
do

28
	local rp = RealPlayer

29
	script.Parent = rp.Character

30
	

31
	--RemoteEvent for communicating

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

33
	Event.Name = "UserInput_Event"

34
35
	--Fake event to make stuff like Mouse.KeyDown work

36
	local function fakeEvent()

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

38
		t.connect = t.Connect

39
		return t

40
	end

41
42
	--Creating fake input objects with fake variables

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

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

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

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

47
	end}

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

49
	CAS.UnbindAction = CAS.BindAction

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

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

53
		local t = m[ev]

54
		if t and t._fakeEvent then

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

56
				f(...)

57
			end

58
		end

59
	end

60
	m.TrigEvent = te

61
	UIS.TrigEvent = te

62
63
	Event.OnServerEvent:Connect(function(plr,io)

64
	    if plr~=rp then return end

65
		m.Target = io.Target

66
		m.Hit = io.Hit

67
		if not io.isMouse then

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

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

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

71
			end

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

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

74
					if k==io.KeyCode then

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

76
					end

77
				end

78
			end

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

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

81
	    end

82
	end)

83
	Event.Parent = NLS([==[

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

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

86
87
	local Mouse = Player:GetMouse()

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

89
	local input = function(io,a)

90
		if a then return end

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

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

93
	end

94
	UIS.InputBegan:Connect(input)

95
	UIS.InputEnded:Connect(input)

96
97
	local h,t

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

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

100
	while wait(1/30) do

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

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

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

104
		end

105
	end]==],Player.Character)

106
107
	----Sandboxed game object that allows the usage of client-side methods and services

108
	--Real game object

109
	local _rg = game

110
111
	--Metatable for fake service

112
	local fsmt = {

113
		__index = function(self,k)

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

115
			if s then return s[k] end

116
		end,

117
		__newindex = function(self,k,v)

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

119
			if s then s[k]=v end

120
		end,

121
		__call = function(self,...)

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

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

124
		end

125
	}

126
	local function FakeService(t,RealService)

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

128
		return setmetatable(t,fsmt)

129
	end

130
131
	--Fake game object

132
	local g = {

133
		GetService = function(self,s)

134
			return self[s]

135
		end,

136
		Players = FakeService({

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

138
		},"Players"),

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

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

141
	}

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

143
	g.service = g.GetService

144
	

145
	g.RunService = FakeService({

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

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

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

149
		end,

150
		UnbindFromRenderStep = function(self,name)

151
			self._btrs[name]:Disconnect()

152
		end,

153
	},"RunService")

154
155
	setmetatable(g,{

156
		__index=function(self,s)

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

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

159
		end,

160
		__newindex = fsmt.__newindex,

161
		__call = fsmt.__call

162
	})

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

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

165
end

166
167
Player = owner

168
PlayerGui = Player.PlayerGui

169
Cam = workspace.CurrentCamera

170
Backpack = Player.Backpack

171
Character = Player.Character

172
Humanoid = Character.Humanoid

173
Mouse = Player:GetMouse()

174
RootPart = Character["HumanoidRootPart"]

175
Torso = Character["Torso"]

176
Head = Character["Head"]

177
RightArm = Character["Right Arm"]

178
LeftArm = Character["Left Arm"]

179
RightLeg = Character["Right Leg"]

180
LeftLeg = Character["Left Leg"]

181
RootJoint = RootPart["RootJoint"]

182
Neck = Torso["Neck"]

183
RightShoulder = Torso["Right Shoulder"]

184
LeftShoulder = Torso["Left Shoulder"]

185
RightHip = Torso["Right Hip"]

186
LeftHip = Torso["Left Hip"]

187
188
Character = Player.Character

189
Humanoid = Character.Humanoid

190
191
---------

192
plr = game.Players.LocalPlayer

193
chara = plr.Character

194
mouse = plr:GetMouse()

195
Create = Instance.new

196
Huge = math.huge

197
198
199
local shadowhead = Create("Part",chara.Head)

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

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

202
shadowhead.CanCollide = false

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

204
shadowheadmesh.MeshType = "Head"

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

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

207
weld2.Part0 = shadowhead

208
weld2.Part1 = chara.Head

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

210
211
Player = game:GetService("Players").LocalPlayer

212
PlayerGui = Player.PlayerGui

213
Cam = workspace.CurrentCamera

214
Backpack = Player.Backpack

215
Character = Player.Character

216
char = Player.Character

217
Humanoid = Character.Humanoid

218
Mouse = Player:GetMouse()

219
RootPart = Character["HumanoidRootPart"]

220
Torso = Character["Torso"]

221
Head = Character["Head"]

222
RightArm = Character["Right Arm"]

223
LeftArm = Character["Left Arm"]

224
RightLeg = Character["Right Leg"]

225
LeftLeg = Character["Left Leg"]

226
RootJoint = RootPart["RootJoint"]

227
Neck = Torso["Neck"]

228
RightShoulder = Torso["Right Shoulder"]

229
LeftShoulder = Torso["Left Shoulder"]

230
RightHip = Torso["Right Hip"]

231
LeftHip = Torso["Left Hip"]

232
233
local Orin = "http://www.roblox.com/asset/?id=7074786"

234
Head.face.Texture = Orin

235
function weld(a, b, acf)

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

237
	w.Part0 = a

238
	w.Part1 = b

239
	w.C0 = acf

240
end

241
242
local righteyebrickcolor = "Institutional white"

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

244
reye.CanCollide = false

245
reye.BrickColor = BrickColor.new(righteyebrickcolor)

246
reye.Material = "Neon"

247
reye.Size = Vector3.new(.25,.35,.25)

248
weld(reye, char.Head, CFrame.new(-0.12,-0.2,0.55), CFrame.new(1,0,0))

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

250
m1.MeshType = "Sphere"

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

252
reye.Locked = true

253
reye.Name = "re"

254
255
256
local righteyebrickcolor = "Institutional white"

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

258
reye.CanCollide = false

259
reye.BrickColor = BrickColor.new(righteyebrickcolor)

260
reye.Material = "Neon"

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

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

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

264
m1.MeshType = "Sphere"

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

266
reye.Locked = true

267
reye.Name = "re"

268
--------------------------------

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

270
--------------------------------

271
272
-------------------------------------------------------

273
274
local FavIDs = {

275
	340106355, --Nefl Crystals

276
	927529620, --Dimension

277
	876981900, --Fantasy

278
	398987889, --Ordinary Days

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

280
	885996042, --Action Winter Journey

281
	919231299, --Sprawling Idiot Effigy

282
	743466274, --Good Day Sunshine

283
	727411183, --Knife Fight

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

285
	595230126 --Robot Language

286
	}

287
288
289
290
--The reality of my life isn't real but a Universe -makhail07

291
wait(0.2)

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

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

294
print('SCRIPTNAME Loaded')

295
print('SCRIPT DESCRIPTION')

296
local char = plr.Character

297
local hum = char.Humanoid

298
local hed = char.Head

299
local root = char.HumanoidRootPart

300
local rootj = root.RootJoint

301
local tors = char.Torso

302
local ra = char["Right Arm"]

303
local la = char["Left Arm"]

304
local rl = char["Right Leg"]

305
local ll = char["Left Leg"]

306
local neck = tors["Neck"]

307
local mouse = plr:GetMouse()

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

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

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

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

312
313
-------------------------------------------------------

314
--Start Good Stuff--

315
-------------------------------------------------------

316
cam = game.Workspace.CurrentCamera

317
CF = CFrame.new

318
angles = CFrame.Angles

319
attack = false

320
Euler = CFrame.fromEulerAnglesXYZ

321
Rad = math.rad

322
IT = Instance.new

323
BrickC = BrickColor.new

324
Cos = math.cos

325
Acos = math.acos

326
Sin = math.sin

327
Asin = math.asin

328
Abs = math.abs

329
Mrandom = math.random

330
Floor = math.floor

331
-------------------------------------------------------

332
--End Good Stuff--

333
-------------------------------------------------------

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

335
RSH, LSH = nil, nil 

336
RW = Instance.new("Weld") 

337
LW = Instance.new("Weld")

338
RH = tors["Right Hip"]

339
LH = tors["Left Hip"]

340
RSH = tors["Right Shoulder"] 

341
LSH = tors["Left Shoulder"] 

342
RSH.Parent = nil 

343
LSH.Parent = nil 

344
RW.Name = "RW"

345
RW.Part0 = tors 

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

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

348
RW.Part1 = ra

349
RW.Parent = tors 

350
LW.Name = "LW"

351
LW.Part0 = tors 

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

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

354
LW.Part1 = la

355
LW.Parent = tors

356
Effects = {}

357
-------------------------------------------------------

358
--Start HeartBeat--

359
-------------------------------------------------------

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

361
ArtificialHB.Name = "Heartbeat"

362
script:WaitForChild("Heartbeat")

363
364
frame = 1 / 60

365
tf = 0

366
allowframeloss = false

367
tossremainder = false

368
369
370
lastframe = tick()

371
script.Heartbeat:Fire()

372
373
374
game:GetService("RunService").Heartbeat:connect(function(s, p)

375
	tf = tf + s

376
	if tf >= frame then

377
		if allowframeloss then

378
			script.Heartbeat:Fire()

379
			lastframe = tick()

380
		else

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

382
				script.Heartbeat:Fire()

383
			end

384
			lastframe = tick()

385
		end

386
		if tossremainder then

387
			tf = 0

388
		else

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

390
		end

391
	end

392
end)

393
-------------------------------------------------------

394
--End HeartBeat--

395
-------------------------------------------------------

396
397
-------------------------------------------------------

398
--Start Important Functions--

399
-------------------------------------------------------

400
function swait(num)

401
	if num == 0 or num == nil then

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

403
	else

404
		for i = 0, num do

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

406
		end

407
	end

408
end

409
function thread(f)

410
	coroutine.resume(coroutine.create(f))

411
end

412
function clerp(a, b, t)

413
	local qa = {

414
		QuaternionFromCFrame(a)

415
	}

416
	local qb = {

417
		QuaternionFromCFrame(b)

418
	}

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

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

421
	local _t = 1 - t

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

423
end

424
function QuaternionFromCFrame(cf)

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

426
	local trace = m00 + m11 + m22

427
	if trace > 0 then

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

429
		local recip = 0.5 / s

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

431
	else

432
		local i = 0

433
		if m00 < m11 then

434
			i = 1

435
		end

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

437
			i = 2

438
		end

439
		if i == 0 then

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

441
			local recip = 0.5 / s

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

443
		elseif i == 1 then

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

445
			local recip = 0.5 / s

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

447
		elseif i == 2 then

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

449
			local recip = 0.5 / s

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

451
		end

452
	end

453
end

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

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

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

457
	local xx = x * xs

458
	local xy = x * ys

459
	local xz = x * zs

460
	local yy = y * ys

461
	local yz = y * zs

462
	local zz = z * zs

463
	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))

464
end

465
function QuaternionSlerp(a, b, t)

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

467
	local startInterp, finishInterp

468
	if cosTheta >= 1.0E-4 then

469
		if 1 - cosTheta > 1.0E-4 then

470
			local theta = math.acos(cosTheta)

471
			local invSinTheta = 1 / Sin(theta)

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

473
			finishInterp = Sin(t * theta) * invSinTheta

474
		else

475
			startInterp = 1 - t

476
			finishInterp = t

477
		end

478
	elseif 1 + cosTheta > 1.0E-4 then

479
		local theta = math.acos(-cosTheta)

480
		local invSinTheta = 1 / Sin(theta)

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

482
		finishInterp = Sin(t * theta) * invSinTheta

483
	else

484
		startInterp = t - 1

485
		finishInterp = t

486
	end

487
	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

488
end

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

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

491
end

492
local RbxUtility = LoadLibrary("RbxUtility")

493
local Create = RbxUtility.Create

494
495
-------------------------------------------------------

496
--Start Damage Function--

497
-------------------------------------------------------

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

499
	if hit.Parent == nil then

500
		return

501
	end

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

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

504
		if v:IsA("Humanoid") then

505
			h = v

506
		end

507
	end

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

509
	

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

511
         end

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

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

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

516
				return

517
			end

518
		end

519
         if insta == true then

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

521
         end

522
		local c = Create("ObjectValue"){

523
			Name = "creator",

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

525
			Parent = h,

526
		}

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

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

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

530
		end

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

532
		local blocked = false

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

534
		if block ~= nil then

535
			if block.className == "IntValue" then

536
				if block.Value > 0 then

537
					blocked = true

538
					block.Value = block.Value - 1

539
					print(block.Value)

540
				end

541
			end

542
		end

543
		if blocked == false then

544
			h.Health = h.Health - Damage

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

546
		else

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

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

549
		end

550
		if Type == "Knockdown" then

551
			local hum = hit.Parent.Humanoid

552
			hum.PlatformStand = true

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

554
				swait(1)

555
				HHumanoid.PlatformStand = false

556
			end), hum)

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

558
			local bodvol = Create("BodyVelocity"){

559
				velocity = angle * knockback,

560
				P = 5000,

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

562
				Parent = hit,

563
			}

564
			local rl = Create("BodyAngularVelocity"){

565
				P = 3000,

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

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

568
				Parent = hit,

569
			}

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

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

572
		elseif Type == "Normal" then

573
			local vp = Create("BodyVelocity"){

574
				P = 500,

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

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

577
			}

578
			if knockback > 0 then

579
				vp.Parent = hit.Parent.Torso

580
			end

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

582
		elseif Type == "Up" then

583
			local bodyVelocity = Create("BodyVelocity"){

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

585
				P = 5000,

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

587
				Parent = hit,

588
			}

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

590
		elseif Type == "DarkUp" then

591
			coroutine.resume(coroutine.create(function()

592
				for i = 0, 1, 0.1 do

593
					swait()

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

595
				end

596
			end))

597
			local bodyVelocity = Create("BodyVelocity"){

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

599
				P = 5000,

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

601
				Parent = hit,

602
			}

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

604
		elseif Type == "Snare" then

605
			local bp = Create("BodyPosition"){

606
				P = 2000,

607
				D = 100,

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

609
				position = hit.Parent.Torso.Position,

610
				Parent = hit.Parent.Torso,

611
			}

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

613
		elseif Type == "Freeze" then

614
			local BodPos = Create("BodyPosition"){

615
				P = 50000,

616
				D = 1000,

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

618
				position = hit.Parent.Torso.Position,

619
				Parent = hit.Parent.Torso,

620
			}

621
			local BodGy = Create("BodyGyro") {

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

623
				P = 20e+003,

624
				Parent = hit.Parent.Torso,

625
				cframe = hit.Parent.Torso.CFrame,

626
			}

627
			hit.Parent.Torso.Anchored = true

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

629
				swait(1.5)

630
				Part.Anchored = false

631
			end), hit.Parent.Torso)

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

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

634
		end

635
		local debounce = Create("BoolValue"){

636
			Name = "DebounceHit",

637
			Parent = hit.Parent,

638
			Value = true,

639
		}

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

641
		c = Create("ObjectValue"){

642
			Name = "creator",

643
			Value = Player,

644
			Parent = h,

645
		}

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

647
	end

648
end

649
-------------------------------------------------------

650
--End Damage Function--

651
-------------------------------------------------------

652
653
-------------------------------------------------------

654
--Start Damage Function Customization--

655
-------------------------------------------------------

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

657
	local Rate = (1 / 30)

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

659
	local Text = (Text or "")

660
	local Time = (Time or 2)

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

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

663
	EffectPart.Anchored = true

664
	local BillboardGui = Create("BillboardGui"){

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

666
		Adornee = EffectPart,

667
		Parent = EffectPart,

668
	}

669
	local TextLabel = Create("TextLabel"){

670
		BackgroundTransparency = 1,

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

672
		Text = Text,

673
		Font = "Bodoni",

674
		TextColor3 = Color,

675
		TextScaled = true,

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

677
		Parent = BillboardGui,

678
	}

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

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

681
	delay(0, function()

682
		local Frames = (Time / Rate)

683
		for Frame = 1, Frames do

684
			wait(Rate)

685
			local Percent = (Frame / Frames)

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

687
			TextLabel.TextTransparency = Percent

688
		end

689
		if EffectPart and EffectPart.Parent then

690
			EffectPart:Destroy()

691
		end

692
	end)

693
end

694
-------------------------------------------------------

695
--End Damage Function Customization--

696
-------------------------------------------------------

697
698
function MagniDamage(Part, magni, mindam, maxdam, knock, Type)

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

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

701
    if hum ~= nil then

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

703
      if head ~= nil then

704
        local targ = head.Position - Part.Position

705
        local mag = targ.magnitude

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

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

708
        end

709
      end

710
    end

711
  end

712
end

713
714
715
CFuncs = {

716
	Part = {

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

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

719
				Parent = Parent,

720
				Reflectance = Reflectance,

721
				Transparency = Transparency,

722
				CanCollide = false,

723
				Locked = true,

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

725
				Name = Name,

726
				Size = Size,

727
				Material = Material

728
			})

729
			RemoveOutlines(Part)

730
			return Part

731
		end

732
	},

733
	Mesh = {

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

735
			local Msh = Create(Mesh)({

736
				Parent = Part,

737
				Offset = OffSet,

738
				Scale = Scale

739
			})

740
			if Mesh == "SpecialMesh" then

741
				Msh.MeshType = MeshType

742
				Msh.MeshId = MeshId

743
			end

744
			return Msh

745
		end

746
	},

747
	Mesh = {

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

749
			local Msh = Create(Mesh)({

750
				Parent = Part,

751
				Offset = OffSet,

752
				Scale = Scale

753
			})

754
			if Mesh == "SpecialMesh" then

755
				Msh.MeshType = MeshType

756
				Msh.MeshId = MeshId

757
			end

758
			return Msh

759
		end

760
	},

761
	Weld = {

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

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

764
				Parent = Parent,

765
				Part0 = Part0,

766
				Part1 = Part1,

767
				C0 = C0,

768
				C1 = C1

769
			})

770
			return Weld

771
		end

772
	},

773
	Sound = {

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

775
			coroutine.resume(coroutine.create(function()

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

777
					Volume = vol,

778
					Pitch = pit or 1,

779
					SoundId = id,

780
					Parent = par or workspace

781
				})

782
				wait()

783
				S:play()

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

785
			end))

786
		end

787
	},

788
	ParticleEmitter = {

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

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

791
				Parent = Parent,

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

793
				LightEmission = LightEmission,

794
				Size = Size,

795
				Texture = Texture,

796
				Transparency = Transparency,

797
				ZOffset = ZOffset,

798
				Acceleration = Accel,

799
				Drag = Drag,

800
				LockedToPart = LockedToPart,

801
				VelocityInheritance = VelocityInheritance,

802
				EmissionDirection = EmissionDirection,

803
				Enabled = Enabled,

804
				Lifetime = LifeTime,

805
				Rate = Rate,

806
				Rotation = Rotation,

807
				RotSpeed = RotSpeed,

808
				Speed = Speed,

809
				VelocitySpread = VelocitySpread

810
			})

811
			return fp

812
		end

813
	}

814
}

815
function RemoveOutlines(part)

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

817
end

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

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

820
		formFactor = FormFactor,

821
		Parent = Parent,

822
		Reflectance = Reflectance,

823
		Transparency = Transparency,

824
		CanCollide = false,

825
		Locked = true,

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

827
		Name = Name,

828
		Size = Size,

829
		Material = Material

830
	})

831
	RemoveOutlines(Part)

832
	return Part

833
end

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

835
	local Msh = Create(Mesh)({

836
		Parent = Part,

837
		Offset = OffSet,

838
		Scale = Scale

839
	})

840
	if Mesh == "SpecialMesh" then

841
		Msh.MeshType = MeshType

842
		Msh.MeshId = MeshId

843
	end

844
	return Msh

845
end

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

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

848
		Parent = Parent,

849
		Part0 = Part0,

850
		Part1 = Part1,

851
		C0 = C0,

852
		C1 = C1

853
	})

854
	return Weld

855
end

856
857
858
-------------------------------------------------------

859
--Start Effect Function--

860
-------------------------------------------------------

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

862
Effects = {

863
  Block = {

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

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

866
      prt.Anchored = true

867
      prt.CFrame = cframe

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

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

870
      if Type == 1 or Type == nil then

871
        table.insert(Effects, {

872
          prt,

873
          "Block1",

874
          delay,

875
          x3,

876
          y3,

877
          z3,

878
          msh

879
        })

880
      elseif Type == 2 then

881
        table.insert(Effects, {

882
          prt,

883
          "Block2",

884
          delay,

885
          x3,

886
          y3,

887
          z3,

888
          msh

889
        })

890
      else

891
        table.insert(Effects, {

892
          prt,

893
          "Block3",

894
          delay,

895
          x3,

896
          y3,

897
          z3,

898
          msh

899
        })

900
      end

901
    end

902
  },

903
  Sphere = {

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

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

906
      prt.Anchored = true

907
      prt.CFrame = cframe

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

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

910
      table.insert(Effects, {

911
        prt,

912
        "Cylinder",

913
        delay,

914
        x3,

915
        y3,

916
        z3,

917
        msh

918
      })

919
    end

920
  },

921
  Cylinder = {

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

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

924
      prt.Anchored = true

925
      prt.CFrame = cframe

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

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

928
      table.insert(Effects, {

929
        prt,

930
        "Cylinder",

931
        delay,

932
        x3,

933
        y3,

934
        z3,

935
        msh

936
      })

937
    end

938
  },

939
  Wave = {

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

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

942
      prt.Anchored = true

943
      prt.CFrame = cframe

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

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

946
      table.insert(Effects, {

947
        prt,

948
        "Cylinder",

949
        delay,

950
        x3 / 60,

951
        y3 / 60,

952
        z3 / 60,

953
        msh

954
      })

955
    end

956
  },

957
  Ring = {

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

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

960
      prt.Anchored = true

961
      prt.CFrame = cframe

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

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

964
      table.insert(Effects, {

965
        prt,

966
        "Cylinder",

967
        delay,

968
        x3,

969
        y3,

970
        z3,

971
        msh

972
      })

973
    end

974
  },

975
  Break = {

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

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

978
      prt.Anchored = true

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

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

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

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

983
      table.insert(Effects, {

984
        prt,

985
        "Shatter",

986
        num,

987
        prt.CFrame,

988
        math.random() - math.random(),

989
        0,

990
        math.random(50, 100) / 100

991
      })

992
    end

993
  },

994
Spiral = {

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

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

997
      prt.Anchored = true

998
      prt.CFrame = cframe

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

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

1001
      table.insert(Effects, {

1002
        prt,

1003
        "Cylinder",

1004
        delay,

1005
        x3,

1006
        y3,

1007
        z3,

1008
        msh

1009
      })

1010
    end

1011
  },

1012
Push = {

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

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

1015
      prt.Anchored = true

1016
      prt.CFrame = cframe

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

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

1019
      table.insert(Effects, {

1020
        prt,

1021
        "Cylinder",

1022
        delay,

1023
        x3,

1024
        y3,

1025
        z3,

1026
        msh

1027
      })

1028
    end

1029
  }

1030
}

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

1032
	local fp = IT("Part")

1033
	fp.formFactor = formfactor 

1034
	fp.Parent = parent

1035
	fp.Reflectance = reflectance

1036
	fp.Transparency = transparency

1037
	fp.CanCollide = false 

1038
	fp.Locked = true

1039
	fp.BrickColor = brickcolor

1040
	fp.Name = name

1041
	fp.Size = size

1042
	fp.Position = tors.Position 

1043
	RemoveOutlines(fp)

1044
	fp.Material = "SmoothPlastic"

1045
	fp:BreakJoints()

1046
	return fp 

1047
end 

1048
 

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

1050
	local mesh = IT(Mesh) 

1051
	mesh.Parent = part

1052
	if Mesh == "SpecialMesh" then

1053
		mesh.MeshType = meshtype

1054
	if meshid ~= "nil" then

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

1056
		end

1057
	end

1058
	mesh.Offset = offset

1059
	mesh.Scale = scale

1060
	return mesh

1061
end

1062
1063
function Magic(bonuspeed, type, pos, scale, value, color, MType)

1064
	local type = type

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

1066
	rng.Anchored = true

1067
	rng.BrickColor = color

1068
	rng.CanCollide = false

1069
	rng.FormFactor = 3

1070
	rng.Name = "Ring"

1071
	rng.Material = "Neon"

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

1073
	rng.Transparency = 0

1074
	rng.TopSurface = 0

1075
	rng.BottomSurface = 0

1076
	rng.CFrame = pos

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

1078
	rngm.MeshType = MType

1079
	rngm.Scale = scale

1080
	local scaler2 = 1

1081
	if type == "Add" then

1082
		scaler2 = 1 * value

1083
	elseif type == "Divide" then

1084
		scaler2 = 1 / value

1085
	end

1086
	coroutine.resume(coroutine.create(function()

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

1088
			swait()

1089
			if type == "Add" then

1090
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1091
			elseif type == "Divide" then

1092
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1093
			end

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

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

1096
		end

1097
		rng:Destroy()

1098
	end))

1099
end

1100
1101
function Eviscerate(dude)

1102
	if dude.Name ~= char then

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

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

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

1106
		val.Name = "IsHit"

1107
		local ds = coroutine.wrap(function()

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

1109
			wait(0.5)

1110
			target = nil

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

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

1113
					if v:IsA("Accessory") then

1114
						v:Destroy()

1115
					end

1116
					if v:IsA("Humanoid") then

1117
						v:Destroy()

1118
					end

1119
					if v:IsA("CharacterMesh") then

1120
						v:Destroy()

1121
					end

1122
					if v:IsA("Model") then

1123
						v:Destroy()

1124
					end

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

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

1127
							if o:IsA("Decal") then

1128
								o:Destroy()

1129
							end

1130
						end

1131
						coroutine.resume(coroutine.create(function()

1132
							v.Material = "Neon"

1133
							v.CanCollide = false

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

1135
							PartEmmit1.LightEmission = 1

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

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

1138
							PartEmmit1.Rate = 150

1139
							PartEmmit1.Lifetime = NumberRange.new(1)

1140
							PartEmmit1.Size = NumberSequence.new({

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

1142
								NumberSequenceKeypoint.new(1, 0, 0)

1143
							})

1144
							PartEmmit1.Transparency = NumberSequence.new({

1145
								NumberSequenceKeypoint.new(0, 0, 0),

1146
								NumberSequenceKeypoint.new(1, 1, 0)

1147
							})

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

1149
							PartEmmit1.VelocitySpread = 30000

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

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

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

1153
							BodPoss.P = 3000

1154
							BodPoss.D = 1000

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

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

1157
							v.Color = maincolor.Color

1158
							coroutine.resume(coroutine.create(function()

1159
								for i = 0, 49 do

1160
									swait(1)

1161
									v.Transparency = v.Transparency + 0.08

1162
								end

1163
								wait(0.5)

1164
								PartEmmit1.Enabled = false

1165
								wait(3)

1166
								v:Destroy()

1167
								dude:Destroy()

1168
							end))

1169
						end))

1170
					end

1171
				end

1172
			end))

1173
		end)

1174
		ds()

1175
	end

1176
end

1177
1178
function FindNearestHead(Position, Distance, SinglePlayer)

1179
	if SinglePlayer then

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

1181
	end

1182
	local List = {}

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

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

1185
			table.insert(List, v)

1186
		end

1187
	end

1188
	return List

1189
end

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

1192
	local type = type

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

1194
	rng.Anchored = true

1195
	rng.BrickColor = color

1196
	rng.CanCollide = false

1197
	rng.FormFactor = 3

1198
	rng.Name = "Ring"

1199
	rng.Material = "Neon"

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

1201
	rng.Transparency = 0

1202
	rng.TopSurface = 0

1203
	rng.BottomSurface = 0

1204
	rng.CFrame = pos

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

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

1207
	rngm.MeshType = MType

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

1209
	local scaler2 = 1

1210
	local speeder = FastSpeed

1211
	if type == "Add" then

1212
		scaler2 = 1 * value

1213
	elseif type == "Divide" then

1214
		scaler2 = 1 / value

1215
	end

1216
	coroutine.resume(coroutine.create(function()

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

1218
			swait()

1219
			if type == "Add" then

1220
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1221
			elseif type == "Divide" then

1222
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1223
			end

1224
			speeder = speeder - 0.01 * FastSpeed * bonuspeed

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

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

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

1228
		end

1229
		rng:Destroy()

1230
	end))

1231
end

1232
1233
function SoulSteal(dude)

1234
if dude.Name ~= char then

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

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

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

1238
val.Name = "IsHit"

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

1240
local soulst = coroutine.wrap(function()

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

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

1243
soul.CanCollide = false

1244
soul.Anchored = false

1245
soul.Position = torso.Position

1246
soul.Transparency = 1

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

1248
PartEmmit1.LightEmission = 1

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

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

1251
PartEmmit1.Rate = 250

1252
PartEmmit1.Lifetime = NumberRange.new(1.6)

1253
PartEmmit1.Size = NumberSequence.new({

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

1255
	NumberSequenceKeypoint.new(1, 0, 0)

1256
})

1257
PartEmmit1.Transparency = NumberSequence.new({

1258
	NumberSequenceKeypoint.new(0, 0, 0),

1259
	NumberSequenceKeypoint.new(1, 1, 0)

1260
})

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

1262
PartEmmit1.VelocitySpread = 30000

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

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

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

1266
BodPoss.P = 3000

1267
BodPoss.D = 1000

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

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

1270
wait(1.6)

1271
soul.Touched:connect(function(hit)

1272
	if hit.Parent == char then

1273
	soul:Destroy()

1274
	end

1275
end)

1276
wait(1.2)

1277
while soul do

1278
	swait()

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

1280
	BodPoss.Position = tors.Position

1281
end

1282
end)

1283
	soulst()

1284
	end

1285
end

1286
function FaceMouse()

1287
local	Cam = workspace.CurrentCamera

1288
	return {

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

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

1291
	}

1292
end

1293
1294
BTAUNT = Instance.new("Sound", tors)

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

1296
BTAUNT.Volume = 3

1297
BTAUNT.Pitch = 1

1298
BTAUNT.Looped = true

1299
BTAUNT.TimePosition = 0

1300
1301
BTAUNT3 = Instance.new("Sound", tors)

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

1303
BTAUNT3.Volume = 10

1304
BTAUNT3.Pitch = 1

1305
BTAUNT3.Looped = false

1306
BTAUNT3.TimePosition = 0

1307
1308
TEST = Instance.new("Sound", tors)

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

1310
TEST.Volume = 25

1311
TEST.Pitch = 1

1312
TEST.Looped = false

1313
TEST.TimePosition = 0

1314
-------------------------------------------------------

1315
--End Effect Function--

1316
-------------------------------------------------------

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

1318
	local NSound = nil

1319
	coroutine.resume(coroutine.create(function()

1320
		NSound = IT("Sound", PARENT)

1321
		NSound.Volume = VOLUME

1322
		NSound.Pitch = PITCH

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

1324
		swait()

1325
		NSound:play()

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

1327
	end))

1328
	return NSound

1329
end

1330
function CameraEnshaking(Length, Intensity)

1331
	coroutine.resume(coroutine.create(function()

1332
		local intensity = 1 * Intensity

1333
		local rotM = 0.01 * Intensity

1334
		for i = 0, Length, 0.1 do

1335
			swait()

1336
			intensity = intensity - 0.05 * Intensity / Length

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

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

1339
			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)

1340
		end

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

1342
	end))

1343
end

1344
-------------------------------------------------------

1345
--End Important Functions--

1346
-------------------------------------------------------

1347
1348
1349
-------------------------------------------------------

1350
--Start Customization--

1351
-------------------------------------------------------

1352
local Player_Size = 1

1353
if Player_Size ~= 1 then

1354
root.Size = root.Size * Player_Size

1355
tors.Size = tors.Size * Player_Size

1356
hed.Size = hed.Size * Player_Size

1357
ra.Size = ra.Size * Player_Size

1358
la.Size = la.Size * Player_Size

1359
rl.Size = rl.Size * Player_Size

1360
ll.Size = ll.Size * Player_Size

1361
----------------------------------------------------------------------------------

1362
rootj.Parent = root

1363
neck.Parent = tors

1364
RW.Parent = tors

1365
LW.Parent = tors

1366
RH.Parent = tors

1367
LH.Parent = tors

1368
----------------------------------------------------------------------------------

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

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

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

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

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

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

1375
----------------------------------------------------------------------------------

1376
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))

1377
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))

1378
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))

1379
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))

1380
--hat.Parent = Character

1381
end

1382
----------------------------------------------------------------------------------

1383
----------------------------------------------------------------------------------

1384
local equipped = false

1385
local idle = 0

1386
local change = 1

1387
local val = 0

1388
local toim = 0

1389
local idleanim = 0.4

1390
local sine = 0

1391
local Sit = 1

1392
----------------------------------------------------------------------------------

1393
hum.WalkSpeed = 8

1394
hum.JumpPower = 57

1395
hum.Animator.Parent = nil

1396
----------------------------------------------------------------------------------

1397
wait(1)

1398
player = game.Players.LocalPlayer

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

1400
mouse = player:GetMouse()

1401
1402
mouse.KeyDown:connect(function(key)

1403
    if key == "t" then

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

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

1406
        if dist <= 10000 then

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

1408
        end

1409
    end

1410
end)

1411
-------------------------------------------------------

1412
--End Customization--

1413
-------------------------------------------------------

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

1415
Blobby.Name = "Blob"

1416
Blobby.CanCollide = false

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

1418
Blobby.Transparency = 0

1419
Blobby.Material = "Plastic"

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

1421
Blobby.TopSurface = Enum.SurfaceType.Smooth

1422
Blobby.BottomSurface = Enum.SurfaceType.Smooth

1423
1424
local Weld = Instance.new("Weld", Blobby)

1425
Weld.Part0 = ra

1426
Weld.Part1 = Blobby

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

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

1429
1430
local M2 = Instance.new("SpecialMesh")

1431
M2.Parent = Blobby

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

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

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

1435
1436
--[[local naeeym2 = Instance.new("BillboardGui",char)

1437
naeeym2.AlwaysOnTop = true

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

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

1440
naeeym2.Adornee = hed

1441
naeeym2.Name = "Name"

1442
--naeeym2.PlayerToHideFrom = Player

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

1444
tecks2.BackgroundTransparency = 1

1445
tecks2.TextScaled = true

1446
tecks2.BorderSizePixel = 0

1447
tecks2.Text = "Fight Me"

1448
tecks2.Font = Enum.Font.Bodoni

1449
tecks2.TextSize = 30

1450
tecks2.TextStrokeTransparency = 0

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

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

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

1454
tecks2.Parent = naeeym2]]

1455
----------------------------------------------------------------------------------

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

1457
local Obj = Instance.new(Object)

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

1459
Obj[i] = v

1460
end

1461
return Obj

1462
end

1463
----------------------------------------------------

1464
		local Reaper = AddInstance("Part",{

1465
			Parent = hed,

1466
			CFrame = hed.CFrame,

1467
			formFactor = "Symmetric",

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

1469
			CanCollide = false,

1470
			TopSurface = "Smooth",

1471
			BottomSurface = "Smooth",

1472
			Locked = true,

1473
		})

1474
		local Weld = AddInstance("Weld",{

1475
			Parent = Reaper,

1476
			Part0 = hed,

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

1478
			Part1 = Reaper,

1479
		})

1480
		local Mesh = AddInstance("SpecialMesh",{

1481
			Parent = Reaper,

1482
			MeshId = "rbxassetid://193760002",

1483
			TextureId = "rbxassetid://89867215",

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

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

1486
		})

1487
-------------------------------------------------------

1488
wait(1)

1489
plr = game.Players.LocalPlayer

1490
char = plr.Character

1491
mouse = plr:GetMouse()

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

1493
epicmode = false

1494
normal = true

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

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

1497
      v:Destroy()

1498
     end

1499
end

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

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

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

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

1504
local bdycolors = char["Body Colors"]

1505
bdycolors.HeadColor3 = whitecolor

1506
bdycolors.LeftArmColor3 = whitecolor

1507
bdycolors.LeftLegColor3 = whitecolor

1508
bdycolors.RightArmColor3 = whitecolor

1509
bdycolors.RightLegColor3 = whitecolor

1510
bdycolors.TorsoColor3 = whitecolor

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

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

1513
        v:Destroy()

1514
    end

1515
end

1516
1517
-------------------------------------------------------

1518
--Start Attacks N Stuff--

1519
-------------------------------------------------------

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

1521
naeeym2.AlwaysOnTop = true

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

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

1524
naeeym2.Adornee = hed

1525
naeeym2.Name = "Name"

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

1528
tecks2.BackgroundTransparency = 1

1529
tecks2.TextScaled = true

1530
tecks2.BorderSizePixel = 0

1531-
tecks2.Text = "J E V I L"

1531+
tecks2.Text = "??? Wha boi"

1532
tecks2.Font = "Fantasy"

1533
tecks2.TextSize = 50

1534
tecks2.TextStrokeTransparency = 0

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

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

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

1538
tecks2.Parent = naeeym2

1539
textfag = tecks2

1540-
tecks2.Text = "J E V I L"

1540+
tecks2.Text = "yeah im still bein a skid"

1541
BTAUNT:Play()

1542
coroutine.resume(coroutine.create(function()

1543
    while textfag ~= nil do

1544
        swait()

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

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

1547
    end

1548
end))

1549
1550
function get_out()

1551
        BTAUNT:Stop()

1552
	attack = true

1553
        BTAUNT3:Remove()

1554
        BTAUNT3:Play()

1555
        repeat

1556
	hum.WalkSpeed = 10

1557
	for i = 0,0.37,0.03 do 

1558
                swait()

1559
                BTAUNT3.Parent = tors

1560
                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)

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

1562
                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)

1563
                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)

1564
                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)

1565
                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)	

1566
             end

1567
        for i = 0,0.37,0.03 do

1568
                swait()

1569
                BTAUNT3.Parent = tors

1570
                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)

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

1572
                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)

1573
                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)

1574
                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)

1575
                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)	

1576
             end

1577
        until BTAUNT3.Playing == false

1578
        BTAUNT3:Stop()

1579
        BTAUNT3:Play()

1580
        BTAUNT3:Remove()

1581
        BTAUNT:Play()

1582
	attack = false

1583
	hum.WalkSpeed = 20

1584
        BTAUNT:Play()

1585
end

1586
function Taunt2()

1587
	attack = true

1588
	hum.WalkSpeed = 0

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

1590
	for i = 0, 2, 0.1 do

1591
		swait()

1592
		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)

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

1594
		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)

1595
		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)

1596
		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)

1597
		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)

1598
	end

1599
	for i = 0, 6, 0.1 do

1600
		swait()

1601
		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)

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

1603
		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)

1604
		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)

1605
		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)

1606
		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)

1607
	end

1608
	for i = 0, 2, 0.1 do

1609
		swait()

1610
		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)

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

1612
		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)

1613
		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)

1614
		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)

1615
		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)

1616
	end

1617
	attack = false

1618
	hum.WalkSpeed = 20

1619
end

1620
function icando()

1621
print('>:3')

1622
	attack = true

1623
	hum.WalkSpeed = 0

1624
        TEST:Remove()

1625
        TEST:Play()

1626
        repeat

1627
	for i = 0,4,0.1 do

1628
		swait()

1629
                TEST.Parent = tors

1630
		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)

1631
		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)

1632
		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)

1633
		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)

1634
		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)

1635
		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)

1636
	end

1637
        until TEST.Playing == false

1638
        TEST:Stop()

1639
        TEST:Play()

1640
        TEST:Remove()

1641
        print('I CAN DO ANYTHING')

1642
		attack = false

1643
		hum.WalkSpeed = 20

1644
end

1645
function Blood_ball()

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

1647
	orb.Anchored = true

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

1649
	orb.CanCollide = false

1650
	orb.FormFactor = 3

1651
	orb.Name = "Ring"

1652
	orb.Material = "Neon"

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

1654
	orb.Transparency = 0

1655
	orb.TopSurface = 0

1656
	orb.BottomSurface = 0

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

1658
	orbm.MeshType = "Sphere"

1659
	orbm.Name = "SizeMesh"

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

1661
	local scaled = 0.1

1662
	local posid = 0

1663
	for i = 0, 109, 0.1 do

1664
		swait()

1665
		scaled = scaled + 0.001

1666
		posid = posid - scaled

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

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

1669
                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)

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

1671
		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)

1672
		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)

1673
		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)

1674
		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)

1675
	end

1676
	coroutine.resume(coroutine.create(function()

1677
		orb.Anchored = false

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

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

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

1681
		a.Name = "Direction"

1682
		a.Anchored = true

1683
		a.BrickColor = BrickC("Crimson")

1684
		a.Material = "Neon"

1685
		a.Transparency = 1

1686
		a.CanCollide = false

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

1688
		local ignore = orb

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

1690
		a.BottomSurface = 10

1691
		a.TopSurface = 10

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

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

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

1695
		orb.CFrame = a.CFrame

1696
		a:Destroy()

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

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

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

1700
		bv.Parent = orb

1701
		local hitted = false

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

1703
		wait()

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

1705
			if hitted == false then

1706
				hitted = true

1707
				coroutine.resume(coroutine.create(function() 

1708
		for i = 0,1.8,0.1 do

1709
			swait()

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

1711
		end

1712
		for i = 0,1.8,0.1 do

1713
			swait()

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

1715
		end

1716
	end))

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

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

1719
		if v:FindFirstChild("Head") then

1720
			Eviscerate(v)

1721
		end

1722
	end

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

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

1725
				for i = 0, 9 do

1726
					--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")

1727
					--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")

1728
				end

1729
				orb.Anchored = true

1730
				orb.Transparency = 1

1731
				wait(8)

1732
				orb:Destroy()

1733
			end

1734
		end)

1735
	end))

1736
	for i = 0, 2, 0.1 do

1737
		swait()

1738
                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)

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

1740
		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)

1741
		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)

1742
		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)

1743
		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)

1744
	end

1745
	attack = false

1746
end

1747
function Blood_ball()

1748
	attack = true

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

1750
	orb.Anchored = true

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

1752
	orb.CanCollide = false

1753
	orb.FormFactor = 3

1754
	orb.Name = "Ring"

1755
	orb.Material = "Neon"

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

1757
	orb.Transparency = 0

1758
	orb.TopSurface = 0

1759
	orb.BottomSurface = 0

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

1761
	orbm.MeshType = "Sphere"

1762
	orbm.Name = "SizeMesh"

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

1764
	local scaled = 0.1

1765
	local posid = 0

1766
	for i = 0, 12, 0.1 do

1767
		swait()

1768
		scaled = scaled + 0.001

1769
		posid = posid - scaled

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

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

1772
	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)

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

1774
				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)

1775
				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)

1776
		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)

1777
		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)

1778
	end

1779
	coroutine.resume(coroutine.create(function()

1780
		orb.Anchored = false

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

1782
		a.Name = "Direction"

1783
		a.Anchored = true

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

1785
		a.Material = "Neon"

1786
		a.Transparency = 1

1787
		a.CanCollide = false

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

1789
		local ignore = orb

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

1791
		a.BottomSurface = 10

1792
		a.TopSurface = 10

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

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

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

1796
		orb.CFrame = a.CFrame

1797
		a:Destroy()

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

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

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

1801
		bv.Parent = orb

1802
		local hitted = false

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

1804
		swait()

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

1806
			if hitted == false then

1807
				hitted = true

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

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

1810
					if v:FindFirstChild("Head") then

1811
						Eviscerate(v)

1812
					end

1813
				end

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

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

1816
				for i = 0, 9 do

1817
					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")

1818
					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")

1819
				end

1820
				orb.Anchored = true

1821
				orb.Transparency = 1

1822
				wait(8)

1823
				orb:Destroy()

1824
			end

1825
		end)

1826
	end))

1827
	for i = 0, 1, 0.1 do

1828
		swait()

1829
		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)

1830
		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)

1831
		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)

1832
		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)

1833
		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)

1834
		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)

1835
	end

1836
	attack = false

1837
end

1838
function blast()

1839
	attack = true

1840
	hum.WalkSpeed = 0

1841
	for i = 0,1.2,0.1 do

1842
		swait()

1843
		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)

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

1845
		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)

1846
		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)

1847
		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)

1848
		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)

1849
	end

1850
		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")

1851
		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")

1852
        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)

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

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

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

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

1857
1858
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1859
		if v:FindFirstChild("Head") then

1860
			Eviscerate(v)

1861
		end

1862
	end

1863
1864
	for i = 1,4.7,0.1 do

1865
	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)

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

1867
	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)

1868
	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)

1869
	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)

1870
	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)

1871
	end

1872
	 wait(.6)

1873
		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")

1874
		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")

1875
        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)

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

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

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

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

1880
1881
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1882
		if v:FindFirstChild("Head") then

1883
			Eviscerate(v)

1884
		end

1885
	end

1886
1887
	for i = 1,4.7,0.1 do

1888
	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)

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

1890
	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)

1891
	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)

1892
	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)

1893
	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)

1894
	end

1895
      wait(.6)

1896
		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")

1897
		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")

1898
        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)

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

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

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

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

1903
1904
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1905
		if v:FindFirstChild("Head") then

1906
			Eviscerate(v)

1907
		end

1908
	end

1909
1910
	for i = 1,4.7,0.1 do

1911
	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)

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

1913
	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)

1914
	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)

1915
	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)

1916
	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)

1917
	end

1918
	 wait(.6)

1919
		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")

1920
		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")

1921
        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)

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

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

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

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

1926
1927
        for i, v in pairs(FindNearestHead(tors.CFrame.p, 14.5)) do

1928
		if v:FindFirstChild("Head") then

1929
			Eviscerate(v)

1930
		end

1931
	end

1932
1933
	for i = 1,4.7,0.1 do

1934
	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)

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

1936
	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)

1937
	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)

1938
	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)

1939
	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)

1940
	end

1941
      wait(.6)

1942
	attack = false

1943
	hum.WalkSpeed = 8

1944
end

1945
function dejzrXD()

1946
        attack = true

1947
    hum.WalkSpeed = 20

1948
    for i = 0, 4, 0.1 do

1949
        swait()

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

1951
        hum.CameraOffset = Vector3.new(0, -0.1 + 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(-10), 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(125), 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
    Magic(5, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

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

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

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

1963
    CameraEnshaking(4, 5)

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

1965
        if v:FindFirstChild("Head") then

1966
            Eviscerate(v)

1967
        end

1968
    end

1969
    for i = 0, 2, 0.1 do

1970
        swait()

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

1972
        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)

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

1974
        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)

1975
        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)

1976
        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)

1977
        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)

1978
    end

1979
	attack = false

1980
	Speed = 20

1981
end

1982
1983
function Attack()

1984
	attack = true

1985
	for i = 0, 2.6, 0.1 do

1986
		swait()

1987
		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)

1988
		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)

1989
		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)

1990
		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)

1991
		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)

1992
		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)

1993
	end

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

1995
	CameraEnshaking(2, 15)

1996
	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)

1997
  	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)

1998
  	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)

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

2000
		if v:FindFirstChild("Head") then

2001
			Eviscerate(v)

2002
		end

2003
	end

2004
	for i = 0, 3, 0.1 do

2005
		swait()

2006
		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)

2007
		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)

2008
		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)

2009
		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)

2010
		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)

2011
		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)

2012
	end

2013
	attack = false

2014
end

2015
function Orb_Strike()

2016
	attack = true

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

2018
    	for i = 0, 9 do

2019
			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")

2020
			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")

2021
		end

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

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

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

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

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

2027
		if v:FindFirstChild("Head") then

2028
			Eviscerate(v)

2029
		end

2030
	end

2031
	attack = false

2032
	hum.WalkSpeed = 20

2033
end

2034
-------------------------------------------------------

2035
--End Attacks N Stuff--

2036
-------------------------------------------------------

2037
mouse.KeyDown:connect(function(key)

2038
	if attack == false then

2039
		if key == 'e' then

2040
                       icando()

2041
		elseif key == 'c' then

2042
                       Blood_ball()

2043
		elseif key == "x" then

2044
                        blast()

2045
        elseif key == "y" then

2046
                        Taunt2()

2047
        elseif key == 'h' then

2048
                   Orb_Strike()

2049
		elseif key == "z" then

2050
                        dejzrXD()

2051
 		end

2052
	end

2053
end)

2054
2055
mouse.Button1Down:connect(function(key)

2056
	if attack == false then

2057
		Attack()

2058
	end

2059
end)

2060
2061
2062
2063
-------------------------------------------------------

2064
--Start Animations--

2065
-------------------------------------------------------

2066
print("By Makhail07")

2067
while true do

2068
	swait()

2069
	sine = sine + change

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

2071
	local velderp = root.Velocity.y

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

2073
	if equipped == true or equipped == false then

2074
		if attack == false then

2075
			idle = idle + 1

2076
		else

2077
			idle = 0

2078
		end

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

2080
			Anim = "Jump"

2081
			if attack == false then

2082
				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)

2083
				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)

2084
				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)

2085
				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)

2086
				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)

2087
				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)

2088
			end

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

2090
			Anim = "Fall"

2091
			if attack == false then

2092
				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)

2093
				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)

2094
				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)

2095
				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)

2096
				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)

2097
				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)

2098
			end

2099
		elseif torvel < 1 and hitfloor ~= nil then

2100
			Anim = "Idle"

2101
			change = 1

2102
			if attack == false then

2103
				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)

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

2105
                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)

2106
                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)

2107
				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)

2108
				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)

2109
			end

2110
		elseif torvel > 2 and torvel < 25 and hitfloor ~= nil then

2111
			Anim = "Walk"

2112
			change = 1

2113
			if attack == false then

2114
				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)

2115
				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)

2116
				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)

2117
         		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)

2118
					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)

2119
				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)

2120
			end

2121
		elseif torvel >= 25 and hitfloor ~= nil then

2122
			Anim = "Sprint"

2123
			change = 1.35

2124
			if attack == false then

2125
			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)

2126
			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)

2127
			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)

2128
         	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)

2129
			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)

2130
			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)

2131
			end

2132
		end

2133
	end

2134
	if 0 < #Effects then

2135
		for e = 1, #Effects do

2136
			if Effects[e] ~= nil then

2137
				local Thing = Effects[e]

2138
				if Thing ~= nil then

2139
					local Part = Thing[1]

2140
					local Mode = Thing[2]

2141
					local Delay = Thing[3]

2142
					local IncX = Thing[4]

2143
					local IncY = Thing[5]

2144
					local IncZ = Thing[6]

2145
					if 1 >= Thing[1].Transparency then

2146
						if Thing[2] == "Block1" then

2147
							Thing[1].CFrame = Thing[1].CFrame * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50))

2148
							local Mesh = Thing[1].Mesh

2149
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2150
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2151
						elseif Thing[2] == "Block2" then

2152
							Thing[1].CFrame = Thing[1].CFrame + Vector3.new(0, 0, 0)

2153
							local Mesh = Thing[7]

2154
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2155
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2156
						elseif Thing[2] == "Block3" then

2157
							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)

2158
							local Mesh = Thing[7]

2159
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2160
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2161
						elseif Thing[2] == "Cylinder" then

2162
							local Mesh = Thing[1].Mesh

2163
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2164
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2165
						elseif Thing[2] == "Blood" then

2166
							local Mesh = Thing[7]

2167
							Thing[1].CFrame = Thing[1].CFrame * Vector3.new(0, 0.5, 0)

2168
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2169
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2170
						elseif Thing[2] == "Elec" then

2171
							local Mesh = Thing[1].Mesh

2172
							Mesh.Scale = Mesh.Scale + Vector3.new(Thing[7], Thing[8], Thing[9])

2173
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2174
						elseif Thing[2] == "Disappear" then

2175
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2176
						elseif Thing[2] == "Shatter" then

2177
							Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2178
							Thing[4] = Thing[4] * CFrame.new(0, Thing[7], 0)

2179
							Thing[1].CFrame = Thing[4] * CFrame.fromEulerAnglesXYZ(Thing[6], 0, 0)

2180
							Thing[6] = Thing[6] + Thing[5]

2181
						end

2182
					else

2183
						Part.Parent = nil

2184
						table.remove(Effects, e)

2185
					end

2186
				end

2187
			end

2188
		end

2189
	end

2190
end

2191
-------------------------------------------------------

2192
--End Animations And Script--

2193
-------------------------------------------------------
        

    


            


                                


        

            



                
    

        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!